השתמשו ב-Agent SDK כדי להריץ את Claude Code באופן תכנותי מה-CLI, מ-Python או מ-TypeScript.
ה-Agent SDK נותן לכם את אותם כלים, לולאת סוכן וניהול הקשר שמפעילים את Claude Code. הוא זמין כ-CLI לסקריפטים ול-CI/CD, או כחבילות Python ו-TypeScript לשליטה תכנותית מלאה.
כדי להריץ את Claude Code במצב לא אינטראקטיבי, העבירו -p עם הפרומפט שלכם ועם אפשרויות ה-CLI שאתם צריכים:
claude -p "Find and fix the bug in auth.py" --allowedTools "Read,Edit,Bash"
הדף הזה עוסק בשימוש ב-Agent SDK דרך ה-CLI (claude -p). לחבילות ה-SDK של Python ו-TypeScript עם פלטים מובנים, callbacks לאישור כלים ואובייקטי הודעות מקוריים, ראו את תיעוד Agent SDK המלא.
הוסיפו את הדגל -p (או --print) לכל פקודת claude כדי להריץ אותה באופן לא אינטראקטיבי. לא כל אפשרות CLI משתלבת עם -p. Claude Code דוחה את --bg, ודוחה את --cloud עם תיאור משימה, עם שגיאה שמציינת את הקונפליקט. --cloud עם מזהה סשן ו--p במקום זאת מכניס הודעה לתור של סשן הענן הזה ויוצא. אפשרויות שתשלבים לעתים קרובות עם -p כוללות:
הדוגמה הזו שואלת את Claude שאלה על בסיס הקוד שלכם ומדפיסה את התשובה:
claude -p "What does the auth module do?"
Claude Code יוצא עם קוד 0 בהצלחה ועם קוד שאינו אפס כשההרצה נכשלת, כך שהסקריפטים שלכם יכולים להסתעף לפי סטטוס היציאה. אם מעבירים דגל לא תקין, Claude Code מדווח על השגיאה ל-stderr לפני שההרצה מתחילה. כשכשל קורה בתוך ההרצה, למשל אימות חסר, Claude Code מדפיס את הכשל כתוצאה ב-stdout.
הוסיפו --bare כדי לקצר את זמן ההפעלה על ידי דילוג על גילוי אוטומטי של hooks, skills, פקודות מותאמות, subagents, תוספים מותקנים, שרתי MCP, auto memory ו-CLAUDE.md. בלי הדגל, claude -p מגלה וטוען אותם כמו שסשן אינטראקטיבי היה עושה, כולל כל מה שמוגדר בתיקיית העבודה או ב-~/.claude.
מצב bare שימושי ל-CI ולסקריפטים שבהם צריך את אותה תוצאה בכל מכונה. hook ב-~/.claude של חבר צוות או שרת MCP ב-.mcp.json של הפרויקט לא ירוצו, כי מצב bare אף פעם לא קורא אותם. תיקייה שאתם מציינים עם --add-dir היא חריג חלקי: מצב bare טוען skills מתיקיית .claude/skills/ שלה, אבל עדיין מדלג על תיקיות .claude/commands/ ו-.claude/agents/ שלה. Skills מתיקיות נוספות מכסה מה נטען ומה לא.
בלי --bare, סשן -p מריץ את ה-hooks ב-.claude/settings.json של פרויקט ומתחבר לשרתים ב-.mcp.json שלו, גם בתיקייה שמעולם לא נתתם בה אמון. סשן -p לא מציג דיאלוג אמון בסביבת העבודה ולא בקשת אישור לכל שרת. מה רץ לפני שנותנים אמון בתיקייה מכסה כל סוג של תוכן מאגר תחת -p ואיך להשאיר אותו בחוץ.
הדוגמה הזו מריצה משימת סיכום חד פעמית במצב bare ומאשרת מראש את כלי Read כדי שהקריאה תושלם בלי בקשת הרשאה. הגדירו את ANTHROPIC_API_KEY לפני ההרצה, כי מצב bare לא משתמש בהתחברות המנוי שלכם:
claude --bare -p "Summarize README.md" --allowedTools "Read"
במצב bare, Claude Code אף פעם לא קורא אישורי OAuth או את מחזיק המפתחות של המערכת. עבור Anthropic API, הגדירו את ANTHROPIC_API_KEY בסביבה, עם מפתח שנוצר ב-Claude Console, או ספקו apiKeyHelper ב-JSON של --settings. Amazon Bedrock, Agent Platform של Google Cloud ו-Microsoft Foundry ממשיכים לקרוא את אישורי הספק שלהם כרגיל.
במצב bare ל-Claude יש גישה לכלי Bash, לקריאה מקבצים ולעריכת קבצים. העבירו את ההקשר שאתם צריכים עם דגל:
Hooks עדיין לא רצים במצב bare כשמעבירים אותם עם --settings, או ב-hooks/hooks.json או במפתח המניפסט hooks של תוסף שטוענים עם דגל. אל תשתמשו במצב bare להרצה שצריכה אותם.
מצב bare גם מגביל את מה שקורה בזמן שהסשן רץ:
שרתי MCP: רק שרתים שסופקו בשורת הפקודה מתחברים, למשל עם --mcp-config. בסשן אינטראקטיבי, Claude Code גם מדלג על חיבור ה-IDE האוטומטי אלא אם מעבירים --ide.
תזכורות מערכת: Claude מקבל את הפרומפטים שלכם ואת תוצאות הכלים בלי תזכורות המערכת ש-Claude Code היה מוסיף לצידן. למשל, Claude לא מקבל הודעה כשקובץ שקרא קודם משתנה בדיסק, והוא לא מקבל את רשימת ה-skills הזמינים, כולל skills מתיקיית --add-dir.
לפני v2.1.286, המגבלות האלה החזיקו רק חלקית: סשן --bare אינטראקטיבי התחבר לשרתי MCP שסשן רגיל היה מתחבר אליהם, כל סשן --bare שלח תזכורות מערכת, ומשימות רקע נשארו זמינות.
[!NOTE]
--bare הוא המצב המומלץ לקריאות מסקריפט ומ-SDK, והוא יהפוך לברירת המחדל עבור -p במהדורה עתידית.
אחרי ש-Claude מסיים את התור שלו ו-stdin נסגר, הרצת claude -p יכולה להישאר פתוחה כדי להמתין לעבודת רקע ש-Claude התחיל.
אלא אם פקודת רקע שהשיחה הראשית התחילה עדיין רצה, Claude Code עוצר כברירת מחדל את מה שעדיין רץ אחרי 10 דקות של המתנה רציפה בלי פעילות ומוותר על התוצאה החלקית שלה. כדי לשנות את תקרת 10 הדקות, הגדירו את CLAUDE_CODE_PRINT_BG_WAIT_CEILING_MS, או הגדירו אותו ל-0 כדי להמתין בלי תקרה.
ההרצה ממתינה לעבודת רקע כמו פקודות רקע, subagents ו-workflows, מעקבי Monitor, והתעוררויות /loop ממתינות:
פקודות רקע: עבור פקודה שהשיחה הראשית התחילה, למשל שרת פיתוח או בניית watch, ההרצה ממתינה עד שהפקודה יוצאת או מגיעה למגבלת הזמן שלה. אחר כך Claude לוקח עוד תור אחד עם התוצאה. בזמן שהפקודה רצה, תקרת 10 הדקות לא מסיימת את ההמתנה.
subagents ו-workflows ברקע: ההרצה נשארת פתוחה עד שהעבודה הזו מסתיימת, כי התוצאה שלה היא חלק מהפלט הסופי.
מעקבי Monitor: ההרצה ממתינה עד שהמעקב מגיע ל-timeout או שתקרת 10 הדקות מסיימת את ההמתנה, מה שקורה קודם. בזמן ההמתנה, Claude ממשיך להגיב למה שהמעקב מדווח. כברירת מחדל, מעקב מגיע ל-timeout חמש דקות אחרי ש-Claude מתחיל אותו.
התעוררויות ממתינות: בהרצה שהפרומפט שלה הועבר כטקסט ולא עם --input-format stream-json, כש-Claude תזמן התעוררות /loop בקצב עצמי, ההרצה ממתינה לכל התעוררות שתתרחש ומריצה את האיטרציה שלה עד שהלולאה מסתיימת, גם מעבר לתקרת 10 הדקות.
כש-stderr הוא מסוף וההרצה המתינה חמש שניות, Claude Code מדפיס שורה ל-stderr שמתחילה ב-Waiting for background work to finish ומציינת את העבודה. עם פלט json או stream-json, השורה מודפסת רק כש-stdout אינו מסוף, כך שה-JSON שהסקריפט שלכם קורא אף פעם לא נושא אותה.
אם ההרצה מגיעה לתקרת --max-budget-usd שלה, Claude Code עוצר את עבודת הרקע שנותרה במקום להמתין.
כשעבודת רקע מתחילה תור נוסף, ההרצה מדפיסה את תוצאת כל תור עם פלט text ברירת המחדל ואת תוצאת התור האחרון עם פלט json. לפני v2.1.295, ההרצה הדפיסה רק את תוצאת התור האחרון גם עם פלט text.
אם עוצרים הרצת claude -p עם SIGTERM, למשל עם kill או ממפקח תהליכים, Claude Code יוצא עם קוד 143. Claude Code משאיר את התור שהיה בתהליך לא גמור ולא רושם עבורו תוצאה. כדי לסיים את התור במקום זאת, שלחו SIGINT, או קראו ל-interrupt() של Agent SDK, לפני שאתם עוצרים את התהליך.
ב-SIGTERM, Claude Code מסיים את עץ התהליכים של כל פקודת Bash שעדיין רצה. אחר כך Claude Code מריץ hooks של SessionEnd ויוצא. בזמן היציאה, Claude Code לא מתחיל קריאת כלי חדשה, לא שולח בקשת מודל חדשה, ולא מריץ hook מלבד SessionEnd. אם ההרצה הייתה באמצע פקודה או המתינה לבקשת הרשאה כשהאות הגיע, Claude Code מטפל בשלב הזה כך:
הרצת פקודה: Claude Code רושם את הפקודה כנהרגת בסשן.
המתנה לתשובה לבקשת הרשאה: אם שולחים SIGTERM לתהליך, Claude Code משאיר את הבקשה בלי מענה. אם התוכנית שלכם סוגרת את הסשן דרך Agent SDK, ה-SDK מסיים את הקלט של Claude Code לפני שליחת אות כלשהו, ו-Claude Code מבטל את הבקשה ברגע שהקלט מסתיים.
אם תיקיית העבודה של סשן claude -p או Agent SDK נמחקת באמצע הסשן, הסשן ממשיך לרוץ. כשתור מתחיל בזמן שהתיקייה חסרה, Claude Code פולט הודעת אזהרה בפלט stream-json, ופקודות מעטפת נכשלות עד שהתיקייה קיימת שוב.
הדוגמאות האלה מדגישות דפוסי CLI נפוצים. כשפקודה מציינת קובץ כמו auth.py או build-error.txt, החליפו בקובץ מהפרויקט שלכם. ב-CI או בסביבות סקריפט אחרות, הוסיפו --bare כדי ש-Claude Code יתחיל בלי לטעון hooks, תוספים, auto memory או CLAUDE.md של המארח.
מצב לא אינטראקטיבי קורא את stdin, כך שאפשר להזרים נתונים פנימה ולהפנות את התשובה החוצה כמו כל כלי שורת פקודה אחר.
הדוגמה הזו מזרימה יומן בנייה אל Claude וכותבת את ההסבר לקובץ:
cat build-error.txt | claude -p 'concisely explain the root cause of this build error' > output.txt
עם --output-format json, מטען התשובה כולל את total_cost_usd ופירוט עלות לפי מודל, כך שקוראים מסקריפט יכולים לעקוב אחרי הוצאה בלי להתייעץ בלוח השימוש. כשממשיכים שיחה קודמת עם --continue או --resume, ההרצה מדווחת על הסכום הכולל של השיחה, כולל ההוצאה של הרצות קודמות. שני המספרים הם הערכות בצד הלקוח ויכולים להיות שונים מהחשבון בפועל.
[!NOTE]
stdin שמוזרם בצינור מוגבל ל-10MB. אם חורגים מהתקרה, Claude Code יוצא עם שגיאה ברורה וסטטוס שאינו אפס. כדי לעבוד עם קלטים גדולים יותר, כתבו את התוכן לקובץ והפנו לנתיב הקובץ בפרומפט במקום להזרימו בצינור.
אם Claude Code לא יכול לקרוא את stdin, למשל כי התהליך שהתחיל אותו ניתק את הצד שלו, Claude Code מדפיס אזהרה ל-stderr וממשיך עם הפרומפט משורת הפקודה.
אפשר לעטוף קריאה לא אינטראקטיבית בסקריפט כדי להשתמש ב-Claude כ-linter או כסוקר ייעודי לפרויקט.
סקריפט package.json הזה מזרים את ה-diff מול main אל Claude ומבקש ממנו לדווח על שגיאות כתיב. הזרמת ה-diff אומרת ש-Claude לא צריך הרשאת Bash כדי לקרוא אותו, והמרכאות הכפולות עם escape שומרות על הסקריפט נייד ל-Windows:
{
"scripts": {
"lint:claude": "git diff main | claude -p \"you are a typo linter. for each typo in this diff, report filename:line on one line and the issue on the next. return nothing else.\""
}
}
השתמשו ב---output-format כדי לשלוט באופן החזרת התשובות:
text (ברירת מחדל): פלט טקסט רגיל
json: JSON מובנה עם תוצאה, מזהה סשן ומטא-נתונים
stream-json: JSON מופרד בשורות להזרמה בזמן אמת
הדוגמה הזו מחזירה סיכום פרויקט כ-JSON עם מטא-נתוני סשן, כשתוצאת הטקסט בשדה result:
claude -p "Summarize this project" --output-format json
כדי לקבל פלט שתואם לסכמה מסוימת, השתמשו ב---output-format json עם --json-schema והגדרת JSON Schema. התשובה כוללת מטא-נתונים על הבקשה (מזהה סשן, שימוש וכו') עם הפלט המובנה בשדה structured_output.
הדוגמה הזו מחלצת שמות פונקציות ומחזירה אותם כמערך של מחרוזות:
claude -p "Extract the main function names from auth.py" \
--output-format json \
--json-schema '{"type":"object","properties":{"functions":{"type":"array","items":{"type":"string"}}},"required":["functions"]}'
אם הערך אינו JSON Schema תקין, claude יוצא עם Error: --json-schema is not a valid JSON Schema ואחריו האבחון של המאמת. Claude Code מקבל סכמות שמשתמשות במילת המפתח format, כמו "format": "email", אבל מתייחס ל-format כהערה ולא אוכף אותו.
אם הרצה מסתיימת בלי פלט מובנה תקין, למשל כי Claude דחה את הבקשה, אין בתשובה שדה structured_output. לפני שהסקריפט שלכם משתמש ב-structured_output, בדקו שהשדה קיים.
[!TIP]
השתמשו בכלי כמו jq כדי לנתח את התשובה ולחלץ שדות מסוימים:
# Extract the text result
claude -p "Summarize this project" --output-format json | jq -r '.result'
# Extract structured output
claude -p "Extract function names from auth.py" \
--output-format json \
--json-schema '{"type":"object","properties":{"functions":{"type":"array","items":{"type":"string"}}},"required":["functions"]}' \
| jq '.structured_output'
השתמשו ב---output-format stream-json יחד עם --verbose ו---include-partial-messages כדי לקבל טוקנים בזמן שהם נוצרים. כל שורה היא אובייקט JSON שמייצג אירוע:
claude -p "Explain recursion" --output-format stream-json --verbose --include-partial-messages
השורה האחרונה בזרם היא הודעת result עם טקסט התגובה הסופי, העלות ומטא נתונים של הסשן.
אם הצרכן שלכם קורא את הזרם לאט, Claude Code ממתין שהפלט שבתור יתרוקן לפני היציאה, ומרחיב את ההמתנה לפי כמה עדיין נמצא בתור, עד תקרה של 30 שניות.
הדוגמה הבאה משתמשת ב-jq כדי לסנן דלתאות טקסט ולהציג רק את הטקסט שמוזרם. הדגל -r מוציא מחרוזות גולמיות (בלי מרכאות) ו--j משרשר בלי שורות חדשות, כך שהטוקנים זורמים ברצף:
claude -p "Write a poem" --output-format stream-json --verbose --include-partial-messages | \
jq -rj 'select(.type == "stream_event" and .event.delta.type? == "text_delta") | .event.delta.text'
הודעות מ-subagents ומ-skills שרצות ב-subagent מופיעות בזרם כהודעות assistant ו-user. השדה parent_tool_use_id שלהן אומר לאיזו הרצה כל אחת שייכת. הודעות מהשיחה הראשית נושאות null בשדה הזה.
ההודעה הראשונה מ-skill מפוצל (forked skill), או מ-subagent שרץ בחזית, היא הודעת user שנושאת את ה-prompt או את תוכן ה-skill שמניע אותה. אחרי ההודעה הראשונה הזו, Claude Code פולט:
כברירת מחדל: בלוקי tool_use ו-tool_result של ההרצה.
כשמפעילים אחת מהאפשרויות, Claude Code מעביר הודעות מ-subagents בכל עומק קינון, בין אם כל אחד נוצר עם כלי Agent ובין אם התחיל כ-skill מפוצל. ב-parent_tool_use_id, הודעות של subagent מקונן נושאות את המזהה של קריאת כלי Agent או Skill שהתחילה אותו, כך שאפשר לבנות מחדש את עץ הקינון המלא על ידי מעקב אחרי המזהים האלה.
הרצה ש-Claude מתחיל בקריאת כלי נושאת את המזהה של קריאת הכלי הזו. skill מפוצל שאתם מתחילים על ידי העברת /<skill-name> כ-prompt אין לו קריאת כלי, ולכן ההודעות שלו נושאות ערך forked-command- במקום, ומגיעות אחרי שהוא מסתיים. מצאו איך ההרצה התחילה בעמודה הראשונה:
איך ההרצה מתחילה
parent_tool_use_id
מתי ההודעות שלה מגיעות
Claude קורא לכלי Agent מהשיחה הראשית
המזהה של בלוק tool_use של Agent הזה
בזמן שה-subagent עובד
Claude קורא לכלי Skill עבור skill מפוצל מהשיחה הראשית
המזהה של בלוק tool_use של Skill הזה
בזמן שה-skill המפוצל עובד
אתם מעבירים /<skill-name> כ-prompt
ערך שמתחיל ב-forked-command-
יחד ובסדר אחרי שה-skill המפוצל מסתיים
עבור skill מפוצל שהתחיל מה-prompt, התאימו את parent_tool_use_id לפי הקידומת forked-command-, כי השם שאחריה יכול להיות שונה מזה שהקלדתם.
אם חלק מההודעות האלה חסרות בזרם שלכם, בדקו את גרסת Claude Code מול המינימום הבאים:
skill מפוצל ש-Claude מתחיל עם כלי Skill מהשיחה הראשית: v2.1.86 או חדש יותר עבור בלוקי tool_use ו-tool_result שלו, ו-v2.1.265 או חדש יותר עבור הודעת user הראשונה שלו ועבור בלוקי הטקסט והחשיבה שלו
הודעות של subagents ש-skill מפוצל יוצר, ושל skills מפוצלים שהתחילו בתוך subagent או skill מפוצל אחר: v2.1.275 או חדש יותר
הודעות של skill מפוצל שאתם מתחילים על ידי העברת /<skill-name> כ-prompt: v2.1.287 או חדש יותר
כשבקשת API נכשלת עם שגיאה שאפשר לנסות שוב, Claude Code פולט אירוע system/api_retry לפני הניסיון החוזר. ב-v2.1.246 או חדש יותר, כש-401 או ``403 דוחים אישור [apiKeyHelper](https://code.claude.com/docs/en/settings-reference#apikeyhelper), Claude Code מבצע את שני הניסיונות החוזרים הראשונים בשקט בלי אירוע, ואז פולט את האירוע כרגיל מהניסיון החוזר הרצוף השלישי ואילך. הניסיונות השקטים עדיין נספרים ב-attempt`. אפשר להשתמש באירוע כדי להציג התקדמות של ניסיונות חוזרים בממשק שלכם.
שדה
סוג
תיאור
type
"system"
סוג ההודעה
subtype
"api_retry"
מזהה שזה אירוע ניסיון חוזר
attempt
integer
מספר הניסיון הנוכחי, מתחיל ב-1
max_retries
integer
סך הניסיונות החוזרים המותרים לסיבה של הכשל הזה
retry_delay_ms
integer
מילישניות עד הניסיון הבא
error_status
integer או null
קוד סטטוס HTTP של הניסיון שנכשל, או null כשהניסיון לא קיבל תגובת HTTP מה-API
no_response
object, אופציונלי
קיים רק כשהניסיון שנכשל לא קיבל כותרות תגובה בזמן. waited_ms הוא כמה זמן הניסיון הזה חיכה ו-retry_wait_ms הוא כמה זמן הניסיון החוזר יחכה. דורש Claude Code v2.1.261 או חדש יותר
האירוע גם נושא מערך אופציונלי capabilities של מחרוזות שמציינות את התנהגויות הפרוטוקול שהגרסה הזו של Claude Code מממשת, כמו interrupt_receipt_v1 או interrupt_cancel_queued_v1. בדקו אותו כדי לזהות יכולות במקום להשוות מחרוזות גרסה, והתעלמו מערכים שאינכם מזהים. ראו SDKSystemMessage לרשימת היכולות.
השתמשו בשדות התוספים באירוע system/init כדי לתפוס תוסף שלא נטען:
שדה
סוג
תיאור
plugins
array
תוספים שנטענו בהצלחה, כל אחד עם name ו-path
plugin_errors
array
שגיאות בזמן טעינת תוסף, כל אחת עם plugin, type ו-message. כולל גרסאות תלות שלא סופקו וכשלי טעינה של --plugin-dir כמו נתיב חסר או ארכיון לא תקין. תוסף שלא נטען נעדר מ-plugins. המפתח מושמט כשאין שגיאות
כשספריית --plugin-dir או ארכיון עצמו נכשל בטעינה, רשומת plugin_errors שלו כוללת את הנתיב המוחלט שנפתר כ-path. השתמשו בו כדי לדעת איזה מבין כמה ערכי --plugin-dir נכשל. השדה path דורש Claude Code v2.1.283 או חדש יותר.
השתמשו בשדות שרת MCP באותו אופן. כשמעבירים --mcp-config עם -p, Claude Code ממתין לשרתים שעדיין ממתינים לפני הרצת התור הראשון, עד פסק הזמן של ההפעלה MCP_TIMEOUT, 30 שניות כברירת מחדל. שרת מרוחק עם רשימת כלים במטמון מדלג על ההמתנה, מציג pending ב-system/init, ומתחבר בקריאת הכלי הראשונה שלו. בסביבה self-hosted, המתנה קצרה יותר חלה במקום. ההמתנה דורשת Claude Code v2.1.221 או חדש יותר.
Claude Code מאמת כל רשומת --mcp-config בהפעלה ומדלג על רשומות שנכשלות באימות, למשל רשומת url בלי type. ההרצה ממשיכה ויוצאת בצורה נקייה, אז בדקו את השדות האלה כדי לתפוס שרת שמעולם לא נטען:
שדה
סוג
תיאור
mcp_servers
array
שרתי MCP בסשן, כל אחד עם name ו-status
mcp_server_errors
array
רשומות --mcp-config שדולגו בגלל אימות תצורה, כל אחת עם name, type ו-message. type הוא קטגוריית דילוג כמו unknown_type, url_missing_type, invalid_config או reserved_name. התייחסו לערכים שאינכם מזהים כדילוג כללי. שרתים מושפעים נעדרים מ-mcp_servers. המפתח מושמט כשאין שגיאות, כך ששער CI יכול להיכשל על מערך לא ריק
כשמריצים את הפקודה בעצמכם בטרמינל, Claude Code גם מדפיס אזהרת הפעלה ל-stderr, כמו Warning: 1 MCP server skipped due to invalid config:, ואחריה הסיבה לכל רשומה שדולגה.
כשמפנים את stderr, או כשתוכנית כמו רץ CI או מארח SDK לוכדת אותו, Claude Code לא מדפיס אזהרה. הוא מדווח על הרשומות שדולגו רק בשדה mcp_server_errors.
כש-CLAUDE_CODE_SYNC_PLUGIN_INSTALL מוגדר, Claude Code פולט אירועי system/plugin_install בזמן שתוספי marketplace מותקנים לפני התור הראשון. השתמשו בהם כדי להציג התקדמות התקנה בממשק שלכם.
שדה
סוג
תיאור
type
"system"
סוג ההודעה
subtype
"plugin_install"
מזהה שזה אירוע התקנת תוסף
status
"started", "installed", "failed" או "completed"
started ו-completed תוחמים את ההתקנה הכוללת. installed ו-failed מדווחים על marketplaces בודדים
השתמשו ב---allowedTools כדי לאפשר ל-Claude להשתמש בכלים מסוימים בלי בקשת אישור. ציון Read ו-Edit מאפשר ל-Claude לקרוא ולערוך קבצים בלי לבקש הרשאה, מלבד קריאות מנתיבי רשת. ציון Bash עושה אותו דבר עבור פקודות מעטפת, חוץ מהרצה שמתחילה במצב auto, שם Claude Code משמיט רשומת Bash חשופה ככלל הרשאה רחב, ומצב auto מעריך כל פקודה במקום. הדוגמה הזו מריצה חבילת בדיקות ומתקנת כשלים עם שלושת הכלים האלה ברשימה:
claude -p "Run the test suite and fix any failures" \
--allowedTools "Bash,Read,Edit"
כדי להגדיר בסיס לכל הסשן במקום לציין כלים בודדים, העבירו מצב הרשאות עם --permission-mode, כמו auto, dontAsk או acceptEdits:
auto: העבירו --permission-mode auto כדי שמסווג יסקור את רוב הפעולות במקומכם
dontAsk: Claude Code דוחה כל קריאה שהייתה אחרת מבקשת אישור, וזה שימושי להרצות CI נעולות, אם כי mod שהתקנתם עדיין יכול לאשר חלק מהקריאות האלה. כדי לבדוק אילו קריאות mod יכול לאשר, ראו Extend permissions with hooks.
acceptEdits: Claude כותב קבצים בלי בקשת אישור, ו-Claude Code מאשר אוטומטית פקודות מערכת קבצים נפוצות כמו mkdir, touch, mv ו-cp. הפעולות שאף מצב לא מאשר אוטומטית עדיין חלות. מלבד קבוצת הפקודות לקריאה בלבד, פקודות מעטפת אחרות ובקשות רשת עדיין צריכות רשומת --allowedTools או כלל permissions.allow. ראו מה acceptEdits מאשר אוטומטית לרשימה המלאה
הדוגמה הזו מחילה תיקוני lint עם acceptEdits כבסיס:
claude -p "Apply the lint fixes" --permission-mode acceptEdits
העבירו --permission-prompts none כשאף אחד לא זמין לענות לבקשות הרשאה, למשל במשימה מתוזמנת. הדגל חשוב במיוחד כשלהרצה שלכם יש מארח הרשאות: אפליקציית Agent SDK עם callback של canUseTool, או כלי MCP שאתם מעבירים עם --permission-prompt-tool. בלי הדגל, ההרצה שלכם ממתינה שהמארח הזה יענה לכל בקשת הרשאה.
עם הדגל, ההרצה שלכם לא מתייעצת עם המארח ולא ממתינה לו. כל דבר שהיה מבקש אישור נדחה אלא אם hook של PermissionRequest מתיר אותו, ל-Claude נאמר שאף אחד לא יכול לאשר את הבקשה ושלא לנסות אותה שוב, וההרצה ממשיכה. בהרצת -p בלי מארח, הבקשות האלה נדחות בכל מקרה, והדגל גם אומר ל-Claude לא לנסות אותן שוב. כללי הרשאה, hooks של PermissionRequest, ומצב ההרשאות שהגדרתם עדיין מחליטים על כל קריאה קודם. Claude Code דוחה רק את הבקשות ששום דבר אחר לא פותר.
הדוגמה הזו מריצה משימה ללא השגחה במצב auto. המסווג סוקר כל פעולה כרגיל, ו-Claude Code דוחה כל דבר שהיה נופל חזרה לבקשת אישור:
claude -p "Update the dependency pins and run the tests" --permission-mode auto --permission-prompts none
הדוגמה הזו סוקרת שינויים שנמצאים ב-stage ויוצרת commit עם הודעה מתאימה:
claude -p "Look at my staged changes and create an appropriate commit" \
--allowedTools "Bash(git diff *),Bash(git log *),Bash(git status *),Bash(git commit *)"
דגל --allowedTools משתמש בתחביר כללי הרשאה. ה- * שבסוף מאפשר התאמת קידומת, כך ש-Bash(git diff *) מתיר כל פקודה שמתחילה ב-git diff. הרווח לפני * חשוב: בלעדיו, Bash(git diff*) היה מתאים גם ל-git diff-index.
[!NOTE]
תמיכת הפקודות שונה במצב -p:
skills ופקודות מותאמות שהמשתמש מפעיל עובדות. כללו את /skill-name במחרוזת הפרומפט, ו-Claude Code מרחיב אותה לפני ההרצה.
פקודות מובנות שרצות רק בממשק הטרמינל, כמו /login, אינן זמינות.
/model, /effort, /fast, /color ו-/rename מקבלים את הערך כארגומנט, לדוגמה /model sonnet, ו-/mcp בלי ארגומנט מדפיס סיכום טקסט של סטטוס השרת. הצורות האלה עוקבות אחרי הערות הזמינות של כל פקודה.
כדי לשנות הגדרה, העבירו key=value אל /config, לדוגמה /config thinking=false.
/output-style <style> מחליף סגנונות פלט ו-/output-style לבד מציג אותם ברשימה. דורש Claude Code v2.1.269 או חדש יותר.
השתמשו ב---append-system-prompt כדי להוסיף הנחיות תוך שמירה על התנהגות ברירת המחדל של Claude Code. הדוגמה הזו מעבירה בצינור diff של PR אל Claude ומנחה אותו לסקור חולשות אבטחה. שמרו אותה כסקריפט shell, לדוגמה review.sh:
gh pr diff "$1" | claude -p \
--append-system-prompt "You are a security engineer. Review for vulnerabilities." \
--output-format json
בסקריפט, "$1" מייצג את הארגומנט הראשון שאתם מעבירים בשורת הפקודה. הריצו bash review.sh 123 וה-shell מחליף את "$1" ב-123, כך שהסקריפט מביא את ה-diff של PR 123. Claude Code מדפיס את הסקירה כ-JSON, עם הטקסט בשדה result.
השתמשו ב---continue כדי להמשיך את השיחה האחרונה, או ב---resume עם מזהה session כדי להמשיך שיחה מסוימת. ב-Claude Code v2.1.257 או חדש יותר, כשמעבירים --continue, Claude Code פותח session ברקע שהסתיים, אבל לא session שעדיין רץ. הדוגמה הזו מריצה סקירה, ואז שולחת פרומפטים המשך:
# First request
claude -p "Review this codebase for performance issues"
# Continue the most recent conversation
claude -p "Now focus on the database queries" --continue
claude -p "Generate a summary of all issues found" --continue
אם מריצים כמה שיחות, תפסו את מזהה ה-session כדי לחדש אחת מסוימת:
session_id=$(claude -p "Start a review" --output-format json | jq -r '.session_id')
claude -p "Continue that review" --resume "$session_id"