🤖 פרק 12

אוטומציה, סקריפטים וצנרת CLI

ערכת Agent SDK מעניקה את אותם הכלים, אותה לולאת סוכן ואותו ניהול הקשר שמפעילים את קלוד קוד. היא זמינה ככלי שורת פקודה (CLI) עבור סקריפטים ותהליכי CI/CD, או כחבילות Python ו-TypeScript לשליטה תכנותית מלאה.

להרצת קלוד קוד במצב לא אינטראקטיבי, מעבירים את הדגל -p יחד עם ההנחיה והאפשרויות הנדרשות משורת הפקודה:

claude -p "Find and fix the bug in auth.py" --allowedTools "Read,Edit,Bash"

חלק זה מתמקד בשימוש ב-Agent SDK דרך שורת הפקודה באמצעות claude -p. לחבילות SDK בשפות Python ו-TypeScript עם פלט מובנה, פונקציות חזרה לאישור כלים ואובייקטי הודעות מקוריים, עיינו בתיעוד המלא של Agent SDK.

#שימוש בסיסי

מוסיפים את הדגל -p (או --print) לכל פקודת claude כדי להריץ אותה באופן לא אינטראקטיבי.

לא כל אפשרות CLI משתלבת עם -p. קלוד קוד דוחה את --bg, ודוחה את --cloud עם תיאור משימה, בשגיאה שמציינת את ההתנגשות. --cloud עם מזהה סשן ו--p מכניס הודעה לתור של סשן הענן הזה ויוצא.

אפשרויות שנפוץ לשלב עם -p:

• הדגל --continue להמשך שיחות.
• הדגל --allowedTools (כינוי: --allowed-tools) לאישור מראש של כלים.
• הדגל --output-format לקבלת פלט מובנה.
• הדגל --session-id עם UUID תקין, כשסקריפט צריך מזהה קבוע מראש.
• הדגל --no-session-persistence כדי שלא לשמור את הסשן לדיסק ולא לאפשר חידוש. מצב print בלבד. משתנה הסביבה CLAUDE_CODE_SKIP_PROMPT_HISTORY עושה את אותו הדבר בכל מצב.
• הדגל --model לקביעת המודל לסשן: כינוי כמו sonnet, opus, haiku או fable, או שם מלא של מודל. דורס את ההגדרה model ואת ANTHROPIC_MODEL.
• הדגל --fallback-model לשרשרת נפילה אוטומטית כשהמודל הראשי עמוס או אינו זמין, למשל מודל שיצא משימוש. רשימה מופרדת בפסיקים, לפי הסדר. דורס את ההגדרה fallbackModel. כדי לשמור שרשרת בין סשנים משתמשים בהגדרה fallbackModel.

דוגמה זו שואלת את קלוד שאלה על בסיס הקוד ומדפיסה את התשובה:

claude -p "What does the auth module do?"

קלוד קוד יוצא עם קוד 0 בהצלחה, ועם קוד שאינו אפס כאשר הריצה נכשלת, וכך סקריפטים יכולים להסתעף לפי סטטוס היציאה. אם מועבר דגל שאינו חוקי, קלוד קוד מדווח על השגיאה ל-stderr לפני תחילת הריצה. כאשר כשל מתרחש בתוך הריצה עצמה, כמו היעדר אימות, קלוד קוד מדפיס את הכשל כתוצאה ל-stdout.

claude --help אינו מציג כל דגל. היעדר דגל מ---help אינו אומר שהוא אינו זמין.

#הגבלות והרשאות בריצה לא מלווה

• --max-turns מגביל את מספר התורות (מצב print בלבד). בלי הדגל אין מגבלה. עם --input-format stream-json, הודעה שעדיין בתור כשהמגבלה מסיימת תור נשארת בתור ומתחילה תור חדש עם מגבלה משלו.
• --max-budget-usd הוא תקרת דולרים לקריאות API לפני עצירה (מצב print בלבד). קלוד קוד בודק את התקרה מול אומדן העלות בצד הלקוח, שיכול להיות שונה מהחשבון. הוצאת סוכני משנה נספרת. ההוצאה יכולה לעבור את התקרה, לכן משאירים מרווח. בסשן שחוזרים אליו עם --continue או --resume, סכומים ששוחזרו מריצות קודמות אינם נספרים לתקרה. כשההוצאה מגיעה לתקרה, הפעלת סוכן משנה נוסף נכשלת עם Budget limit reached, וקלוד קוד עוצר סוכני משנה ברקע שעדיין רצים. התנהגויות אכיפת התקרה דורשות קלוד קוד v2.1.217 ומעלה.
• --permission-mode קובע באיזה מצב הרשאות להתחיל. מקבל default, acceptEdits, plan, auto, dontAsk, bypassPermissions, או manual ככינוי ל-default. הכינוי manual בוחר את המצב שהממשק מתייג כ-Manual ודורש קלוד קוד v2.1.200 ומעלה. claude --help מציג את manual במקום default, ושני הערכים עובדים. דורס את defaultMode מקובצי ההגדרות. מקלוד קוד v2.1.302 ומעלה, ריצת claude -p מתחילה במצב Manual כאשר שום דבר אינו קובע מצב הרשאות.
• --permission-prompts קובע מי עונה על שאלות הרשאה במצב print. ברירת המחדל host שולחת אותן למארח Agent SDK או לכלי --permission-prompt-tool. none מתאים כשאין מי שיענה, וקלוד קוד דוחה את השאלות. דורש קלוד קוד v2.1.259 ומעלה.
• --permission-prompt-tool מצביע על כלי MCP שמטפל בשאלות הרשאה במצב לא אינטראקטיבי. מעבירים את השם המלא, כמו mcp__<server>__<tool>, של כלי בשרת MCP שהריצה טוענת. קלוד קוד ממתין לחיבור שרת ה-MCP של הכלי לפני התור הראשון, עד MCP_TIMEOUT, 30 שניות כברירת מחדל. הכלי אינו יכול לאשר כלי MCP שמסומן כדורש אינטראקציה של משתמש: תוצאת allow לכלי כזה הופכת לדחייה. המגבלה הזו דורשת קלוד קוד v2.1.199 ומעלה.
• --restricted מיועד ל-harness שעל מכונה משותפת, כשקלוד קוד אינו אמור להריץ פקודות או לקרוא הגדרות משתמש ופרויקט של המכונה. קלוד קוד מסיר את הכלים המובנים שמריצים פקודות או קוד, וגם את WebFetch, אלא אם מציינים אותם בשמם ב---tools, לא דרך הערכה default. כלי הקבצים המובנים מוגבלים לתיקיות העבודה. נטענות רק הגדרות מנוהלות ו---settings. bypassPermissions נדחה, וגם יצירת סשני ענן נדחית. דורש קלוד קוד v2.1.248 ומעלה.

hooks לפני השיחה:

• --init מריץ Setup hooks עם ה-matcher init לפני הסשן. מצב print בלבד.
• --maintenance מריץ Setup hooks עם ה-matcher maintenance לפני הסשן. מצב print בלבד.
• --init-only מריץ Setup ו-SessionStart ואז יוצא בלי להתחיל שיחה.

#הפעלה מהירה במצב bare

הוספת הדגל --bare מקצרת את זמן העלייה על ידי דילוג על גילוי אוטומטי של hooks, סקילים, פקודות מותאמות אישית, סוכני משנה, תוספים מותקנים, שרתי MCP, זיכרון אוטומטי וקובץ CLAUDE.md. הדגל מגדיר את CLAUDE_CODE_SIMPLE. בלי דגל זה, claude -p טוען את אותו ההקשר שסשן אינטראקטיבי היה טוען, כולל כל מה שמוגדר בתיקיית העבודה או בנתיב ~/.claude.

מצב bare שימושי לסביבות CI ולסקריפטים שבהם נדרשת אותה תוצאה בדיוק בכל מכונה. hook שמוגדר בנתיב ~/.claude של חבר צוות או שרת MCP מקובץ .mcp.json של הפרויקט לא ירוצו, כי מצב bare לעולם אינו קורא אותם. תיקייה ששמה צוין באמצעות הדגל --add-dir מהווה חריג חלקי: מצב bare טוען סקילים מתוך תיקיית .claude/skills/ שלה, אך עדיין מדלג על התיקיות .claude/commands/ ו-.claude/agents/ שלה.

בלי --bare, סשן -p מריץ את ה-hooks מתוך קובץ .claude/settings.json של הפרויקט ומתחבר לשרתים מתוך .mcp.json, אפילו בתיקייה שמעולם לא הוגדרה כמהימנה. סשן -p אינו מציג תיבת אישור אמון לסביבת העבודה ואינו מציג בקשת אישור לכל שרת.

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

claude --bare -p "Summarize README.md" --allowedTools "Read"

במצב bare, קלוד קוד לעולם אינו קורא נתוני אימות של OAuth או את מחסן הסיסמאות של מערכת ההפעלה. עבור Anthropic API, מגדירים את ANTHROPIC_API_KEY בסביבה עם מפתח שנוצר ב-Claude Console, או מספקים apiKeyHelper בתוך ה-JSON של הדגל --settings. פלטפורמות Amazon Bedrock, Google Cloud's Agent Platform ו-Microsoft Foundry ממשיכות לקרוא את פרטי האימות הרגילים של הספק שלהן.

במצב bare יש לקלוד גישה לכלי Bash, לקריאת קבצים ולעריכת קבצים. כל הקשר נוסף מועבר באמצעות דגלים:

hooks עדיין אינם רצים במצב bare גם כשמעבירים אותם עם --settings, או בקובץ hooks/hooks.json, או במפתח hooks במניפסט של תוסף שנטען עם דגל. אל תשתמשו במצב bare לריצה שצריכה אותם.

מצב bare מגביל גם את מה שמתרחש בזמן שהסשן רץ:

• שרתי MCP: מתחברים רק שרתים שסופקו בשורת הפקודה, למשל באמצעות --mcp-config. בסשן אינטראקטיבי, קלוד קוד מדלג גם על החיבור האוטומטי ל-IDE אלא אם מעבירים --ide.
• תזכורות מערכת (System reminders): קלוד מקבל את ההנחיות שלכם ואת תוצאות הכלים בלי תזכורות המערכת שקלוד קוד היה מוסיף לצידן. לדוגמה, לקלוד לא מדווח כאשר קובץ שקרא קודם השתנה בדיסק, והוא אינו מקבל את רשימת הסקילים הזמינים, כולל סקילים מתיקיית --add-dir.
• משימות רקע: קלוד אינו יכול להריץ פקודות רקע או סוכני משנה ברקע, וגם שאר היכולות ש-CLAUDE_CODE_DISABLE_BACKGROUND_TASKS מכבה כבויות. פקודה שמגיעה לזמן הקצוב שלה (timeout) נעצרת במקום לעבור לרקע.

לפני גרסה v2.1.286, מגבלות אלו חלו באופן חלקי בלבד: סשן --bare אינטראקטיבי חיבר את שרתי ה-MCP שסשן רגיל חיבר, כל סשן --bare שלח תזכורות מערכת, ומשימות רקע נשארו זמינות.

--append-subagent-system-prompt חל רק עם -p, כולל סוכני משנה מקוננים, חוץ מסוכן משנה מפוצל שמשתמש בהנחיה של השיחה עצמה. דורש קלוד קוד v2.1.205 ומעלה. --append-subagent-system-prompt-file הוא החלופה לקובץ, גם הוא רק עם -p, ואי אפשר לשלב את שני הדגלים. דורש v2.1.261 ומעלה.

עם --print, הערך של --agents יכול להיות נתיב לקובץ JSON או מחרוזת JSON. צורת הקובץ דורשת קלוד קוד v2.1.281 ומעלה. קלוד קוד בודק את הערך בעלייה ויוצא אם הוא אינו תקין. הבדיקה דורשת v2.1.242 ומעלה. בעמוד השגיאה של תצורת --agents לא תקינה מתועדים דגלים ומשתנה סביבה שמדלגים על הבדיקה.

--plugin-dir טוען תוסף מתיקייה או מארכיון .zip לסשן הזה בלבד, או מכמה תוספים מתוך תיקיית תוספים. כל דגל מקבל נתיב אחד, וחוזרים על הדגל לנתיבים נוספים. תיקיית תוספים דורשת קלוד קוד v2.1.265 ומעלה. --plugin-url מביא ארכיון .zip של תוסף מכתובת, לסשן הזה בלבד. אפשר לחזור על הדגל, או להעביר כמה כתובות מופרדות ברווח בתוך ערך אחד במרכאות.

קובץ --settings צריך להיות קובץ רגיל שאינו גדול מ-2 MiB. מפתחות שמוגדרים שם דורסים את אותם המפתחות בקבצי settings.json לסשן הזה. מפתחות שחסרים שומרים על הערך מהקובץ. הערך יכול להיות גם מחרוזת JSON בשורה.

--mcp-config מקבל קבצי JSON או מחרוזות JSON, מופרדים ברווח. כשמעבירים --mcp-config עם -p, קלוד קוד ממתין לשרתים שעדיין ממתינים לחיבור לפני התור הראשון, עד MCP_TIMEOUT, 30 שניות כברירת מחדל. בסביבה עצמית (self-hosted) חלה המתנה קצרה יותר. שרת עם רשימת כלים במטמון מדלג על ההמתנה ומתחבר בשימוש הראשון. ההמתנה דורשת קלוד קוד v2.1.221 ומעלה. --strict-mcp-config משתמש רק בשרתים מ---mcp-config ומתעלם מכל שאר תצורות ה-MCP. תחת קובץ MCP מנוהל, מה שהדגל עושה מתואר בתיעוד השליטה הבלעדית של managed MCP.

מלכודת: הדגל --bare הוא המצב המומלץ לקריאות מסקריפטים ול-SDK, והוא מתוכנן להפוך לברירת המחדל עבור -p בגרסה עתידית. --safe-mode מכבה התאמות אישיות לצורך אבחון: לא נטענים CLAUDE.md, סקילים, תוספים, hooks, שרתי MCP, פקודות וסוכנים מותאמים, סגנונות פלט, תהליכי עבודה, ערכות נושא מותאמות, קיצורי מקשים מותאמים, פקודות שורת סטטוס והצעת קבצים, שרתי LSP, וזיכרון אוטומטי. אימות, בחירת מודל, כלים מובנים והרשאות ממשיכים לעבוד, וזה שונה מ---bare. מדיניות managed settings עדיין חלה, כולל hooks, שורת סטטוס ופקודות הצעת קבצים שמוגדרים במדיניות. תוספים מנוהלים, סקילים מנוהלים, CLAUDE.md מנוהל ושרתי MCP שמוגדרים במדיניות אינם נטענים. המצב שימושי כדי לבדוק אם התאמה אישית היא מה שמפעיל נפילה אוטומטית למודל אחר. --safe-mode מגדיר את CLAUDE_CODE_SAFE_MODE.

#משימות רקע בעת יציאה

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

אלא אם פקודת רקע שהשיחה הראשית התחילה עדיין רצה, קלוד קוד עוצר כברירת מחדל את מה שעדיין רץ אחרי 10 דקות של המתנה רצופה בלי פעילות, ומשמיט את התוצאה החלקית. לשינוי התקרה מגדירים את CLAUDE_CODE_PRINT_BG_WAIT_CEILING_MS, או קובעים 0 להמתנה בלי מגבלה.

הריצה ממתינה לעבודה כזו: פקודות רקע, סוכני משנה ותהליכי עבודה, האזנות Monitor, והתעוררויות /loop שממתינות.

• פקודות רקע: לפקודה שהשיחה הראשית התחילה, למשל שרת פיתוח או build במעקב, הריצה ממתינה עד שהפקודה יוצאת או מגיעה למגבלת הזמן שלה. אחר כך קלוד לוקח תור נוסף עם התוצאה. כל עוד הפקודה רצה, תקרת 10 הדקות אינה מסיימת את ההמתנה.
• סוכני משנה ותהליכי עבודה ברקע: הריצה נשארת פתוחה עד שהעבודה מסתיימת, כי התוצאה היא חלק מהפלט הסופי.
• האזנות Monitor: הריצה ממתינה עד שתוקף ההאזנה פוקע או עד שתקרת 10 הדקות מסיימת את ההמתנה, המוקדם מביניהם. בזמן ההמתנה קלוד ממשיך להגיב לדיווחים מההאזנה. כברירת מחדל תוקף האזנה פוקע חמש דקות אחרי שקלוד הפעיל אותה.
• התעוררויות שממתינות: בריצה שההנחיה שלה הועברה כטקסט, ולא עם --input-format stream-json, כאשר קלוד תזמן התעוררות /loop בקצב שהוא בוחר, הריצה ממתינה לכל התעוררות ומריצה את האיטרציה שלה עד שהלולאה נגמרת, גם אחרי תקרת 10 הדקות.

כש-stderr הוא מסוף והריצה המתינה חמש שניות, קלוד קוד מדפיס ל-stderr שורה שמתחילה ב-Waiting for background work to finish ומציינת את העבודה. עם פלט json או stream-json, השורה מודפסת רק כש-stdout אינו מסוף, כך שה-JSON שהסקריפט קורא אינו נושא אותה.

אם הריצה מגיעה לתקרת --max-budget-usd, קלוד קוד עוצר את עבודת הרקע שנשארה במקום להמתין לה.

כשמשימת רקע מתחילה תור נוסף, פלט text מדפיס את התוצאה של כל תור, ופלט json מדפיס את התוצאה של התור האחרון. לפני גרסה v2.1.295 גם פלט text הדפיס רק את תוצאת התור האחרון.

#עבודת MCP כשריצה לא אינטראקטיבית מסתיימת

ריצת claude -p אינה ממתינה לעבודת MCP ברקע:

• משימות MCP: בשרת מרוחק העבודה ממשיכה. כדי לעקוב אחריה שוב מחדשים את הסשן. ריצת claude -p "<prompt>" חד פעמית אינה הדרך לחזור אליה.
• קריאות MCP שהעברה אוטומטית לרקע הזיזה: תוצאת הקריאה אובדת.

#עצירת ריצה באמצעות SIGTERM

אם עוצרים ריצת claude -p באמצעות אות SIGTERM, למשל בעזרת פקודת kill או ממנהל תהליכים, קלוד קוד יוצא עם קוד 143. קלוד קוד משאיר את התור שהיה בעיצומו במצב לא גמור ואינו רושם עבורו תוצאה. כדי לסיים את התור, שלחו SIGINT או קראו לפונקציה interrupt() ב-Agent SDK לפני עצירת התהליך.

בעת קבלת SIGTERM, קלוד קוד מסיים את עץ התהליכים של כל פקודת Bash שעדיין רצה. לאחר מכן קלוד קוד מריץ hooks מסוג SessionEnd בלבד ויוצא. במהלך היציאה, קלוד קוד אינו מתחיל קריאת כלי חדשה, אינו שולח בקשת מודל חדשה ואינו מריץ שום hook אחר מלבד SessionEnd. אם הריצה הייתה באמצע פקודה או המתינה למענה בשאלת הרשאה כאשר האות הגיע:

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

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

#אם תיקיית העבודה נמחקת

אם תיקיית העבודה של סשן claude -p או Agent SDK נמחקת באמצע הסשן, הסשן ממשיך לרוץ. כאשר תור מתחיל בזמן שהתיקייה חסרה, קלוד קוד פולט הודעת אזהרה בפלט stream-json, ופקודות מעטפת נכשלות עד שהתיקייה קיימת שוב.

#פקודות עזר לסקריפטים ול-CI

מעבר ל-claude -p, ה-CLI כולל פקודות שמיועדות לסקריפטים, לאבחון ולהרצה בסביבות אוטומטיות. לפי התיעוד הרשמי:

אם מקלידים תת פקודה בשגיאה, קלוד קוד מציע את ההתאמה הקרובה ויוצא בלי לפתוח סשן. לדוגמה, claude udpate מדפיס Did you mean claude update?.

claude --dangerously-skip-permissions daemon <subcommand> מריץ את תת הפקודה daemon, כך שתת הפקודה עובדת גם כש-claude מוגדר ככינוי שכולל את הדגל. רק דגל מוביל --dangerously-skip-permissions או --allow-dangerously-skip-permissions מנתב כך אל daemon. עם כל דגל אחר לפני daemon, תת הפקודה אינה רצה.

#בדיקת התחברות

claude auth status מחזיר JSON כברירת מחדל ומתאים לבדיקת שער ב-CI. קוד יציאה 0 פירושו שהתהליך מחובר, וקוד 1 פירושו שאינו מחובר.

claude auth status

פקודות התחברות נוספות:

• claude auth login: התחברות לחשבון Anthropic. --email ממלא מראש את כתובת הדואל, --sso מאלץ אימות SSO, ו---console מתחבר עם Anthropic Console לחיוב לפי שימוש ב-API במקום מנוי Claude. דוגמה: claude auth login --console.
• claude auth logout: התנתקות מחשבון Anthropic.
• claude setup-token: יוצר אסימון OAuth ארוך טווח ל-CI ולסקריפטים, מדפיס אותו למסוף בלי לשמור אותו, ודורש מנוי Claude.

#מעקב אחר סשנים ברקע

claude agents --json מדפיס את הסשנים הפעילים כמערך JSON לסקריפטים:

claude agents --json

אפשרויות שימושיות:

• --json --all: כולל גם סשני רקע שהסתיימו.
• --cwd <path>: מציג רק סשנים שהתחילו תחת התיקייה הזו.
• --permission-mode, --model, --effort, --agent: קובעים ברירות מחדל לסשנים שנשלחים מהתצוגה.
• --settings, --add-dir, --plugin-dir, --mcp-config: אותם דגלים כמו בפקודת claude ברמה העליונה.

מלכודת: פתיחת תצוגת הסוכנים דורשת מסוף אינטראקטיבי. בסקריפטים השתמשו ב---json.

חיבור לסשן רקע במסוף הנוכחי. במקום המזהה אפשר להעביר חלק משם של סשן רץ, וזה דורש קלוד קוד v2.1.290 ומעלה:

claude attach 7c5dcf5d

פלט אחרון מסשן רקע. אפשר להעביר חלק משם של סשן במקום המזהה, וזה דורש קלוד קוד v2.1.290 ומעלה:

claude logs 7c5dcf5d

עצירת סשן רקע. מתקבל גם claude kill:

claude stop 7c5dcf5d

הפעלה מחדש של סשן רקע, רץ או עצור, כשהשיחה נשמרת. --all מפעיל מחדש כל סשן רץ, למשל כדי לקלוט בינארי מעודכן של קלוד קוד:

claude respawn 7c5dcf5d

הסרת סשן רקע מהרשימה. תמליל השיחה נשאר במכונה וזמין דרך claude --resume:

claude rm 7c5dcf5d

אם ההסרה נדחית בגלל ה-worktree של הסשן, והרצה שנייה של claude rm יכולה לפתור את זה, הסירוב מדפיס את הדגל והערך המדויקים. --discard-unpushed <commit>@<worktree-id> משליך worktree שיש בו commits שלא נדחפו, יחד עם ה-commits האלה, ודורש קלוד קוד v2.1.260 ומעלה. --force-remove-worktree <worktree-id> מוחק תיקיית worktree ש-git או hook מסוג WorktreeRemove לא הצליחו להסיר, ודורש v2.1.268 ומעלה.

בסשן שהתחיל עם --bg, מצב --dangerously-skip-permissions (שווה ערך ל---permission-mode bypassPermissions) נשמר גם כשמפקח הרקע מפעיל את הסשן מחדש.

אבחון מפקח סשני הרקע:

claude daemon status

מעקב אחרי לוג המפקח. הפקודה מדפיסה שורות חדשות מקובץ ~/.claude/daemon.log עד שלוחצים Ctrl+C:

claude daemon logs

הרצת המפקח בחזית המסוף הזה, עם הדפסת הלוג:

claude daemon run

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

claude daemon stop --any --keep-workers

השתמשו בזה לשחזור ממפקח שאינו מגיב.

#אבחון בלי לפתוח סשן

claude doctor מדפיס אבחון לקריאה בלבד מהמסוף בלי להתחיל סשן: תקינות התקנה, שגיאות אימות של קבצי הגדרות, וזכאות ל-Remote Control.

claude doctor

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

לאבחון של ריצה עצמה, --debug מפעיל מצב דיבאג עם סינון קטגוריות אופציונלי, למשל --debug='mcp,startup' או --debug='!mcp'. הסינון נקשר רק בצורה עם =. מסנן מופרד ברווח מפעיל דיבאג בלי סינון. --debug-file <path> כותב את לוגי הדיבאג לנתיב, מפעיל דיבאג בעצמו, ודורס את CLAUDE_CODE_DEBUG_LOGS_DIR.

#כללי מצב auto ב-JSON

הדפסת כללי הסיווג המובנים של מצב auto כ-JSON. claude auto-mode config מציג את התצורה האפקטיבית אחרי החלת ההגדרות. --label <prefix> מדפיס רק כללים שתוויתם מתחילה בקידומת הזו, בהתאמה בלי תלות ברישיות. דורש קלוד קוד v2.1.208 ומעלה:

claude auto-mode defaults --label 'Git Destructive'

שחזור תצורת ברירת המחדל של מצב auto מוחק את המקטע autoMode מקובץ הגדרות המשתמש. הפקודה מבקשת אישור לפני הכתיבה. -y או --yes מדלג על הבקשה. כללים מ-managed settings או מהדגל --settings ממשיכים לחול. דורש קלוד קוד v2.1.212 ומעלה:

claude auto-mode reset --yes

#ultrareview בלי מסוף אינטראקטיבי

claude ultrareview [target] מדפיס ממצאים ל-stdout ויוצא עם קוד 0 בהצלחה או 1 בכישלון. --json מחזיר את המטען הגולמי. --timeout <minutes> מחליף את ברירת המחדל של 45 דקות. על יעד pull request ב-github.com, --post מפרסם את הממצאים הסופיים כתגובה רגילה אחת מחשבון GitHub. --no-post הוא ברירת המחדל. --post ו---no-post דורשים קלוד קוד v2.1.227 ומעלה.

claude ultrareview 1234 --json

#התחברות MCP משורת הפקודה

claude mcp login <name> מריץ את זרימת ה-OAuth של שרת MCP שכבר מוגדר, בלי לפתוח את פאנל /mcp. זה עובד לשרתי HTTP, SSE ולמחברי claude.ai. ב-SSH, --no-browser מדפיס את כתובת האישור במקום לפתוח דפדפן. לשרת HTTP או SSE מדביקים את כתובת ה-redirect בחזרה בשורת הקלט. למחבר claude.ai יש מסלול נפרד בתיעוד Remote Control: אישור מחבר מחדש מהמעטפת. claude mcp logout <name> מוחק את אישורי ה-OAuth השמורים של השרת.

claude mcp login sentry

#התקנה, שער ופקודות תחזוקה

• claude update: עדכון לגרסה האחרונה.
• claude install [version]: התקנה או התקנה מחדש של הבינארי המקורי. מקבל גרסה כמו 2.1.118, או stable או latest. דוגמה: claude install stable.
• claude gateway --config gateway.yaml: הפעלת שרת Claude apps gateway עצמי, למנהלים שפורסים SSO ומדיניות מול קלוד קוד ב-Amazon Bedrock, ב-Google Cloud's Agent Platform או ב-Microsoft Foundry. דורש --config שמצביע לקובץ gateway.yaml.
• claude import [source]: פתיחת סשן אינטראקטיבי שמריץ /import כדי לייבא תצורה מסוכני קידוד אחרים. מקבל את אותן האפשרויות --dry-run ו---yes כמו הפקודה. אינו זמין ב-Amazon Bedrock, ב-Google Cloud's Agent Platform, ב-Microsoft Foundry או ב-Claude Platform on AWS, וגם כאשר כיביתם את משיכת דגלי התכונות. דורש קלוד קוד v2.1.213 ומעלה. דוגמה: claude import codex --dry-run.
• claude purge [path]: מוחק את כל המצב המקומי של קלוד קוד לפרויקט: תמלילים, רשימות משימות, לוגים של debug, היסטוריית עריכות, שורות היסטוריית הנחיות, והרשומה של הפרויקט ב-~/.claude.json. בלי [path] נבחרים מתוך רשימה אינטראקטיבית. --dry-run לתצוגה מקדימה, -y או --yes בלי אישור, -i או --interactive לאישור לכל פריט, --all לכל פרויקט.
• claude remote-control: מפעיל שרת Remote Control לשליטה מקלוד.ai או מאפליקציית Claude, במצב שרת בלי סשן אינטראקטיבי מקומי. אחרי עצירת השרת אפשר להחזיר את הסשנים שהוא שירת. הדגל --remote-control (כינוי: --rc) מתחיל סשן אינטראקטיבי עם Remote Control, ואפשר להעביר שם לסשן. --remote-control-session-name-prefix קובע קידומת לשמות שנוצרים אוטומטית כשאין שם מפורש. ברירת המחדל היא שם המארח של המכונה, למשל myhost-graceful-unicorn. אותו אפקט ל-CLAUDE_REMOTE_CONTROL_SESSION_NAME_PREFIX.
• claude self-hosted-runner: תהליך runner שרושם את המכונה או הקונטיינר מול סביבה עצמית ומארח סשני ענן על התשתית שלכם. claude self-hosted-runner setup למסלול מודרך, claude self-hosted-runner doctor לאבחון runner שכבר פרוס, claude self-hosted-runner orchestrator ל-runners לפי דרישה. דורש קלוד קוד v2.1.224 ומעלה. לסשן ענן חדש על סביבה עצמית מעבירים --environment עם מזהה שמתחיל ב-ccpool_. עם --ref <branch> ה-checkout של הסשן החדש מבוסס על ה-ref הזה במקום על HEAD המקומי. --environment דורש קלוד קוד v2.1.224 ומעלה. התנהגות השיגור, ושילובי הדגלים שהדגל דוחה, מתוארים בתיעוד הרשמי של --environment.

#דוגמאות מעשיות

דוגמאות אלו מדגישות דפוסי CLI נפוצים. בכל מקום שבו פקודה מציינת קובץ כמו auth.py או build-error.txt, החליפו אותו בקובץ מהפרויקט שלכם. בסביבות CI או בסקריפטים, הוסיפו את הדגל --bare כדי שקלוד קוד יתחיל בלי לטעון hooks, תוספים, זיכרון אוטומטי או קובץ CLAUDE.md מהמכונה המארחת.

#הזרמת נתונים דרך קלוד (צנרת וקלט stdin)

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

דוגמה זו מזרימה לוג בנייה לתוך קלוד וכותבת את ההסבר לקובץ:

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, הריצה מדווחת על הסכום המצטבר של השיחה כולה, כולל ההוצאות מריצות קודמות. שני הנתונים הם הערכות בצד הלקוח ויכולים להיות שונים מהחשבון בפועל.

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

אם קלוד קוד אינו מצליח לקרוא מ-stdin, למשל משום שהתהליך שהפעיל אותו ניתק את החיבור שלו, קלוד קוד מדפיס אזהרה ל-stderr וממשיך עם ההנחיה משורת הפקודה.

הדגל --input-format קובע את פורמט הקלט במצב print: text או stream-json. --replay-user-messages מחזיר הודעות משתמש מ-stdin אל stdout כאישור קבלה, ודורש --input-format stream-json יחד עם --output-format stream-json.

#הוספת קלוד לסקריפט בנייה

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

סקריפט זה בקובץ package.json מזרים את ה-diff מול ענף main לתוך קלוד ומבקש ממנו לדווח על שגיאות הקלדה. הזרמת ה-diff בצנרת חוסכת מקלוד את הצורך בהרשאת Bash כדי לקרוא אותו, והמרכאות הכפולות המוברחות שומרות על תאימות גם ב-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.\""
  }
}

מריצים אותו באמצעות הפקודה npm run lint:claude.

#קבלת פלט מובנה

השתמשו בדגל --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. --json-schema הוא מצב print בלבד.

דוגמה זו מחלצת שמות פונקציות ומחזירה אותם כמערך של מחרוזות:

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 תקינה, claude יוצא עם השגיאה Error: --json-schema is not a valid JSON Schema ולאחריה אבחון הבדיקה. קלוד קוד מקבל סכימות שמשתמשות במילת המפתח format, כגון "format": "email", אך מתייחס ל-format כהערה בלבד ואינו אוכף אותה.

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

טיפ: השתמשו בכלי כמו jq כדי לנתח את התגובה ולחלץ שדות ספציפיים:

# חילוץ תוצאת הטקסט
claude -p "Summarize this project" --output-format json | jq -r '.result'

# חילוץ הפלט המובנה
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 כדי לקבל טוקנים בזמן יצירתם. --include-partial-messages דורש --print ו---output-format stream-json. כל שורה היא אובייקט JSON המייצג אירוע:

claude -p "Explain recursion" --output-format stream-json --verbose --include-partial-messages

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

אם הצרכן שלכם קורא את הזרם באיטיות, קלוד קוד ממתין לריקון הפלט שבתור לפני היציאה, בהתאם לכמות הפלט שעדיין בתור ועד לתקרה של 30 שניות.

דוגמה זו משתמשת ב-jq כדי לסנן מקטעי טקסט (text deltas) ולהציג רק את הטקסט המוזרם. הדגל -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'

--prompt-suggestions פולט הודעת prompt_suggestion עם הנחיה חזויה אחרי כל תור שמייצר אחת. שיחה קצרה מאוד יכולה לא לייצר אף אחת. הדגל דורש --print, --output-format stream-json ו---verbose.

--include-hook-events מוסיף אירועי מחזור חיים של hooks לזרם, ודורש --output-format stream-json. אירועי SessionStart ו-Setup נכללים תמיד ואינם דורשים את הדגל. אירועים כמו Notification, SessionEnd, PreCompact ו-PostCompact אינם מייצרים hook_started גם עם הדגל. עבורם קלוד קוד עדיין פולט hook_progress כשפקודת hook שרצה יותר משנייה מייצרת פלט, ופולט hook_response רק כש-hook שרץ ברקע מסתיים.

להזרמה תכנותית עם פונקציות חזרה ואובייקטי הודעות, עיינו בתיעוד Agent SDK בנושא הזרמת תשובות בזמן אמת.

#מעקב אחר הודעות סוכני משנה

הודעות מסוכני משנה, ומסקילים שרצים בתוך סוכן משנה, מופיעות בזרם כהודעות assistant ו-user. השדה parent_tool_use_id מציין לאיזו ריצה כל הודעה שייכת. הודעות מהשיחה הראשית נושאות null בשדה זה.

ההודעה הראשונה מסקיל מפוצל, או מסוכן משנה שרץ בחזית, היא הודעת user שנושאת את ההנחיה או את תוכן הסקיל שמניע את הריצה. לאחר אותה הודעה ראשונה, קלוד קוד פולט:

• כברירת מחדל: את בלוקי ה-tool_use וה-tool_result של הריצה.
• עם --forward-subagent-text או משתנה הסביבה CLAUDE_CODE_FORWARD_SUBAGENT_TEXT: גם את בלוקי הטקסט והחשיבה, כך שניתן לשחזר את התמליל של כל ריצה. בלי הדגל, קלוד קוד משמיט את בלוקי הטקסט והחשיבה של סוכן משנה שרץ בחזית. הדגל דורש --print ו---output-format stream-json, ודורש קלוד קוד v2.1.211 ומעלה.

כשמפעילים אחת משתי האפשרויות, קלוד קוד מעביר הודעות מסוכני משנה בכל עומק קינון, בין אם כל אחד הופעל באמצעות כלי ה-Agent ובין אם התחיל כסקיל מפוצל. בשדה parent_tool_use_id, הודעות של סוכן משנה מקונן נושאות את מזהה קריאת כלי ה-Agent או ה-Skill שהתחילה אותו, וכך אפשר לבנות מחדש את עץ הקינון המלא לפי המזהים האלה.

ריצה שקלוד מתחיל בקריאת כלי נושאת את מזהה אותה קריאה. סקיל מפוצל שמתחילים על ידי העברת /<skill-name> כהנחיה אינו קריאת כלי, ולכן ההודעות שלו נושאות ערך שמתחיל ב-forked-command- ומגיעות יחד ובסדר אחרי שהוא מסתיים:

לסקיל מפוצל שהתחיל מההנחיה, התאימו את parent_tool_use_id לפי הקידומת forked-command-, כי השם שאחריה יכול להיות שונה מהשם שהקלדתם.

אם חלק מההודעות חסרות בזרם, בדקו את גרסת קלוד קוד מול המינימום:

• סקיל מפוצל שקלוד מתחיל עם כלי Skill מהשיחה הראשית: v2.1.86 ומעלה לבלוקי tool_use ו-tool_result, ו-v2.1.265 ומעלה להודעת ה-user הראשונה ולבלוקי הטקסט והחשיבה.
• הודעות של סוכני משנה שסקיל מפוצל מפעיל, ושל סקילים מפוצלים שהופעלו בתוך סוכן משנה או בתוך סקיל מפוצל אחר: v2.1.275 ומעלה.
• הודעות של סקיל מפוצל שמתחילים בהעברת /<skill-name> כהנחיה: v2.1.287 ומעלה.

claude -p --output-format stream-json --verbose --forward-subagent-text "query"

#טיפול בניסיונות חוזרים של API

כאשר בקשת API נכשלת עם שגיאה המאפשרת ניסיון חוזר, קלוד קוד פולט אירוע system/api_retry לפני הניסיון החוזר. בגרסה v2.1.246 ומעלה, כאשר קוד 401 או 403 דוחה פרטי אימות של apiKeyHelper, קלוד קוד מבצע את שני הניסיונות החוזרים הראשונים בשקט בלי לפלוט אירוע, ואז פולט את האירוע כרגיל מהניסיון השלישי הרצוף ואילך. הניסיונות השקטים עדיין נספרים בתוך attempt. ניתן להשתמש באירוע כדי להציג את התקדמות הניסיונות בממשק שלכם.

#קריאת מטא דאטה של הסשן

האירוע system/init מדווח על מטא דאטה של הסשן כולל המודל, הכלים, שרתי ה-MCP והתוספים שנטענו. זהו האירוע הראשון בזרם אלא אם קודמים לו אירועי עלייה:

• אירועי plugin_install, כאשר משתנה הסביבה CLAUDE_CODE_SYNC_PLUGIN_INSTALL מוגדר.
• אירועי hook_started, hook_progress, ו-hook_response, בזמן ש-hook מוגדר מסוג SessionStart או Setup רץ. אירועים אלה מוזרמים כשה-hook מייצר אותם.

האירוע נושא גם מערך אופציונלי capabilities של מחרוזות המציינות התנהגויות פרוטוקול שגרסת קלוד קוד זו מממשת, כגון interrupt_receipt_v1 או interrupt_cancel_queued_v1. בדקו שדה זה לזיהוי יכולות (feature detection) במקום להשוות מחרוזות גרסה, והתעלמו מערכים שאינכם מכירים. רשימת היכולות מופיעה בתיעוד של SDKSystemMessage.

#הכשלת CI כאשר תוסף או שרת MCP אינו נטען

השתמשו בשדות התוספים באירוע system/init כדי לזהות תוסף שלא נטען:

כאשר תיקייה או ארכיון של --plugin-dir עצמם נכשלים בטעינה, הרשומה ב-plugin_errors כוללת את הנתיב המוחלט שנפתר תחת path. השתמשו בזה כדי לדעת איזה מבין כמה ערכי --plugin-dir נכשל. השדה path דורש קלוד קוד v2.1.283 ומעלה.

השתמשו בשדות שרתי ה-MCP באותו אופן. כאשר מעבירים את הדגל --mcp-config יחד עם -p, קלוד קוד ממתין לשרתים שעדיין ממתינים לחיבור לפני הרצת התור הראשון, עד לזמן הקצוב לעלייה המוגדר ב-MCP_TIMEOUT, 30 שניות כברירת מחדל. שרת מרוחק עם רשימת כלים שמורה במטמון מדלג על ההמתנה, מציג סטטוס pending ב-system/init, ומתחבר בקריאת הכלי הראשונה שלו. בסביבה עצמית (self-hosted) חלה המתנה קצרה יותר. ההמתנה דורשת קלוד קוד v2.1.221 ומעלה.

קלוד קוד בודק את תקינות כל רשומת --mcp-config בעלייה ומדלג על רשומות שנכשלות בבדיקה, למשל רשומת url ללא type. הריצה ממשיכה ויוצאת בצורה תקינה, לכן בדקו שדות אלה כדי לזהות שרת שמעולם לא נטען:

כאשר מריצים את הפקודה ידנית במסוף, קלוד קוד מדפיס גם אזהרת עלייה ל-stderr, כגון Warning: 1 MCP server skipped due to invalid config:, ולאחריה הסיבה לכל רשומה שדולגה. כאשר מפנים את stderr, או כאשר תוכנית כמו CI runner או מארח SDK לוכדת אותו, קלוד קוד אינו מדפיס אזהרה ומדווח על הרשומות שדולגו רק בשדה mcp_server_errors.

#מעקב אחר התקנת תוספים

כאשר משתנה הסביבה CLAUDE_CODE_SYNC_PLUGIN_INSTALL מוגדר, קלוד קוד פולט אירועי system/plugin_install בזמן שתוספי חנות (marketplace) מותקנים לפני התור הראשון. השתמשו באירועים אלה כדי להציג את התקדמות ההתקנה בממשק שלכם.

#אישור מראש של כלים

השתמשו ב---allowedTools (כינוי: --allowed-tools) כדי לאפשר לקלוד להשתמש בכלים מסוימים בלי לבקש אישור, חוץ מקריאות מנתיבי רשת. ציון Read ו-Edit מאפשר לקלוד לקרוא ולערוך קבצים בלי לבקש הרשאה, חוץ מקריאות מנתיבי רשת. ציון Bash עושה את אותו הדבר עבור פקודות מעטפת, למעט בריצה שמתחילה במצב auto, שבה קלוד קוד משמיט רשומת Bash חשופה ככלל אישור רחב ומצב auto מעריך כל פקודה בנפרד במקום זאת. כדי להגביל אילו כלים מובנים זמינים, השתמשו ב---tools: "" מכבה את כולם, "default" הוא ערכת ברירת המחדל, או שמות כמו "Bash,Edit,Read". ב-macOS, ב-Linux וב-WSL ערכת ברירת המחדל משמיטה את Glob ואת Grep. אם מציינים כאן אחד מכלי מעקב המשימות, קלוד קוד גם מפעיל את המעקב בסשן. הדגל אינו משפיע על כלי MCP. כדי לדחות גם אותם, השתמשו ב---disallowedTools "mcp__*". רשימה שמשמיטה את EndConversation אינה מסירה אותו. "" מסיר אותו רק כשלא נשארו כלי MCP.

--disallowedTools (כינוי: --disallowed-tools) הוא כללי דחייה. שם כלי חשוף מסיר את הכלים התואמים מההקשר של קלוד: "Edit" מסיר את Edit, "*" מסיר כל כלי, ו-"mcp__*" מסיר כל כלי MCP. כלל ממוקד כמו Bash(rm *) משאיר את הכלי זמין ודוחה רק קריאות שתואמות כפי שנכתבו. כלל שמציין את EndConversation אינו יכול להסיר אותו כל עוד נשאר כלי אחר. ציון אחד מכלי מעקב המשימות ב---allowedTools או ב---tools מפעיל את המעקב בסשן.

דוגמה זו מריצה סוויטת בדיקות ומתקנת כשלים עם שלושת הכלים המצוינים:

claude -p "Run the test suite and fix any failures" \
  --allowedTools "Bash,Read,Edit"

קריאות לכלים שלא ציינתם רצות אם הן אינן דורשות אישור. בריצת claude -p במצב Manual, קריאה שדורשת אישור נדחית אלא אם משהו מאשר אותה, כמו hook מסוג PermissionRequest או --permission-prompt-tool. מקלוד קוד v2.1.302 ומעלה, ריצת claude -p מתחילה במצב Manual כאשר שום דבר אינו קובע מצב הרשאות.

כדי לקבוע קו בסיס לסשן כולו במקום למנות כלים בודדים, מעבירים מצב הרשאות עם --permission-mode, למשל auto, dontAsk, או acceptEdits:

• auto: העבירו --permission-mode auto כדי שמסווג יבדוק את רוב הפעולות במקומכם. הדגל --enable-auto-mode הוסר בגרסה v2.1.111. מצב auto נמצא במחזור Shift+Tab כברירת מחדל, ולהתחלה במצב הזה משתמשים ב---permission-mode auto.
• dontAsk: קלוד קוד דוחה כל קריאה שהייתה מבקשת אישור, דבר שימושי עבור ריצות CI נעולות. mod שהתקנתם עדיין יכול לאשר חלק מהקריאות האלה. אילו קריאות mod יכול לאשר מתואר בתיעוד ההרשאות, תחת הרחבת הרשאות עם hooks. פעולות שאינן דורשות אישור במצב Manual עדיין רצות, כגון קריאת קבצים בתיקיות העבודה וערכת הפקודות לקריאה בלבד, וכך גם פעולות שרשומות ה---allowedTools או כללי permissions.allow שלכם מכסים. הכלי AskUserQuestion, כלי מחברים שהארגון שלכם הגדיר כ-ask, כלי MCP המסומנים כ-requiresUserInteraction, וקריאות מנתיבי רשת נדחים גם כאשר כלל אישור מתאים להם.
• acceptEdits: קלוד כותב קבצים בלי לבקש אישור, וקלוד קוד מאשר אוטומטית פקודות מערכת קבצים נפוצות כגון mkdir, touch, mv, ו-cp. הפעולות שאף מצב אינו מאשר אוטומטית עדיין חלות. מלבד ערכת הפקודות לקריאה בלבד, פקודות מעטפת אחרות ובקשות רשת עדיין דורשות רשומת --allowedTools או כלל permissions.allow. הרשימה המלאה של מה ש-acceptEdits מאשר אוטומטית מופיעה בתיעוד מצבי ההרשאה.

דוגמה זו מחילה תיקוני lint עם acceptEdits כקו בסיס:

claude -p "Apply the lint fixes" --permission-mode acceptEdits

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

העבירו --permission-prompts none כאשר אין מי שיענה על שאלות הרשאה, למשל במשימה מתוזמנת. הדגל משמעותי ביותר כאשר לריצה יש מארח הרשאות: אפליקציית Agent SDK עם פונקציית חזרה מסוג canUseTool, או כלי MCP שאתם מעבירים באמצעות --permission-prompt-tool. בלי הדגל, הריצה שלכם ממתינה לאותו מארח שיענה על כל בקשת הרשאה.

עם הדגל, הריצה שלכם אינה פונה למארח ואינה ממתינה לו. כל מה שהיה מבקש אישור נדחה אלא אם כן hook מסוג PermissionRequest מאשר זאת, לקלוד נמסר שאיש אינו יכול לאשר את הבקשה ושלא ינסה שוב, והריצה נמשכת. בריצת -p ללא מארח, בקשות אלה נדחות בכל מקרה, והדגל גם מורה לקלוד לא לנסה שוב. כללי הרשאה, hooks מסוג PermissionRequest, ומצב ההרשאות שהגדרתם עדיין מכריעים לגבי כל קריאה תחילה. קלוד קוד דוחה רק את הבקשות ששום מנגנון אחר לא פתר.

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

claude -p "Update the dependency pins and run the tests" --permission-mode auto --permission-prompts none

עם --permission-prompts none, קלוד קוד מסיר את הכלים שדורשים תשובה מאדם, כגון AskUserQuestion, כך שקלוד אינו יכול לקרוא להם. כל בקשת elicitation של MCP ששום hook מסוג Elicitation אינו עונה עליה מבוטלת.

עם --output-format stream-json, דחיות מופיעות כהודעות מערכת מסוג permission_denied, והודעת ה-result הסופית מונה אותן ב-permission_denials.

הערה: הדגל --permission-prompts דורש קלוד קוד v2.1.259 ומעלה. גרסאות קודמות דוחות אותו עם שגיאת אפשרות לא מוכרת.

#יצירת commit

דוגמה זו סוקרת שינויים שבשלב ה-staging ויוצרת 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.

תמיכת פקודות שונה במצב -p:

• סקילים ופקודות מותאמות אישית שהופעלו על ידי המשתמש עובדים. כללו את /skill-name במחרוזת ההנחיה וקלוד קוד מרחיב אותו לפני ההרצה.
• פקודות מובנות שרצות רק בממשק המסוף, כגון /login, אינן זמינות.
• הפקודות /model, /effort, /fast, /color, ו-/rename מקבלות את הערך כארגומנט, לדוגמה /model sonnet, ו-/mcp ללא ארגומנט מדפיס סיכום טקסט של סטטוס השרת. על הצורות האלה חלות הערות הזמינות של כל פקודה.
• כדי לשנות הגדרה, מעבירים key=value אל /config, לדוגמה /config thinking=false.
• /output-style <style> מחליף סגנון פלט, ו-/output-style לבד מציג את הרשימה. דורש קלוד קוד v2.1.269 ומעלה.

#התאמת הנחיית המערכת

השתמשו ב---append-system-prompt כדי להוסיף הוראות תוך שמירה על התנהגות ברירת המחדל של קלוד קוד. דוגמה זו מזרימה diff של PR לתוך קלוד ומורה לו לבדוק פגיעויות אבטחה. שמרו את הקוד כסקריפט מעטפת, למשל 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 גורמת למעטפת להחליף את "$1" ב-123, כך שהסקריפט מביא את ה-diff עבור PR 123. קלוד קוד מדפיס את הסקירה כ-JSON, כאשר הטקסט נמצא בשדה result.

הדגל --exclude-dynamic-system-prompt-sections מעביר הקשר שתלוי במשתמש, כגון מיקום הזיכרון האוטומטי, מהנחיית המערכת להודעה הראשונה. הוא מיועד לשיפור שימוש חוזר במטמון במשימות מרובות משתמשים, יחד עם -p. הדגל חל רק עם הנחיית המערכת הרגילה ונזנח כשמגדירים --system-prompt או --system-prompt-file.

חמישה דגלים מתאימים את הנחיית המערכת, במצב אינטראקטיבי ובמצב לא אינטראקטיבי. ארבעה קובעים את הטקסט, ו---system-prompt-snapshot קובע אם השיחה שומרת את הטקסט שהתחילה איתו.

אפשר לשלב דגלים אלה. כדי להחליף את הנחיית ברירת המחדל ועדיין לצרף טקסט משלכם, מעבירים את --append-system-prompt או --append-system-prompt-file יחד עם --system-prompt או --system-prompt-file. מקלוד קוד v2.1.283 ומעלה, ניתן גם להעביר דגל יחד עם צורת הקובץ שלו, כגון --append-system-prompt יחד עם --append-system-prompt-file, וקלוד קוד משתמש בשניהם.

לדוגמה, הרצה זו במעטפת מצרפת גם מדריך סגנון מקובץ וגם הוראה נוספת אחת:

claude -p --append-system-prompt-file ./style.md --append-system-prompt "Always reply in French" "Summarize README.md"

קלוד מקבל את הנחיית המערכת של ברירת המחדל ולאחריה את תוכן style.md, שורה ריקה, ואז Always reply in French. תוכן הקובץ מגיע ראשון אפילו אם מעבירים את --append-system-prompt לפני --append-system-prompt-file.

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

דגל הוספה מתאים כשקלוד נשאר עוזר קידוד וגם עומד בכללים הנוספים: הוראות לאותה קריאה, עיצוב פלט, או הקשר תחום לסקריפט -p. ההוספה שומרת על הנחיית הכלים, הוראות הבטיחות ומוסכמות הקידוד של ברירת המחדל, כך שמספקים רק את מה ששונה. דגל החלפה מתאים כשהמשטח, הזהות או מודל ההרשאות שונים משל קלוד קוד, למשל סוכן שאינו סוכן קידוד בצנרת בלי אדם שצופה. ההחלפה מורידה את כל הנחיית ברירת המחדל, כולל הנחיית כלים והוראות בטיחות, והריצה מתחילה גם בלי צילום סטטוס ה-git. האחריות על מה שהמשימה עדיין צריכה עוברת אליכם. לפרסונות קבועות שאפשר להחליף ביניהן ולשתף בפרויקט, השתמשו ב-output styles. למוסכמות פרויקט שקלוד צריך תמיד לעקוב אחריהן, השתמשו ב-CLAUDE.md. מדריך Agent SDK על הנחיות מערכת מכסה את אותה בחירה ביתר פירוט.

#דגלי הנחיית מערכת בשיחות מחודשות

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

מחוץ לסשני ענן, אם מתחילים במצב bare באמצעות --bare או CLAUDE_CODE_SIMPLE=1, הרישום כבוי אלא אם מעבירים --system-prompt-snapshot on. לפני v2.1.268, סשנים שאינם מושכים דגלי תכונות, כולל Amazon Bedrock, Google Cloud's Agent Platform ו-Microsoft Foundry, בנו את ההנחיה מחדש בכל בקשה, ול---system-prompt-snapshot לא הייתה השפעה.

כדי לבנות את ההנחיה מחדש בכל בקשה, למשל בזמן שמנסחים אותה לאורך ריצות --continue, מעבירים --system-prompt-snapshot off. הדגל דורש קלוד קוד v2.1.257 ומעלה. לפני v2.1.265, עצם העברת אחד מדגלי הנחיית המערכת כיבתה את הרישום, אלא אם הועבר --system-prompt-snapshot on.

#המשך שיחות

השתמשו ב---continue כדי להמשיך את השיחה האחרונה, או ב---resume עם מזהה סשן כדי להמשיך שיחה ספציפית. בגרסה v2.1.257 ומעלה, כאשר מעבירים את --continue, קלוד קוד פותח סשן רקע שהסתיים, אך לא סשן שעדיין רץ.

claude -c בלי -p מדלג על סשנים שנוצרו עם claude -p או עם Agent SDK, ועל סשנים שההנחיה הראשונה שלהם הייתה /loop. claude -p --continue כולל גם את הסשנים האלה. הפקודה טוענת את השיחה האחרונה בתיקייה הנוכחית, כולל סשנים שהוסיפו את התיקייה הזו עם /add-dir.

דוגמה זו מריצה סקירה, ולאחר מכן שולחת הנחיות המשך:

# בקשה ראשונה
claude -p "Review this codebase for performance issues"

# המשך השיחה האחרונה
claude -p "Now focus on the database queries" --continue
claude -p "Generate a summary of all issues found" --continue

אם אתם מריצים מספר שיחות, תפסו את מזהה הסשן כדי לחדש שיחה ספציפית:

session_id=$(claude -p "Start a review" --output-format json | jq -r '.session_id')
claude -p "Continue that review" --resume "$session_id"

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

במקום מזהה סשן, ניתן להעביר ל---resume את הנתיב המוחלט לקובץ תמליל .jsonl של הסשן, וקלוד קוד ממשיך את השיחה השמורה באותו קובץ. אפשר גם לחדש לפי שם תצוגה. --name (כינוי: -n) קובע שם תצוגה שמופיע ב-/resume ובכותרת המסוף, ואפשר לחדש אותו עם claude --resume <name>. /rename משנה את השם באמצע הסשן ומציג אותו גם בשורת ההנחיה.

החיפוש והבורר כוללים סשנים שהוסיפו את התיקייה הזו באמצעות /add-dir. סשני רקע מופיעים בבורר עם הסימון bg. חידוש סשן רקע שעדיין רץ פותח אותו במסוף הנוכחי באמצעות claude attach, והנחיה שמועברת בשורת הפקודה עוברת אליו כתור הבא שלו. לפני v2.1.285 קלוד קוד סירב והדפיס את פקודת claude attach להרצה ידנית. עבור --resume על סשן רקע שעדיין רץ יחד עם --print, ההתנהגות מתוארת בתיעוד חידוש סשן רקע רץ. --fork-session, יחד עם --resume או --continue, יוצר מזהה סשן חדש במקום לשחזר את המקורי.