📘 תיעוד 96

הגדרת הרשאות

שליטה במה ש-Claude Code יכול לגשת אליו ולבצע באמצעות כללי הרשאות מפורטים, מצבים ומדיניות מנוהלת.

Claude Code תומך בהרשאות מפורטות כדי שתוכל לציין בדיוק מה הסוכן מורשה לעשות ומה לא. באפשרותך לשמור את הגדרות ההרשאות במערכת בקרת גרסאות כדי לשתף אותן עם כל מפתח בארגון שלך, וכל מפתח יכול להתאים אישית את ההגדרות שלו.

#מערכת ההרשאות

Claude Code משתמש במערכת הרשאות מדורגת כדי לאזן בין עוצמה לבטיחות. הטבלה מציגה, עבור כל סוג כלי, האם מצב Manual שואל לפני ביצוע הפעולה. מצבי ההרשאות האחרים משנים אילו מהם שואלים אותך. במצב auto, מסווג בודק פעולות במקומך, והסעיף כיצד המסווג מעריך פעולות מפרט אילו מהן הוא רואה.

כאשר אתה בוחר "Yes, and don't ask again" והאישור נשמר לצמיתות, כמו עבור פקודת Bash או דומיין של WebFetch, ‏Claude Code שומר את הכלל ב-.claude/settings.local.json בשורש מאגר ה-git, כפי שמפוענח דרך עצי עבודה (worktrees) אל ה-checkout הראשי. הכלל חל על הפעלות עתידיות בכל מקום באותו מאגר, כולל הפעלות שהופעלו בתת-ספריות וב-worktrees. אישור לשינוי קובץ אינו נשמר לקובץ: כפי שמראה הטבלה, הוא נמשך עד לסיום ההפעלה. במקרים מסוימים, כמו מחוץ למאגר git או ב-Windows, ‏Claude Code אינו משתמש בשורש המאגר. הסעיף היכן Claude Code מחפש כל קובץ מפרט מקרים אלה והיכן הוא שומר את הכלל במקום זאת.

לפני גרסה v2.1.211, ‏Claude Code תמיד שמר את הכלל בספריית ההתחלה, כך שאישור שניתן ב-worktree או בתת-ספרייה לא חל על שאר המאגר. כללים שגרסאות קודמות שמרו בתת-ספרייה או ב-worktree עדיין חלים על הפעלות שמתחילות שם.

לעיתים הנחיית הרשאה מציעה אישור חד-פעמי בלבד, ללא אפשרות "don't ask again" וללא אפשרות לאשר את הפעולה למשך שארית ההפעלה. Claude Code מציע אפשרויות אלו רק כאשר ההנחיה יכולה להציג לך את כל מה שהן יאפשרו, כך שכלל שאתה שומר מתוך הנחיה מכסה רק את מה שהאפשרות שלו ציינה במפורש.

כאשר הספרייה שבה הפעלת את Claude Code היא זו שהופכת את תווית האפשרות לארוכה מדי, Claude Code מקצר אותה בתווית, מחליף את ספריית הבית שלך ב-~ ולאחר מכן את סוף הנתיב ב-…, ושומר על האפשרות. אתה עדיין שומר את אותו הכלל. Claude Code משמיט את האפשרויות בשלושה מקרים:

• פקודה או עריכה: גדולים מכדי להציג במלואם.
• פקודות או נתיבים שהכלל יכסה: התווית אינה יכולה להכיל את כולם.
• ספריית התחלה ארוכה מדי, שלא קוצרה: היא מכילה תווים ש-Claude Code אינו יכול להציג בבטחה, או שאפילו תחילתה אינה נכנסת.

אשר את הפעולה פעם אחת, או הוסף את הכלל בעצמך ב-/permissions.

#הוספת הערה כאשר אתה עונה להנחיית הרשאה

באפשרותך לצרף הערה ל-Claude כאשר אתה מאשר או דוחה פעולה בודדת. ברוב הנחיות ההרשאה, כולל הנחיות של Bash, ‏PowerShell, קבצים וכלי MCP, עבור אל Yes או No ולחץ על Tab כדי לפתוח שדה הערה באותה אפשרות. הנחיות של WebFetch ודפדפן אינן מציעות שדה זה. האפשרויות שמאשרות את הפעולה למשך שארית ההפעלה או שומרות כלל אינן מקבלות הערה אף הן.

כאשר השדה פתוח, הקלד את ההערה ולאחר מכן לחץ על אחד מהמקשים הבאים:

• Enter: מגיש את תשובתך בצירוף ההערה. אם תשאיר את השדה ריק, Claude Code מגיש את התשובה ללא הערה.
• Tab: סוגר את השדה מבלי לענות. Claude Code שומר את הטקסט שהקלדת ועדיין שולח אותו אם תענה באמצעות אותה אפשרות.
• Shift+Tab: בהנחיית קובץ, כגון הנחיית Edit או Write, סוגר את השדה בדומה ל-Tab. לפני גרסה v2.1.235, לחיצה על Shift+Tab בתוך השדה בחרה במקום זאת באפשרות המאשרת את הפעולה למשך שארית ההפעלה, כך ש-Claude Code אישר את הפעולה לשארית ההפעלה והתעלם מההערה.

Claude Code מעביר את ההערה באופן שונה בהתאם לאופן שבו ענית:

• Yes: ‏Claude Code מריץ את הפעולה, ולאחר מכן שולח את הערתך ל-Claude לאחר קבלת התוצאה.
• No: ‏Claude Code שולח את הערתך ל-Claude כסיבה לדחייה, ו-Claude ממשיך לעבוד. אם תבחר No ללא הערה בהנחיה מתוך השיחה הראשית, Claude Code עוצר את התור.

#ניהול הרשאות

באפשרותך להציג ולנהל את הרשאות הכלים של Claude Code באמצעות /permissions. תיבת הדו-שיח מציגה את כל כללי ההרשאות ואת קובץ ה-settings.json שממנו מגיע כל כלל. באפשרותך לפתוח את תיבת הדו-שיח בזמן ש-Claude עובד: כאשר אתה מוסיף או מסיר כלל, Claude Code מחיל את השינוי החל מקריאת הכלי הבאה של Claude באותו תור. לפני גרסה v2.1.234, ‏Claude Code העמיד את הפקודה בתור עד לסיום התור.

• כללי Allow מאפשרים ל-Claude Code להשתמש בכלי שצוין ללא אישור ידני.
• כללי Ask מבקשים אישור בכל פעם ש-Claude Code מנסה להשתמש בכלי שצוין.
• כללי Deny מונעים מ-Claude Code להשתמש בכלי שצוין.

הכללים מוערכים לפי הסדר: דחייה (deny), לאחר מכן שאלה (ask), ולאחר מכן אפשור (allow). ההתאמה הראשונה לפי סדר זה קובעת את התוצאה, ורמת הספציפיות של הכלל אינה משנה את הסדר.

כלל דחייה רחב כגון Bash(aws *) חוסם כל קריאה תואמת, כולל קריאות שתואמות גם לכלל אפשור צר יותר כגון Bash(aws s3 ls), כך שכלל דחייה אינו יכול לכלול חריגות של רשימת היתרים. אותה קדימות חלה בין ask לבין allow: כלל ask תואם יציג הנחיה לאישור גם כאשר כלל allow ספציפי יותר תואם לאותה קריאה.

כללי דחייה מתנהגים באופן שונה בהתאם לשאלה האם הם מציינים שם כלי בלבד או תוחמים תבנית בתוכו. שם כלי בלבד כגון Bash מסיר את הכלי לחלוטין מההקשר של Claude, כך ש-Claude לעולם אינו רואה אותו. הסרה באמצעות שם כלי בלבד חלה על כל כלי למעט EndConversation: כלל דחייה אינו יכול להסיר אותו כל עוד נותר כלי אחר כלשהו, וכלל ask לעולם אינו שואל לגביו. כלל מתוחם כגון Bash(rm *) משאיר את הכלי זמין וחוסם קריאות תואמות כאשר Claude מנסה לבצע אותן.

[!NOTE] כללי הרשאות נאכפים על ידי Claude Code, ולא על ידי המודל. הנחיות בהודעתך או ב-CLAUDE.md מעצבות את מה ש-Claude מנסה לעשות, אך אינן משנות את מה ש-Claude Code מתיר. כדי להעניק או לבטל גישה, השתמש ב-/permissions, בכללים המתוארים כאן, ב-מצב הרשאות, או ב-hook מסוג PreToolUse.

כאשר מצב auto זמין בהפעלה שלך, תיבת הדו-שיח כוללת גם את כללי המסווג של מצב auto. בחר בלשונית Auto mode כדי להציג אותם.

#מצבי הרשאות

Claude Code תומך במספר מצבי הרשאות השולטים באופן שבו הוא מאשר קריאות לכלים. עיין בסעיף מצבי הרשאות כדי לדעת מתי להשתמש בכל אחד מהם. כדי לשנות את המצב שבו הפעלות מתחילות, הגדר את defaultMode ב-קבצי ההגדרות שלך. הסעיף באיזה מצב הפעלה מתחילה מכסה את ברירת המחדל המובנית עבור כל תוכנית ומה תוסף VS Code קורא.

[!WARNING] מצב bypassPermissions מדלג על הנחיות הרשאה, כולל עבור כתיבה ל-נתיבים מוגנים כגון .git ו-.claude. מנגנוני ההגנה על העברת הודעות בין הפעלות עדיין חלים. השתמש במצב זה רק בסביבות מבודדות כגון קונטיינרים או מכונות וירטואליות שבהן Claude Code אינו יכול לגרום נזק.

כדי למנוע את השימוש במצב bypassPermissions או במצב auto, הגדר את permissions.disableBypassPermissionsMode או permissions.disableAutoMode ל-"disable" בכל קובץ הגדרות. הגדרות אלו שימושיות במיוחד ב-הגדרות מנוהלות שבהן לא ניתן לדרוס אותן.

#תחביר כללי הרשאות

כללי הרשאות עוקבים אחר המבנה Tool או Tool(specifier). סוגריים בתוך המאפיין (specifier) הם תוויים מילוליים, כך שפקודה או נתיב המכילים סוגריים אינם דורשים תו מילוט.

#התאמת כל השימושים בכלי

כדי להתאים לכל השימושים בכלי מסוים, השתמש בשם הכלי בלבד ללא סוגריים:

הכלל Bash(*) שווה ערך ל-Bash ומתאים לכל פקודות Bash. ככלל דחייה, שתי הצורות מסירות את הכלי מההקשר של Claude.

#שימוש במאפיינים לשליטה מדויקת

הוסף מאפיין בסוגריים כדי להתאים לשימושים ספציפיים בכלי:

#התאמה לפי פרמטר קלט

כללי דחייה (deny) ושאלה (ask) יכולים להתאים לפרמטר קלט ברמה העליונה בכל כלי מובנה באמצעות Tool(param:value).

כדי להתאים לפרמטר בכלי MCP, העבר כלל דחייה באמצעות --disallowedTools. כאשר Claude Code טוען קובץ הגדרות, הוא מדלג על כל כלל mcp__ המכיל סוגריים. Claude Code מציג את הכלל שדולג בתיבת הדו-שיח של הגדרות לא תקינות בעת הפעלת הפעלה אינטראקטיבית, ובפלט של claude doctor.

כלל פרמטר מתאים כאשר Claude קורא לכלי כאשר אותו פרמטר מוגדר בדיוק לערך זה. כלל allow עבור ערך פרמטר יחיד לא יוכיח שהקריאה בטוחה באופן כללי, ולכן כללי allow ממשיכים להשתמש בתחביר המאפיינים הייעודי של כל כלי. הדבר פועל עבור כל פרמטר סקלרי שהכלי מקבל:

התאמת פרמטרים פועלת לפי הכללים הבאים:

• שם הפרמטר חייב להיות שדה ישיר של קלט הכלי, כגון model בכלי Agent. שדות המקוננים בתוך אובייקט או מערך אינם ניתנים להתאמה.
• כל כלל מציין פרמטר אחד. כדי להגביל גם לפי model וגם לפי isolation, כתוב שני כללים: Agent(model:opus) ו-Agent(isolation:worktree), במקום לשלב אותם בכלל אחד.
• הערך תומך ב-* כתו כוכבית המתאים לכל רצף תווים, כך ש-Agent(isolation:*) מתאים לכל ערך בידוד מפורש. ללא * ההתאמה היא מדויקת.
• פרמטר שהמודל משמיט לעולם אינו מותאם, כך ש-Agent(model:*) אינו מתאים לקריאה שמשאירה את model לא מוגדר.
• הערך מושווה מול הקלט המילולי ש-Claude שולח, לפני כל נרמול. Agent(model:opus) מתאים לכינוי opus אך לא למזהה מודל מלא. הרץ עם --verbose כדי לראות את שמות הפרמטרים והערכים המדויקים בכל קריאת כלי.
• רווחים מסביב לנקודתיים אינם נחשבים.

אינך יכול להתאים לשדה התוכן הראשי של כלי באופן זה: command עבור Bash ו-PowerShell, ‏file_path עבור Read, ‏Edit ו-Write, ‏path עבור Grep ו-Glob, ‏notebook_path עבור NotebookEdit, ו-url עבור WebFetch. כלל כמו Bash(command:rm *) ניתן לעקיפה על ידי פקודה מורכבת, ולכן Claude Code מתעלם ממנו ומפיק אזהרת הפעלה. השתמש במקום זאת ב-Bash(rm *), ‏Read(./path) או WebFetch(domain:host).

#תבניות עם תווי כוכבית

תו * בכלל Bash מתאים לכל טקסט, כולל רווחים, כך שכלל אחד מכסה משפחה של פקודות. כלל ללא * מתאים לפקודה מדויקת אחת.

[!WARNING] מקם את ה-* אחרי תת-הפקודה. ב-git log --oneline main, ‏git היא התוכנית ו-log היא תת-הפקודה, המילה שקובעת מה התוכנית עושה. Claude Code מתאים את כל מה שלפני ה-* הראשון כפי שנכתב, ולכן מילים אלו הן מה שמגביל את הכלל: Bash(git log *) מאפשר רק פקודות git log, ו-Bash(git *) מאפשר כל פקודת git. ‏Claude Code מזהיר בעת ההפעלה מפני כלל אפשור המכיל * לפני תת-הפקודה, כגון Bash(git * main).

כתוב את הפקודה שברצונך ש-Claude יריץ מבלי לשאול, והחלף את החלקים המשתנים ב-*. באמצעות תצורה זו, Claude Code מריץ סקריפטים של npm ו-git commits מבלי לשאול, ומסרב ל-git push:

{
  "permissions": {
    "allow": [
      "Bash(npm run *)",
      "Bash(git commit *)"
    ],
    "deny": [
      "Bash(git push *)"
    ]
  }
}

תו * יכול להופיע בכל מקום בכלל: בהתחלה, באמצע או בסוף. כל שורה מציגה כלל, פקודות שהוא מתאים להן, ופקודות קרובות שהוא אינו מתאים להן:

שלושה כללי התאמה מייצרים שורות אלו:

• ה-* מייצג כל טקסט שנמצא במקומו. ב-Bash(git * main), הוא מייצג את תת-הפקודה, ולכן Claude Code מתאים לכל תת-פקודה של git ולכל אפשרות לפניה. זה כולל את -c, שגורם ל-git להריץ תוכנית שאתה מציין. ב-Bash(* --version), ה-* מייצג את התוכנית, כך שכל תוכנית מתאימה.
• תו * בסוף, עם רווח לפניו, מתאים גם לפקודה הבסיסית. Bash(ls *) מתאים ל-ls, ו-Bash(git log *) מתאים ל-git log. זה מתקיים רק כאשר ה-* שבסוף הוא תו הכוכבית היחיד בכלל: Bash(* --help *) מתאים ל-npm --help x אך לא ל-npm --help.
• הרווח לפני * בסוף הוא חלק מהכלל. Bash(ls *) דורש רווח אחרי ls, ולכן lsof אינו מתאים. ל-Bash(ls*) אין רווח, ולכן הוא מתאים גם ל-lsof.

הסיומת :* היא דרך שוות ערך לכתיבת תו כוכבית בסוף, כך ש-Bash(ls:*) מתאים לאותן פקודות כמו Bash(ls *).

תיבת הדו-שיח של ההרשאות כותבת את הצורה המופרדת ברווח כאשר אתה בוחר "Yes, and don't ask again" עבור קידומת פקודה. צורת ה-:* מזוהה רק בסוף תבנית. בתבנית כמו Bash(git:* push), הנקודתיים נחשבות כתו מילולי ולא יתאימו לפקודות git.

#תווי כוכבית בשמות כלים

כללי deny ו-ask מקבלים גם תבניות glob במיקום של שם הכלי. התבנית חייבת להתאים לשם הכלי המלא: "*" מתאים לכל כלי, ו-"mcp__*" מתאים לכל כלי MCP בכל השרתים. כלי שהותאם על ידי כלל דחיית glob של שם בלבד מוסר מההקשר של Claude, בדיוק כמו שם כלי בלבד, כולל החריג של EndConversation: כלל דחיית glob אינו יכול להסיר אותו כל עוד נותר כלי אחר כלשהו, וכלל ask של glob לעולם אינו שואל לגביו. תצורה זו דוחה כל כלי MCP:

{
  "permissions": {
    "deny": [
      "mcp__*"
    ]
  }
}

כללי allow מקבלים תבניות glob של שם כלי רק לאחר קידומת מילולית של mcp__<server>__. חלק השרת חייב להיות ללא glob כדי שהכלל יציין שרת ספציפי שהגדרת. mcp__puppeteer__* מתאים לכל כלי משרת ה-puppeteer, ו-mcp__github__get_* מתאים לכלי ה-get_ שלו. תבנית glob של allow שאינה מעוגנת כגון "*", "B*" או "mcp__*" מדולגת עם אזהרה ואינה מאשרת דבר באופן אוטומטי.

כלל deny או ask ששם הכלי שלו אינו תואם לאף כלי מוכר מפיק אזהרת הפעלה כדי לתפוס שגיאות הקלדה. שמות כלים המכילים _ או * פטורים מבדיקה זו.

התווית המוצגת עבור כלי בתעתיק ובתיבת הדו-שיח של ההרשאות יכולה להיות שונה משמו הקנוני. לדוגמה, הכלי המתויג כ-Stop Task בתעתיק הוא בעל השם הקנוני TaskStop. כללי הרשאות ו-מתאמי hooks מתאימים לשם הקנוני בלבד, כך שכלל שנכתב כ-Stop Task אינו מתאים. עבור כללי deny ו-ask, אזהרת ההפעלה שלעיל תופסת את אי-ההתאמה. השתמש בשמות הקנוניים המפורטים ב-מדריך הכלים המלא.

#כללי הרשאות ספציפיים לכלים

#Bash

כללי Bash מתאימים לכל טקסט הפקודה, כאשר * מייצג כל טקסט. הסעיף תבניות עם תווי כוכבית מציג לאילו פקודות כל מבנה כלל מתאים והיכן למקם את ה-*. שאר סעיף זה מכסה כיצד Claude Code מתאים פקודות מורכבות, עטיפות, פקודות לקריאה בלבד והפניות.

#פקודות מורכבות

[!TIP] Claude Code מודע לאופרטורים של המעטפת, ולכן כלל כמו Bash(safe-cmd *) לא יעניק לו הרשאה להריץ את הפקודה safe-cmd && other-cmd. מפרידי הפקודות המוכרים הם &&, ||, ;, |, |&, & ומעברי שורה. כלל חייב להתאים לכל תת-פקודה באופן עצמאי.

כללי deny ו-ask חלים כאשר תת-פקודה כלשהי תואמת להם, כולל פקודה המקוננת בתוך תת-מעטפת, החלפת פקודה, או גוף של בקרת זרימה כגון לולאת for. כלל ask כגון Bash(git clean *) עדיין יבקש ממך אישור עבור cd /tmp && git clean -f או echo "$(git clean -f)", אפילו ב-מצב auto.

כאשר אין דבר אחרי && או ||, כגון ב-npm test &&, ‏Claude Code מתייחס לפקודה כבלתי ניתנת לניתוח ואינו מפצל אותה לתת-פקודות לצורך התאמה לכללי allow, ולכן כלל כגון Bash(npm *) אינו מאשר אותה.

כאשר אתה מאשר פקודה מורכבת באמצעות "Yes, and don't ask again", ‏Claude Code שומר כלל נפרד עבור כל תת-פקודה הדורשת אישור, ולא כלל יחיד עבור מחרוזת הפקודה המורכבת המלאה. לדוגמה, אישור של git status && npm test שומר כלל עבור npm test, כך שהפעלות עתידיות של npm test יזוהו ללא תלות במה שמופיע לפני ה-&&. תת-פקודות כגון cd לתוך תת-ספרייה מייצרות כלל Read משלהן עבור אותו נתיב. ניתן לשמור עד 5 כללים עבור פקודה מורכבת אחת.

#עטיפות (Wrappers)

לפני התאמת כללי Bash, ‏Claude Code מסיר קבוצה קבועה של עטיפות, כך שכלל כמו Bash(npm test *) מתאים גם ל-timeout 30 npm test. העטיפות המוסרות הן timeout, time, nice, nohup ו-stdbuf, בנוסף לפקודות המובנות של המעטפת command ו-builtin, וה-noglob של zsh. כל אחת מהן מריצה את הארגומנט שלה כפקודה בפועל. שתי צורות קשורות אינן מוסרות: צורת השאילתה command -v, אשר מחפשת פקודה במקום להריץ אותה, וה-nocorrect של zsh.

Claude Code מסיר גם השמה מובילה של משתני סביבה מסוימים הידועים כבטוחים, כך ש-Bash(npm test *) מתאים ל-NODE_ENV=test npm test. כלל allow לא יתאים מעבר להשמה של כל משתנה אחר. כלל deny או ask מתאים מעבר לכל השמה מובילה, כך ש-Bash(rm *) ב-deny עדיין מתאים ל-FOO=bar rm -rf tmp/.

הפקודה xargs לבדה מוסרת גם כן, כך ש-Bash(grep *) מתאים ל-xargs grep pattern. ההסרה חלה רק כאשר ל-xargs אין דגלים: הפעלה כגון xargs -n1 grep pattern מותאמת כפקודת xargs, ולכן כללים שנכתבו עבור הפקודה הפנימית אינם מכסים אותה.

רשימת עטיפות זו היא מובנית ואינה ניתנת להגדרה. כלי הרצה של סביבות פיתוח כגון direnv exec, devbox run, mise exec, npx ו-docker exec אינם ברשימה. מכיוון שכלים אלו מבצעים את הארגומנטים שלהם כפקודה, כלל כמו Bash(devbox run *) מתאים לכל מה שמגיע אחרי run, כולל devbox run rm -rf .. כדי לאשר עבודה בתוך כלי הרצת סביבה, כתוב כלל ספציפי הכולל הן את כלי ההרצה והן את הפקודה הפנימית, כגון Bash(devbox run npm test). הוסף כלל אחד לכל פקודה פנימית שברצונך לאפשר.

עטיפות הפעלה כגון watch, setsid, ionice ו-flock אינן יכולות לקבל אישור אוטומטי על ידי כלל קידומת כמו Bash(watch *), ולכן במצב Manual הן תמיד מציגות בקשת אישור. אותו הדבר חל על find עם -exec או -delete: כלל Bash(find *) אינו מכסה צורות אלו. כדי לאשר הפעלה ספציפית, כתוב כלל התאמה מדויקת עבור מחרוזת הפקודה המלאה.

#פקודות לקריאה בלבד

Claude Code מזהה קבוצה מובנית של פקודות Bash כפקודות לקריאה בלבד ומריץ אותן ללא בקשת אישור בכל מצב, למעט עבור נתיב המגודר על ידי permissions.blockReadsOutsideWorkingDirectories. הקבוצה כוללת את ls, cat, echo, pwd, head, tail, grep, find, wc, which, diff, stat, du, cd וצורות לקריאה בלבד של git. הקבוצה אינה ניתנת להגדרה. כדי לדרוש בקשת אישור עבור אחת מפקודות אלו, הוסף עבורה כלל ask או deny.

הפניה כגון ls > out.txt מוסיפה בדיקה על היעד. ראה הפניות.

תבניות glob ללא מרכאות מותרות עבור פקודות שכל הדגלים שלהן הם לקריאה בלבד, כך ש-ls *.ts ו-wc -l src/*.py רצות ללא בקשת אישור.

במצב Manual, פקודות מקבוצה זו עדיין מבקשות אישור במקרים הבאים:

• תבניות glob ללא מרכאות עבור פקודות עם דגלים בעלי יכולת כתיבה: פקודות עם דגלים בעלי יכולת כתיבה או יכולת הרצה, כגון find, sort, sed ו-git, מבקשות אישור כאשר ישנו glob ללא מרכאות, מכיוון שה-glob עלול להתרחב לדגל כמו -delete.
• docker המכוון לדמון אחר: צורות לקריאה בלבד של docker מבקשות אישור כאשר הפקודה נושאת דגל הבוחר דמון אחר, כגון -H, --context, או --url ו---connection של Podman.
• file עם דגלים הפותחים נתיבים: file מבקש אישור כאשר הוא מעביר את -m/--magic-file או -f/--files-from, מכיוון שדגלים אלו גורמים ל-file לפתוח את הנתיבים המצוינים בערך הדגל.
• נתיבי רשת ב-Windows: פקודה שהארגומנטים שלה כוללים נתיב רשת (UNC), כגון \\server\share\file, מבקשת אישור מכיוון שגישה לנתיב רשת עלולה לשלוח את פרטי ההתחברות שלך ב-Windows למארח שהוא מציין. אותה בדיקה חלה על פקודות של כלי PowerShell.
• פקודות שהניתוח אינו מצליח לפענח: כאשר Claude Code אינו יכול לפענח פקודה במלואה, הוא מבקש אישור במקום להתייחס לפקודה כפקודה לקריאה בלבד. פקודות הארוכות מ-10,000 תווים תמיד מבקשות אישור מכיוון שהן חורגות ממה שהניתוח מפענח.

פקודת cd לנתיב בתוך ספריית העבודה שלך או ספרייה נוספת היא גם כן לקריאה בלבד, ופקודה מורכבת כגון cd packages/api && ls רצה ללא בקשת אישור כאשר כל חלק עומד בתנאים בפני עצמו. השילובים הבאים מבקשים אישור גם כאשר כל חלק הוא לקריאה בלבד:

• cd עם git: מבקש אישור כאשר ה-cd עובר לספרייה אחרת, מכיוון שהרצת git בספרייה חדשה עלולה להפעיל את ה-hooks של אותה ספרייה. פקודת cd שיעדה מתפענח לספריית העבודה הנוכחית היא פעולה ללא השפעה ואינה מפעילה את בקשת האישור.
• cd עם הפניה: מבקש אישור כאשר Claude Code אינו יכול לקבוע כנגד איזו ספרייה יעד ההפניה מתפענח לאחר ביצוע ה-cd. פקודה שיעד ההפניה היחיד שלה הוא /dev/null, כגון cd app; grep -r pattern . 2>/dev/null, אינה מבקשת אישור, מכיוון ש-/dev/null אינו תלוי בספריית העבודה.

[!WARNING] תבניות הרשאה של Bash המנסות להגביל ארגומנטים של פקודות הן שבריריות. לדוגמה, Bash(curl http://github.com/ *) מתכוון להגביל את curl לכתובות אתר של GitHub, אך לא יתאים לווריאציות כגון:

• אפשרויות לפני ה-URL: curl -X GET http://github.com/...
• פרוטוקול שונה: curl https://github.com/...
• הפניות: curl -L http://short.example.com/xyz, שמפנה ל-GitHub
• משתנים: URL=http://github.com && curl $URL
• רווחים נוספים: curl http://github.com

לסינון אמין יותר של כתובות URL, שקול:

• הגבלת כלי רשת של Bash: השתמש בכללי דחייה כדי לחסום את curl, wget ופקודות דומות, ולאחר מכן השתמש בכלי WebFetch עם הרשאת WebFetch(domain:github.com) עבור דומיינים מורשים.
• שימוש ב-PreToolUse hooks: יישם hook שמאמת כתובות URL בפקודות Bash וחוסם דומיינים שאינם מורשים.
• הוספת הנחיות ב-CLAUDE.md: תאר את תבניות ה-curl המותרות שלך ב-CLAUDE.md. פעולה זו מעצבת את מה ש-Claude מנסה לעשות אך אינה אוכפת גבול, ולכן שלב אותה עם אחת מהאפשרויות שלעיל.

שים לב ששימוש ב-WebFetch לבדו אינו מונע גישה לרשת. אם Bash מותר, Claude עדיין יכול להשתמש ב-curl, wget או כלים אחרים כדי לגשת לכל כתובת URL.

#הפניות (Redirections)

כאשר פקודה מפנה פלט או קלט, Claude Code בודק את יעד ההפניה מול כללי הקבצים שלך כאילו Claude כתב או קרא את אותו קובץ ישירות:

• הפניות פלט: עבור > file, >> file או 2> file, הבדיקה מכסה את כללי ה-allow וה-deny של Edit, נתיבים מוגנים, ו-ספריות העבודה. כלל כגון Bash(git commit *) מאפשר את הפקודה, לא את היעד. יעד המתחיל ב-~ או מכיל תו glob דורש את אישורך.
• הפניות קלט: עבור < file, הבדיקה מכסה את כללי ה-allow וה-deny של Read ואת ספריות העבודה. יעד מחוץ לספריות העבודה דורש את אישורך אלא אם כלל allow מכסה אותו. יעד המכיל תבנית glob, או נתיב יחסי המופיע לאחר cd באותה פקודה, דורש את אישורך גם כאשר כלל allow מכסה אותו. Claude Code בודק יעדי קלט בגרסה v2.1.257 ומעלה.

יעדים שאין מאחוריהם קובץ אינם נבדקים: /dev/null, צורות של מתארי קבצים כגון 2>&1 ו-<&3, וכן here-docs ו-here-strings.

#PowerShell

כללי הרשאה של PowerShell משתמשים באותו מבנה כמו כללי Bash. תווי כוכבית עם * מתאימים בכל מיקום, הסיומת :* שוות ערך ל- * בסוף, ו-PowerShell או PowerShell(*) בלבד מתאימים לכל פקודה. תצורה זו מאפשרת את הפקודות Get-ChildItem ו-git commit תוך חסימת Remove-Item:

{
  "permissions": {
    "allow": [
      "PowerShell(Get-ChildItem *)",
      "PowerShell(git commit *)"
    ],
    "deny": [
      "PowerShell(Remove-Item *)"
    ]
  }
}

כינויים נפוצים מומרים לצורתם הקנונית לפני ההתאמה. כלל שנכתב עבור שם ה-cmdlet מתאים גם לכינויים שלו, כך ש-PowerShell(Get-ChildItem *) מתאים גם ל-gci, ls ו-dir. ההתאמה אינה רגישה לאותיות גדולות/קטנות.

Claude Code מנתח את ה-AST של PowerShell ובודק כל פקודה בפקודה מורכבת באופן עצמאי. אופרטורי צינור |, מפרידי הצהרות ;, וב-PowerShell 7 ומעלה אופרטורי שרשור && ו-|| מפצלים פקודה מורכבת לתת-פקודות. כלל חייב להתאים לכל תת-פקודה כדי שהפקודה המורכבת תאושר.

#קריאה ועריכה (Read and Edit)

כדי לחסום את כלי הקבצים של Claude מקריאת קובץ או ספרייה, הוסף כלל דחייה מסוג Read עבור הנתיב שלו, כגון Read(./.env) או Read(./secrets/**). הסעיף החרגת קבצים רגישים מכיל דוגמה מוכנה להעתקה.

כללי Edit חלים על כל הכלים המובנים שעורכים קבצים. Claude עושה מאמץ מרבי להחיל כללי Read על כל הכלים המובנים שקוראים קבצים כגון Grep ו-Glob, על אזכורי @file בהנחיות שלך, ועל הקשר הבחירה והקבצים הפתוחים שסביבת פיתוח מחוברת (IDE) משתפת עם Claude.

כלל דחייה של Read חוסם גם את כלי Edit ו-Write באותו נתיב, כולל יצירת קובץ חדש שם. NotebookEdit אינו מכוסה, לכן הוסף כלל דחייה מסוג Edit עבור נתיבים שאף כלי אינו רשאי לשנות. הבדיקה דורשת את Claude Code בגרסה v2.1.208 ומעלה עבור עריכות, ובגרסה v2.1.228 ומעלה עבור כתיבות.

Claude Code בודק הרשאות קבצים מול כללי Edit(path) ו-Read(path) בלבד. אם תכתוב במקום זאת כלל נתיב עבור Write, NotebookEdit, Glob או כלי ה-MultiEdit הישן, Claude Code יקבל את הכלל אך לעולם לא יבדוק אותו, ו-יזהיר בעת ההפעלה, למעט כלל Glob המועבר ב---allowedTools. השתמש ב-Edit(docs/**) במקום Write(docs/**), NotebookEdit(docs/**) או MultiEdit(docs/**), וב-Read(docs/**) במקום Glob(docs/**). ‏Claude Code אינו מזהיר לגבי כלל של שם כלי ללא נתיב, כגון כלל דחייה עבור Write. הוא מתאים כלל כזה ברמת הכלי בכל מקום. דורש את Claude Code בגרסה v2.1.210 ומעלה.

[!WARNING] כללי דחייה של Read ו-Edit חלים על כלי הקבצים המובנים של Claude, על פקודות קבצים ש-Claude Code מזהה ב-Bash, כגון cat, head, tail ו-sed, ועל היעדים של הפניות ב-Bash כגון > file ו-< file. הם אינם חלים על תהליכי משנה שרירותיים שקוראים או כותבים קבצים בעקיפין, כמו סקריפט Python או Node שפותח קבצים בעצמו. לאכיפה ברמת מערכת ההפעלה שחוסמת את כל התהליכים מגישה לנתיב, הפעל את ארגז החול.

כללי Read ו-Edit משתמשים שניהם בתחביר תבניות של gitignore עם ארבעה סוגי תבניות נפרדים. עבור תבניות ספרייה בעלות מקטע יחיד, עומק ההתאמה תלוי גם בסוג הכלל, כפי שמתואר בהמשך סעיף זה:

[!WARNING] תבנית כגון /Users/alice/file אינה נתיב מוחלט. הלוכסן המוביל הבודד מעגן במקור ההגדרות, ולא בשורש מערכת הקבצים. השתמש ב-//Users/alice/file עבור נתיבים מוחלטים.

תבנית /path מתעגנת בספרייה המשויכת למקור ההגדרות שמגדיר אותה, כך שאותו כלל מתאים למיקומים שונים בהתאם למקום שבו אתה מציב אותו:

כלל שאתה מוסיף דרך /permissions פועל לפי השורה המתאימה לקובץ ההגדרות שבו אתה שומר אותו.

כללי הגדרות מקומיות מתעגנים ב-ספריית העבודה הראשית של ההפעלה, ולא בשורש המאגר שבו Claude Code שומר את הקובץ בגרסה v2.1.211 ומעלה. בהפעלה שהחלה בשורש המאגר, שתי הספריות זהות. בהפעלת עץ עבודה, כלל משותף כגון Edit(/src/**) מתאים לספריית src/ של אותו עץ עבודה עצמו.

כלל דחייה כגון Read(/secrets/**) בהגדרות משתמש חוסם את ~/.claude/secrets/**, ולא ספריית secrets בפרויקט שלך. כדי לכתוב כלל בהגדרות משתמש שיחול בתוך כל פרויקט, השתמש במקום זאת בנתיב מוחלט עם // או בנתיב יחסי לבית עם ~/.

ב-Windows, נתיבים מומרים לצורת POSIX לפני ההתאמה. C:\Users\alice הופך ל-/c/Users/alice, לכן השתמש ב-//c/**/.env כדי להתאים לקבצי .env בכל מקום באותו כונן. כדי להתאים בכל הכוננים, השתמש ב-//**/.env.

דוגמאות:

• Edit(/docs/**): עריכות ב-<primary working directory>/docs/, ולא ב-/docs/ או ב-<primary working directory>/.claude/docs/.
• Read(~/.zshrc): קורא את ה-.zshrc של ספריית הבית שלך.
• Edit(//tmp/scratch.txt): עורך את הנתיב המוחלט /tmp/scratch.txt.
• Read(src/**): ככלל allow, קורא מ-<current-directory>/src/ בלבד. ככלל deny או ask, מתאים לספריית src בכל עומק תחת הספרייה הנוכחית.

כלל מתאים רק לקבצים תחת העוגן שלו. בתוך גבול זה, עומק ההתאמה תלוי במבנה התבנית, ועבור תבניות ספרייה בעלות מקטע יחיד, בסוג הכלל, כמפורט להלן. שמות קבצים בלבד פועלים לפי הסמנטיקה של gitignore ומתאימים בכל עומק, כך ש-Read(.env) ו-Read(**/.env) שווי ערך:

תבנית יחסית בעלת מקטע ספרייה יחיד, כגון src/**, מתאימה בעומקים שונים בהתאם לסוג הכלל:

• כללי Allow: ‏Edit(src/**) מתאים רק ל-<cwd>/src ולקבצים שתחתיו. כדי לאפשר שם ספרייה בכל עומק, כתוב Edit(**/src/**).
• כללי Deny ו-Ask: ‏Read(secrets/**) מתאים לספרייה בשם secrets בכל עומק תחת הספרייה הנוכחית, כך שהכלל חל גם על עותקים מקוננים.

כל מבנה תבנית אחר מתאים באותו עומק בכל סוג כלל: Edit(/src/**) ו-Edit(src/components/**) מתאימים רק במיקום המעוגן שלהם, בעוד ש-Edit(**/src/**) מתאים בכל עומק.

הדוגמה הבאה מציגה כל מבנה תבנית מול פרויקט עם ספריית src/ ברמה העליונה ועותק מקונן תחת vendor/:

<current-directory>/
├── src/
│   └── app.ts
└── vendor/
    └── pkg/
        └── src/
            └── lib.js

[!NOTE] בתבניות gitignore, ‏* מתאים בתוך מקטע נתיב בודד ויכול להופיע בכל מיקום בתבנית, בעוד ש-** מתאים לרוחב ספריות.

כאשר אתה מאשר נתיב קובץ באמצעות "Yes, and don't ask again", ‏Claude Code מוסיף תווי מילוט לתווי תבנית gitignore באותו נתיב, כגון [, ] ו-*, כך שהכלל שנוצר מתאים רק לנתיב המילולי שאישרת. כללים שאתה כותב בעצמך אינם מקבלים תווי מילוט. לפני גרסה v2.1.202, ‏Claude Code שמר את הנתיב ללא מילוט, כך שכלל שנוצר עבור ספרייה בשם [2024-06] Reports עלול היה להיכשל בהתאמה לנתיב שלו או להתאים לספריות אחיות בלתי מכוונות.

אינך צריך להוסיף מילוט לסוגריים בנתיב, כך ש-Edit(./Finance (2024)/**) מתאים לתיקייה Finance (2024) בדיוק כפי שהיא מאויתת.

כלל deny או ask שהנתיב שלו אינו שמיש כתבנית gitignore עדיין מגן על אותו נתיב מדויק. כלל allow עם תבנית שאינה שמישה אינו מאשר דבר.

כאשר Claude ניגש לקישור סימבולי, כללי ההרשאות בודקים שני נתיבים: הקישור הסימבולי עצמו והקובץ שאליו הוא מתפענח. כללי allow ו-deny מתייחסים לצמד זה באופן שונה: כללי allow חוזרים לבקש ממך אישור, בעוד שכללי deny חוסמים לחלוטין:

• כללי Allow: חלים רק כאשר גם נתיב הקישור הסימבולי וגם היעד שלו מתאימים. קישור סימבולי בתוך ספרייה מורשית המצביע מחוצה לה עדיין יבקש ממך אישור.
• כללי Deny: חלים כאשר נתיב הקישור הסימבולי או היעד שלו מתאימים. קישור סימבולי המצביע על קובץ שנדחה נדחה בעצמו.

לדוגמה, כאשר Read(./project/**) מורשה ו-Read(~/.ssh/**) נדחה, קישור סימבולי ב-./project/key המצביע על ~/.ssh/id_rsa נחסם: היעד נכשל בכלל ה-allow ומתאים לכלל ה-deny.

כאשר כלי פותח קובץ שאושר, Claude Code מוודא שהנתיב עדיין מתפענח למיקום שבדיקת ההרשאות אישרה.

Grep ו-Glob מחפשים בספרייה שהארגומנט path מתפענח אליה. Claude Code מחיל כללי דחייה מסוג Read על אותה ספרייה.

#WebFetch

כללי WebFetch משתמשים בקידומת domain: ומתאימים לשם המארח של כתובת ה-URL המבוקשת. ההתאמה אינה רגישה לאותיות גדולות/קטנות, תומכת בתווי כוכבית *, ומסירה נקודה . בסוף הן מהכלל והן משם המארח, כך ש-example.com. ו-example.com מטופלים באותו אופן:

• WebFetch(domain:example.com) מתאים לבקשות אל example.com.
• WebFetch(domain:*.example.com) מתאים לכל תת-דומיין בכל עומק, כגון api.example.com או a.b.example.com, אך לא ל-example.com עצמו.
• WebFetch(domain:*) מתאים לכל דומיין. הוא אינו זהה לכלל WebFetch ללא מאפיין. ראה אפשור או דחייה של כל אחזור.

בכל מיקום שאינו *. מוביל או * בודד, תו הכוכבית מתאים רק לטקסט שבין שתי נקודות. WebFetch(domain:example.*) מתאים ל-example.org, שבו * הופך ל-org, אך לא ל-example.evil.com, שבו * יצטרך להפוך ל-evil.com ולחצות נקודה. הדבר מונע מתו כוכבית בסוף להתאים לדומיינים שתוקף עלול לרשום.

תווי כוכבית בכללי WebFetch דורשים את Claude Code בגרסה v2.1.172 ומעלה כדי להתאים לאחזורים.

#אפשור או דחייה של כל אחזור

כלל WebFetch ללא מאפיין הוא שם הכלי ללא חלק של domain:, כגון "deny": ["WebFetch"]. הן הוא והן WebFetch(domain:*) מכסים כל כתובת URL, אך Claude Code מחיל אותם באופן שונה, ורק צורת ה-domain: מוסיפה בנוסף את הדומיין שלה אל רשימת הדומיינים המורשים או הנדחים של ארגז החול. אותו סעיף מפרט את צורות תווי הכוכבית שארגז החול מכבד ואת הגרסה שהוסיפה * בודד.

כל שורה מציגה מה כלל עושה ברשימת ה-allow וברשימת ה-deny:

כדי לאפשר ל-Claude לאחזר בחופשיות תוך שמירה על רשימת ההיתרים של ארגז החול כפי שהיא, השתמש בצורה ללא מאפיין. קובץ settings.json זה עושה זאת:

{
  "permissions": {
    "allow": ["WebFetch"]
  }
}

כאשר אתה מבקש מ-Claude לאחזר דף, הוא מאחזר ללא בקשת אישור. כאשר אתה מבקש ממנו להריץ curl ב-ארגז חול מול מארח שמחוץ לרשימת ההיתרים של ארגז החול, Claude Code עדיין יבקש ממך אישור עבור אותו מארח, או ב-מצב auto ישלח את הבקשה למסווג, מכיוון שהכלל ללא מאפיין לא הוסיף את המארח לרשימת ההיתרים.

#MCP

כללי MCP משתמשים בשם השרת כפי שהוגדר ב-Claude Code, ואחריו אופציונלית שם של כלי מאותו שרת:

• mcp__puppeteer מתאים לכל כלי שמסופק על ידי שרת ה-puppeteer.
• mcp__puppeteer__* משתמש בתחביר כוכבית ומתאים גם הוא לכל הכלים משרת ה-puppeteer.
• mcp__puppeteer__puppeteer_navigate מתאים לכלי puppeteer_navigate שמסופק על ידי שרת ה-puppeteer.

אם הארגון שלך הגדיר כלי של מחבר ב-claude.ai ל-ask והגדרה זו מגיעה ל-Claude Code בהפעלה שלך, כללי allow עבור אותו כלי אינם נכנסים לתוקף: Claude Code מבקש אישור בכל קריאה, אפילו במצבי auto ו-bypassPermissions. במצב dontAsk, שלעולם אינו מבקש אישור, Claude Code דוחה את הקריאה במקום זאת. כלים ממחברים ש-Claude Code מאחזר בעצמו מופיעים כ-mcp__claude_ai_<server>__<tool>.

בהפעלת Cowork באפליקציית שולחן העבודה של Claude, Claude מריץ פקודות מעטפת דרך הכלי mcp__workspace__bash של Cowork במקום הכלי המובנה Bash, ו-Cowork מספק באופן דומה את mcp__workspace__web_fetch עבור אחזורי רשת. Claude Code מחיל גם כללי דחייה המציינים את הכלי Bash או WebFetch במלואו על כלי Cowork אלו, כך שכלל דחייה מנוהל של Bash מונע מ-Claude להריץ פקודות מעטפת ב-Cowork. כאשר Claude Code חוסם קריאה כזו, ההודעה מציינת את שם הכלי של Cowork: ‏Permission to use mcp__workspace__bash has been denied.. כללי allow אינם מועברים: Claude Code לעולם אינו מחיל כלל אפשור של Bash על mcp__workspace__bash.

#Agent (סוכני משנה)

השתמש בכללי Agent(AgentName) כדי לשלוט באילו סוכני משנה Claude יכול להשתמש:

• Agent(Explore) מתאים לסוכן המשנה Explore.
• Agent(Plan) מתאים לסוכן המשנה Plan.
• Agent(my-custom-agent) מתאים לסוכן משנה מותאם אישית בשם my-custom-agent.

הוסף כללים אלו למערך ה-deny בהגדרות שלך או השתמש בדגל ה-CLI בשם --disallowedTools כדי להשבית סוכנים ספציפיים. כדי להשבית את סוכן Explore:

{
  "permissions": {
    "deny": ["Agent(Explore)"]
  }
}

#Cd

כללי Cd שולטים לאילו ספריות הפקודה /cd יכולה להעביר את ההפעלה. Cd אינו כלי שהמודל יכול להפעיל: Claude אינו יכול לקרוא לו, והכללים חלים רק כאשר אתה מריץ את /cd בעצמך.

כלל דחייה של Cd ללא מאפיין משבית את /cd לחלוטין. כלל דחייה של Cd(<path-pattern>) חוסם יעדים תואמים. כללי דחייה בודקים כל איות של היעד, כולל כל דילוג בקישור סימבולי שדרכו הוא מתפענח, כך שכלל שנכתב עבור נתיב אחד חוסם גם יעדים שמתפענחים אליו.

הוספת כלל allow כלשהו של Cd מעבירה את /cd למצב רשימת היתרים: ספריית היעד המפוענחת חייבת להתאים לאחד מכללי ה-allow שלך, אחרת /cd יסרב. כאשר לא מוגדרים כללי Cd, ‏/cd שומר על התנהגות ברירת המחדל שלו ומבקש ממך לתת אמון בספרייה לא מוכרת.

תבניות נתיב חולקות את העוגנים //, ~/ ו-/ מ-כללי Read ו-Edit, אך ההתאמה מעוגנת לכל נתיב הספרייה ולא בסגנון gitignore. תו * מתאים בדיוק למקטע נתיב אחד ו-** מתאים לאורך מקטעים. סיומת /** מתאימה גם לשורש המצוין שלה.

#הרחבת הרשאות באמצעות hooks

Hooks של Claude Code מאפשרים לך לרשום פקודות מעטפת מותאמות אישית שמעריכות הרשאות בזמן ריצה. כאשר Claude Code מבצע קריאה לכלי, ה-hooks מסוג PreToolUse רצים לפני בקשת אישור ההרשאה, עבור כל כלי למעט EndConversation. פלט ה-hook יכול לדחות את קריאת הכלי, לחייב בקשת אישור, או לדלג על בקשת האישור כדי לאפשר לקריאה להמשיך.

החלטות של hook אינן עוקפות את כללי ההרשאות. Claude Code מעריך כללי deny ו-ask ללא קשר למה ש-PreToolUse hook מחזיר: כלל deny תואם חוסם את הקריאה, וכלל ask תואם עדיין מבקש אישור גם כאשר ה-hook החזיר "allow" או "ask". הדבר שומר על קדימות הדחייה תחילה המתוארת בסעיף ניהול הרשאות, כולל כללי דחייה שהוגדרו בהגדרות מנוהלות.

כלי MCP המסומנים כ-requiresUserInteraction עדיין מבקשים אישור גם כאשר hook מחזיר "allow", וכך גם כלי מחבר שהארגון שלך הגדיר כ-ask בהפעלות שבהן הגדרה זו מגיעה ל-Claude Code.

בנוסף, hook חוסם מקבל עדיפות על פני כללי allow. ‏Hook שמסתיים עם קוד יציאה 2 עוצר את קריאת הכלי לפני שכללי ההרשאות מוערכים, כך שהחסימה חלה גם כאשר כלל allow היה מאפשר לקריאה להמשיך. כדי להריץ את כל פקודות Bash ללא בקשות אישור למעט כמה בודדות שברצונך לחסום, הוסף את "Bash" לרשימת ה-allow שלך ורשום PreToolUse hook שדוחה את אותן פקודות ספציפיות. ראה חסימת עריכות לקבצים מוגנים עבור סקריפט hook שתוכל להתאים.

#ספריות עבודה

כברירת מחדל, ל-Claude יש גישה לקבצים בספרייה שבה הפעלת אותו. ספרייה זו היא ספריית העבודה הראשית של ההפעלה עד שאתה מעביר את ההפעלה באמצעות /cd. באפשרותך להרחיב גישה זו:

• במהלך ההפעלה: השתמש בארגומנט ה-CLI בשם --add-dir <path>.
• במהלך הפעלה פעילה: השתמש בפקודה /add-dir.
• תצורה קבועה: הוסף ל-additionalDirectories ב-קבצי הגדרות.

קבצים בספריות נוספות פועלים לפי אותם כללי הרשאות של ספריית העבודה המקורית: הם הופכים לקריאים ללא בקשת אישור, והרשאות עריכת קבצים פועלות לפי מצב ההרשאות הנוכחי.

אינך יכול להוסיף את רוב נתיבי הרשת, כגון שיתוף UNC של \\server\share, כספריות עבודה, מכיוון שחיפוש בהם עלול ליצור קשר עם המארח שהם מציינים. ב-Windows, מפה את השיתוף לאות כונן במקום זאת והעבר את הכונן עם --add-dir בעת ההפעלה.

הגדר את permissions.blockReadsOutsideWorkingDirectories כדי לגרום לכלי הקבצים לסרב לנתיבים שהוא מגדר בכל מצב הרשאות. במצב auto, ‏Claude Code מציע להפעיל זאת בפעם הראשונה ש-Claude קורא מחוץ לספריות העבודה.

בהפעלות רקע ב-macOS, מארח ההפעלה מבקש גישה לתיקיות מוגנות כגון ~/Desktop, ~/Documents ו-~/Downloads בנפרד מהטרמינל שלך כאשר Claude צריך לקרוא או לכתוב קבצים שם. אם פעולות קריאה שם נכשלות עם Operation not permitted, ראה כיצד להעניק גישה לתיקיות עבור הפעלות רקע.

#העברת ההפעלה לספרייה אחרת

כדי להעביר את ההפעלה לספריית עבודה ראשית אחרת, במקום להוסיף ספרייה לצד הנוכחית, הרץ /cd <path>. ‏Claude Code שומר על השיחה, טוען את קובץ ה-CLAUDE.md של הספרייה החדשה, ומבקש ממך לתת אמון בסביבת העבודה אם לא עבדת בה בעבר. לאחר מכן, Claude Code מוצא את ההפעלה שהועברה כאשר אתה מריץ --resume מהספרייה החדשה. הפקודה /cd דורשת את Claude Code בגרסה v2.1.169 ומעלה.

ברגע שאתה עובר, Claude Code מחיל את תצורת הפרויקט של הספרייה החדשה:

• הגדרות הפרויקט שלה, כולל כללי ההרשאות שלהן ו-ה-hooks.
• שרתי ה-.mcp.json שלה, בכפוף לאותו אישור שרתים כמו בעת ההפעלה, ואת שרתי ה-MCP ב-טווח מקומי שרשמת בה.
• ה-תוספים שההגדרות שלה מפעילות, ה-מיומנויות שלה, ו-סוכני המשנה שלה.
• ערכי ה-env שלה, המוחלים מעל משתני הסביבה מהגדרות הספרייה הקודמת, אשר נשארים בתוקף.

Claude Code מנתק בנוסף את שרתי ה-MCP של הפרויקט וב-טווח מקומי של הספרייה הקודמת, ואת השרתים של תוספים שאינם מופעלים עוד לאחר המעבר. הוא לוקח ספריות נוספות מהגדרות הספרייה החדשה במקום מאלו של הקודמת, ושומר על הספריות שהוספת באמצעות --add-dir או /add-dir. ‏Hooks שהמעבר מפעיל עדיין מקבלים את ${CLAUDE_PROJECT_DIR} כשהוא מוגדר לשורש הפרויקט שבו ההפעלה החלה.

כאשר הספרייה החדשה עדיין אינה מהימנה, Claude Code מפרט בהנחיית האמון את כללי ה-allow, הספריות הנוספות, ה-hooks ופקודות העזר שהגדרות הספרייה יפעילו, כך שתוכל לבדוק אותם לפני שתאשר. אם תדחה, ההפעלה תישאר היכן שהיא. לפני גרסה v2.1.246, ‏/cd לא החיל את ההגדרות, ה-hooks, שרתי ה-MCP או המיומנויות של הספרייה החדשה עד שחידשת את ההפעלה, והנחיית האמון שלו לא פירטה מה הגדרות הספרייה יפעילו.

הגבל או השבת יעדי /cd באמצעות כללי הרשאת Cd.

#ספריות נוספות מעניקות גישה לקבצים, לא לתצורה

הוספת ספרייה מרחיבה את המקומות שבהם Claude יכול לקרוא ולערוך קבצים. היא אינה הופכת את אותה ספרייה לשורש תצורה מלא: רוב התצורה של .claude/ אינה מתגלה מתוך ספריות נוספות, אם כי סוגים בודדים נטענים כחריגים.

חריגים אלו חלים רק על ספריות שנוספו באמצעות הדגל --add-dir או הפקודה /add-dir, כולל ספריות שערכת ה-Agent SDK מוסיפה דרך הדגל. ספריות המפורטות ב-permissions.additionalDirectories בקובץ הגדרות מעניקות גישה לקבצים בלבד ואינן טוענות אף אחד מרכיבי התצורה שלהלן.

האפשרות additionalDirectories של Agent SDK ב-TypeScript והאפשרות add_dirs ב-Python מקבלות את החריגים גם כן, אף על פי שאפשרות TypeScript חולקת את שמה עם מפתח ההגדרות. ה-SDK מעביר כל רשומה אל Claude Code כ---add-dir, כך שספריות אלו מתנהגות כמו ספריות שנוספו באמצעות דגל. מיומנויות, פקודות וסוכני משנה מכל ספרייה שנוספה באמצעות דגל נטענים דרך מקור ההגדרות מסוג project, כך שהם אינם נטענים כאשר אתה מחריג מקור זה באמצעות --setting-sources ב-CLI או settingSources ב-SDK, ו-מצב bare מדלג על הפקודות וסוכני המשנה שביניהם.

סוגי התצורה הבאים נטענים מספריות של --add-dir:

כדי לטעון את המיומנויות, הפקודות וסוכני המשנה מתת-ספרייה של ספריית העבודה הראשית שלך במהלך ההפעלה, הרץ /add-dir עם הנתיב של אותה תת-ספרייה. Claude Code טוען אותם למשך שארית ההפעלה מבלי לבקש ממך אישור או להוסיף ספריית עבודה, מכיוון שתת-הספרייה כבר ניתנת לקריאה. פעולה זו דורשת את Claude Code בגרסה v2.1.257 ומעלה.

Claude Code מגלה סגנונות פלט מספריית העבודה הנוכחית ומספריות האב שלה, מספריית המשתמש שלך ב-~/.claude/, ומהגדרות מנוהלות. ‏Hooks ומפתחות אחרים ב-.claude/settings.json נטענים מתיקיית .claude/ של ספריית העבודה הנוכחית ללא חזרה לספריית אב, לצד ~/.claude/settings.json של המשתמש שלך והגדרות מנוהלות. קובץ .claude/settings.local.json נטען במקום זאת משורש מאגר ה-git, גם כאשר אתה מפעיל את Claude Code בתת-ספרייה, למעט במקרים שבהם Claude Code אינו משתמש בשורש המאגר, כגון ב-Windows. לפני גרסה v2.1.211, גם הוא נטען מספריית העבודה הנוכחית בלבד. הפעלות של Agent SDK טוענות אותו מספריית העבודה בכל הגרסאות.

כדי לשתף תצורה זו בין פרויקטים, השתמש באחת מהגישות הבאות:

• תצורה ברמת המשתמש: הנח קבצים ב-~/.claude/agents/, ~/.claude/output-styles/ או ~/.claude/settings.json כדי להפוך אותם לזמינים בכל פרויקט.
• תוספים: ארוז והפץ תצורה בתור תוסף שצוותים יכולים להתקין.
• הפעלה מספריית התצורה: הרץ את Claude Code מהספרייה המכילה את תצורת ה-.claude/ הרצויה.

#כיצד הרשאות מקיימות אינטראקציה עם ארגז חול

הרשאות ו-ארגז חול הן שכבות אבטחה משלימות:

• הרשאות שולטות באילו כלים Claude Code יכול להשתמש ולאילו קבצים או דומיינים הוא יכול לגשת. הן חלות על Bash, Read, Edit, WebFetch, MCP וכל כלי אחר, למעט העובדה שכלל deny או ask אינו יכול לחסום את EndConversation כל עוד נותר כלי אחר כלשהו.
• ארגז חול מספק אכיפה ברמת מערכת ההפעלה המגבילה את הגישה למערכת הקבצים ולרשת של הכלי Bash. הוא חל רק על פקודות Bash ותהליכי הבת שלהן.

השתמש בשניהם להגנה לעומק:

• כללי דחיית הרשאות חוסמים את Claude מראש מניסיון לגשת
• כללי דחיית הרשאות חוסמים את Claude מראש מניסיון לגשת למשאבים מוגבלים.
• מגבלות ארגז החול מונעות מפקודות Bash להגיע למשאבים מחוץ לגבולות המוגדרים, אפילו אם הזרקת הנחיות עוקפת את קבלת ההחלטות של Claude.
• מגבלות מערכת הקבצים בארגז החול משלבות את הגדרות sandbox.filesystem עם כללי דחייה של Read ו-Edit. שתיהן ממוזגות אל תוך גבול ארגז החול הסופי.
• מגבלות רשת משלבות כללי הרשאה של WebFetch(domain:...) עם רשימות allowedDomains ו-deniedDomains של ארגז החול.

כאשר אתה מפעיל את ארגז החול ומשאיר את autoAllowBashIfSandboxed בערך ברירת המחדל שלו שהוא true, פקודות Bash בארגז החול רצות ללא בקשת אישור אפילו אם ההרשאות שלך כוללות כלל ask של Bash בלבד, או את הצורה השקולה Bash(*): גבול ארגז החול מחליף את אותה בקשת אישור של הכלי כולו.

ב-מצב plan, ‏Claude Code מדלג על החלפה זו. ללא כלל ask, ‏הפקודות המובנות לקריאה בלבד עדיין רצות ללא בקשת אישור, וכל פקודת מעטפת אחרת עוברת דרך תהליך ההרשאות הרגיל בזמן שאתה עדיין מתכנן. ראה מצב plan לגבי האופן שבו Claude Code מגביל פקודות שם. עם כלל ask של Bash בלבד, כל פקודת Bash מבקשת אישור, כולל פקודות לקריאה בלבד בארגז החול, בדיוק כמו מחוץ לארגז החול. לפני גרסה v2.1.212, ההחלפה חלה גם במצב plan.

בדיקות אלו עדיין חלות:

• כללי ask התחומים לתוכן כמו Bash(git push *) עדיין מחייבים בקשת אישור.
• כללי deny מפורשים עדיין חלים.
• פקודות rm או rmdir המכוונות אל נתיב קריטי עדיין עוברות דרך תהליך ההרשאות הרגיל.

פקודות שלא ירוצו בתוך ארגז החול, כגון פקודות מוחרגות, מכבדות כרגיל את כלל ה-ask של Bash בלבד. ראה מצבי ארגז חול כדי לשנות התנהגות זו.

#הגדרות מנוהלות

עבור ארגונים הזקוקים לשליטה מרכזית, מנהלי מערכת פורסים הגדרות מנוהלות שהגדרות משתמש ופרויקט אינן יכולות לדרוס, מלבד מספר מפתחות רגישים מבחינה אבטחתית. הסעיף פריסת הגדרות מנוהלות מכסה את מנגנוני המסירה, את סדר הקדימויות בתוך השכבה המנוהלת, ואת המפתחות שרק הגדרות מנוהלות יכולות להגדיר.

אחד ממפתחות אלו, allowManagedPermissionRulesOnly, הופך את ההגדרות המנוהלות למקור ההגדרות היחיד עבור כללי הרשאות. התיעוד שלו מפרט כל מקור ש-Claude Code מתעלם ממנו במקרה זה.

ההגדרה disableBypassPermissionsMode ממוקמת בדרך כלל בהגדרות מנוהלות כדי לאכוף מדיניות ארגונית, אך היא פועלת מכל טווח. משתמש יכול להגדיר אותה בהגדרות שלו כדי לנעול את עצמו מחוץ למצב bypass.

#קדימות הגדרות

כללי הרשאות פועלים לפי אותו סדר קדימות הגדרות כמו כל שאר הגדרות Claude Code, כאשר הגדרות מנוהלות הן הגבוהות ביותר: אף רמה אחרת, כולל ארגומנטים של שורת הפקודה, אינה יכולה לדרוס כלל הרשאה מנוהל.

אם כלי נדחה ברמה כלשהי, אף רמה אחרת אינה יכולה לאפשר אותו. לדוגמה, דחייה בהגדרות מנוהלות אינה ניתנת לדריסה על ידי --allowedTools, ו---disallowedTools יכול להוסיף מגבלות מעבר למה שההגדרות המנוהלות מגדירות.

אותו הדבר נכון גם בין טווחי הגדרות: אם הגדרות משתמש מאפשרות הרשאה והגדרות פרויקט דוחות אותה, כלל הדחייה חוסם אותה. ההפך נכון גם כן: דחייה ברמת המשתמש חוסמת אפשור ברמת הפרויקט, מכיוון שכללי דחייה מכל טווח מוערכים לפני כללי אפשור.

מארחים מוטמעים יכולים לספק מדיניות מנוהלת נוספת באמצעות אפשרות ה-SDK בשם managedSettings, כולל כללי אפשור הרשאות, אלא אם מנהל המערכת הגדיר את נעילות allowManaged*Only. הסעיף מסירת מדיניות להפעלות Claude Desktop מכסה מתי מדיניות מארח מוטמע חלה בכלל.

#כללי אפשור של פרויקט ואמון בסביבת עבודה

כללי permissions.allow ורשומות permissions.additionalDirectories בקובץ .claude/settings.json של פרויקט מעניקים יכולות, ולכן Claude Code מחיל אותם רק לאחר שאישרת את תיבת הדו-שיח של מתן אמון בסביבת העבודה עבור אותה תיקייה. תיבת הדו-שיח מפרטת את הכללים והספריות שהתיקייה תעניק, כך שתוכל לבדוק אותם תחילה. כללי deny ו-ask אינם מושפעים, מכיוון שהם רק מגבילים.

Claude Code ממפתח ושומר את האמון שאישרת בהתאם למקום שבו הפעלת אותו:

• בתוך מאגר, Claude Code ממפתח את האמון על שורש מאגר ה-git, כך שהאמון מכסה את כל המאגר מלבד כל מאגר git המקונן בתוכו, כגון submodule. ב-עץ עבודה, הוא משתמש בשורש של ה-checkout הראשי, כפי שהוא עושה עבור כללים שמורים.
• מחוץ למאגר, Claude Code ממפתח את האמון על הספרייה שממנה הפעלת אותו, והאמון מכסה כל תת-ספרייה של אותה ספרייה מלבד כל מאגר git המקונן בתוכה, כגון clone. כל תת-ספרייה מכוסה נחשבת אז כתיקייה שההורה שלה מהימן עליך.
• כאשר אתה מפעיל בספריית הבית שלך, Claude Code שומר את האמון להפעלה הנוכחית בלבד ואינו כותב אותו לדיסק. ראה את הערת אמצעי הגנה נוספים.

Claude Code מציג את תיבת הדו-שיח של האמון בהפעלות אינטראקטיביות בלבד. הרצת claude -p או הפעלת SDK לעולם אינן מציגות אותה, ומתן אמון בתיקיית אב אינו נחשב עבור כללים אלו, ולכן הסעיף מה רץ לפני שאתה נותן אמון בתיקייה מציין באיזה תוכן מאגר Claude Code עדיין משתמש בכל אחד משני מצבים אלו.

#מתי קובץ ההגדרות המקומיות שלך זקוק לאמון

הקובץ .claude/settings.local.json הוא בדרך כלל קובץ שלך, ולכן Claude Code מחיל את כללי ה-allow שלו ואת הספריות הנוספות ללא שלב האמון. כאשר הקובץ נמצא במעקב ב-git, או כאשר .claude הוא קישור סימבולי, Claude Code מתייחס אליו כקובץ שסופק על ידי המאגר ומשהה את הכללים שלו עד שתיתן אמון בתיקייה.

Claude Code מריץ את git כדי להבדיל בין השניים, והוא מריץ את git רק לאחר שנתת אמון בתיקייה: אישרת את תיבת הדו-שיח של האמון עבורה או עבור ספריית אב שהאמון שלה מתרחב אליה, או שאתה נמצא בהפעלת -p או SDK, הנחשבת כמאושרת. עד אז, המקום שבו הפעלת את Claude Code קובע מה יקרה לכללי הקובץ:

• בבית התצורה שלך: Claude Code מחיל את ה-.claude/settings.local.json של אותה תיקייה באופן מיידי מבלי להריץ את git. בית התצורה שלך הוא ספריית הבית שלך, או ספרייה שתת-ספריית ה-.claude שלה הוגדרה כ-CLAUDE_CONFIG_DIR. אם ספריית CLAUDE_CONFIG_DIR זו נמצאת בתוך מאגר git ו-Claude Code שומר את ההגדרות המקומיות שלך בשורש המאגר במקום זאת, הוא משהה את הכללים כמו בכל מקום אחר.
• בכל מקום אחר: Claude Code משהה את כללי הקובץ כמו הגדרות פרויקט. לאחר שהבדיקה רצה, Claude Code מחיל את הכללים של קובץ שאינו במעקב, או של קובץ בספרייה שמחוץ לכל מאגר git, אף על פי שלא נתת אמון באותה תיקייה מדויקת.

[!NOTE] החריג של בית התצורה מדלג על שלב האמון בלבד. הקובץ ~/.claude/settings.local.json עדיין בעל טווח מקומי, כך ש-Claude Code קורא אותו רק בהפעלות שאתה מתחיל בספריית הבית שלך עצמה, ולא בכל פרויקט. כדי להחיל כללי הרשאות בכל הפרויקטים שלך, הוסף אותם במקום זאת להגדרות המשתמש שלך: ~/.claude/settings.json, או $CLAUDE_CONFIG_DIR/settings.json כאשר CLAUDE_CONFIG_DIR מוגדר.

בגרסאות 2.1.196 עד 2.1.199, ‏Claude Code השהה את כללי הקובץ גם בבית התצורה שלך ומחוץ למאגרי git, והדפיס שם את האזהרה this workspace has not been trusted. לפני גרסה v2.1.207, ‏Claude Code החיל את הכללים של קובץ שאינו במעקב לפני שאישרת את תיבת הדו-שיח.

#מה רץ לפני שאתה נותן אמון בתיקייה

כל שורה היא סוג אחד של תוכן שמאגר יכול לספק. העמודות הן שני המצבים שבהם לא נתת אמון בתיקייה עצמה: נתת אמון רק בתיקיית אב, או שהרצת שם claude -p או את ה-SDK, שלעולם אינם מציגים את תיבת הדו-שיח של האמון. עמודת תיקיית האב אינה חלה בתוך מאגר מקונן: בהפעלה אינטראקטיבית Claude Code מציג את תיבת הדו-שיח של האמון עבורו, והרצת claude -p או SDK שם פועלת לפי עמודת claude -p:

עבור השורות הדורשות מתן אמון בתיקייה מדויקת זו, תן בה אמון באופן ידני: הגדר את projects["<path>"].hasTrustDialogAccepted ל-true ב-~/.claude.json, כאשר <path> הוא שורש המאגר, או התיקייה עצמה מחוץ למאגר. Claude Code מדפיס את המפתח המדויק בשורת יומן הניפוי עבור hook של סוכן משנה או שרת MCP מוטבע שדולגו, באזהרת ה-stderr עבור כללי allow שדולגו, ובשורת headersHelper not run עבור helper שדולג.

לפני שאתה מריץ claude -p במאגר שלא אתה כתבת, החלט מה מותר לו להריץ במחשב שלך:

• העבר --setting-sources user, או הגדר את ה-settingSources של ה-SDK ללא הגדרות פרויקט, כדי ש-Claude Code לא יקרא את קבצי ההגדרות של הפרויקט ולא את ה-.mcp.json שלו.
• התחל עם --bare כדי ש-Claude Code לא יקרא hooks, מיומנויות, פקודות מותאמות אישית, סוכני משנה, תוספים או שרתי .mcp.json מהפרויקט. בלוק ה-env של הפרויקט ועוזרים כגון awsAuthRefresh בקבצי ההגדרות שלו עדיין חלים, ו-Claude Code קורא את apiKeyHelper רק מ---settings.
• העבר --settings '{"disableAllHooks": true}' כדי לבטל hooks עבור אותה הרצה. הגדרתו בהגדרות המשתמש שלך בלבד אינה מספיקה, מכיוון שהגדרות הפרויקט של המאגר מקבלות קדימות על פני שלך ויכולות להחזיר אותו ל-false.
• הוסף רשומת disabledMcpjsonServers כדי לדחות שרת .mcp.json לפי שמו בכל סוגי ההפעלות.

#תצורות לדוגמה

מאגר זה כולל תצורות הגדרות ראשוניות לתרחישי פריסה נפוצים. השתמש בהן כנקודות התחלה והתאם אותן לצרכים שלך.

#ראה גם

• מפרט הגדרות: כל מפתח הגדרות, כולל מפתחות ההרשאות
• הגדרת מצב auto: ספר למסווג של מצב auto באיזו תשתית הארגון שלך נותן אמון
• ארגז חול: בידוד מערכת קבצים ורשת ברמת מערכת ההפעלה עבור פקודות Bash
• אימות: הגדרת גישת משתמשים ל-Claude Code
• אבטחה: אמצעי הגנה ושיטות עבודה מומלצות לאבטחה
• Hooks: אוטומציה של תהליכי עבודה והרחבת הערכת הרשאות