🖥️ פרק 1

מה זה קלוד דסקטופ

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

האפליקציה זמינה ב-macOS (קובץ Universal למעבדי Intel ולמעבדי Apple Silicon), ב-Windows למעבדי x64, ובמתקין נפרד ל-Windows ARM64. בלינוקס היא בגרסת בטא: התקנה בהפצות Ubuntu ו-Debian דרך apt או חבילת .deb.

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

הפרק מבוסס על התיעוד הרשמי של Anthropic לדף Desktop application, נכון לנובמבר 2026.

#שלוש הלשוניות: Chat, Cowork ו-Code

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

1. Chat: שיחות כלליות. מתאים לחשיבה, כתיבה, ניסוח ושאלות בלי לעבוד על מאגר קוד.
2. Cowork: עבודה סוכנית ארוכה ו-Dispatch. מתאים למשימות ידע שדורשות תכנון וביצוע לאורך זמן.
3. Code: סביבת פיתוח תוכנה. כל שיחה היא סשן עם היסטוריה משלה, תיקיית פרויקט ושינויי קוד עצמאיים. מכאן מריצים כמה סשנים במקביל, בודקים diff, צופים באפליקציה, עוקבים אחרי Pull Request, ומתחברים לכלים חיצוניים.

הדף הרשמי הזה הוא הייחוס ללשונית Code. פירוט מלא של Chat ו-Cowork מופיע בתיעוד הייעודי שלהם.

+-------------------------------------------------------------------+
|                          Claude Desktop                           |
+-------------------------------------------------------------------+
|  [ Chat ]           |  [ Cowork ]          |  [ Code ]            |
|  שיחות כלליות       |  סוכן ארוך, Dispatch |  סביבת פיתוח         |
|  בלי סשן קוד        |  משימות ידע ארוכות   |  סשן, תיקייה, diff   |
+-------------------------------------------------------------------+

#פתיחת סשן

בלשונית Code, כל שיחה היא session: יש לה היסטוריית צ'אט משלה ותיקיית פרויקט משלה, ללא תלות בסשנים אחרים. סרגל הצד מציג את הסשנים ומאפשר להריץ כמה סשנים במקביל.

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

• Environment: בורר הסביבה, הבקר הראשון בשורה, קובע איפה Claude רץ. בוחרים Local להרצה על המחשב, Cloud לסשן בענן שממשיך גם אחרי שסוגרים את האפליקציה, חיבור SSH למכונה מרוחקת, וב-Windows גם הפצת WSL. אם בסשן חדש אין בורר סביבה מתחת לתיבת השליחה, זו הפריסה הקודמת: הסביבה ותיקיית הפרויקט נמצאות מעל התיבה, ומצב ההרשאה והמודל בשורה שמתחתיה. איך מזהים את הפריסה מפורט בסעיף בדיקת הפריסה.
• Project folder: לוחצים על בקר תיקיית הפרויקט, ליד בורר הסביבה, ובוחרים את התיקייה שבה Claude עובד. בסשן ענן בוחרים מאגרים במקום תיקייה. בסביבה מקומית או SSH שמורה התיקיות כבר שמורות בסביבה, ולכן השורה לא מציגה בקר תיקייה. כדי לשנות תיקיות עורכים את הסביבה.
• Permission mode: בורר המצבים קובע כמה עצמאות יש ל-Claude. אפשר להחליף מצב גם במהלך הסשן.
• Model: בוחרים מודל מבורר המודל לקראת הקצה הימני של השורה. אפשר להחליף מודל גם במהלך הסשן.

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

בתוך סשן אפשר:

• לסקור ולהעיר על שינויים ב-diff, ולעקוב אחרי ה-PR שנוצר דרך בדיקות CI.
• לצפות בתצוגה מקדימה של האפליקציה בחלונית Browser בזמן ש-Claude מאמת את השינויים של עצמו, ולפתוח אתרים חיצוניים לצידה.
• לצפות ב-Claude מריץ ובודק אפליקציית iOS בחלונית iOS Simulator.
• לסדר חלוניות של צ'אט, diff, דפדפן, טרמינל ועורך קבצים זו לצד זו.
• לשאול שאלת צד על אותו הקשר בלי לסטות מהמשימה הראשית.
• לאפשר ל-Claude לבדוק, לשלוח הודעה או לארכב סשנים אחרים שלכם.
• לחבר כלים חיצוניים כמו GitHub, Slack ו-Linear.
• לאפשר ל-Claude לפתוח אפליקציות ולשלוט במסך.
• להריץ מקומית, בענן, או דרך חיבור SSH.

שליחת משימות מהטלפון דרך Dispatch מתוארת בהמשך. משימות מחזוריות מתוזמנות מתועדות בעמוד נפרד. מי שעובד מה-CLI ימצא בהמשך מה עובר לאפליקציה.

#עבודה עם קוד

מתן הקשר נכון ל-Claude, שליטה על הפעולות שהוא מבצע בעצמו, וסקירת השינויים שביצע.

#שימוש בתיבת השליחה

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

הכפתור + ליד תיבת השליחה מאפשר גישה לצירוף קבצים, כישורים (skills), מחברים (connectors) ותוספים (plugins).

#קבלת הנחיה מוצעת

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

• שימוש בהצעה: לוחצים Tab או Right arrow כדי להכניס אותה לתיבה, עורכים אם רוצים, ואז לוחצים Enter לשליחה. Enter לפני שמקבלים את ההצעה לא שולח אותה.
• כתיבה עצמאית: מתחילים להקליד. ההצעה מופיעה רק כשהתיבה ריקה ואין אליה קבצים מצורפים.

כדי להפסיק הצעות, נכנסים ל-Settings > Code או ל-Settings > Claude Code ומכבים את Prompt suggestions תחת Sessions. הכיבוי חל על כל סשן מהפעם הבאה שהוא מתחיל או ממשיך.

#הוספת קבצים והקשר להודעות

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

• תיוג קבצים עם @: כותבים @ ואחריו שם קובץ כדי להוסיף את הקובץ להקשר השיחה. Claude יכול לקרוא את הקובץ ולהתייחס אליו. בסשן ענן, @ מציג קבצים רק אחרי ששולחים את ההודעה הראשונה. אם @ לא מציג כלום, שולחים את ההודעה הראשונה בלי הקובץ, ומתייגים אותו בהודעה הבאה.
• צירוף קבצים: מצרפים תמונות, קובצי PDF וקבצים נוספים באמצעות כפתור +, או גוררים קבצים ישירות לתיבה. שימושי לשיתוף צילומי מסך של באגים, מוקאפים עיצוביים ומסמכי ייחוס. בסשן WSL, אם תפריט + מציג Add image במקום Add files or photos, אפשר לצרף רק תמונות. כדי לתת ל-Claude כל קובץ אחר מתיקיית הסשן, מתייגים אותו ב-@.

#בחירת מצב הרשאה

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

להגדרת מצב ברירת מחדל לסשנים מקומיים חדשים, מוסיפים את permissions.defaultMode לקובץ ההגדרות. האפליקציה קוראת את אותם קובצי הגדרות כמו ה-CLI. מצב שנבחר בסשן מקומי נשמר לפי תיקייה וגובר על defaultMode בהגדרות .claude/ של הפרויקט. סשן מקומי חדש עדיין יכול להתחיל לפי defaultMode מ-~/.claude/settings.json או מההגדרות המנוהלות, ולכן בודקים את הבורר לפני ההודעה הראשונה. אם בוחרים Plan, הוא חל רק על הסשן הנוכחי.

בגרסאות ישנות של לשונית Code, המצבים נקראו Ask permissions, Auto accept edits ו-Plan mode.

מצב ההרשאה dontAsk זמין ב-CLI בלבד.

#זמינות מצב Auto

מצב Auto זמין לכל משתמשי Anthropic API ודורש מודל Claude Opus 4.6 ומעלה, Sonnet 4.6 ומעלה, Haiku 5.5, או מודל Fable. מנהלי ארגון יכולים לכבות את מצב Auto באמצעות המפתח disableAutoMode בהגדרות מנוהלות (managed settings).

בפריסות Enterprise שמנתבות את אפליקציית שולחן העבודה אל Google Cloud Agent Platform, מצב Auto זמין גם הוא כברירת מחדל. המודלים הנתמכים שם מפורטים בתיעוד של מצב Auto על Bedrock, Agent Platform או Foundry.

מומלץ להתחיל משימות מורכבות במצב Plan כדי ש-Claude יתכנן את הגישה לפני ביצוע שינויים. לאחר אישור התוכנית, עוברים ל-Accept edits או Manual כדי לבצע אותה.

סשני Cloud תומכים במצבים Accept edits, Plan ו-Auto. מצב Accept edits מקביל להגדרת default: עריכות קבצים מאושרות מראש בענן, ולכן הבורר מציג Accept edits במקום Manual. מצב Bypass permissions אינו זמין בסשני ענן, כולל סשנים בסביבה באירוח עצמי (self-hosted environment).

מנהלי ארגון יכולים להגביל אילו מצבי הרשאה יהיו זמינים למשתמשים.

#תצוגה מקדימה של האפליקציה

Claude יכול להפעיל שרת פיתוח ולפתוח אותו בחלונית Browser כדי לאמת את השינויים שלו. הדבר פועל הן עבור אפליקציות ווב (frontend) והן עבור שרתי backend: Claude יכול לבדוק נקודות קצה של API, לצפות בלוגים של השרת, ולתקן בעיות שהוא מוצא. ברוב המקרים Claude מפעיל את השרת אוטומטית לאחר עריכת קובצי הפרויקט. אפשר גם לבקש ממנו תצוגה מקדימה בכל רגע. כברירת מחדל, Claude מאמת שינויים אוטומטית לאחר כל עריכה.

בסשן מקומי, לוחצים על נתיב של קובץ HTML, PDF או וידאו בצ'אט כדי לפתוח אותו בחלונית Browser.

בסשן SSH אין ל-Claude את הכלים של חלונית Browser, ולכן הוא לא יכול לפתוח שם את האפליקציה ולא לאמת אוטומטית את השינויים. גם תפריט Dev servers של החלונית וגם שרתי התצוגה המקדימה שהגדרתם אינם זמינים. כדי להסתכל על האפליקציה בעצמכם, מפעילים את השרת על המכונה המרוחקת, ואז מעבירים את הפורט למחשב, כמו בסעיף הגעה לפורט במכונה המרוחקת.

אם חלונית Browser לא נפתחת אחרי ש-Claude מפעיל שרת בסשן מקומי, לוחצים Open בכרטיס השרת בצ'אט.

מתוך חלונית Browser אפשר:

• לקיים אינטראקציה ישירה עם האפליקציה שרצה בחלונית Browser.
• לצפות ב-Claude מאמת שינויים בעצמו: הוא מצלם מסך, בודק את ה-DOM, לוחץ על אלמנטים, ממלא טפסים ומתקן בעיות שהוא מוצא.
• להפעיל או לעצור שרתים, או לעצור את כולם בבת אחת, מתפריט Dev servers בכותרת חלונית Browser.
• לבחור אם הדפדפן שומר עוגיות אחרי שיוצאים מהאפליקציה, באמצעות Keep cookies בתפריט ⋮ של חלונית Browser, כדי שלא תצטרכו להתחבר מחדש במהלך הפיתוח.

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

Claude יוצר את הגדרת השרת הראשונית על פי הפרויקט שלכם. אם האפליקציה משתמשת בפקודת הרצה מותאמת אישית, עורכים את הקובץ .claude/launch.json כדי להתאים למבנה שלכם.

כדי למחוק נתונים שמורים של הדפדפן, בוחרים Clear browsing data בתפריט ⋮ של חלונית Browser. כדי לכבות את ה-Browser לחלוטין, מכבים את Browser tools תחת Settings > Code או Settings > Claude Code.

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

חלונית Browser היא דפדפן עם לשוניות, כך שאפשר לפתוח תיעוד, מעקב באגים או כל אתר אחר לצד האפליקציה שרצה. פותחים את הדפדפן באמצעות Cmd+Shift+B ב-macOS או Ctrl+Shift+B ב-Windows, או בלחיצה על Browser בשורת הכותרת של הסשן. אפשר להתחבר לאתרים בתוך החלונית, כולל תהליכי התחברות בחלונות קופצים כמו Google OAuth.

בפעם הראשונה שלוחצים על קישור חיצוני בצ'אט, תיבת דו-שיח שואלת אם קישורים נפתחים בחלונית Browser או בדפדפן ברירת המחדל. כדי לשנות את הבחירה אחר כך, משתמשים ב-Open links in built-in browser בתפריט ⋮ של חלונית Browser. לחיצה עם מקש Cmd ב-macOS או Ctrl ב-Windows פותחת קישור ישירות בדפדפן ברירת המחדל.

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

• מסווגי בטיחות בודקים פעולות כתיבה של Claude בדפים חיצוניים, כגון לחיצה והקלדה, בכל מצב הרשאה. אלו אותם מסווגים שבהם משתמש מצב Auto, וכאשר הם מסמנים פעולה, מופיעה בקשת אישור ללא תלות במצב ההרשאה.
• במצבי הרשאה שאינם Auto או Bypass permissions, מתבצעת בדיקת רשימת אתרים מורשים (domain allowlist) לפני ש-Claude מנווט לאתר חדש.

#אישור פעולות של Claude באתר

בפעם הראשונה ש-Claude פועל באתר חיצוני, מופיע כרטיס אישור ו-Claude ממתין לבחירתכם: Allow once, Always allow או Deny. האפשרות Allow once מאשרת את הפעולה בלי לשמור דבר. האפשרות Always allow שומרת את האישור עבור אותו אתר במכשיר שלכם, וניתן לבטל אותה ב-Settings. כל אתר וכל subdomain דורשים אישור משלהם. שרתי פיתוח מקומיים וקובצי הפרויקט אינם דורשים אישור, ולכן אימות שינויים אוטומטי ממשיך לעבוד ללא בקשות אישור.

גם באתר מאושר, Claude לא ירכוש פריטים, לא יפתח חשבונות ולא יעקוף CAPTCHA ללא התערבותכם. גלישה בחלונית Browser משתמשת באותו מודל אבטחה של תוסף Claude in Chrome. המאמר על שימוש בטוח ב-Claude in Chrome מתאר איך Claude מטפל באתרים רגישים ובפעולות מסוכנות.

#בחירה בין חלונית הדפדפן לתוסף Chrome

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

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

חלונית Browser מצייתת לאותן בקרות allowlist ו-blocklist של תוסף Claude in Chrome. אם הארגון שלכם כבר הגדיר רשימות אלו עבור התוסף, החלונית מכבדת אותן אוטומטית. מנהלי ארגון יכולים גם להשבית את הכלים של Claude בדפים חיצוניים באמצעות ההגדרה המנוהלת browserExternalPageTools בערך "disabled". כאשר הכלים מושבתים, משתמשים עדיין יכולים לגלוש באתרים חיצוניים, אך הכלים של Claude אינם יכולים לקרוא אותם או לפעול בהם.

כדי לחסום גלישה חיצונית לחלוטין, מגדירים את ההגדרה המנוהלת disableBrowserExternalNavigation לבוליאני true ב-JSON. המחרוזת "true" מתעלמים ממנה. הדבר חוסם כל ניווט חיצוני בדפדפן, כולל אתרים ברשימת allowlist של הארגון. שרתי פיתוח localhost ותצוגות מקדימות של קבצים מקומיים ממשיכים לעבוד. משתמשים ב-browserExternalPageTools כדי לאפשר למשתמשים להמשיך לגלוש באתרים חיצוניים בלי הכלים של Claude, וב-disableBrowserExternalNavigation כדי לחסום אתרים חיצוניים הן עבור המשתמשים והן עבור Claude.

#סקירת שינויים בתצוגת diff

אחרי ש-Claude מבצע שינויים בקוד, תצוגת ה-diff מאפשרת לסקור שינויים קובץ אחר קובץ לפני יצירת Pull Request.

כדי לפתוח את התצוגה, לוחצים על ספירת השורות, למשל +12 -1, בכרטיס Changes של לוח פרטי הסשן. אפשר גם ללחוץ Changes בשורת הכותרת של הסשן. התצוגה מציגה רשימת קבצים משמאל ואת השינויים בכל קובץ מימין. בסשן ענן, ה-diff מול ענף הבסיס יכול להשמיט שינויים שעדיין לא נדחפו. לפי התיעוד הרשמי, ראו את פתרון התקלות לקובץ חסר בתצוגת ה-diff.

כדי להעיר על שורות מסוימות, מרחפים מעל שורה ולוחצים על ה-+ שמופיע ליד מספר השורה כדי לפתוח תיבת תגובה. כותבים משוב ולוחצים Enter להוספת ההערה. לאחר הוספת הערות לכמה שורות, שולחים את כל ההערות בבת אחת:

• ב-macOS: לוחצים Cmd+Enter
• ב-Windows: לוחצים Ctrl+Enter

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

#ביקורת קוד

כדי ש-Claude יבקר את השינויים לפני commit, מקלידים /code-review בתיבת השליחה. הממצאים מגיעים לשיחה כשהביקורת מסתיימת.

בסשנים מקומיים, ב-SSH וב-WSL, הממצאים מופיעים ככרטיס Code review, מקובצים לפי קובץ. מהכרטיס:

• לוחצים Walk through in diff כדי לפתוח את תצוגת ה-diff ולעבור על הממצאים אחד אחד. ממצא שנמצא ב-diff הנוכחי מופיע בשורה שלו, ושם לוחצים Fix this one או דוחים אותו.
• לוחצים Apply fixes כדי לבקש מ-Claude לתקן את הממצאים שעדיין פתוחים.

בכל סשן אפשר גם לבקש מ-Claude בתיבת השליחה לתקן את מה שהביקורת מצאה. מה ש-/code-review מחפש ואילו ארגומנטים הוא מקבל מפורטים בתיעוד Review a diff locally, לפי הדף הרשמי.

#מעקב אחרי סטטוס Pull Request

כדי ש-Claude יתקן בדיקות שנכשלו, או ש-GitHub ימזג את ה-Pull Request, מפעילים Auto-fix או Merge when ready. אחרי פתיחת Pull Request הוא מופיע בכרטיס Changes של לוח פרטי הסשן, עם סטטוס בדיקות ה-CI. פותחים את תפריט ⋮ ליד הכותרת שלו:

• Auto-fix: בסשן מקומי, Claude גם מטפל בהערות ביקורת חדשות שמשאיר מישהו אחר, לא אתם. מחבר ההערה צריך להיות בעל המאגר, חבר בארגון, collaborator, או GitHub App.
• Merge when ready: מפעיל את ה-auto-merge של GitHub ל-PR. בסשן מקומי הדסקטופ מבקש מיזוג squash, אלא אם ענף הבסיס משתמש ב-merge queue.
  • בסשני SSH ו-WSL: Merge when ready כבוי, ולכן מפעילים auto-merge ל-Pull Request ב-GitHub.
  • אם המאגר לא מתיר auto-merge: Merge when ready לא נדלק. מפעילים auto-merge בהגדרות המאגר ב-GitHub קודם.
• פריסה קודמת: אחרי שיש לסשן Pull Request, לוחצים CI בסרגל הסטטוס שלו.

כדי לארכב את הסשן אוטומטית לאחר מיזוג או סגירת ה-PR, מפעילים את ארכוב הסשנים האוטומטי תחת Settings > Code או Settings > Claude Code.

ניטור PR דורש התקנה ואימות של GitHub CLI (gh) במחשב שלכם. אם gh אינו מותקן, האפליקציה תבקש להתקין אותו בפעם הראשונה שמנסים ליצור PR.

בסשן SSH מכינים את git ואת gh על המכונה המרוחקת לפני לחיצה על Create PR, כי Claude דוחף את הענף ומריץ שם gh pr create. מתקינים את gh שם בעצמכם: בדסקטופ אין בקשת התקנה בסשן SSH. אחר כך בודקים שם ש-git push עובד, וש-gh auth status מדווח שאתם מחוברים.

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

לשונית Code בנויה מחלוניות שניתן לסדר בכל פריסה: צ'אט, diff, דפדפן, טרמינל, קובץ, תוכנית (plan), משימות (tasks), סוכן משנה (subagent), וב-macOS גם חלונית iOS Simulator. גוררים חלונית מהכותרת שלה כדי למקם אותה מחדש, או גוררים את הקצה כדי לשנות גודל. לוחצים Cmd+\ ב-macOS או Ctrl+\ ב-Windows כדי לסגור את החלונית הממוקדת.

לפתיחת חלונית נוספת לוחצים על כפתור הסמל שלה בשורת הכותרת של הסשן. ריחוף מציג את שם הכפתור, כמו Terminal, Changes לתצוגת ה-diff, Browser ו-Files. אם לחלונית אין כפתור בשורת הכותרת, בוחרים אותה מתפריט ⋮ ליד הכפתורים:

• כשהחלון צר: כפתורים שלא נכנסים עוברים לתפריט.
• לחלוניות בלי כפתור: חלוניות כמו Background tasks ו-Plan מופיעות ברשימה אחרי שיש בסשן מה להציג בהן.

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

סידור החלוניות, הטרמינל, עורך הקבצים ומצבי התצוגה דורשים גרסה 1.2581.0 ומעלה של Claude Desktop. ב-macOS מעדכנים דרך Claude > Check for Updates…, וב-Windows דרך Help > Check for Updates….

#פרטי הסשן

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

כדי להסתיר או להציג את הלוח, לוחצים Hide session rail או Show session rail בשורת הכותרת של הסשן, או בתפריט ⋮ של השורה כשהחלון צר. אם הלוח עדיין לא נראה, בודקים איזו פריסה של לשונית Code יש, כמו בסעיף בדיקת הפריסה.

#מזעור חלונית

כדי להשאיר את Terminal, את Browser או את iOS Simulator גלויים בגודל קטן, לוחצים Minimize בכותרת החלונית. הכפתור דורש Claude Desktop מגרסה 4.0.0 ומעלה, וחשבון Claude ולא ספק צד שלישי. בחלונית Browser הכפתור קיים רק בסשנים מקומיים.

החלונית הממוזערת יושבת בלוח פרטי הסשן כל עוד הלוח על המסך, ואחרת צפה בפינה של הצ'אט:

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

כדי להחזיר את החלונית המלאה, לוחצים Expand בכותרת החלונית הממוזערת. כדי לסגור אותה, לוחצים על כפתור הסגירה ליד Expand.

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

הטרמינל המשולב מאפשר להריץ פקודות לצד הסשן בלי לעבור לאפליקציה אחרת. לוחצים Terminal בשורת הכותרת של הסשן, או לוחצים Ctrl+` ב-macOS וב-Windows. הטרמינל נפתח בספריית העבודה של הסשן וחולק את אותה הסביבה עם Claude, כך שפקודות כמו npm test או git status רואות את אותם הקבצים ש-Claude עורך. לפתיחת לשונית טרמינל נוספת, לוחצים על + בכותרת חלונית הטרמינל או לוחצים לחיצה ימנית על תיקייה בצ'אט ובוחרים Open in terminal.

אם בסשן WSL אין טרמינל, הבדיקה מפורטת בתיעוד WSL, לפי הדף הרשמי. הטרמינל זמין בסשנים מקומיים ובסשני SSH, עם מגבלה במכונה מרוחקת של Windows: הוא לא נפתח בסשן שהתיקייה שלו היא נתיב Windows, כמו C:/projects/app.

#פתיחה ועריכה של קבצים

כדי לפתוח קובץ ש-Claude מזכיר, לוחצים על הנתיב שלו בצ'אט.

כדי לערוך קובץ בעצמכם, משתמשים בחלונית הקבצים:

• סשנים מקומיים: אפשר לערוך קבצים בתוך ספריית העבודה של הסשן, חוץ מקבצים לצפייה בלבד כמו .mcp.json ו-.claude/settings.json. כדי לשנות קובץ כזה, פותחים אותו באפליקציה אחרת.
• סשני ענן, SSH ו-WSL: חלונית הקבצים לצפייה בלבד, ולכן מבקשים מ-Claude לבצע את השינוי.

#שמירת עריכות בחלונית הקבצים

כברירת מחדל העריכות בחלונית נשמרות לבד, ולכן אין בה כפתור Save. כדי לשמור בעצמכם, מבטלים את הסימון של Auto save בתפריט ⋮ של החלונית. כש-Auto save כבוי, לוחצים Save אחרי שינוי כדי לכתוב את העריכות, או Cancel כדי לבטל אותן.

אם החלונית מזהירה שהקובץ השתנה בדיסק, לוחצים Override כדי לכתוב את העריכות מעל הגרסה בדיסק, או Discard כדי לוותר עליהן.

#פתיחת קבצים באפליקציות אחרות

לחיצה ימנית על נתיב קובץ כלשהו בצ'אט, בתצוגת ה-diff או בחלונית הקבצים פותחת תפריט הקשר:

• Attach as context: הוספת הקובץ להודעה הבאה שלכם.
• Open in: פתיחת הקובץ בעורך מותקן כמו VS Code, Cursor או Zed.
• Show in Finder ב-macOS, או Show in Explorer ב-Windows: פתיחת התיקייה המכילה את הקובץ.
• Copy: תת-תפריט שמעתיק את Absolute path, את Relative path, או את Filename.

#החלפת מצבי תצוגה

מצבי התצוגה קובעים כמה פירוט יופיע בתמליל השיחה. פותחים את תפריט הסשן מהחץ שליד כותרת הסשן ובוחרים Transcript view, או לוחצים Ctrl+O ב-macOS או ב-Windows כדי לעבור ביניהם באופן מעגלי. מצב Thinking מופיע בתפריט רק אחרי ש-Claude יצר חשיבה בסשן שבו אתם צופים.

משתמשים ב-Thinking כדי לעקוב אחר קו המחשבה של Claude כאשר קריאות הכלים עדיין מכווצות. משתמשים ב-Verbose כדי לחקור ולנפות שגיאות כאשר רוצים להבין מדוע Claude נקט בפעולה מסוימת. גרסאות של Claude Desktop שלפני 1.46388.1 הציגו גם מצב Summary, וסשן שעדיין מוגדר בו Summary ייפתח במצב Normal לאחר העדכון.

#קיצורי מקלדת

לוחצים Cmd+/ ב-macOS או Ctrl+/ ב-Windows כדי לצפות בכל קיצורי המקלדת הזמינים בלשונית Code. הטבלה מציגה את המקשים של macOS. ב-Windows ובלינוקס מחליפים כך:

• Cmd+Option: לוחצים Alt.
• Cmd+Ctrl: לוחצים Ctrl+Alt.
• Cmd: לוחצים Ctrl.

מעבר מעגלי בין סשנים, פתיחת הטרמינל ומעבר בין מצבי תצוגה משתמשים ב-Ctrl בכל הפלטפורמות.

קיצורים אלה חלים על לשונית Code בלבד. בדסקטופ, Shift+Tab לא עובר בין מצבי הרשאה כמו במצב האינטראקטיבי של ה-CLI בטרמינל.

#בדיקת ניצול משאבים

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

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

בשתי הפריסות מקלידים /context בתיבת השליחה כדי להדפיס בצ'אט פירוט לפי קטגוריה של חלון ההקשר של הסשן הזה.

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

#שליטה של Claude במחשב

Computer use נותן ל-Claude לפתוח אפליקציות, לשלוט במסך ולעבוד על המחשב כמוכם. מתאים לכלי שולחן עבודה בלי CLI, או לאוטומציה שפועלת רק דרך ממשק גרפי. להרצה ובדיקה של אפליקציות iOS נפתחת חלונית iOS Simulator ייעודית, בלי שליטה במסך, והיא פועלת גם בלי להפעיל computer use.

זו תצוגת מחקר ב-macOS וב-Windows, ודורשת תוכנית Pro, Max או Ultra. היא אינה זמינה בתוכניות Team או Enterprise. אפליקציית Claude Desktop חייבת לרוץ. ב-macOS, computer use דורש macOS 14 ומעלה.

היכולת כבויה כברירת מחדל. מפעילים אותה ב-Settings לפני ש-Claude יכול לשלוט במסך. ב-macOS צריך גם הרשאות Accessibility ו-Screen Recording.

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

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

#מתי זה נכנס לפעולה

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

• אם יש connector לשירות, Claude משתמש בו.
• אם המשימה היא פקודת מעטפת, Claude משתמש ב-Bash.
• אם המשימה היא עבודה בדפדפן ויש Claude in Chrome, Claude משתמש בו.
• אם המשימה היא הרצה או בדיקה של אפליקציית iOS, Claude משתמש בחלונית iOS Simulator, בלי שליטה במסך.
• אם אף אחת מאלה לא מתאימה, Claude משתמש ב-computer use.

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

#הפעלה

היכולת כבויה כברירת מחדל. אם מבקשים מ-Claude משימה שדורשת אותה כשהיא כבויה, הוא אומר שאפשר לבצע אותה אחרי הפעלה ב-Settings.

1. עדכון האפליקציה. מוודאים את הגרסה האחרונה של Claude Desktop. ב-macOS וב-Windows מורידים או מעדכנים ב-claude.com/download. בלינוקס מעדכנים דרך מנהל החבילות. אחר כך מפעילים מחדש את האפליקציה.

2. הפעלת המתג. באפליקציה נכנסים ל-Settings, ואז:

   • אם תפריט Settings מציג This computer: נכנסים ל-This computer > System.
   • אחרת: נכנסים ל-Capabilities.

   תחת Computer use מפעילים את Enable computer use. ב-Windows המתג נכנס לתוקף מיד וההגדרה הושלמה. ב-macOS ממשיכים לשלב הבא. אם המתג לא מופיע, מוודאים שזו מערכת macOS או Windows עם תוכנית Pro, Max או Ultra, מעדכנים ומפעילים מחדש.

3. הרשאות macOS. ב-macOS מעניקים שתי הרשאות מערכת לפני שהמתג נכנס לתוקף:

   • Accessibility: מאפשר ל-Claude ללחוץ, להקליד ולגלול.
   • Screen Recording: מאפשר ל-Claude לראות את המסך.

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

#הרשאות לאפליקציות

בפעם הראשונה ש-Claude צריך אפליקציה, מופיעה בקשה בסשן. לוחצים Allow for this session או Deny. אישור נשמר לסשן הנוכחי, או ל-30 דקות בסשן שנפתח מ-Dispatch.

הבקשה גם מראה איזו רמת שליטה Claude מקבל. הדרגות קבועות לפי קטגוריית האפליקציה ואי אפשר לשנות אותן:

אפליקציות עם טווח רחב, כמו טרמינלים, Finder או File Explorer, ו-System Settings או Settings, מציגות אזהרה נוספת בבקשה כדי שיהיה ברור מה האישור מעניק.

ב-Settings, בקטע Computer use שבו הפעלתם את היכולת, יש שתי הגדרות:

• Denied apps: אפליקציות שנדחות בלי בקשה. Claude עדיין יכול להשפיע על אפליקציה חסומה בעקיפין דרך פעולה באפליקציה מותרת, אבל לא לגשת אליה ישירות.
• Unhide apps when Claude finishes: כש-computer use לא רץ ברקע, Claude מסתיר חלונות אחרים בזמן העבודה כדי לגעת רק באפליקציה שאושרה. בסיום, החלונות המוסתרים חוזרים, אלא אם מכבים את ההגדרה הזו.

#ניהול סשנים

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

#עבודה במקביל

לוחצים + New בסרגל הצד, או Cmd+N ב-macOS ו-Ctrl+N ב-Windows. Ctrl+Tab ו-Ctrl+Shift+Tab עוברים בין הסשנים בסרגל.

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

• זה לצד זה: מחזיקים Option ב-macOS או Alt ב-Windows ולוחצים על סשן בסרגל, או לוחצים לחיצה ימנית על הסשן ובוחרים Open in ואז Split view.
• בחלון משלו: מחזיקים Cmd ב-macOS או Ctrl ב-Windows ולוחצים על סשן, או לוחצים לחיצה ימנית על הסשן ובוחרים Open in ואז New window.

בפיצול, החלונית שנפתחה או שנלחצה אחרונה היא במיקוד, והחלונית השנייה מעומעמת. כדי להחליף איזה סשן חלונית מציגה, לוחצים בתוך החלונית כדי לתת לה מיקוד, ואז לוחצים על סשן בסרגל. כדי להוציא את הסשן שבמיקוד מהפיצול, לוחצים Cmd+Ctrl+W ב-macOS או Ctrl+Alt+W ב-Windows.

#סשן ב-worktree משלו

בפרויקט שהוא מאגר Git, מפעילים Worktree לפני תחילת הסשן כדי להריץ אותו ב-Git worktree משלו, עותק מבודד של הפרויקט. כברירת מחדל Worktree כבוי, ו-Claude עובד בתיקיית הפרויקט עצמה. בפריסה הנוכחית מפעילים את כפתור Worktree בשורה שמתחת לתיבת השליחה.

• עם ספק צד שלישי: אם השורה שמתחת לתיבת השליחה מציגה את בקר תיקיית הפרויקט אבל אין בה כפתור Worktree, לוחצים על הבקר הזה ומפעילים Worktree.
• כברירת מחדל לסביבה מקומית או SSH שמורה: קובעים Worktree ביצירה או בעריכה של הסביבה.
• פריסה קודמת: בוחרים בתיבת worktree ליד שם הענף, מעל תיבת השליחה.

כברירת מחדל ה-worktrees נשמרים ב-<project-root>/.claude/worktrees/. אפשר לשנות את המיקום:

• סשנים מקומיים: Worktree location ב-Settings > Code או ב-Settings > Claude Code.
• סשני SSH: Worktree folder על חיבור ה-SSH.

אפשר גם לקבוע Branch prefix ב-Settings > Code או ב-Settings > Claude Code. הדסקטופ מדביק אותה לכל שם ענף של worktree, כדי לשמור על סדר בענפים ש-Claude יוצר.

כדי לכלול ב-worktree חדש קבצים ש-Git מתעלם מהם, כמו .env, יוצרים קובץ .worktreeinclude בשורש הפרויקט. איפה סשן worktree קורא הגדרות פרויקט, הוקים וכישורים מפורט בתיעוד What worktrees share with the main checkout, לפי הדף הרשמי.

בידוד סשנים דורש Git. רוב מחשבי Mac כוללים Git כברירת מחדל. מריצים git --version בטרמינל: אם מודפס מספר גרסה, Git מותקן. אם נתקלים בשגיאות Git, אפשר לבקש מ-Claude בלשונית Cowork לסייע בפתרון.

#הוספת תיקיות לסשן

אפשר להוסיף תיקיות לפני שהסשן מתחיל או בזמן שהוא רץ:

• לפני שסשן מקומי מתחיל: מוסיפים את התיקיות תחת Folders ביצירה או בעריכה של סביבה שמורה, ואז מתחילים את הסשן מהסביבה הזו.
• בזמן שסשן מקומי או SSH רץ: לוחצים + ליד תיבת השליחה ובוחרים Add folder. Claude עובד בתיקייה עצמה, בלי worktree.

#ארכוב סשן

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

כדי שסשנים יתארכבו כשה-PR ממוזג או נסגר, מפעילים Auto-archive after PR merge or close ב-Settings > Code או ב-Settings > Claude Code. סשני ענן וסשנים שעדיין רצים לא מארכבים את עצמם.

#שמירת שינויים שלא נכנסו ל-commit בארכוב

אפשר לאבד שינויים שלא נכנסו ל-commit ב-worktree של סשן כשהסשן מארכב, ולכן עושים commit למה שרוצים לשמור קודם:

• אם הדסקטופ שואל על השינויים: בוחרים Archive anyway כדי לזרוק אותם, או מבטלים ועושים להם commit.
• אם השינויים היחידים הם קבצים שלא במעקב: עושים commit לאלה שרוצים לשמור לפני ש-Pull Request ש-Claude פתח בסשן מתמזג, כי הדסקטופ יכול אז למחוק אותם בלי לשאול.
• בכל מקרה אחר: ה-worktree נשאר בדיסק עם השינויים שלו. בסשן מקומי הדסקטופ מסיר את שניהם כ-30 יום אחרי שהסשן אורכב או אחרי הפעם האחרונה שפתחתם אותו, המאוחר מביניהם. כדי לשמור את השינויים, פותחים את הסשן מלשונית Archived ובוחרים Unarchive.

#ארגון ומציאת סשנים

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

• פריסה נוכחית: מרחפים מעל כותרת ברשימת הסשנים כדי להציג את סמל Group and sort, ואז לוחצים עליו. כדי למצוא סשנים בארכיון בוחרים View all, השורה האחרונה בתפריט, ואז פותחים את לשונית Archived.
• פריסה קודמת: סמל Filter מופיע בלי ריחוף. לוחצים עליו ומסדרים את הרשימה עם Group by או Sort by. כדי להציג סשנים בארכיון בוחרים Status, ואז Archived.

לשינוי שם פותחים את הסשן ולוחצים על כותרת הסשן בשורת הכותרת.

#בדיקת הקשר ופינוי

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

#התראה כשסשן מסתיים

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

#שאלת צד בלי להסיט את הסשן

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

Cmd+; ב-macOS או Ctrl+; ב-Windows פותחים צ'אט צד, וגם הקלדת /btw בתיבת השליחה. הצ'אט הצד קורא את כל מה שיש בשרשור הראשי עד לאותו רגע. בסיום סוגרים אותו וממשיכים את הסשן הראשי מהמקום שבו עצרתם.

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

#משימות ברקע

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

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

#עבודה בין סשנים

Claude יכול לרשום סשנים אחרים בלשונית Code, לקרוא מה כל אחד עשה, ולשלוח ביניהם הודעות. אפשר לשאול בשפה רגילה, למשל איזה סשן נגע בשינוי של האימות, מה הסשן של ה-API הסיק, או לבקש לעדכן את סשן התשלומים שהסכמה השתנתה. אפשר גם לבקש לשנות שם או לארכב סשן, למשל לארכב סשנים שה-PR שלהם כבר מוזג. הארכיון זהה לבחירת Archive מהתפריט בסרגל.

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

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

Claude Code מפעיל שלוש התנהגויות בטיחות בין סשנים:

• כרטיס אישור מופיע לפני ש-Claude מארכב סשן, חוץ ממצב Auto ומצב Bypass permissions, שבהם Claude יכול לארכב סשן בלי כרטיס. כדי שישאלו, עוברים ל-Manual.
• Claude Code בודק כל הודעה מהמשטח הזה מול בקרות הכניסה של הסשן המקבל, גם אם לסשן המקבל אין בעצמו הודעות בין סשנים. אם מגדירים crossSessionInbound ל-refuse בסשן המקבל, Claude Code משליך את ההודעות מהמשטח הזה ומדווח על הסירוב לאפליקציה. לפני גרסה 2.1.234, Claude Code השליך כל הודעה מהמשטח הזה אל סשן מקבל בלי הודעות בין סשנים.
• Claude Code מצטט כל הודעה נכנסת ומייחס אותה לסשן ששלח אותה, ו-Claude עדיין פועל לפי הרשאות הסשן המקבל כשהוא פועל על הודעה.

#התחלת משימה ש-Claude מציע

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

• Start: מתחיל את המשימה בסשן אחר. כברירת מחדל המשימה רצה בסביבה של הסשן הנוכחי. הכרטיס מציג אחר כך את מצב הסשן שהתחיל, וסרגל הצד מציג את הסשן שהתחיל תחת הסשן הנוכחי.
• Do it here: שולח את המשימה לסשן הנוכחי כהודעה.
• Options: בודקים או משנים הגדרות כמו הסביבה, המודל, ה-worktree וההרשאות לפני שלוחצים Start.
• Start all: כשהכרטיס מציג כמה משימות, מתחיל כל משימה בסשן משלה בלי להמתין שאחת תסתיים לפני שמתחילים את הבאה.

בסשני ענן, ובסשנים מקומיים וב-SSH בפריסה הקודמת, ההצעה היא כרטיס Suggested task. כדי להתחיל את המשימה איפה שכפתור הכרטיס הראשי אומר, למשל Send to cloud או Start with worktree, לוחצים על הכפתור הזה. לוחצים על החץ ליד הכפתור הראשי לדרכים אחרות להתחיל את המשימה, כולל Do it here.

#משימות ארוכות בענן

לרפקטורים גדולים, חבילות בדיקה, מיגרציות או משימות ארוכות אחרות, בוחרים סביבה תחת Cloud בבורר הסביבה בפתיחת הסשן. סשני ענן רצים כברירת מחדל על תשתית שמנוהלת אצל Anthropic וממשיכים גם אחרי שסוגרים את האפליקציה או מכבים את המחשב. אפשר לחזור בכל רגע כדי לראות התקדמות או לכוון את Claude לכיוון אחר. אפשר גם לעקוב מ-claude.ai/code או מאפליקציית Claude לנייד.

סשני ענן תומכים גם בכמה מאגרים:

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

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

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

#המשך במשטח אחר

כדי להמשיך סשן במקום אחר, פותחים את תפריט הסשן מהחץ שליד כותרת הסשן, או משורת הסשן בסרגל הצד, ובוחרים Open in:

• Cloud: ממשיך את הסשן כסשן ענן, והשיחה עוברת כסיכום. לפני האישור, תיבת הדו-שיח מציינת אם הקבצים עוברים גם הם, ואם הסשן הזה נכנס לארכיון ברגע שסשן הענן מוכן. אי אפשר להעביר כך סשן שרץ ב-SSH או ב-WSL.
• בחירה בעורך מותקן או במנהל הקבצים פותחת שם את תיקיית הסשן על הדיסק.

#אילו סשנים מופיעים במכשירים אחרים

סשן מקומי מופיע במכשירים האחרים ברגע ש-Remote Control מחבר אותו. סשן מחובר מופיע ברשימת הסשנים ב-claude.ai/code ובאפליקציות Claude במכשירים שמחוברים לאותו חשבון claude.ai.

סשן מקומי מתחבר כשמפעילים לו Remote Control, או אוטומטית כשהוא מתחיל:

• הפעלה לסשן הזה: מתג Remote Control של הסשן, או הקלדת /remote-control בתיבת השליחה.
• חיבור בהפעלה: סשנים חדשים מתחברים אוטומטית כל עוד Connect new sessions to Remote Control דלוק ב-Settings > Code או ב-Settings > Claude Code. אם מעולם לא שיניתם את ההגדרה, הדסקטופ פועל לפי remoteControlAtStartup בהגדרות המשתמש או בהגדרות המנוהלות, ואחר כך לפי ברירת המחדל של הארגון.

כדי לראות אם סשן מחובר, בודקים את מתג Remote Control בכרטיס Environment של לוח פרטי הסשן.

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

• סשן אחד: מכבים את מתג Remote Control שלו. בסשן שהתחבר כשהתחיל, הקלדת /remote-control משאירה את Remote Control דלוק ומציגה את השורה Remote Control is already on. This session connected automatically when it started. לוחצים Turn off בשורה הזו כדי לנתק.
• סשני דסקטופ חדשים במחשב הזה: מכבים את Connect new sessions to Remote Control ב-Settings > Code או ב-Settings > Claude Code. אם זה כבר כבוי, מדליקים ואז מכבים כדי שהדסקטופ ישמור את הבחירה. אחרי השמירה היא גוברת על remoteControlAtStartup ועל ברירות המחדל.
• כל סשן במחשב הזה, כולל ה-CLI: מגדירים disableRemoteControl ל-true ב-~/.claude/settings.json כדי לעצור חיבור של סשנים. סשן שכבר היה מחובר כששמרתם את הקובץ נשאר מחובר עד שמכבים לו את Remote Control.

כדי להסתיר סשן שכבר מופיע במכשירים האחרים, מארכבים אותו בדסקטופ. הדסקטופ מארכב גם את עותק ה-Remote Control, והסשן יוצא מרשימת ברירת המחדל שם. צפייה או מחיקה שם מתוארות בתיעוד Archive sessions, לפי הדף הרשמי.

#סשנים מ-Dispatch

Dispatch הוא שיחה מתמשכת עם Claude בלשונית Cowork. שולחים אליו משימה, והוא מחליט איך לטפל בה.

משימה מגיעה לסשן Code בשתי דרכים: מבקשים זאת במפורש, למשל לפתוח סשן Claude Code ולתקן באג התחברות, או ש-Dispatch מזהה שזו עבודת פיתוח ופותח סשן בעצמו. משימות שבדרך כלל מנותבות ל-Code כוללות תיקון באגים, עדכון תלויות, הרצת בדיקות או פתיחת Pull Request. מחקר, עריכת מסמכים ועבודה בגיליונות נשארים ב-Cowork.

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

אם computer use מופעל, גם סשני Code שנפתחו מ-Dispatch יכולים להשתמש בו. אישורי אפליקציה בסשנים האלה פגים אחרי 30 דקות ומבקשים שוב, בניגוד לסשן Code רגיל שבו האישור נמשך לכל הסשן.

Dispatch דורש תוכנית Pro, Max או Ultra, ואינו זמין בתוכניות Team או Enterprise. ההגדרה, הצימוד וההגדרות מפורטים במאמר העזרה של Dispatch.

Dispatch הוא אחת מכמה דרכים לעבוד עם Claude כשלא נמצאים ליד הטרמינל. השוואה לאפשרויות האחרות מופיעה בתיעוד Platforms and integrations, לפי הדף הרשמי.

#הרחבת Claude Code

מחברים שירותים חיצוניים, מוסיפים תהליכי עבודה לשימוש חוזר, ומתאימים את ההתנהגות של Claude. לניהול מחברים, כישורים ותוספים במקום אחד, לוחצים Customize בסרגל הצד. לשונית Cowork שואבת כישורים, תוספים ומחברים מההגדרה הזו, שמסתנכרנת דרך חשבון claude.ai, לא מתיקיית ~/.claude של ה-CLI.

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

#חיבור כלים חיצוניים

מחברים הם שרתי MCP עם תהליך הגדרה גרפי.

בסשן מקומי או SSH עם חשבון Claude, לוחצים + ליד תיבת השליחה לפני הסשן או במהלכו. בוחרים Add connectors כדי לפתוח את ספריית המחברים. אם התפריט מציג Connectors, בוחרים אותו ואז Browse connectors.

אם Connectors אפור בסשן WSL, או שמחברים בסשן ענן, הפירוט בעמודים הייעודיים לפי התיעוד הרשמי.

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

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

#שימוש בכישורים

כישורים (skills) מרחיבים את מה ש-Claude יכול לעשות. הוא טוען אותם אוטומטית כשהם רלוונטיים, או שאפשר להפעיל אחד ישירות: מקלידים / בתיבת השליחה, או לוחצים + ובוחרים Slash commands. הרשימה כוללת פקודות מובנות, כישורים מותאמים, כישורי פרויקט מהמאגר, וכישורים מתוספים מותקנים. אחרי הבחירה הפקודה מסומנת בשדה, כותבים את המשימה ושולחים כרגיל.

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

סשנים מקומיים טוענים כישורים אישיים מ-~/.claude/skills/. סשן SSH קורא את ~/.claude/skills/ מתיקיית הבית של המארח המרוחק, לא מהמחשב שלכם.

סשנים מקומיים וסשני ענן טוענים גם את הכישורים שמופעלים לחשבון claude.ai, חוץ מסשנים מקומיים כשהארגון מגדיר disableSideloadFlags. סשני ענן טוענים אותם במקום את ~/.claude/skills/.

#התקנת תוספים

תוספים (plugins) הם חבילות לשימוש חוזר שמוסיפות כישורים, סוכנים, הוקים, שרתי MCP והגדרות LSP. אפשר להתקין אותם מהאפליקציה בלי טרמינל.

בסשן מקומי או SSH, לוחצים + ליד תיבת השליחה ובוחרים Add plugins כדי לפתוח את דפדפן התוספים. אם התפריט מציג Plugins, בוחרים אותו ואז Browse plugins, או Manage plugins כדי להפעיל, לכבות או להסיר תוספים.

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

דפדפן התוספים אינו זמין בסשני ענן, ותוספים שהותקנו מהאפליקציה אינם זמינים לסשני ענן. סשן ענן גם לא מתקין תוספים שמוצהרים ב-.claude/settings.json של המאגר. תוספים אינם זמינים בסשני WSL.

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

Claude מזהה את שרת הפיתוח ושומר את ההגדרה ב-.claude/launch.json בשורש התיקייה שנבחרה בפתיחת הסשן. התצוגה המקדימה משתמשת בתיקייה הזו כספריית עבודה. אם נבחרה תיקיית אב, תת-תיקיות עם שרת משלהן לא יזוהו אוטומטית. כדי לעבוד עם שרת של תת-תיקייה, פותחים סשן באותה תיקייה או מוסיפים הגדרה ידנית.

כדי לשנות את אופן ההפעלה, למשל yarn dev במקום npm run dev, או כדי לשנות פורט, עורכים את .claude/launch.json. הקובץ תומך ב-JSON עם הערות.

{
  "version": "0.0.1",
  "configurations": [
    {
      "name": "my-app",
      "runtimeExecutable": "npm",
      "runtimeArgs": ["run", "dev"],
      "port": 3000
    }
  ]
}

אפשר להגדיר כמה תצורות ולהריץ שרתים שונים מאותו פרויקט, למשל חזית ו-API.

#אימות אוטומטי

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

אימות אוטומטי מופעל כברירת מחדל. מכבים אותו לפרויקט על ידי "autoVerify": false ב-.claude/launch.json, או מכבים את Auto-verify changes בתפריט ⋮ של חלונית Browser.

{
  "version": "0.0.1",
  "autoVerify": false,
  "configurations": [
    {
      "name": "my-app",
      "runtimeExecutable": "npm",
      "runtimeArgs": ["run", "dev"],
      "port": 3000
    }
  ]
}

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

#שדות ההגדרה

כל רשומה במערך configurations מקבלת את השדות הבאים:

#מתי להשתמש ב-program ומתי ב-runtimeExecutable

משתמשים ב-runtimeExecutable עם runtimeArgs כדי להפעיל שרת פיתוח דרך מנהל חבילות. לדוגמה, "runtimeExecutable": "npm" עם "runtimeArgs": ["run", "dev"] מריץ npm run dev.

משתמשים ב-program כשיש סקריפט עצמאי שרוצים להריץ עם node ישירות. לדוגמה, "program": "server.js" מריץ node server.js. דגלים נוספים עוברים ב-args.

#פתיחת התצוגה בכתובת מסוימת

כברירת מחדל התצוגה פותחת את http://localhost:<port>. מגדירים url כשהשרת צריך כתובת אחרת. מקרים נפוצים: שרת שדורש HTTPS מקומי, אפליקציה שמשתמשת בתת-דומיין *.localhost, ואפליקציה שמתחברת דרך הפניה.

{
  "version": "0.0.1",
  "configurations": [
    {
      "name": "my-app",
      "runtimeExecutable": "npm",
      "runtimeArgs": ["run", "dev"],
      "port": 8443,
      "url": "https://localhost:8443"
    }
  ]
}

כתובות localhost נפתחות ישירות, כמו כתובת הפורט הרגילה. זה כולל את localhost, כל תת-דומיין *.localhost, את 127.0.0.1 ואת ::1. מטעמי אבטחה, url של localhost חייב להיות ה-origin של השרת בלבד, בלי נתיב ובלי query, והפורט שלו חייב להתאים לפורט של הרשומה. כדי להציג עמוד מסוים, מבקשים מ-Claude לנווט אליו אחרי שהתצוגה נפתחת. url של localhost עם נתיב, query או פורט לא תואם מדווח כשגיאת הגדרה שמציינת את ה-url ואת התיקון.

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

כדי להציג שרת שאתם כבר מריצים בעצמכם, מגדירים url בלי פקודה. Claude מחבר את התצוגה לשרת שרץ, בלי להפעיל שרת:

{
  "version": "0.0.1",
  "configurations": [
    {
      "name": "my-app",
      "url": "https://app.localhost:3000"
    }
  ]
}

ה-url חייב להיות http או https, ובלי שם משתמש או סיסמה.

#התנגשות פורטים

השדה autoPort קובע מה קורה כשהפורט המועדף תפוס:

• true: Claude מוצא פורט פנוי ומשתמש בו. מתאים לרוב שרתי הפיתוח.
• false: Claude נכשל עם שגיאה. מתאים כשהשרת חייב פורט מסוים, למשל ל-callbacks של OAuth או לרשימות CORS.
• לא מוגדר (ברירת מחדל): השרת מקבל את הפורט הפנוי הבא, כמו ב-true, חוץ מהמקרה שלהלן. לפני Claude Desktop מגרסה 2.37337.0, Claude שואל אם השרת צריך בדיוק את הפורט הזה, ושומר את התשובה ב-launch.json.

אם הפורט המועדף תפוס ו-autoPort לא מוגדר, השרת נשאר עצור כשכל אלה מתקיימים:

• מפעילים את השרת דרך סקריפט של npm, yarn, pnpm או bun.
• הפורט המועדף קשיח בסקריפט, או ש-Claude לא יכול לבדוק את הסקריפט.
• לא מעבירים את הפורט ב-runtimeArgs.

במקרה הזה משחררים את הפורט, מסירים את הערך הקשיח, או משנים את port כך שיתאים לסקריפט. "autoPort": true עובד כאן רק לסקריפט שקורא את PORT.

השרת צריך לקרוא את הפורט ממשתנה הסביבה PORT, שמחזיק את הפורט שהוקצה. כש-Claude מעביר את השרת לפורט אחר, הוא גם משכתב ערך --port או -p ב-runtimeArgs כדי שיתאים.

#דוגמאות

Next.js עם Yarn על פורט 3000:

{
  "version": "0.0.1",
  "configurations": [
    {
      "name": "web",
      "runtimeExecutable": "yarn",
      "runtimeArgs": ["dev"],
      "port": 3000
    }
  ]
}

monorepo עם חזית ושרת API. החזית עם autoPort: true בוחרת פורט פנוי אם 3000 תפוס, ושרת ה-API דורש בדיוק את פורט 8080:

{
  "version": "0.0.1",
  "configurations": [
    {
      "name": "frontend",
      "runtimeExecutable": "npm",
      "runtimeArgs": ["run", "dev"],
      "cwd": "apps/web",
      "port": 3000,
      "autoPort": true
    },
    {
      "name": "api",
      "runtimeExecutable": "npm",
      "runtimeArgs": ["run", "start"],
      "cwd": "server",
      "port": 8080,
      "env": { "NODE_ENV": "development" },
      "autoPort": false
    }
  ]
}

סקריפט Node.js ישירות, בלי מנהל חבילות, דרך השדה program:

{
  "version": "0.0.1",
  "configurations": [
    {
      "name": "server",
      "program": "server.js",
      "args": ["--verbose"],
      "port": 4000
    }
  ]
}

#הגדרת הסביבה

הסביבה שנבחרת בפתיחת סשן קובעת איפה Claude רץ ואיך מתחברים:

• Local: על המחשב שלכם, עם גישה ישירה לקבצים.
• Cloud: כברירת מחדל על תשתית שמנוהלת אצל Anthropic. הסשן ממשיך גם אחרי סגירת האפליקציה.
• SSH: על מכונה מרוחקת שמתחברים אליה ב-SSH, כמו שרתים שלכם, מכונות וירטואליות בענן, או מכולות פיתוח. משימה שרצה יכולה להמשיך כשהדסקטופ מנותק, אבל בחשבון Claude היא יכולה להיעצר כשההתחברות פגה.
• WSL ב-Windows: בתוך הפצת WSL 2 על המחשב, עם שרשרת הכלים של לינוקס ונתיבים נייטיב.

#יצירת סביבה שמורה

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

1. פתיחת תיבת New environment. פותחים את בורר הסביבה מתחת לתיבת השליחה ובוחרים New environment בתחתית התפריט.
2. בחירה איפה Claude רץ. בוחרים את הלשונית Local, SSH או Cloud וממלאים את הטופס. בלשונית SSH בוחרים חיבור ותיקייה במכונה המרוחקת.
3. שמירה. בוחרים Create environment, או Add environment בלשונית Cloud.

#סביבות שהדסקטופ יוצר בעצמו

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

#שימוש, עריכה או הסרה

מוצאים את הרשומה בבורר הסביבה:

• פתיחת סשן: בוחרים את הרשומה.
• עריכה או מחיקה: מרחפים מעל הרשומה ולוחצים על גלגל השיניים. כדי למחוק סביבה מקומית או SSH, לוחצים Delete environment ב-Edit environment.
• ארכוב סביבת ענן: לפי התיעוד הרשמי, ראו Archive an environment.

#משתני סביבה בסשנים מקומיים

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

למשתנים האלה יש הנחיה משלהם:

ב-macOS או בלינוקס, אם כבר קבעתם את המשתנה עם export ב-~/.zshrc או ב-~/.bashrc, ראו את הסעיף משתנה מיוצא שחסר או שגוי בפקודות ש-Claude מריץ.

#משתני סביבה לסשנים מקומיים

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

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

1. פתיחת הטופס.
   • ליצירת סביבה מקומית שמורה: בוחרים New environment בתחתית תפריט בורר הסביבה, ואז את לשונית Local.
   • לשינוי סביבה שכבר יש: בבורר הסביבה מרחפים מעל סביבה שמורה תחת Local ולוחצים על גלגל השיניים כדי לפתוח Edit environment.
2. הזנת המשתנים. בוחרים Environment variables, מזינים KEY=value אחד בכל שורה, ובוחרים Done.
3. שמירה. בוחרים Create environment או Save.

רק סשנים שמתחילים מהסביבה הזו מקבלים את המשתנים.

כדי לקבוע משתנה לכל סשן מקומי, מוסיפים אותו למפתח env ב-~/.claude/settings.json. Claude Code מתעלם מהערך אם המשתנה כבר נמצא בסביבה שבה הדסקטופ מתחיל את הסשן.

#משתני סביבה לשרתי פיתוח

כדי לתת לשרת פיתוח סוד בלי להכניס אותו ל-launch.json, קובעים אותו באחד המקומות האלה, ואז מפעילים מחדש את הדסקטופ:

• macOS ולינוקס: מייצאים אותו בפרופיל המעטפת.
• Windows: מוסיפים אותו למשתני המשתמש או המערכת.
• כל פלטפורמה: שומרים אותו בעורך הסביבה המקומית, אם אפשר לפתוח אותו.

שרתי פיתוח לא מקבלים משתנים שמוסיפים לסביבה שמורה או ל-~/.claude/settings.json.

#עורך הסביבה המקומית

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

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

מזינים KEY=value אחד בכל שורה ובוחרים Save changes. המשתנים נשמרים מוצפנים על המחשב. סשנים מקומיים מקבלים אותם, חוץ ממשתנה שהדסקטופ קובע בעצמו, כמו API_TIMEOUT_MS. מפעילים מחדש את הדסקטופ כדי לתת את המשתנים לשרתי הפיתוח.

#משתנה מיוצא שחסר או שגוי בפקודות ש-Claude מריץ

אם פקודה ש-Claude מריץ ב-macOS או בלינוקס לא מקבלת משתנה שקבעתם עם export ב-~/.zshrc או ב-~/.bashrc, או מקבלת ערך שגוי, מנסים לפי הסדר:

1. התחלת סשן חדש. מבקשים מ-Claude להריץ את הפקודה שוב.
2. יציאה ופתיחה מחדש של הדסקטופ. אחר כך מתחילים סשן חדש.
3. בדיקת המשתנים השמורים. אם פקודה מקבלת ערך שגוי, בודקים אם קבעתם את המשתנה גם בסביבה שמורה או בעורך הסביבה המקומית. אם כן, משנים שם את הערך ומתחילים סשן חדש.
4. שימוש בסביבה שמורה. מוסיפים את המשתנה לסביבה מקומית שמורה, ואז מתחילים ממנה סשן חדש. למשתנה כמו PATH, CLAUDE_CONFIG_DIR או API_TIMEOUT_MS עוקבים אחרי ההנחיה שלו בסעיף משתני סביבה בסשנים מקומיים.

לפני גרסה 2.1.304, Claude Code לא מעביר משתנים מיוצאים לפקודות, אז בודקים איזו גרסה הסשן מריץ.

#משתנים שהדסקטופ קובע בעצמו

אם קבעתם API_TIMEOUT_MS או ANTHROPIC_BASE_URL ושום דבר לא השתנה בסשנים המקומיים, זה כי הדסקטופ קובע את המשתנים האלה, בין היתר, בעצמו. סשן מקומי מקבל את הערך של הדסקטופ בין שהערך שלכם נקבע בפרופיל המעטפת, במשתני המשתמש או המערכת ב-Windows, בעורך הסביבה המקומית, או בסביבה שמורה. העברה לקובץ הגדרות לא עוזרת, כי Claude Code מתעלם מהערך הזה בסשן מקומי.

• API_TIMEOUT_MS: סשן מקומי מקבל 900000, כלומר 15 דקות. ל-timeout ארוך יותר מתקינים את ה-CLI של Claude Code ומשתמשים בו. קובעים את המשתנה במעטפת ומריצים claude בטרמינל.
• ANTHROPIC_BASE_URL: סשן מקומי מקבל את מארח ה-API של Anthropic כשמתחברים בחשבון Claude. כדי להשתמש בשער, מגדירים את תצורת ההסקה של צד שלישי בדסקטופ, לפי התיעוד הרשמי.

#כיבוי חשיבה מורחבת

חשיבה מורחבת (extended thinking) מופעלת כברירת מחדל. היא משפרת משימות הסקה מורכבות ומשתמשת בטוקנים נוספים. כדי לכבות, מגדירים MAX_THINKING_TOKENS ל-0 בסביבה מקומית שמורה או בעורך הסביבה המקומית. החשיבה נכבית אז ב-Anthropic API, חוץ מ-Opus 5.5, Sonnet 5.5, Haiku 5.5 ומודלי Fable, שתמיד משתמשים בחשיבה מורחבת.

ב-Opus 5 בוחרים גם מאמץ high או נמוך יותר לפני תחילת הסשן. בפריסה הנוכחית פותחים את בורר המודל ובוחרים רמה תחת Effort. אם הסשן התחיל ברמה גבוהה יותר, פותחים סשן חדש ב-high או נמוך יותר.

#תקציב חשיבה קבוע

במודלים עם הסקה מסתגלת (adaptive reasoning), Claude Code מתעלם מהמספר עצמו בערך חיובי של MAX_THINKING_TOKENS, כי עומק החשיבה נשלט על ידי ההסקה המסתגלת. ב-Opus 4.6 וב-Sonnet 4.6 מגדירים CLAUDE_CODE_DISABLE_ADAPTIVE_THINKING ל-1 כדי להשתמש בתקציב חשיבה קבוע. מודלי Fable, Sonnet 5 ומעלה, Haiku 5.5, ו-Opus 4.7 ומעלה תמיד משתמשים בהסקה מסתגלת ואין להם מצב תקציב קבוע.

#סשנים מקומיים במכשיר מנוהל

אם הרשומה של המחשב אפורה בבורר הסביבה, עם הטולטיפ Disabled by your organization, המנהל כיבה סשנים מקומיים. ב-Windows גם רשומת WSL מאפירה באותו אופן. הזמינות של WSL במכשירים מנוהלים נשלטת בנפרד.

סשנים חדשים עוברים לחיבור ה-SSH הראשון אם הוגדר אחד. אם מנסים להמשיך סשן מקומי קיים מופיעה הודעה שסשנים מקומיים אינם זמינים במכשיר הזה. בחירה בסביבה מקומית שמורה מציגה את השגיאה Couldn't switch environments: the Local environment isn't available anymore. בוחרים סביבת SSH או ענן, או פונים לצוות ה-IT.

#סשני ענן

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

כדי להוסיף, לערוך או לארכב סביבת ענן, פותחים את בורר הסביבה:

• הוספה: בוחרים New environment בתחתית התפריט, ואז את לשונית Cloud בתיבת New environment.
• עריכה או ארכוב של סביבה שלכם: מרחפים מעליה ולוחצים על גלגל השיניים.

אפשר ליצור סביבות ענן מותאמות עם רמות גישה שונות לרשת ועם משתני סביבה. הפירוט בתיעוד סביבות הענן, לפי הדף הרשמי.

#סשני SSH

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

אם משתמשים בדסקטופ עם ספק צד שלישי, לסשני SSH יש הגדרה נפרדת. לפי התיעוד הרשמי, היא מתוארת ב-SSH remote sessions in Claude Desktop on 3P.

מוסיפים חיבור SSH בתיבת New environment, ואז מתחילים סשן על החיבור. אם בסשן חדש אין בורר סביבה מתחת לתיבת השליחה, זו הפריסה הקודמת. ראו את סעיף בדיקת הפריסה.

1. פתיחת תיבת New environment. לפני פתיחת סשן פותחים את בורר הסביבה מתחת לתיבת השליחה ובוחרים New environment בתחתית התפריט.

2. הוספת החיבור. בלשונית SSH פותחים את רשימת Host, בוחרים Add SSH connection…, וממלאים:

   • Name: תווית לחיבור.
   • SSH Host: user@hostname, או מארח שמוגדר ב-~/.ssh/config.
   • SSH Port: ברירת מחדל 22 אם משאירים ריק, או הפורט מקובץ ה-SSH.
   • SSH key (optional): נתיב למפתח הפרטי, כמו ~/.ssh/id_ed25519. משאירים ריק כדי להשתמש בקובץ ה-SSH או ב-SSH agent.
   • Worktree folder: תיקייה במכונה המרוחקת, כמו ~/worktrees, שבה סשנים חדשים יוצרים את ה-worktrees שלהם. משאירים ריק כדי להשתמש בברירת המחדל של המכונה המרוחקת.

   אחר כך בוחרים Add SSH connection.

3. פתיחת סשן על החיבור. בוחרים תיקייה במכונה המרוחקת ולוחצים Create environment. המכונה והתיקייה נשמרות יחד כסביבה שמורה לסשנים הבאים. הדסקטופ בוחר אותה לסשן החדש, אז כותבים את המשימה ולוחצים Enter.

המכונה המרוחקת יכולה להריץ לינוקס, macOS, או Windows. הדסקטופ מתקין את Claude Code על המכונה אוטומטית בחיבור הראשון. אחרי החיבור, סשני SSH תומכים במצבי הרשאה, מחברים, תוספים ושרתי MCP.

#דרישות למכונה מרוחקת של לינוקס או macOS

בודקים את הדרישות לפני החיבור, או כשחיבור נכשל אחרי ההתחברות:

• מערכת: מעבד x86_64 או arm64, וגם דרישות המערכת של Claude Code. בלינוקס Claude Code צריך glibc 2.17 ומעלה, או musl. כדי לראות מה יש במכונה מריצים שם ldd --version. בהפצה מבוססת musl כמו Alpine Linux מתקינים גם את החבילות ש-Claude Code צריך.
• SFTP: שרת ה-SSH צריך להציע את תת-מערכת ה-SFTP, ששורת Subsystem sftp ב-sshd_config מפעילה. לבדיקה מתחברים לאותו מארח ופורט עם sftp מטרמינל במחשב. שרת תקין מציג את ההנחיה sftp>.
• MaxSessions 1 בשרת: כדי להתחבר לשרת ש-sshd_config שלו קובע MaxSessions 1, עושים אחד מאלה:
  • המחשב רץ ב-macOS או בלינוקס: מעדכנים ל-Claude Desktop מגרסה 3.1623.0 ומעלה.
  • המחשב רץ ב-Windows: מוודאים שהדסקטופ מתחבר דרך לקוח OpenSSH, כי לקוח ה-SSH המובנה של הדסקטופ לא יכול להתחבר לשרת הזה.
  • אפשר לשנות את השרת: מעלים את MaxSessions, למשל לברירת המחדל של OpenSSH שהיא 10.
• התחברויות עם MaxSessions 1: משתמשים בהתחברות שעובדת בלי בקשה, למשל מפתח ש-SSH agent מחזיק. הדסקטופ מתחבר לפחות פעמיים בכל חיבור או חיבור מחדש. מצפים לעוד התחברות אחת לפחות לכל לשונית טרמינל, ולכל סשן דסקטופ שבו מריצים פקודות שמתחילות ב-!. לפקודות ש-Claude מריץ לא מצפים להתחברות נוספת.
• קודים חד-פעמיים עם MaxSessions 1: אם כל התחברות מבקשת מכם, כמו בקודים חד-פעמיים, פקודות ! נכשלות. מריצים את הפקודות האלה בלשונית טרמינל במקום, שמבקשת בחלונית משלה.
• תיקיית התקנה: הדסקטופ מתקין תוכנית עזר ואת Claude Code תחת ~/.claude/remote/ בתיקיית הבית, ומריץ אותם משם. התיקייה לא יכולה להיות על מערכת קבצים שמורכבת עם noexec. משאירים בערך 1 GB פנוי בתיקיית הבית של כל משתמש שמתחבר. מה יש בתיקייה מפורט בסעיף הקבצים והתהליכים במכונה המרוחקת.
• מעטפת: המעטפת של החשבון במכונה המרוחקת צריכה להריץ פקודות שנשלחות ב-SSH, כמו ש-Bash, Zsh ו-sh עושים.
• רשת: Claude Code רץ על המכונה המרוחקת ושולח ממנה את בקשות הרשת, ולכן המכונה צריכה את הגישה לרשת ש-Claude Code דורש. אם המכונה לא יכולה להוריד את Claude Code, הדסקטופ מוריד אותו במחשב ומעלה אותו. שאר הבקשות של Claude Code עדיין יוצאות מהמכונה המרוחקת. במכונת לינוקס מרוחקת, אם הבקשות צריכות מתווך, מגדירים אותו לסשני SSH כמו בסעיף הבא.

#בדיקת מפתח המארח

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

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

• הדסקטופ שואל Connect to <host> for the first time?, או שנבחר Review new key: המכונה שהדסקטופ מציין, <host>.
• הדסקטופ שואל Connect through <jump host> for the first time?: מארח הקפיצה, המכונה שהחיבור עובר דרכה, לא המכונה שרוצים להגיע אליה.
• ssh שואל או מזהיר בטרמינל: המכונה שההודעה שלו מציינת, שיכולה להיות לא זו שהקלדתם.

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

• מישהו אחר מנהל את המכונה: מבקשים ממנו את טביעת האצבע של מפתח המארח.
• אתם מנהלים אותה, והיא רצה לינוקס או macOS: מריצים עליה ssh-keygen -lf /etc/ssh/ssh_host_<type>_key.pub, בקונסולה שלה או דרך חיבור שכבר סומכים עליו. ל-<type> משתמשים בסוג המפתח שהדסקטופ או ssh מציגים ליד טביעת האצבע, באותיות קטנות: ed25519 עבור ED25519 או ssh-ed25519.

אחר כך משווים את טביעת האצבע של המכונה לזו שהוצגה:

• הן תואמות: סומכים על המפתח. בוחרים Trust and connect או Trust new key בדסקטופ, או עונים yes בטרמינל.
• הן שונות, או שאי אפשר לבדוק: לא מתחברים. בוחרים Cancel בדסקטופ, או עונים no בטרמינל. אם מישהו אחר מנהל את המכונה, אומרים לו איזו טביעת אצבע הוצגה.

אם שלב בפתרון התקלות שלח לכאן, חוזרים אליו אחרי כל אחת מהתוצאות.

#מתווך או אישור CA לסשני SSH

אם מכונת לינוקס מרוחקת יוצאת לאינטרנט דרך מתווך, או שצריך אישור CA, מוסיפים את משתני המתווך וה-CA תחת env ב-~/.claude/settings.json שם. מוסיפים אותם גם אם כבר מייצאים אותם ב-~/.profile, ב-~/.bash_profile, ב-~/.zprofile או ב-~/.zshrc על המכונה.

סשן SSH לא מקבל אותם מהקבצים האלה, גם כש-claude בטרמינל על אותה מכונה כן מקבל. הסשן יכול להיתקע, או להציג The connection from … to the API failed, Authentication failed, או Claude Code on … couldn’t verify the API connection’s certificate. התחברות מחדש לא עוזרת.

1. הוספת המשתנים. לקובץ ה-CA משתמשים ב-NODE_EXTRA_CA_CERTS, כי Claude Code לא סומך על CA מ-SSL_CERT_FILE ב-~/.claude/settings.json. הדוגמה קובעת מתווך וקובץ CA:

{
  "env": {
    "HTTPS_PROXY": "http://proxy.example.com:8080",
    "NODE_EXTRA_CA_CERTS": "/etc/ssl/certs/example-ca.pem"
  }
}

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

#מתווך או CA שמוגדרים במקום אחר במכונה המרוחקת

בודקים אם מכונת הלינוקס המרוחקת קובעת את משתנה המתווך או ה-CA במקום אחר, כי הסשנים משתמשים בערך הזה ומתעלמים מהערך בכל קובץ הגדרות:

1. רשימת המשתנים שהמכונה המרוחקת קובעת. בטרמינל על המחשב מריצים ssh devbox env, עם המארח שלכם.
2. שינוי המשתנה במקום שבו הוא נקבע. אם הרשימה כוללת את המשתנה, משנים אותו בקובץ שקובע אותו, כמו ~/.zshenv, /etc/environment או ~/.bashrc על המכונה המרוחקת.
3. מסירת הערך החדש לסשנים. מפעילים מחדש את המכונה המרוחקת, או יוצאים מהדסקטופ ומסיימים את תהליכי תוכנית העזר, כמו בשני השלבים הראשונים להסרת תוכנית העזר. עושים את זה כשאין משימה רצה, כי כל אחת מהדרכים קוטעת את העבודה של Claude.

#שימוש בקובץ SSH

אפשר להשתמש בקובץ ה-SSH ב-macOS, בלינוקס וב-Windows כשהדסקטופ מתחבר דרך לקוח OpenSSH שעל המחשב:

• macOS ולינוקס: הדסקטופ מריץ את לקוח OpenSSH שעל המחשב, ולכן הוא משתמש ב-~/.ssh/config. החיבור דרך לקוח OpenSSH דורש Claude Desktop מגרסה 1.37937.0 ומעלה.

• Windows: כשהדסקטופ מתחבר דרך לקוח OpenSSH, הוא משתמש ב-%USERPROFILE%\.ssh\config. עם חשבון Claude, לא עם ספק צד שלישי, החיבור דרך לקוח OpenSSH דורש את כל אלה:

  • Claude Desktop מגרסה 2.2553.0 ומעלה. את הגרסה רואים בסעיף בדיקת הגרסה.
  • OpenSSH 9.4 ומעלה של Microsoft.
  • דסקטופ שהותקן מכפתורי ההורדה בראש הדף הרשמי, כי דסקטופ מ-Microsoft Store לא מתחבר דרך לקוח OpenSSH.

  אם אי אפשר לעמוד בדרישות האלה, או שמשתמשים בספק צד שלישי, ראו את הסעיף חיבור ב-Windows בלי לקוח OpenSSH.

עם לקוח OpenSSH מזינים בשדה SSH host שם Host מהקובץ. הדסקטופ משתמש אז בהגדרות הרשומה, כמו HostName, User, IdentityFile, CertificateFile, ProxyJump ו-ProxyCommand.

לפני הוספת החיבור בודקים את הלקוח ואת הרשומה בטרמינל על המחשב:

• גרסת הלקוח ב-macOS ובלינוקס: מריצים ssh -V. הלקוח צריך להיות OpenSSH 7.6 ומעלה.
• גרסת הלקוח ב-Windows: הדסקטופ מנסה קודם את ssh שב-PATH, אז מריצים ssh -V. הלקוח עובר אם הפלט מציג OpenSSH_for_Windows_ וגרסה 9.4 ומעלה. אם הוא לא עובר, בודקים את שתי התיקיות שהדסקטופ מנסה אחר כך: מריצים .\ssh.exe -V ב-C:\Windows\System32\OpenSSH, ואז ב-C:\Program Files\OpenSSH.
• אף לקוח לא עובר ב-Windows: מוסיפים את הרכיב האופציונלי OpenSSH Client ב-Windows ומתקינים עדכוני Windows ממתינים, או מתקינים את ה-build החדש יותר של Microsoft. אחר כך יוצאים מהדסקטופ ופותחים אותו מחדש. כדי לראות אם הדסקטופ מצא לקוח OpenSSH שמיש, מחפשים ב-ssh.log את Windows OpenSSH client: וגרסה, או את no usable Windows OpenSSH client.
• הרשומה: ב-Windows משתמשים בלקוח שעבר את בדיקת הגרסה. מריצים ssh עם שם ה-Host, למשל ssh devbox. אם זה נכשל, מתקנים קודם את הרשומה.

אפשר להשאיר את SSH port ואת SSH key (optional) ריקים. אם ממלאים אחד מהם, הדסקטופ משתמש בו יחד עם הרשומה:

• SSH port: ערך כאן גובר על Port של הרשומה.
• SSH key (optional): עם לקוח OpenSSH, הדסקטופ מציע את קובץ המפתח שנבחר בנוסף ל-IdentityFile של הרשומה ולמפתחות ב-SSH agent. ב-Windows בוחרים מפתח בפורמט OpenSSH, כי ssh לא קורא קובץ PuTTY .ppk.

#חיבור ב-Windows בלי לקוח OpenSSH

ב-Windows מתחברים דרך לקוח ה-SSH המובנה של הדסקטופ אם המחשב לא עומד בדרישות ללקוח OpenSSH. עם ספק צד שלישי, איזה לקוח משמש לחיבור תלוי גם בגרסת הדסקטופ וגם בהגדרות המנהל. לפי התיעוד הרשמי, ראו SSH remote sessions in Claude Desktop on 3P.

עם הלקוח המובנה עדיין אפשר להזין בשדה SSH host שם Host מקובץ ה-SSH, אם יש פקודת ssh ב-PATH, עם המגבלות האלה:

• הגדרות מהרשומה: הדסקטופ לוקח את HostName, User, Port, IdentityFile ו-ConnectTimeout. הוא לוקח גם ProxyCommand אם יש מעטפת sh ב-PATH.
• SSH key (optional): משאירים את השדה ריק כדי לשמור את IdentityFile של הרשומה, כי קובץ מפתח שבוחרים כאן מחליף את ה-IdentityFile.
• CertificateFile ו-ProxyJump: הדסקטופ מתעלם מ-CertificateFile, והחיבור נכשל אם הרשומה קובעת ProxyJump. כדי להשתמש באחד מהם, מתחברים דרך לקוח OpenSSH.

#מכונה מאחורי מארח קפיצה

כדי להגיע למכונה מאחורי jump host, שנקרא גם bastion, מגדירים ProxyJump או ProxyCommand ברשומה. הרשומה הבאה מגיעה אל devbox.internal.example.com דרך bastion.example.com:

Host devbox
  HostName devbox.internal.example.com
  User alice
  ProxyJump bastion.example.com

מזינים devbox בשדה SSH host.

אם המנהל מגביל מארחי SSH, גם מארח הקפיצה חייב להיות ברשימה. מריצים ssh -G bastion.example.com בטרמינל על המחשב, ומבקשים לאפשר את ה-hostname שהפקודה מדפיסה.

#מכולה על מכונה מרוחקת

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

1. הוספת הרשומה. מוסיפים את הרשומה הבאה בסוף ~/.ssh/config, או ישירות מעל רשומת Host * הראשונה אם יש אחת. מחליפים את מכולת Docker devbox, את המשתמש dev, ואת המכונה build.example.com בערכים שלכם. הפקודה ברשומה מפעילה שרת SSH בתוך המכולה לכל חיבור:

Host devbox-container
  User dev
  ProxyCommand ssh build.example.com docker exec -i devbox /usr/sbin/sshd -i

2. הכנת המכולה.

   • מתקינים את שרת OpenSSH, עם מפתח מארח שנשאר זהה כשבונים מחדש את התמונה או יוצרים מחדש את המכולה.
   • נותנים לחשבון שב-User דרך להתחבר, למשל קובץ authorized_keys.
   • בודקים שהמכולה עומדת בדרישות למכונה מרוחקת.

3. בדיקת רשימת המארחים. אם המנהל מגביל מארחי SSH, מריצים ssh -G devbox-container בטרמינל על המחשב. מבקשים לאפשר ב-sshHostAllowlist את ה-hostname שהפקודה מדפיסה, כאן devbox-container. כשמתירים את השם הזה, מתירים את כל מה ש-ProxyCommand של הרשומה מתחבר אליו.

4. בדיקת הרשומה, ואז חיבור. מריצים ssh devbox-container בטרמינל על המחשב. מתקנים את מה שהיא מדווחת, ומריצים שוב עד שנפתחת מעטפת במכולה בלי בקשה:

   • אם ssh מבקש סיסמה, passphrase או קוד: עוברים להתחברות שעובדת בלי בקשה, למשל מפתח ש-SSH agent מחזיק.
   • אם ssh מדווח Cannot execute command-line and remote command. או Bad packet length: מוציאים את RemoteCommand ואת RequestTTY מהרשומה של build.example.com. אחרי זה, ssh build.example.com בטרמינל על המחשב פותח מעטפת על המכונה, לא במכולה.
   • אם ssh מדווח Connection closed by UNKNOWN port 65535: מריצים ssh build.example.com docker exec devbox /usr/sbin/sshd -t באותו טרמינל.
     • אם מודפס Missing privilege separation directory: /run/sshd, יוצרים את התיקייה במכולה.
     • אם מודפס no hostkeys available ולמכולה יש מפתחות מארח, מוסיפים -u root אחרי exec בפקודה הזו וברשומה.

   אחר כך מזינים devbox-container בשדה SSH host.

#משתנים מהמעטפת ב-ProxyCommand

ב-macOS ובלינוקס, כדי להשתמש במשתנה סביבה משלכם בפקודת ProxyCommand או Match exec, מייצאים אותו בקובץ הפעלה של המעטפת, כמו ~/.zshrc, ואז יוצאים מהדסקטופ ופותחים אותו מחדש. כשהדסקטופ עולה, הוא קורא את מה שמעטפת ההתחברות מייצאת, ושומר את הערכים עד שיוצאים.

זה דורש Claude Desktop מגרסה 2.37337.0 ומעלה, ופקודת env שמקבלת -0. בודקים עם env -0 בטרמינל על המחשב.

אם המעטפת קובעת אישורי AWS זמניים, נותנים ל-AWS CLI פרופיל, כמו בסעיף הבא, במקום לייצא משתני AWS_*.

#אישורי AWS ב-ProxyCommand ב-macOS ובלינוקס

אם קובעים אישורי AWS זמניים בקובץ הפעלה של המעטפת, ProxyCommand שמריץ את AWS CLI יכול להתחבר בטרמינל ולהיכשל בדסקטופ. כשהמעטפת מייצאת AWS_SESSION_TOKEN, AWS_SECURITY_TOKEN או AWS_CREDENTIAL_EXPIRATION, ssh וה-ProxyCommand בדסקטופ לא מקבלים את אישורי ה-AWS של המעטפת, את AWS_REGION או את AWS_PROFILE.

אם ל-AWS CLI אין מקור אחר לאזור או לאישורים, הוא נכשל עם You must specify a region או Unable to locate credentials. כדי להתחבר מהדסקטופ, נותנים ל-AWS CLI פרופיל שהוא קורא מ-~/.aws/config:

1. הוספת פרופיל עם אזור ומקור אישורים. הדוגמה מוסיפה פרופיל בשם corp שמקבל אישורים מתוכנית עזר:

[profile corp]
region = us-east-1
credential_process = /full/path/to/your-credential-helper

• region: אזור ה-AWS של המכונות שמתחברים אליהן.
• credential_process: הנתיב המלא של תוכנית שמדפיסה אישורים בצורת ה-JSON ש-AWS מתעדת. בוחרים תוכנית שלא צריכה קלט מכם, כי AWS CLI מריץ אותה בכל חיבור, כולל התחברויות מחדש בזמן שאתם לא ליד המחשב.
• IAM Identity Center: מוסיפים את הגדרות IAM Identity Center של הפרופיל במקום credential_process. מריצים aws sso login --profile corp בטרמינל לפני החיבור, ושוב כשההתחברות הזו פגה.

2. ציון הפרופיל ב-ProxyCommand. הדוגמה מוסיפה --profile לפקודה ש-AWS מתעדת ל-Session Manager:

Host i-*
  ProxyCommand sh -c "aws ssm start-session --profile corp --target %h --document-name AWS-StartSSHSession --parameters 'portNumber=%p'"

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

#הארכת זמן ההמתנה לחיבור

אם הסשן נגמר לו הזמן בזמן שהוא מתחבר דרך jump host או ProxyCommand, מעלים את ConnectTimeout ברשומה של המכונה המרוחקת ב-~/.ssh/config. משתמשים ביותר מ-90 שניות. מוסיפים גם זמן ש-jump host או ProxyCommand ממתינים לכם, למשל בהנחיית התחברות או בדחיפה לטלפון:

Host devbox
  HostName devbox.internal.example.com
  User alice
  ProxyJump bastion.example.com
  ConnectTimeout 120

ssh משתמש בערך הראשון שהוא מוצא למארח, ולכן שומרים את הרשומה מעל כל רשומת Host * שקובעת ConnectTimeout. לאישור מריצים ssh -G devbox בטרמינל על המחשב. הפלט כולל connecttimeout 120. אחרי שינוי הערך יוצאים מהדסקטופ ופותחים אותו מחדש.

אם בקובץ ה-SSH אין ConnectTimeout למארח, הדסקטופ נותן ל-ssh 30 שניות להתחבר. דרך jump host או ProxyCommand הזמן כולל גם את זמן החיבור של המסלול.

אם המכונה המרוחקת עצמה ממתינה לאישור בטלפון, מאשרים תוך 45 שניות, בלי קשר ל-ConnectTimeout שקבעתם. אי אפשר להעלות את המגבלה הזו, כי הדסקטופ קובע בעצמו את ServerAliveInterval ואת ServerAliveCountMax, ו-ssh סוגר התחברות שבה המכונה המרוחקת לא שולחת דבר במשך הזמן הזה.

#בלוק Match host שחל רק בדסקטופ

אם הדסקטופ משתמש בהגדרה ש-ssh devbox בטרמינל לא משתמש בה, מחפשים בלוק Match host מעל שורת ה-HostName של הרשומה. בטרמינל, ssh קורא בלוק שם לפני שורת ה-HostName, ולכן הוא משווה את הבלוק ל-devbox. הדסקטופ נותן ל-ssh את ערך ה-HostName בשורת הפקודה, ולכן ssh משווה את הבלוק לערך הזה.

לבדיקה מריצים ssh -G בטרמינל על המחשב עם ערכי HostName ו-User של הרשומה בשורת הפקודה, כמו שהדסקטופ עושה:

ssh -G -o HostName=devbox.internal.example.com -l alice devbox

משווים את הפלט לפלט של ssh -G devbox. אם הגדרות הבלוק, כמו proxycommand, מופיעות רק בפלט הראשון, הבלוק חל רק בדסקטופ. כדי שהדסקטופ ידלג עליו גם, מוסיפים !originalhost devbox לשורת ה-Match:

Match host *.internal.example.com !originalhost devbox

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

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

בחיבור שלו למכונה המרוחקת, הדסקטופ משאיר את ForwardAgent, ForwardX11, LocalForward, RemoteForward, DynamicForward ו-Tunnel כבויים, גם כשקובץ ה-SSH מדליק אותם. בטרמינל או בפקודת !, מצפים שהגדרות ההעברה יחולו רק לפעמים, כי הדסקטופ יכול להפעיל שם ssh נפרד שעוקב אחריהן.

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

כדי למנוע מהדסקטופ להעביר את סוכן ה-SSH או פורט, מריצים ssh -G devbox בטרמינל על המחשב. אחר כך מריצים שוב כמו שהדסקטופ יכול להריץ, עם ערכי hostname ו-user שהפלט מדפיס, למשל ssh -G -o HostName=devbox.internal.example.com -l alice devbox. הפלט השני יכול להראות הגדרות מבלוק Match שהראשון מדלג עליו.

מחפשים בשני הפלטים שורת forwardagent שאומרת משהו שאינו no, ושורות שמתחילות ב-localforward, remoteforward או dynamicforward. אם מוצאים אחת, מסירים את ההגדרה מקובץ ה-SSH. אותו דבר למארח ש-ProxyCommand מגיע אליו עם ssh.

#הגעה לפורט במכונה המרוחקת

כדי לפתוח שרת שרץ על המכונה המרוחקת, למשל שרת פיתוח על פורט 3000, מעבירים את הפורט בעצמכם. בטרמינל על המחשב מריצים ssh עם -L והמארח שמתחברים אליו, למשל devbox:

ssh -N -L 3000:localhost:3000 devbox

אם מילאתם SSH port או SSH key (optional) בחיבור, מוסיפים -p או -i עם אותו ערך. משאירים את הפקודה רצה, ופותחים http://localhost:3000 בדפדפן על המחשב כדי להגיע לפורט 3000 של המכונה המרוחקת. אם ssh מדפיס open failed: administratively prohibited, מבקשים ממנהל המכונה לאפשר העברת TCP, ש-AllowTcpForwarding ב-sshd_config של שרת ה-SSH שולט בה.

#מכונות מרוחקות של Windows

מכונה מרוחקת של Windows דורשת Claude Desktop מגרסה 2.31226.0 ומעלה.

משתמשים ב-OpenSSH Server של Microsoft. המכונה יכולה להיות x64 או ARM64. המעטפת ששרת ה-SSH מפעיל יכולה להיות cmd.exe, Windows PowerShell 5.1, או Git Bash.

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

בין המגבלות במכונה מרוחקת של Windows:

• טרמינל: הטרמינל לא נפתח בסשן שהתיקייה שלו היא נתיב Windows, כמו C:/projects/app.
• ארגז חול: Claude Code רץ שם על Windows נייטיב, ומריץ פקודות בלי ארגז חול. איפה הארגז חול רץ מפורט בתיעוד ה-sandboxing, לפי הדף הרשמי.
• תוספים: הדסקטופ לא מעתיק תוסף שמחזיק שם קובץ או תיקייה ש-Windows לא יכול לשמור, למשל שם עם :. הסשן מפרט את התוספים שהדסקטופ השאיר בחוץ.
• שרתי MCP: בחלק ממכונות Windows המרוחקות, קריאות של Claude לשרתי MCP מ-claude_desktop_config.json עוברות דרך הדסקטופ, ולכן Claude לא יכול לקרוא לכלים שלהם בזמן שהדסקטופ מנותק. לפני Claude Desktop מגרסה 2.37337.0 זה נכון בכל מכונת Windows מרוחקת.
• Worktrees: ה-worktrees הולכים אל <project-root>/.claude/worktrees/. אם בוחרים תיקייה אחרת, הדסקטופ מתעלם ממנה.
• הודעות קודמות: אם מעטפת שרת ה-SSH היא cmd.exe או Windows PowerShell, ייתכן שצריך להתחבר לפני שרואים הודעות קודמות של הסשן.
• פיצול סשן: אם מעטפת שרת ה-SSH היא cmd.exe או Windows PowerShell, אפשר לפצל סשן רק בהודעה הראשונה שלו.
• ריצה בזמן ניתוק: משימה ממשיכה לרוץ בזמן שהדסקטופ מנותק רק אם שרת ה-SSH מאפשר לתוכנית להמשיך אחרי החיבור שהתחיל אותה. כדי לברר, בודקים את המכונה המרוחקת כמו בסעיף ההכנה למשימה ארוכה.
• תהליכים שנשארים: אחרי שסשן נגמר, בודקים במכונה תוכניות ש-Claude Code הפעיל, כי הן יכולות להמשיך לרוץ. תוכנית העזר ברקע שהדסקטופ מתקין לא נעצרת שם מעצמה.

#המשך משימה כשהדסקטופ מנותק

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

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

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

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

אם המשימה חייבת לרוץ לאורך הלילה:

• משאירים את המחשב ער ומחובר לרשת, עם המכסה פתוח, והדסקטופ רץ ומחובר לחשבון.
• משתמשים בהתחברות שעובדת בלי בקשה, למשל מפתח ש-SSH agent מחזיק, למכונה המרוחקת ולכל jump host בדרך. כך הדסקטופ יכול להתחבר מחדש לבד אחרי נפילה.

למשימה שחייבת לרוץ בזמן שהמחשב ישן או כבוי, פותחים סשן ענן.

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

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

• מסך התחברות: מתחברים. אם המשימה נעצרה, שולחים הודעה כדי להמשיך. בתוכנית Enterprise הארגון יכול לנתק אתכם מספר ימים קבוע אחרי ההתחברות, גם אם אתם פעילים. בחשבון Claude, כל עוד אתם מנותקים מהחשבון הדסקטופ לא מחדש את ההתחברות של המשימה, והמשימה יכולה להיעצר.
• הדסקטופ לא מצליח להתחבר מחדש: הסשן אומר למה, ויכולה להגיע גם התראה. ייתכן שהדסקטופ צריך שתתחברו.
• שגיאת אימות: ייתכן שפג תוקף אסימון ההתחברות או האישור. בחשבון Claude שולחים הודעה כדי להמשיך. בספק צד שלישי, לפי התיעוד הרשמי, ראו SSH remote sessions in Claude Desktop on 3P.
• בקשה ממתינה: עונים לה.
• אף אחד מאלה: שולחים הודעה כדי להמשיך.

#הכנה למשימה ארוכה

• קודם מעדכנים: מעדכנים את הדסקטופ לפני משימה ארוכה. ב-macOS וב-Windows הדסקטופ יכול להפעיל את עצמו מחדש כדי להתקין עדכון שכבר הורד. ההפעלה מחדש ממתינה בזמן ש-Claude עובד על משימת SSH. כברירת מחדל, אחרי שהעדכון חיכה 72 שעות, ההפעלה מחדש יכולה להתקדם במהלך המשימה אם הדסקטופ יכול להצטרף אליה אחר כך.
• בודקים לפני שיוצאים: לא תמיד מקבלים את המשימה הרצה בחזרה אחרי יציאה או הפעלה מחדש, למשל אחרי חלק מעדכוני הדסקטופ. המקרים בסעיף פתיחת סשן מחדש אחרי יציאה.
• בגרסה ישנה משאירים את הדסקטופ פתוח: ב-Windows עם Claude Desktop שלפני גרסה 3.1623.0 לא מקבלים את המשימה הרצה בחזרה אחרי שהדסקטופ יוצא או מופעל מחדש. אותו דבר עם ספק צד שלישי ב-macOS או בלינוקס לפני גרסה 2.42304.0. בשני המקרים משאירים את הדסקטופ פתוח בזמן המשימה. את הגרסה רואים בסעיף בדיקת הגרסה.
• מצמצמים בקשות: בוחרים מצב הרשאה, כללים או הוקים שגורמים למשימה לחכות לכם פחות.
• בודקים את ה-jump host: אם ה-jump host מבקש התחברות, למשל דחיפה לטלפון, עוברים להתחברות שעובדת בלי בקשה. אחרת הדסקטופ יכול לשלוח דחיפה נוספת בכל ניסיון התחברות מחדש.
• בודקים את המכונה המרוחקת: מתחילים משימה קצרה, יוצאים מהדסקטופ בזמן שהיא עדיין רצה, ופותחים את הסשן שוב הרבה אחרי שהמשימה הייתה אמורה להסתיים. אם המשימה לא הסתיימה והסשן לא מציג שגיאת אימות, בודקים במכונה המרוחקת מה יכול לסיים משימה.
• לא מריצים פקודות משלכם בטרמינל של הדסקטופ: אם המכונה המרוחקת מנתקת טרמינלים בטלים, מריצים פקודות משלכם מהתחברות SSH מחוץ לדסקטופ.

#מגבלות בזמן שהדסקטופ מנותק

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

• אסימון או אישור התחברות: בחשבון Claude המשימה נעצרת עם שגיאת אימות כשהאסימון פג. בספק צד שלישי אותו דבר קורה לאישור שפג, למשל מ-SSO או מ-credential helper. בחשבון Claude משאירים את הדסקטופ רץ ומחובר כדי שיוכל לחדש את ההתחברות.
• המכונה המרוחקת: אם המכונה המרוחקת מופעלת מחדש, או מסיימת תהליכים כשחיבור ה-SSH נסגר, המשימה הרצה נגמרת. שום דבר לא מתחיל אותה מחדש בזמן שהדסקטופ מנותק. מכונות לינוקס שבהן KillUserProcesses של systemd-logind הוא yes וחל על המשתמש מסיימות תהליכים כך. כדי שמשימה תמשיך שם, מבקשים מהמנהל לפטור את המשתמש, למשל עם KillExcludeUsers.
• טרמינלים בטלים: חלק ממכונות לינוקס מרוחקות מנתקות טרמינל שאף אחד לא מקליד בו במשך זמן קבוע (StopIdleSessionSec של systemd-logind). כשהדסקטופ ב-macOS או בלינוקס, הטרמינל של הסשן ופקודות ! חולקים כברירת מחדל את חיבור ה-SSH של הדסקטופ. הניתוק הזה מסיים את החיבור בזמן שהדסקטופ מחובר, והמשימה הרצה יכולה להסתיים איתו. סגירת חלונית הטרמינל לא מונעת את זה, ולכן לא מריצים פקודות משלכם בטרמינל הזה.
• עדכוני דסקטופ: אם עדכון מביא תוכנית עזר חדשה, הדסקטופ מחליף את תוכנית העזר במכונה המרוחקת בחיבור מאוחר יותר, וזה יכול לסיים משימה שעדיין רצה.
• היעדרות ארוכה: במכונה מרוחקת של לינוקס או macOS, אם הדסקטופ לא מתחבר 30 יום, תוכנית העזר נעצרת ומסיימת כל תהליך Claude Code שרץ תחתיה. מתחברים לפני כן.

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

• Worktrees: בסשן שמשתמש ב-worktree, הדסקטופ בודק כל עריכת קובץ לפני ש-Claude מבצע אותה. בזמן ניתוק כל עריכה ממתינה כ-30 שניות ואז נכשלת. פקודות מעטפת עדיין רצות. במכונה מרוחקת של לינוקס או macOS עריכות יכולות להמשיך לעבוד, כמו בסעיף הבא. אם לא בטוחים, מתחילים את הסשן בלי worktree.
• הגבלת תיקיות: אם הארגון מגביל אילו תיקיות סשנים רשאים להשתמש בהן, הדסקטופ בודק כל קריאה, חיפוש ועריכה של קובץ, עם או בלי worktree. בזמן ניתוק כל אחד ממתין עד 10 דקות ואז נכשל.
• מחברים: מחברים וכלים אחרים שהדסקטופ מספק רצים דרך הדסקטופ, ולכן בזמן ניתוק כל קריאה נכשלת אחרי כ-30 שניות.
• זרימות עבודה: הדסקטופ בודק כל זרימת עבודה חדשה לפני שהיא מתחילה, ולכן בזמן ניתוק זרימה חדשה ממתינה עד 10 דקות ואז נכשלת.
• שרתי MCP: שרתי MCP ש-Claude Code מפעיל על המכונה המרוחקת לא רצים דרך הדסקטופ, ולכן Claude עדיין יכול לקרוא לכלים שלהם. שרתים מ-claude_desktop_config.json נכללים בהם רק אם הדסקטופ לא משתמש בלקוח ה-SSH המובנה שלו. אחרת, ובחלק ממכונות Windows המרוחקות, Claude לא יכול לקרוא לכלים שלהם בזמן ניתוק.

#מתי עריכות ב-worktree ממשיכות לעבוד

במכונה מרוחקת של לינוקס או macOS הבדיקה לא עוברת דרך הדסקטופ, ולכן עריכות בתוך ה-worktree ממשיכות לעבוד בזמן ניתוק. לפני Claude Desktop מגרסה 2.37337.0 זה נכון רק במכונה מרוחקת של לינוקס.

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

• לקוח SSH מובנה: הדסקטופ משתמש בו, למשל בהתקנת Microsoft Store, או במחשב Windows בלי OpenSSH 9.4 ומעלה של Microsoft.
• מיקום המאגר: המאגר הוא תיקיית הבית, תיקייה מעליה, או ~/.claude.
• נתיבי macOS: במכונה מרוחקת של macOS המאגר נמצא תחת /Volumes, או ששם תיקייה בנתיב המאגר או ה-worktree מכיל ~ או תו שאינו ASCII.
• הגבלת תיקיות: הארגון מגביל אילו תיקיות סשנים רשאים להשתמש בהן.
• משגר ארגוני: לפני Claude Desktop מגרסה 2.37337.0, מתחברים בחשבון Claude, והארגון מפעיל את Claude Code על המכונה המרוחקת דרך משגר ארגוני (corporate launcher).

לסשן בלי worktree אין בדיקה כזו, אלא אם הארגון מגביל אילו תיקיות סשנים רשאים להשתמש בהן.

#בקשות שמגיעות כשאתם לא ליד המחשב

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

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

אם מאבדים בקשה, שולחים הודעה כדי להמשיך.

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

• מצב Auto: בוחרים מצב Auto אם הוא זמין. אחרי חסימות חוזרות שואלים שוב, לפי התיעוד של מצב Auto.
• כללי allow: בקובץ הגדרות המשתמש על המכונה המרוחקת, ~/.claude/settings.json, מוסיפים כללי allow לפקודות שהמשימה צריכה. אם הארגון מקבל כללי הרשאה רק מהגדרות מנוהלות, מבקשים מהמנהל להוסיף אותם להגדרות המנוהלות שמגיעות למכונה המרוחקת. לכללי allow ב-.claude/settings.json של פרויקט, לפי הדף הרשמי, ראו Project allow rules and workspace trust.
• הוק שעונה: מגדירים הוק PermissionRequest ב-~/.claude/settings.json על המכונה המרוחקת כדי לאשר או לדחות בקשות במקומכם.
• הוק שמתריע: מגדירים הוק Notification עם ה-matcher permission_prompt באותו קובץ כדי לשלוח לעצמכם הודעה כשבקשה ממתינה.
• הוק שמודיע ש-Claude סיים: מגדירים הוק Stop באותו קובץ כדי לשלוח לעצמכם הודעה כש-Claude סיים להגיב. הוא לא רץ כששגיאת API מסיימת את התור. למקרה הזה מגדירים הוק StopFailure.

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

Claude Code לא מאשר אוטומטית כמה פעולות באף מצב הרשאה, כולל Bypass permissions. לפי מצב ההרשאה, Claude Code דוחה פעולה כזו או שואל אתכם, והמשימה ממתינה לתשובה.

#התחברות מחדש אחרי שינה או אובדן רשת

אם הדסקטופ לא התחבר מחדש כשחוזרים, שולחים הודעה בסשן. הדסקטופ מתחבר מחדש לבד רק איפה שהוא יכול להתחבר בלי בקשה, למשל עם מפתח ש-SSH agent מחזיק.

• סיסמה שמורה: סיסמה שנתתם לדסקטופ לזכור גם עובדת בלי בקשה, אבל להיעדרות ארוכה עדיף מפתח ש-SSH agent מחזיק. אם התחברויות עם הסיסמה הזו נקטעות או נתקעות, הדסקטופ יכול להפסיק להתחבר מחדש ולחכות לכם.
• כל בקשה אחרת: אם המכונה המרוחקת מבקשת משהו אחר, כמו קוד חד-פעמי, אפשר לקבל התראה במחשב. לוחצים על ההתראה, או שולחים הודעה בסשן, והדסקטופ מציג את הבקשה.

מקרים נוספים:

• Jump host, והדחיפות נעצרות בזמן ההיעדרות: זה יכול לקרות עם דסקטופ ב-macOS או בלינוקס כשאף אחד לא עונה להתחברות של jump host, למשל דחיפה לטלפון. הדסקטופ מפסיק להתחבר מחדש כשאף אחד לא ליד המחשב. כשפותחים את נעילת המחשב או משתמשים בו, יכולה להגיע דחיפה נוספת, כי הדסקטופ יכול לנסות שוב. אחרי שלושה ניסיונות בלי מענה הוא ממתין עד שמנסים שוב או שולחים הודעה.
• Jump host, והדחיפות ממשיכות: איפה שהדסקטופ לא יכול לדעת שאף אחד לא עונה, כמו דסקטופ ב-Windows, הוא ממשיך לנסות כל עוד יש תהליך להצטרף אליו, בין שהתהליך עדיין רץ ובין שלא. אפשר לקבל דחיפה נוספת בכל ניסיון. כדי לסיים את הניסיונות יוצאים מהדסקטופ, וזה יכול לעלות במשימה רצה.
• ניתוק ארוך: הדסקטופ מאט לכניסיון אחד בכל חמש דקות. כדי להתחבר מוקדם יותר, מנסים שוב בסשן או שולחים הודעה, שהדסקטופ מוסר ברגע שהוא מחובר.
• הודעה שלא נשלחה: השורה Your organization's settings haven't loaded, so your message to <host> wasn't sent. Retry to send it. מתחת להודעה אומרת שהדסקטופ התחבר מחדש והחזיק את ההודעה, כי הגדרות הארגון עדיין לא נטענו. בוחרים Retry כדי לשלוח את ההודעה עכשיו. אם לא עושים כלום, הדסקטופ מנסה שוב ברגע שההגדרות נטענות.
• פלט חסר: בזמן ניתוק תוכנית העזר שומרת את פלט Claude Code האחרון של כל סשן בחוצץ של 16 MiB ומשליכה פלט ישן יותר. אחרי החיבור מחדש הסשן יכול להציג Loading recent output from <host>…. אם הדסקטופ לא מצליח לטעון את כל הפלט, מופיעה השורה Some output produced while you were disconnected may be missing here. השורה לא אומרת שהמשימה נעצרה.
• התהליך נעלם: התהליך הסתיים בזמן שהדסקטופ היה מנותק, למשל כשהמכונה המרוחקת מופעלת מחדש. הדסקטופ יכול אז להתחיל תהליך חדש מההיסטוריה השמורה של השיחה ולומר ל-Claude להמשיך את המשימה. אם המשימה נשארת עצורה, שולחים הודעה. עם ספק צד שלישי מעדכנים ל-Claude Desktop מגרסה 2.42304.0 ומעלה, כי גרסאות קודמות אף פעם לא ממשיכות את המשימה לבד.

#פתיחת סשן מחדש אחרי שיצאתם מהדסקטופ

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

• דסקטופ ב-Windows, משימה שהתחילה בגרסה שלפני 3.1623.0: לא מקבלים את המשימה בחזרה, גם אם הדסקטופ עודכן מאז. מפעילים את הדסקטופ מחדש רק כשמצפים שהמשימה כבר הסתיימה, כי הסשן יכול להיפתח כבר בהפעלת הדסקטופ, והמשימה נעצרת כשהסשן נפתח. אם לא יודעים באיזו גרסה התחלתם את המשימה, גם אז מחכים עד שמצפים שהיא הסתיימה.
• ספק צד שלישי ב-macOS או בלינוקס, משימה שהתחילה בגרסה שלפני 2.42304.0: לא מקבלים את המשימה בחזרה. מפעילים את הדסקטופ מחדש רק כשמצפים שהמשימה כבר הסתיימה.
• כל משימה אחרת: מפעילים את הדסקטופ ופותחים את הסשן, והמשימה ממשיכה אם הדסקטופ מצטרף מחדש. הוא לא תמיד יכול להצטרף, למשל אחרי חלק מעדכוני הדסקטופ, ולכן מעדכנים לפני משימה ארוכה.

כשהמשימה נעצרת, הסשן יכול להציג Restarting Claude Code on <host>… בזמן שהדסקטופ מתחיל תהליך חדש. מאבדים גם אישור או שאלה שהמתינו. אם Claude לא ממשיך לבד, שולחים הודעה, ו-Claude ממשיך מההיסטוריה השמורה של השיחה.

לפריסות צד שלישי, לפי התיעוד הרשמי, ראו SSH remote sessions in Claude Desktop on 3P.

כל עוד תהליך Claude Code של שיחה עדיין רץ, לא מריצים claude --resume עבורו על המכונה המרוחקת. Claude Code לא עוצר אתכם, ושני התהליכים כותבים לאותה שיחה. אם לא בטוחים, מוסיפים --fork-session, שממשיך בעותק של השיחה, אבל שני התהליכים עדיין עובדים על אותם קבצים.

#איפה נשמרים worktrees של סשן SSH

אלא אם הארגון מגביל אילו תיקיות סשנים רשאים להשתמש בהן, סשני SSH חדשים יוצרים את ה-worktrees שלהם בראשון מהבאים שמוגדר:

1. Worktree folder על חיבור ה-SSH.
2. worktree.location ב-~/.claude/settings.json על המכונה המרוחקת.
3. <project-root>/.claude/worktrees/, ברירת המחדל.

לכל פרויקט יש תת-תיקייה משלו בתיקייה שהוגדרה, כך שעם ~/worktrees הנתיב הוא ~/worktrees/<project>-<id>/<worktree-name>. אם התיקייה שהוגדרה נמצאת בתוך הפרויקט, הדסקטופ מתעלם ממנה לפרויקט הזה ומשתמש בברירת המחדל. במכונה מרוחקת של Windows הדסקטופ תמיד משתמש בברירת המחדל.

#תיקיית worktree על חיבור קיים

קובעים Worktree folder בהגדרות של חיבור שהוספתם קודם, או של חיבור שהארגון מנהל. השדה דורש Claude Desktop מגרסה 1.44121.0 ומעלה. אם הארגון מגביל אילו תיקיות סשנים רשאים להשתמש בהן, הדסקטופ מסתיר את השדה ושומר את ה-worktrees בתוך הפרויקט.

1. מציאת החיבור. פותחים את בורר הסביבה ומוצאים את החיבור תחת SSH.
2. פתיחת ההגדרות. מרחפים מעל החיבור ולוחצים על גלגל השיניים. אם תיבת הדו-שיח מציגה Edit connection… ליד Host, בוחרים Edit connection….
3. קביעת התיקייה. ב-Worktree folder מזינים תיקייה במכונה המרוחקת, כמו ~/worktrees, ובוחרים Save changes.

#קבצים ותהליכים במכונה המרוחקת

הדסקטופ מתקין תוכנית עזר ואת Claude Code תחת ~/.claude/remote/ בתיקיית הבית של כל משתמש שמתחבר למכונה מרוחקת של לינוקס או macOS. תוכנית העזר לא מאזינה על פורט רשת, אבל Claude Code והתוכניות שהוא מפעיל, כמו שרתי MCP ושרתי פיתוח, יכולים.

כדי לרשום את התהליכים של משתמש אחד, מריצים pgrep -fl "$HOME/.claude/remote/" על המכונה המרוחקת כאותו משתמש, או עם תיקיית הבית של המשתמש במקום $HOME:

• תוכנית העזר: תהליך server אחד או יותר לכל מחשב שמתחבר.
• Claude Code: התהליכים שתוכנית העזר מפעילה לסשנים של המשתמש, כל אחד מקובץ שנקרא על שם הגרסה, כמו 2.1.295-….

הדסקטופ מגיע לתוכנית העזר דרך חיבור ה-SSH של המשתמש, על שקע Unix בשם rpc.sock בתיקייה של תוכנית העזר תחת ~/.claude/remote/run/. חוץ מ-root, משתמשים אחרים במכונה לא יכולים להתחבר לשקע, כי יש לו הרשאה 600 ולתיקייה שלו הרשאה 700.

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

כדי להסיר את תוכנית העזר ואת Claude Code למשתמש אחד:

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

2. סיום התהליכים. מחוברים כאותו משתמש על המכונה המרוחקת, מריצים kill עם המזהה של כל תהליך Claude Code ש-pgrep מציג. אחרי שהם נעלמו מהרשימה, מריצים kill עם המזהה של כל תהליך server. אם מסיימים תהליך server קודם, פקודה ש-Claude Code מריץ יכולה להמשיך לרוץ.

   אחר כך רושמים את התהליכים שנשארו למשתמש, למשל עם ps -u "$(id -un)" -f, ומסיימים כל תהליך שמזהים ככזה ש-Claude Code הפעיל. תוכניות שהוא השאיר ברקע יכולות להמשיך לרוץ אחרי שהוא נגמר, בלי להופיע ברשימת pgrep.

3. מחיקת התיקייה. מוחקים את ~/.claude/remote/. להסרת הקבצים של Claude Code עצמו ב-~/.claude/ וב-~/.claude.json, לפי הדף הרשמי, ראו Remove configuration files.

#סיום התהליך של סשן אחד

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

לפני שארכוב סשן שה-worktree שלו כולל שינויים שלא נכנסו ל-commit, ראו את סעיף שמירת השינויים בארכוב.

#איזה משתמש מריץ את התהליכים

תוכנית העזר ו-Claude Code רצים כמשתמש שהדסקטופ מתחבר אליו ב-SSH. ההתקנה וההפעלה שלהם לא דורשות sudo. לבדיקת המשתמש מריצים ps -o user= -p על המכונה המרוחקת עם מזהה תהליך ש-pgrep מציג.

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

#מי התחבר למכונה המרוחקת

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

אם השרת קובע MaxSessions 1, מצפים לפחות לשתי רשומות בכל פעם שהדסקטופ מתחבר או מתחבר מחדש. מצפים לעוד רשומה אחת לפחות לכל לשונית טרמינל, ולכל סשן דסקטופ שבו מריצים פקודות שמתחילות ב-!.

לא מוצאים את חיבורי ה-SSH של הדסקטופ במדדים ובאירועים של Claude Code. כדי לגלות מהם על איזו מכונה מרוחקת רץ סשן SSH, ראו את התיעוד Attribute telemetry to Desktop SSH sessions, לפי הדף הרשמי. לרשומה של הדסקטופ עצמו על החיבורים שלו, ראו בהמשך את הסעיף יומני הדסקטופ לבעיית SSH.

#חיבורים שנסגרים לפני התחברות

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

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

#זיהוי בדיקה ביומן שרת ה-SSH

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

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

לשורות של 8.0 עד 8.2 אין כתובת. כדי לקבל אחת, קובעים LogLevel VERBOSE ב-sshd_config ומריצים sshd -T | grep -i loglevel כ-root. אם מודפס loglevel VERBOSE, טוענים מחדש את שרת ה-SSH. אחר כך מחפשים שורה עם Connection from 203.0.113.7 port 51234 לפני שורת הבדיקה.

#בדיקה אם שרת ה-SSH עצמו מסרב לכתובת

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

drop connection #0 from [203.0.113.7]:51234 on [192.0.2.10]:22 penalty: connections without attempting authentication

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

כדי למנוע את הסירוב, קובעים PerSourcePenaltyExemptList ב-sshd_config לכתובות שאנשים מתחברים מהן, למשל PerSourcePenaltyExemptList 203.0.113.7. השרת אז לא מפעיל אף אחד מהעונשים שלו על הכתובות האלה, כולל עונשים על התחברויות שנכשלו. לבדיקת הקובץ מריצים sshd -T | grep -i persourcepenalt כ-root. אם מודפסת הרשימה, טוענים מחדש את שרת ה-SSH.

#בדיקה אם fail2ban סופר את הבדיקות של הדסקטופ

אם fail2ban מגרסה 0.10.5 ומעלה חסם כתובת שהדסקטופ מתחבר ממנה, מוצאים את ה-mode של ה-jail ב-jail.conf, ב-jail.local, או תחת jail.d/:

• שורת filter שמציינת mode בסוגריים, כמו filter = sshd[mode=aggressive]: משתמשים ב-mode הזה.
• רק שורת ה-filter הרגילה, עם [mode=%(mode)s]: משתמשים בשורת mode, או ב-normal אם אין שורה כזו.

אם ה-mode הוא normal, fail2ban לא סופר את שורות הבדיקות של הדסקטופ, ולכן מחפשים סיבה אחרת לחסימה.

ל-mode אחר, מעתיקים את השורות מהיומן שלכם לקובץ על המכונה המרוחקת. מעתיקים כל שורה בשלמות, מהתאריך עד הסוף, ואת שתי השורות כשבדיקה משאירה שתיים. מריצים שם fail2ban-regex עם הקובץ ועם ה-mode של ה-jail, למשל aggressive:

fail2ban-regex -o ip lines.log "sshd[mode=aggressive]"

לכל כשל ש-fail2ban סופר, הפקודה מדפיסה את הכתובת בשורה משלה, כמו 203.0.113.7. במקרה הזה מונעים את החסימה כמו בסעיף הבא. אם לא מודפס דבר, fail2ban לא סופר אף אחת מהשורות האלה ב-mode הזה, ולכן מחפשים סיבה אחרת לחסימה.

#מניעת חסימה על ידי fail2ban

כדי ש-fail2ban לא יחסום כתובת בגלל הבדיקות של הדסקטופ, משנים אחת משתי הגדרות של ה-jail. לכל אחת יש מחיר:

• mode: קובעים אותו ל-normal בכל מקום שה-jail קובע אותו, בשורת mode או בסוגריים של שורה כמו filter = sshd[mode=aggressive]. מוותרים על כל ספירה שרק המצבים האחרים עושים, למשל של לקוחות שמתחברים ועוזבים בלי לנסות להתחבר.
• ignoreip: קובעים אותו לכתובות שאנשים מתחברים מהן, למשל ignoreip = 203.0.113.7. fail2ban אז לא סופר דבר מהכתובות האלה, כולל התחברויות שנכשלו.

#שרתי MCP שמוגדרים במכונה המרוחקת

כדי להשתמש בשרת MCP מ-~/.claude.json או מ-.mcp.json של פרויקט בסשן SSH, מגדירים אותו בקבצים האלה על המכונה המרוחקת. Claude Code מפעיל שם את שרתי ה-stdio שלהם, ולכן מתקינים על המכונה המרוחקת את הפקודות שהשרתים האלה מריצים. לשרתים מ-claude_desktop_config.json, ראו את סעיף המגבלות בזמן שהדסקטופ מנותק.

#פתיחת סשן SSH מקישור

קישור claude://code/new פותח את עמוד הסשן החדש בדסקטופ, ויכול לציין חיבור SSH. שמים קישור כזה ב-runbook, בלוח בקרה או בעמוד wiki כדי לפתוח את הדסקטופ מוכן למכונה ולתיקייה הנכונות. פלטפורמות שמורידות קישורים כאלה מתועדות בעמוד הקישורים העמוקים, לפי הדף הרשמי.

קישורי SSH דורשים Claude Desktop מגרסה 2.110.0 ומעלה.

הקישור הבא מציין את המשתמש dev על build.example.com, פורט 2222, והתיקייה /srv/payments, וממלא הנחיה:

claude://code/new?ssh_host=dev%40build.example.com&ssh_port=2222&ssh_folder=/srv/payments&q=Investigate%20the%20failed%20deploy

רק ssh_host חובה:

כינוי מ-~/.ssh/config עובד כ-ssh_host רק אצל מי שיש לו את הרשומה הזו. כדי להתאים לחיבור שכבר קיים, נותנים לקישור את אותו משתמש, מארח ופורט כמו בחיבור.

בפתיחת הקישור הדסקטופ מבקש אישור לפני שהוא בוחר את החיבור:

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

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

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

• לפני האישור: בודקים את המארח ואת התיקייה.
• לפני השליחה: בודקים את ההנחיה ואת הסביבה שנבחרה.

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

קישור לא עוקף את sshHostAllowlist. הדסקטופ בודק את הרשימה בזמן החיבור.

אם הקישור פותח את הדסקטופ בלי תיבת דו-שיח על החיבור, אחת הסיבות האלה יכולה להסביר את זה:

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

#יצירת חיבור SSH מפקודה

אם כלי שורת פקודה יוצר את המכונות המרוחקות לפי דרישה, מוסיפים את הפקודה שלו ל-sshHostCommands ב-~/.claude/settings.json. בורר הסביבה מציג אז פריט לפי שם הרשומה, למשל Create Dev box. כשבוחרים אותו, הדסקטופ מריץ את הפקודה על המחשב, שומר את המארח שהפקודה מדפיסה כחיבור SSH, ומתחבר.

חיבורים מפקודה דורשים Claude Desktop מגרסה 3.6556.0 ומעלה ב-macOS או בלינוקס, או מגרסה 4.16336.0 ומעלה ב-Windows, עם התחברות בחשבון Claude. ב-Windows הדסקטופ גם צריך להתחבר דרך לקוח OpenSSH. מנהלים יכולים להפיץ פקודות לצוות, כמו בסעיף הפצה לצוות.

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

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

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

הדוגמה הבאה מוסיפה חיבור בשם Dev box. אם הקובץ לא קיים, יוצרים אותו. אם כבר יש בו הגדרות, מוסיפים את המפתח לידן. הפקודה acme-dev create מייצגת את הכלי שלכם, ו-~/project היא התיקייה שהדסקטופ בוחר בכל מכונה שהפקודה יוצרת:

{
  "sshHostCommands": [
    {
      "id": "devbox",
      "name": "Dev box",
      "command": "acme-dev create",
      "startDirectory": "~/project"
    }
  ]
}

ב-Windows שם חשוף כמו acme-dev לא עובד, אז מתחילים את הפקודה בנתיב המלא של התוכנית, כמו בסעיף כתיבת הפקודה ב-Windows.

כל רשומה מקבלת את השדות האלה, ו-id, name ו-command חובה:

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

#כתיבת הפקודה

ב-Windows מתחילים בסעיף כתיבת הפקודה ב-Windows, שאומר אילו מהכללים האלה חלים שם.

ב-macOS ובלינוקס הדסקטופ מפעיל את התוכנית ישירות, בלי מעטפת ובלי טרמינל:

• תוכנית: כותבים את שמה, או נתיב מלא מ-/. הדסקטופ מחפש שם חשוף ב-PATH שמעטפת ההתחברות מייצאת. נתיבים יחסיים כמו ./acme-dev, נתיבים שמתחילים ב-~, וכינויי מעטפת ופונקציות לא עובדים.
• רווחים בנתיב: שמים את הנתיב המלא של התוכנית במירכאות בודדות, כמו '/Users/you/My Tools/make-devbox' create. מירכאות, בודדות או כפולות, דורשות Claude Desktop מגרסה 4.16336.0 ומעלה, ועובדות רק סביב נתיב התוכנית.
• ארגומנטים: מפרידים ארגומנטים ברווחים. מחוץ למירכאות, הפקודה יכולה להכיל רק רווחים, אותיות ASCII, ספרות, והתווים +,-./:=@_~, ואף מילה לא יכולה להתחיל ב-~. נתיב בתוך מירכאות יכול להכיל גם תווים אחרים, כמו (, ) ו-&.
• סקריפטים: אם הפקודה צריכה משהו אחר, כמו מרכאות, צינורות, משתנים, או URL עם ? או &, שמים את זה בסקריפט. הופכים את הסקריפט לבר הרצה, מתחילים אותו בשורת #!, וקובעים את command לנתיב המלא שלו, כמו /Users/you/bin/make-devbox. ב-macOS משאירים את הסקריפט מחוץ לתיקיות Documents, Desktop ו-Downloads, שבהן macOS יכול לחסום אותו.
• קלט: התוכנית לא מקבלת קלט ולא טרמינל, אז היא לא יכולה לבקש שם משהו. אם הכלי מתחבר דרך דפדפן או בקשה, מתחברים קודם מטרמינל, ושוב כשההתחברות הזו פגה.
• סביבה: התוכנית רצה בתיקיית הבית עם המשתנים שמעטפת ההתחברות מייצאת. הדסקטופ קורא אותם כשהוא עולה, כמו ב-ProxyCommand, אז יוצאים ופותחים מחדש אחרי שמשנים אותם.
• מגבלת זמן: הדסקטופ עוצר תוכנית שעדיין רצה אחרי 10 דקות. הודעת ההתקדמות של הדסקטופ לא מציגה את פלט התוכנית. כדי לעצור מוקדם יותר, בוחרים Cancel ליד ההודעה.

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

• שורה אחת: host או user@host, באותה צורה כמו ssh_host בקישור SSH. כדי לציין פורט, משתמשים בצורת ה-JSON.
• אובייקט JSON אחד: sshHost, ובאופן אופציונלי sshPort מספרי ו-startDirectory שמחליף את זה של הרשומה, כמו {"sshHost": "[email protected]", "sshPort": 2222}.

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

acme-dev create < /dev/null > host.txt

הקובץ צריך להחזיק רק את המארח. כשמריצים את הבדיקה הזו, הכלי יוצר גם מכונה, אז מוחקים אותה עם הכלי אחר כך.

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

#!/bin/bash
out=$(mktemp) || exit
trap 'rm -f "$out"' EXIT
acme-dev create > "$out" || exit
tail -n 1 "$out"

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

#כתיבת הפקודה ב-Windows

ב-Windows מתחילים את command בנתיב המלא של קובץ .exe, .cmd או .bat, מאות הכונן. הדסקטופ לא מחפש שם חשוף ב-PATH, אז רשומה שה-command שלה הוא acme-dev create אפורה.

הרשומה הבאה ב-%USERPROFILE%\.claude\settings.json מריצה את C:\Program Files\Acme\acme-dev.exe עם הארגומנט create. ב-JSON כותבים כל לוכסן הפוך פעמיים, או כותבים / במקום. המירכאות הבודדות שם כי בנתיב יש רווח:

{
  "sshHostCommands": [
    {
      "id": "devbox",
      "name": "Dev box",
      "command": "'C:\\Program Files\\Acme\\acme-dev.exe' create"
    }
  ]
}

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

• תוכנית: לא משתמשים בנתיב רשת כמו \\server\share, במשתנה כמו %USERPROFILE%, או באות מחוץ ל-ASCII. עם אחד מאלה בנתיב, הרשומה אפורה. אם בשם תיקיית המשתמש יש אות כזו, שומרים את התוכנית מחוץ לתיקייה הזו.
• ארגומנטים: עוקבים אחרי כלל הארגומנטים בסעיף כתיבת הפקודה. הפקודה יכולה להכיל גם \, אבל אף מילה לא יכולה להסתיים בו.
• סקריפטים: משתמשים בקובץ .cmd או .bat, שהדסקטופ מריץ דרך cmd.exe. גם בתוך מירכאות, נתיב הקובץ לא יכול להכיל &, ^ או ;. בקובץ שכותבים, קוראים את הארגומנטים עם %*, כי %1 עד %9 מפצלים ארגומנט ב-, וב-=.
• סביבה: התוכנית מקבלת את משתני הסביבה של אפליקציית הדסקטופ, לא של פרופיל מעטפת. אחרי שמשנים משתנה, יוצאים מהדסקטופ ופותחים אותו מחדש.
• בדיקה: כדי לראות את הפלט שהדסקטופ קורא, מריצים את הפקודה ב-Command Prompt. שמים נתיב עם רווח במירכאות כפולות ומשתמשים ב-NUL בלי קלט, כמו "C:\Program Files\Acme\acme-dev.exe" create < NUL > host.txt. הקובץ צריך להחזיק רק את המארח. הבדיקה יוצרת גם מכונה, אז מוחקים אותה עם הכלי אחר כך.

#עטיפת כלי Windows שמדפיס שורות אחרות

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

@echo off
setlocal
set "host="
set "out=%TEMP%\acme-dev-%RANDOM%.txt"
call "C:\Program Files\Acme\acme-dev.exe" create > "%out%"
set "code=%ERRORLEVEL%"
for /f "usebackq delims=" %%L in ("%out%") do set "host=%%L"
del "%out%"
if not "%code%"=="0" exit /b %code%
setlocal EnableDelayedExpansion
echo(!host!

קובעים את command לנתיב המלא של הקובץ, כמו C:\\tools\\make-devbox.cmd ב-JSON. משאירים את שתי השורות האחרונות כמו שהן, כי הן מדפיסות את המארח בלי להריץ אותו כפקודה.

#חיבור למארח חדש

עונים על שתי שאלות בפעם הראשונה שמתחברים לכל מארח חדש:

• מפתח מארח: עם בדיקת מפתח המארח של ברירת המחדל של OpenSSH, בודקים את טביעת האצבע של המפתח, ואז בוחרים אם להתחבר. כדי לדלג על השאלה, נותנים לפקודה להוסיף את המפתח ל-~/.ssh/known_hosts, או ל-%USERPROFILE%\.ssh\known_hosts ב-Windows, לפני שהיא מדפיסה את המארח:
  • משתמשים במפתח שהכלי למד כשיצר את המכונה.
  • לפורט שאינו 22, השורה מתחילה ב-[host]:port.
  • אם הכלי ממחזר שמות מארח, מסירים גם את שורת המפתח הישן.
• תיקייה: בוחרים אם סומכים על התיקייה שפותחים שם.

משאירים את בדיקת מפתח המארח דלוקה למארחים האלה, ושומרים עבורם קובץ known_hosts. אם StrictHostKeyChecking הוא no או accept-new וגם UserKnownHostsFile הוא /dev/null או none, שום דבר לא רושם את המפתח. כשהכלי ממחזר אז שם, אפשר להתחבר למכונה אחרת בלי אזהרה.

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

• אתם, הפקודה שלכם, או תוכנית אחרת הוסיפו את המפתח החדש ל-known_hosts, או הסירו את שורת המפתח הישן, כמו שהפקודה עושה אם היא מוסיפה מפתחות מארח.
• המכונות של הכלי חולקות מפתח מארח.
• המכונות של הכלי חולקות רשות אישורים ש-known_hosts סומך עליה.
• אתם או המנהל קבעתם KnownHostsCommand, או VerifyHostKeyDNS yes, כך ש-SSH מקבל מפתחות מחוץ ל-known_hosts.

#יצירת מכונה נוספת

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

• סשנים על מכונות קודמות: ממשיכים אותם מהסרגל, כי הבורר מציג את המכונה הנוכחית של Dev box ולא את הקודמות. הדסקטופ יכול להתחבר למכונות שלהן בעצמו, למשל כשהדסקטופ עולה, אז מפסיקים להשתמש במכונה כשמסיימים איתה.
• מארח שהוחלף לפני Claude Desktop מגרסה 4.4212.0: הגרסאות האלה מציגות Replace Dev box's host ומפסיקות להתחבר למארח שהוחלף. כדי להמשיך סשן על המארח הזה, פותחים את הסשן, בוחרים Add SSH connection, ושומרים את החיבור שהדסקטופ ממלא. מעדכנים את הדסקטופ לפני שמחליפים מארח נוסף.
• סשנים חדשים על שתי מכונות: מוסיפים רשומה שנייה ל-sshHostCommands.
• מארח חדש שעדיין לא עונה: משאירים את עמוד הסשן החדש פתוח עד 10 דקות בזמן שהוא ממשיך לנסות להתחבר. אם המארח עדיין לא עונה, בוחרים Create another Dev box בהודעה של העמוד.
• מכונה נוספת זמן קצר אחר כך: אחרי כמה הרצות של הפקודה בתוך שעה, מאשרים כל הרצה נוספת בתיבת הדו-שיח שהדסקטופ פותח, שמציגה את הפקודה.

#הפסקת שימוש במכונה

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

1. מוצאים את הסשנים של המכונה בסרגל. לוח פרטי הסשן מציג את המארח שעליו הוא רץ.
2. מארכבים כל סשן, ומשאירים אותו בארכיון.
3. אם עוד לא יצרתם מכונה נוספת מאותה רשומת sshHostCommands מאז שיצרתם את זו, יוצרים אחת, או מסירים גם את הרשומה. עד אז המכונה היא החיבור השמור של הרשומה, והדסקטופ יכול להתחבר אליה כשפותחים את עמוד הסשן החדש עם החיבור הזה נבחר.
4. מוחקים בדסקטופ כל חיבור SSH אחר למכונה, או מסירים את רשומת ה-sshConfigs שלה.
5. יוצאים מהדסקטופ ופותחים אותו מחדש. זה סוגר את החיבור למכונה ומסיים את הניסיונות להגיע אליה.
6. מוחקים את המכונה עם הכלי.

#הסרת רשומה

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

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

#הפצת פקודות לצוות

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

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

{
  "sshHostCommands": [
    {
      "id": "acme-devbox",
      "name": "Dev box",
      "command": "/usr/local/bin/acme-dev create"
    }
  ],
  "strictPluginOnlyCustomization": ["hooks"]
}

לפני פריסת המפתח, מסדרים כל אחד מאלה:

• איפה לשים את המפתח: אם מדיניות ה-MDM של Claude Code כבר קובעת מפתח מדיניות, שמים אותו שם. אחרת שמים אותו בקובץ ההגדרות המנוהלות. כברירת מחדל מדיניות כזו גוברת על הקובץ, והדסקטופ מתעלם אז מרשומות בקובץ. קובעים אותו על המחשב גם איפה שחלות הגדרות שמנוהלות בשרת: הדסקטופ מתעלם שם מהמפתח, וגם בהגדרות פרויקט ומקומי.
• ה-id: אם לרשומת sshHostCommands של משתמש יש את ה-id שלכם, רק שלכם עובד. אם לחיבור SSH אחר יש אותו, כמו אחד ב-sshConfigs של משתמש, הרשומה שלכם אפורה. בוחרים id שמשתמשים לא סביר שיבחרו.
• התוכנית: נותנים את הנתיב המלא שלה, כי ב-macOS ובלינוקס הדסקטופ מחפש שם חשוף ב-PATH של כל משתמש, וב-Windows רשומה עם שם חשוף אפורה. התוכנית רצה כמשתמש, עם המשתנים של המשתמש הזה, כמו בסעיף כתיבת הפקודה.
• כל פלטפורמה: מפיצים רשומה אחת למחשבי Windows ורשומה אחרת למחשבי macOS ולינוקס. רשומה עם נתיב Windows אפורה ב-macOS ובלינוקס, ורשומה עם נתיב macOS או לינוקס אפורה ב-Windows.
• הרשומות של המשתמשים: הדסקטופ מתייחס לרשומה של משתמש כמו להוק, כי שניהם מריצים תוכנית על המחשב. כדי להתיר רק את הרשומות שלכם, קובעים strictPluginOnlyCustomization ל-["hooks"], או מוסיפים "hooks" לרשימה שלו. זה גם עוצר הוקים של Claude Code מהגדרות משתמש, פרויקט ומקומי, בלי דרך להשאיר אותם. אם קובעים את המפתח הזה, או את allowManagedHooksOnly ל-true, חוסמים יותר, כמו שכל רשומת מפתח מפרטת.
• כל רשומה: כדי לכבות גם את הרשומות שלכם, קובעים disableAllHooks בהגדרות המנוהלות. אם קובעים disableDesktopLocalSessions, או sshHostAllowlist שלא מתיר שום מארח, הבורר לא מציג פריטי Create או Create another.
• איפה הנעילות נספרות: לרשומות האלה הדסקטופ קורא את allowManagedHooksOnly, strictPluginOnlyCustomization ו-disableAllHooks מהגדרות שמנוהלות בשרת ומהקובץ או מהמדיניות של המחשב עצמו, ומחיל את התוצאה המחמירה. כל רשומה נשארת אפורה עד שהדסקטופ בדק ב-claude.ai הגדרות שמנוהלות בשרת, גם אם לארגון אין כאלה.
• מארחים מותרים: אם קובעים sshHostAllowlist, מוודאים שדפוס תואם לכל hostname שהכלי מדפיס, ומשאירים את user@ מחוץ לדפוס. הדסקטופ בודק את השם המודפס רק אחרי שהפקודה רצה, אז מכונה שהרשימה מסרבת לה כבר קיימת, והמשתמש צריך למחוק אותה עם הכלי. בכל התחברות, גם ה-HostName המפוענח צריך להתאים.

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

#אם פקודה חסרה או אפורה

בורר הסביבה לא מציג פריט Create או Create another במקרים האלה:

• הקובץ: ל-~/.claude/settings.json יש JSON לא תקין או ערך שהסכמה דוחה, אייתתם לא נכון את המפתח, או ששמתם אותו בהגדרות פרויקט. מתקנים את הקובץ.
• חשבון: משתמשים בספק צד שלישי במקום בחשבון Claude. מוסיפים כל מארח כחיבור SSH בעצמכם.
• Windows: הדסקטופ ישן מגרסה 4.16336.0, או שהוא לא מתחבר דרך לקוח OpenSSH. מעדכנים את הדסקטופ ועומדים בדרישות ללקוח OpenSSH, ואז יוצאים מהדסקטופ ופותחים אותו מחדש.
• הגדרות הארגון: המנהל כיבה סשנים מקומיים, או כיבה סשני SSH. שואלים אם אפשר להשתמש בפקודות.
• אין תוכנית ssh: הדסקטופ לא הצליח להפעיל את לקוח OpenSSH על המחשב. מתקינים אותו, או מבקשים מהמנהל להתיר אותו, ואז מפעילים מחדש את הדסקטופ.

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

• טעות ברשומה: מתקנים את השדה או את הפקודה שההודעה מציינת. אם ה-id בשימוש, נותנים לרשומה אחר. ב-Windows הפקודה חייבת להתחיל בנתיב המלא של התוכנית.
• קובץ הגדרות שבור: כל עוד קובץ ההגדרות שלכם שבור, רשומות המנהל יכולות להיות אפורות, עם הודעה שמציינת את הקובץ. מתקנים את הקובץ.
• מארח חדש: Create another אפור דקה אחת אחרי שהדסקטופ שומר מארח. בוחרים אותו אחרי הדקה הזו. לפני Claude Desktop מגרסה 4.4212.0, Replace Dev box's host אפור 10 דקות.
• הוקים כבויים או מוגבלים: הרשומות שלכם עובדות רק איפה שהוקים שלכם יכולים לרוץ. מסירים את disableAllHooks מההגדרות, או פונים למנהל.
• ההגדרות עדיין נטענות: כל רשומה אפורה עד שהדסקטופ טען את ההגדרות שמנוהלות בשרת של הארגון, בדרך כלל כמה שניות אחרי ההפעלה. אם הרשומות נשארות אפורות, בודקים את החיבור ל-claude.ai.

#הכנה מראש לצוות

מנהלים יכולים להפיץ חיבורי SSH על ידי הוספת sshConfigs לקובץ הגדרות מנוהלות. החיבורים מופיעים אוטומטית בתפריט הסביבה ומסומנים כמנוהלים. המשתמש יכול לבחור אותם ולהגדיר לעצמו את Worktree folder, אבל לא יכול לערוך שום דבר אחר או למחוק אותם באפליקציה.

{
  "sshConfigs": [
    {
      "id": "shared-dev-vm",
      "name": "Shared Dev VM",
      "sshHost": "[email protected]",
      "sshPort": 22,
      "sshIdentityFile": "~/.ssh/id_ed25519"
    }
  ]
}

כל רשומה דורשת id, name ו-sshHost. השדות sshPort ו-sshIdentityFile אופציונליים. משתמשים יכולים גם להוסיף sshConfigs ל-~/.claude/settings.json שלהם.

אם משמיטים את user@ מ-sshHost, הדסקטופ מתחבר כ-User ש-~/.ssh/config של כל מפתח קובע למארח, ואם אין שם רשומה כזו, בשם המשתמש של המפתח על המחשב שלו.

#הגבלת מארחים

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

{
  "sshHostAllowlist": ["*.devboxes.example.com", "bastion.example.com"]
}

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

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

הדפוסים לא תלויי רישיות. * תואם לכל מארח, ו-*.example.com תואם את example.com וכל תת-דומיין. כל דבר אחר הוא התאמה מדויקת. הבדיקה רצה על שם המארח אחרי פענוח ~/.ssh/config דרך ssh -G, כך שכינויי Host ורשומות ProxyCommand או ProxyJump מותרים כל עוד HostName המפוענח תואם. גם מארחי הקפיצה של הסשן צריכים להתאים.

sshHostAllowlist נקרא רק מהגדרות מנוהלות. ערכים בהגדרות משתמש או פרויקט מתעלמים מהם. רק אפליקציית Claude Desktop מכבדת את ההגדרה. ה-CLI ותוספי ה-IDE לא קוראים אותה, והיא לא מגבילה פקודות ssh דרך כלי Bash. היא קובעת לאילו מארחים האפליקציה מתחברת, לא את יציאת הרשת. לגבול קשיח משלבים אותה עם בקרות הרשת או ה-zero-trust של הארגון.

#התרת מארחי קפיצה

מוסיפים ל-sshHostAllowlist כל מארח קפיצה שהדסקטופ בודק, לפי ה-HostName המפוענח שלו. מוסיפים את מארחי הקפיצה לפני שהמשתמשים מתעדכנים ל-Claude Desktop מגרסה 3.1623.0 ומעלה, אחרת הם לא יכולים להתחבר דרכם.

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

הדסקטופ בודק מארחי קפיצה ב-ProxyJump ש-~/.ssh/config של המשתמש קובע למארח הסשן, או ב-ProxyCommand שנכתב כ-ssh -W %h:%p <host>. אם אחד מהם לא ברשימה כשהדסקטופ מתחבר או מתחבר מחדש לסשן, החיבור נכשל. כשמשתמש מתחיל סשן או שולח הודעה, פרטי השגיאה נותנים את ה-HostName של מארח הקפיצה, וזה השם שצריך להוסיף:

SSH host "bastion.example.com" is not allowed by your organization's managed settings. It is a jump host on the way to "devbox".

אם ההודעה אומרת managed settings on this computer, מוסיפים את השם לרשימה על המחשב של המשתמש. אם חסר יותר ממארח קפיצה אחד, השגיאה מציינת אחד בכל פעם. כדי למצוא כל שם לפני שהמשתמשים מתעדכנים, משתמשים בטרמינל על מחשב של משתמש:

1. מציאת המסלול. מריצים ssh -G עם מארח שהמשתמשים מתחברים אליו, למשל ssh -G devbox. מחפשים שורת proxyjump, או שורת proxycommand שנכתבה כ-ssh -W %h:%p <host>. הפקודה עדיין נספרת עם אחד מ--l, -p, -J, -q, -v, -N, -T, -x או -a, והמארחים אחרי -J הם גם מארחי קפיצה. אם שורת proxycommand מריצה תוכנית שאינה ssh, לא מוסיפים עבורה כלום.
2. איתור כל מארח קפיצה. מריצים ssh -G עם כל מארח קפיצה בשורה הזו, בלי :port, ורושמים את ה-hostname שהפקודה מדפיסה. אם לפלט של מארח הקפיצה הראשון בשורה יש שורה מאחד משני הסוגים, חוזרים על השלב הזה איתו. מתעלמים משורה כזו בפלט של מארח קפיצה מאוחר יותר.
3. הוספת השמות. מוסיפים כל hostname, או תו הכללה שמכסה אותו, ל-sshHostAllowlist בכל מקור מנוהל שבו קובעים רשימה. אחר כך המשתמשים יוצאים מהדסקטופ ופותחים אותו מחדש, כי הוא מושך הגדרות שמנוהלות בשרת בהפעלה.

#כיבוי סשנים מקומיים והפצת חיבורי SSH

כדי לכבות סשנים מקומיים ולהגביל סשני SSH למארחים שבוחרים, מפיצים יחד את disableDesktopLocalSessions, sshConfigs ו-sshHostAllowlist.

ההגדרה הזו מיועדת למשתמשים שמתחברים בחשבון Claude. אצל ספק צד שלישי סשני SSH כבויים כברירת מחדל, והגדרת sshHostAllowlist יכולה להדליק אותם. לפני פריסת המפתחות האלה קוראים את התיעוד SSH remote sessions in Claude Desktop on 3P, לפי הדף הרשמי.

הדוגמה הבאה מכבה סשנים מקומיים, מוסיפה חיבור אחד, ומגבילה סשני SSH למארח של החיבור הזה:

{
  "disableDesktopLocalSessions": true,
  "sshConfigs": [
    {
      "id": "shared-dev-vm",
      "name": "Shared Dev VM",
      "sshHost": "dev.example.com"
    }
  ],
  "sshHostAllowlist": ["dev.example.com"]
}

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

• ה-CLI: אף אחד מהמפתחות לא עוצר מפתח מלהריץ את ה-CLI של Claude Code על המחשב שלו.
• Cowork: אף אחד מהמפתחות לא חל על סשני Cowork או על משימות מתוזמנות של Cowork.
• סשני ענן: אף אחד מהמפתחות לא משנה אם סשני ענן זמינים. כדי לכבות אותם משתמשים בהגדרת Cloud sessions תחת בקרות מסוף הניהול.

כשמתאימים את הדוגמה, בודקים את שמות המארחים, את גרסת הדסקטופ, ואת הרשאות הקובץ:

• שמות מארחים: דפוס ב-sshHostAllowlist צריך להתאים לשם המארח של כל רשומת sshConfigs, בלי user@, אחרת המפתחים לא יכולים להתחבר אליו. מוסיפים גם דפוס שמתאים לכל מארח קפיצה שהדסקטופ בודק בדרך אליו. איך הדסקטופ מתאים שם מארח מפורט בסעיף הגבלת מארחים.
• גרסה: disableDesktopLocalSessions דורש Claude Desktop מגרסה 1.37937.0 ומעלה.
• הרשאות קובץ: חשבון המפתח על המחשב צריך להיות מסוגל לקרוא את קובץ ההגדרות המנוהלות. הדסקטופ לא מחיל את המפתחות בקובץ שהחשבון לא יכול לקרוא, וגם Claude Code עולה בלעדיהם.

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

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

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

   • הרשומה של המחשב, באפור.
   • Shared Dev VM תחת SSH. אם הוא לא מופיע שם, לוחצים על שורת SSH היחידה, או על More בסוף הקבוצה.

   אם הרשומה של המחשב עדיין זמינה, בודקים:

   • גרסת הדסקטופ: מעדכנים אם היא מוקדמת מ-1.37937.0.
   • קובץ ההגדרות המנוהלות: מוודאים שהקובץ הוא JSON תקין.
   • מקור מנוהל: מוודאים שהמחשב קורא את המקור המנוהל שמחזיק את המפתחות.

2. הוספת מארח שאינו ברשימה. מוסיפים חיבור SSH עם שם מארח שאינו ברשימה, כמו other.example.com. הדסקטופ שומר את החיבור אבל מסרב להתחבר, ואומר שהגדרות הארגון לא מתירות את החיבור.

#הגדרות ארגון

ארגונים בתוכניות Team או Enterprise מנהלים את האפליקציה דרך מסוף הניהול, קובצי הגדרות מנוהלות, ומדיניות על המכשיר.

#בקרות במסוף הניהול

ההגדרות האלה נקבעות במסוף הניהול:

• Desktop: האם משתמשים בארגון יכולים לגשת ל-Claude Code באפליקציה.
• Cloud sessions: הפעלה או כיבוי של סשני ענן לארגון.
• Remote Control: הפעלה או כיבוי של Remote Control לארגון.

בארגוני Enterprise שבהם HIPAA מופעל, המתג Desktop כבוי כברירת מחדל, ו-Owner יכול להפעיל אותו. החלת תצורת HIPAA מכבה את המתג גם אם היה דלוק, ולכן Owner צריך להפעיל אותו אחר כך. גם Cloud sessions ו-Remote Control כבויים כברירת מחדל, ו-Owner לא יכול להפעיל אותם אחרי שהוחלת תצורת HIPAA על הארגון.

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

כדי לייצא טלמטריה מסשנים של לשונית Code, מגדירים CLAUDE_CODE_ENABLE_TELEMETRY ואת משתני OTEL_* בבלוק env של הגדרות Claude Code המנוהלות. סשנים מקומיים, סשני ענן וסשני SSH קוראים הגדרות מנוהלות ממקורות שונים. המארחים שסשן ענן יכול להגיע אליהם מפורטים בתיעוד הגישה לרשת של סביבות הענן. ה-service.name שסשני לשונית Code מדווחים מפורט בתיעוד המידע על השירות בניטור. כדי לגלות על איזו מכונה מרוחקת רץ סשן SSH, ראו את התיעוד Attribute telemetry to Desktop SSH sessions, לפי הדף הרשמי.

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

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

אילו הגדרות מגיעות לסשן תלוי במקום שבו הוא רץ. הגבלות מודל כמו availableModels נאכפות בסשני Claude Code של הדסקטופ כמו ב-CLI.

• סשנים מקומיים על המחשב הזה: קובץ הגדרות מנוהלות שנפרס לדיסק חל. הגדרות שנדחפו מרחוק ממסוף הניהול מגיעות גם הן לסשנים האלה על Anthropic API, כשהסשן מזדהה עם התחברות או מפתח זכאים, לפי אותו סדר עדיפות כמו ב-CLI.
• סשני ענן: מקבלים הגדרות שמנוהלות בשרת. קבצים שנפרסו על המכשיר לא מגיעים אליהם, כי הם רצים על מכונות וירטואליות שמנוהלות אצל Anthropic. סשנים שמנותבים לסביבה באירוח עצמי קוראים גם את קובץ ההגדרות המנוהלות בתמונת ה-runner. התיעוד של שילוב מקורות מנוהלים אומר מתי הקובץ הזה חל.
• סשני SSH: הסשן קורא את קובץ ההגדרות המנוהלות מהמארח המרוחק. הדסקטופ עצמו קורא את sshConfigs, sshHostAllowlist, disableSshSavedPasswords ו-disableDesktopLocalSessions מהמכונה המקומית. אם מעבירים יותר ממקור מנוהל אחד, הוא קורא אותם ממקור אחד כברירת מחדל.
• סשני Cowork: בסשן Cowork על המחשב הזה, Claude Code אף פעם לא מושך הגדרות ממסוף הניהול, גם כשהמשתמש מחובר בחשבון Team או Enterprise, וקורא מדיניות שנפרסה למכונה אלא אם תצורת Claude Desktop מגדירה requireCoworkFullVmSandbox. סשני Cowork מרוחקים לא מקבלים אף אחד מהם. אילו קבצי מדיניות על המכשיר מגיעים ל-Cowork, ואיך כללי Bash ו-WebFetch חלים על הכלים של Cowork, מפורטים בתיעוד ההגדרות המנוהלות, לפי הדף הרשמי.

בסשנים מקומיים וב-SSH, האפליקציה מעבירה ל-Claude Code ישירות את מחברי claude.ai של המשתמש. שום הגדרת MCP ושום managed-mcp.json לא מגיעים למחברים האלה, בלי קשר למקור ההגדרות או למיקום הקובץ. כדי לחסום כלים של מחבר בסשנים האלה, משתמשים בבקרות הכלים של המחברים בארגון.

permissions.disableBypassPermissionsMode ו-disableAutoMode עובדים גם בהגדרות משתמש ופרויקט, אבל מיקום שלהם בהגדרות מנוהלות מונע מהמשתמשים לעקוף אותם.

מפתחות של הרשאות, תוספים ומסירה שרק מקור מנוהל יכול לקבוע מפורטים בתיעוד Keys only managed settings can set, לפי הדף הרשמי.

#מפתחות של Claude Code שמתנהגים אחרת בלשונית Code

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

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

צוותי IT מנהלים את האפליקציה דרך MDM ב-macOS, מדיניות קבוצה ב-Windows, או קובץ מדיניות בלינוקס. המדיניות הזמינה כוללת הפעלה או כיבוי של יכולת Claude Code, שליטה בעדכונים אוטומטיים ב-macOS וב-Windows, וכתובת פריסה מותאמת.

• macOS: דומיין ההעדפות com.anthropic.claudefordesktop, בכלים כמו Jamf או Kandji.
• Windows: רשומת הרישום SOFTWARE\Policies\Claude.
• Linux: קובץ בבעלות root בנתיב /etc/claude-desktop/managed-settings.json, שמחזיק את מפתחות המדיניות כאובייקט JSON. הדסקטופ מסרב לקובץ אם מישהו שאינו root יכול לכתוב אליו או לתיקייה שלו. זה קובץ אחר מקובץ ההגדרות המנוהלות של Claude Code.

#הגבלת ההתחברות לארגון

כדי להגביל אילו ארגוני claude.ai יכולים להתחבר ל-Claude Desktop, קובעים את forceLoginOrgUUID במדיניות של Claude Desktop.

המפתח דורש Claude Desktop מגרסה 1.2581.0 ומעלה.

בלינוקס, קובץ מדיניות שקובע רק את המפתח הזה נראה כך:

{
  "forceLoginOrgUUID": "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"
}

מחליפים את המציין במזהה הארגון של claude.ai, שמופיע בהגדרות הניהול של claude.ai. זה אותו מזהה שההגדרה forceLoginOrgUUID של Claude Code מקבלת. לדוגמאות ל-macOS ול-Windows שקובעות את המפתח הזה, לפי התיעוד הרשמי, ראו Deploy the Claude Desktop policy במדריך Cowork לארגונים מוכנים ל-HIPAA.

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

אם קובעים את forceLoginMethod ואת forceLoginOrgUUID בהגדרות המנוהלות של Claude Code, מסך ההתחברות של Claude Desktop לא משתנה.

#דרישות גישה לרשת

הדסקטופ טוען את קוד האפליקציה ואת תוכן המשתמש ממארחי CDN של Anthropic.

anthropic.com
*.anthropic.com
claude.ai
*.claude.ai
claude.com
*.claude.com
claude.app
*.claude.app
*.claudeusercontent.com
*.claudemcpcontent.com

התעבורה היא HTTPS על פורט 443, אלא אם מגדירים פורט מותאם ל-OTLP, לשער LLM, או לשרת MCP.

שרת מתווך, רשויות אישורים מותאמות, mTLS, והדומיינים שדרושים ל-CLI העצמאי, מפורטים בתיעוד network configuration לפי הדף הרשמי.

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

anthropic.com
api.anthropic.com
a-api.anthropic.com
a-cdn.anthropic.com
s-cdn.anthropic.com
assets-proxy.anthropic.com
claude.ai
a.claude.ai
assets.claude.ai
downloads.claude.ai
*.livepreview.claude.ai
claude.com
platform.claude.com
sso.claude.com
*.livepreview.claude.app
*.claudeusercontent.com
*.claudemcpcontent.com

אם לארגון מופעלת רשימת כתובות IP מותרות ל-Claude, מנתבים את bridge.claudeusercontent.com דרך אותה יציאת מתווך כמו claude.ai ו-api.anthropic.com. אם אי אפשר לנתב כך, מוסיפים לרשימת ה-IP של הארגון את כתובת היציאה שהמתווך משתמש בה למארח הזה, ורק כשהכתובת ייעודית לארגון: טווח יציאה משותף של מתווך מכניס גם לקוחות אחרים של ספק המתווך.

Anthropic בודקת חיבורים למארח הזה מול רשימת ה-IP של הארגון לפי הכתובת שממנה הם מגיעים. אם המתווך שולח את התעבורה הזו מכתובת שאינה ברשימה, Claude in Chrome ויכולות אחרות שמתחברות דרך ה-bridge מפסיקות לעבוד, ושאר האפליקציה ממשיכה לעבוד.

artifact שטוען גופן מ-Google Fonts פונה גם אל fonts.googleapis.com ואל fonts.gstatic.com. שני המארחים אופציונליים. אם חוסמים אותם, ה-artifact מוצג בגופני גיבוי. חוסמים בדחייה מהירה, לא בהשמטה שקטה, כדי שבקשת הגופן תיכשל מיד ולא תעכב את הרינדור הראשון של העמוד.

artifact יכול גם לטעון ספריות JavaScript, כמו React או חבילת תרשימים, מ-cdnjs.cloudflare.com, cdn.jsdelivr.net, cdn.tailwindcss.com, code.jquery.com ו-unpkg.com, ומאף מארח חיצוני אחר. אם חוסמים את המארחים האלה, החלקים שתלויים בספרייה לא עובדים, ולספרייה חסומה אין גיבוי כמו לגופן חסום. גם כאן חוסמים בדחייה מהירה, כדי שהבקשה תיכשל מיד ולא תיתקע עד timeout.

#אימות ו-SSO

ארגונים בתוכניות Team ו-Enterprise יכולים לחייב SSO לכל המשתמשים. פרטים לפי תוכנית מופיעים בתיעוד האימות. הגדרת SAML מתוארת במדריך Setting up SSO, והגדרת OIDC במדריך המנהלים Claude Enterprise Administrator Guide.

#טיפול בנתונים

Claude Code מעבד קוד מקומית בסשנים מקומיים, או בסשני ענן על תשתית שמנוהלת אצל Anthropic, אלא אם הארגון מנתב אותם לסביבה באירוח עצמי. סשני ענן, כולל בסביבה באירוח עצמי, שולחים שיחות והקשר קוד ל-API של Anthropic לעיבוד. סשנים מקומיים וסשני SSH שולחים אותם לספק המודל שהפריסה מגדירה, כברירת מחדל ה-API של Anthropic.

#פריסה

אפשר להפיץ את הדסקטופ בכלי פריסה ארגוניים:

• macOS: דרך MDM כמו Jamf או Kandji, עם מתקין .dmg.
• Windows: חבילת MSIX. אפשרויות הפריסה, כולל התקנה שקטה, מתוארות במאמר הפריסה של Claude Desktop ל-Windows.

את מארחי חומת האש מאפשרים לפי דרישות הגישה לרשת למעלה. הגדרות מתווך, רשויות אישורים ושערי LLM מפורטות בתיעוד network configuration, לפי הדף הרשמי.

העיון המלא בהגדרות הארגון מופיע במדריך enterprise configuration, לפי הדף הרשמי.

#מגיעים מה-CLI

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

כדי להעביר סשן CLI לדסקטופ, מריצים /desktop בטרמינל. Claude שומר את הסשן, פותח אותו באפליקציה, ויוצא מה-CLI. הפקודה זמינה ב-macOS וב-Windows x64 כשמחוברים עם מנוי Claude. היא אינה זמינה עם אימות במפתח API, ולא על Amazon Bedrock, Google Cloud's Agent Platform או Microsoft Foundry.

מהמעטפת, claude --desktop פותח את הדסקטופ ישירות בלי להתחיל סשן טרמינל. נדרש Claude Code מגרסה 2.1.285 ומעלה, עם אותן דרישות פלטפורמה והתחברות כמו /desktop. בלי ארגומנטים נוספים, הדסקטופ נפתח על התיקייה הנוכחית. כדי לפתוח סשן CLI קיים בדסקטופ, מוסיפים --continue לשיחה האחרונה בתיקייה הזו, או --resume עם מזהה הסשן ש-/status מציג:

claude --desktop --resume <session-id>

Claude Code מדפיס Opening session <session-id> in Claude Desktop, הסשן נפתח באפליקציה, והפקודה יוצאת. שם סשן לא מחליף את המזהה. Claude Code לא מעביר סשן שפתוח בטרמינל אחר או שעדיין רץ ברקע. אם Claude Desktop לא מותקן, הפקודה מדפיסה קישור להורדה ויוצאת.

אפשר גם לאסוף סשן CLI מתוך הדסקטופ עם /resume. הפקודה זמינה בסשנים מקומיים, לא בסשני SSH, WSL או ענן.

כדי להמשיך סשן טרמינל בדסקטופ:

1. סוגרים את הסשן בטרמינל.
2. בתיבת השליחה של הדסקטופ מקלידים /resume. הדסקטופ מציג את הסשנים שנפתחו מה-CLI במחשב הזה. אפשר לחפש לפי כותרת, תיקייה או ענף, ולראות תצוגה מקדימה של המקום שבו כל סשן עצר.
3. בוחרים את הסשן. הוא ממשיך באפליקציה עם השיחה וההקשר המלאים.

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

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

#מקבילות לדגלי CLI

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

#הגדרות משותפות

הדסקטופ וה-CLI קוראים את אותם קובצי הגדרות:

• קובצי CLAUDE.md ו-CLAUDE.local.md בפרויקט משמשים את שניהם.
• שרתי MCP שמוגדרים ב-~/.claude.json או ב-.mcp.json עובדים בשניהם.
• הוקים וכישורים שמוגדרים בהגדרות חלים על שניהם.
• הגדרות ב-~/.claude.json וב-~/.claude/settings.json משותפות. כללי הרשאה, כלים מותרים והגדרות אחרות ב-settings.json חלים על סשני הדסקטופ. חלק מהמפתחות מתנהגים אחרת בלשונית Code, כמו בסעיף מפתחות של Claude Code שמתנהגים אחרת בלשונית Code.
• אותם מודלים זמינים בשניהם. בדסקטופ בוחרים מודל מבורר המודל בשורה שמתחת לתיבת השליחה, ואפשר להחליף מודל באמצע הסשן מאותו בורר.

#שרתי MCP מאפליקציית הצ'אט

האפליקציה טוענת שרתי MCP מ-claude_desktop_config.json לסשנים מקומיים של לשונית Code, לצד שרתים מ-~/.claude.json ומ-.mcp.json. שרת שמוגדר ב-claude_desktop_config.json זמין גם במשטח הצ'אט של הדסקטופ וגם בסשנים מקומיים של לשונית Code.

אם אותו שם שרת מוגדר ב-claude_desktop_config.json וב-~/.claude.json או ב-.mcp.json, לשונית Code בסשנים מקומיים מתחברת פעם אחת ומשתמשת בהגדרה מ-claude_desktop_config.json.

האפליקציה גם מעבירה מחדש שרתי stdio מ-~/.claude.json אל ה-CLI המוטמע בסשנים מקומיים. כשהרמה העליונה של ~/.claude.json (היקף משתמש) ו-.mcp.json מגדירים אותו שם של שרת stdio, לשונית Code משתמשת בהגדרה מ-~/.claude.json, וזה שונה מהיררכיית ההיקפים של ה-CLI.

ה-CLI העצמאי לא קורא את claude_desktop_config.json. ב-macOS וב-WSL מריצים claude mcp add-from-claude-desktop כדי להעתיק את השרתים האלה אל ~/.claude.json.

#השוואת יכולות

#מה לא זמין בדסקטופ

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

• ספקי צד שלישי: הדסקטופ מתחבר כברירת מחדל ל-API של Anthropic. ניתוב דרך שער, או הרצת לשונית Code על Amazon Bedrock, Google Cloud's Agent Platform, Microsoft Foundry או שער LLM באירוח עצמי, לפי הקישורים בשורת ספקי הצד השלישי בטבלה.
• לינוקס (בטא): Computer Use עדיין לא זמין באפליקציית הדסקטופ ללינוקס.
• הצעות קוד בתוך השורה: אין השלמה אוטומטית בסגנון עורך. העבודה היא דרך הנחיות בשיחה ושינויי קוד מפורשים, ואפשר לקבל הצעה להנחיה הבאה אחרי ש-Claude עונה.
• צוותי סוכנים: צוותים מתואמים, שבהם Claude כראש צוות מחלק משימות לחברי צוות מרשימת משימות משותפת, זמינים ב-CLI ולא בדסקטופ. לעבודה מרובת סוכנים בתוך סשן אחד משתמשים בזרימות עבודה דינמיות, שרצות בדסקטופ. Claude יכול גם לשלוח הודעות ולנהל סשנים אחרים ישירות.
• פקודות שפותחות חלונית בטרמינל: פקודות מובנות שפותחות לוח אינטראקטיבי בטרמינל מתנהגות אחרת בלשונית Code. עורכים את קובצי ההגדרות ישירות כדי לנהל כללי הרשאה ותצורה, או מריצים את הפקודות מה-CLI העצמאי.
  • פקודות בלי צורת ארגומנט, כמו /permissions, עונות isn't available in this environment.
  • /config פותח את Settings > Code או את Settings > Claude Code.

#פתרון תקלות

הסעיפים כאן מכסים בעיות שספציפיות לאפליקציית שולחן העבודה. שגיאות API שמופיעות בצ'אט, כמו API Error: 500, 529 Overloaded, 429 או Prompt is too long, והתיקון שלהן, זהים ב-CLI, בדסקטופ ובווב, ומפורטים בהפניית השגיאות.

#בדיקת הגרסה

כדי לראות איזו גרסה של האפליקציה רצה:

• macOS: לוחצים Claude בשורת התפריטים, ואז About Claude.
• Windows: לוחצים Help, ואז About Claude.

לחיצה על מספר הגרסה מעתיקה אותו ללוח הגזירים.

#גרסת Claude Code בלשונית Code

כדי לראות איזו גרסה של Claude Code סשן מריץ, מקלידים /status בסשן מקומי בלשונית Code וקוראים את שורת Claude Code. השורה מציגה גרסה כמו 2.1.286.

לגרסה חדשה יותר לסשנים מקומיים פותחים Claude > Check for Updates… ב-macOS או Help > Check for Updates… ב-Windows, ואז מתחילים סשן חדש.

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

#בדיקת הפריסה

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

• דסקטופ ישן מגרסה 2.37337.0: מעדכנים כדי לקבל את הפריסה הנוכחית. ב-macOS בוחרים Claude > Check for Updates…, וב-Windows בוחרים Help > Check for Updates….
• ספק צד שלישי עם סשנים על המחשב: הפריסה הנוכחית דורשת Claude Desktop מגרסה 3.1623.0 ומעלה, אז בודקים את הגרסה. כדי לעדכן בוחרים Claude > Check for Updates… ב-macOS או Help > Check for Updates… ב-Windows. אם הארגון מכבה עדכונים אוטומטיים, Check for Updates… מוסתר, אז מבקשים מהמנהל גרסה 3.1623.0 ומעלה.
• ספק צד שלישי עם סשנים על תשתית הארגון: הפריסה הנוכחית דורשת Claude Desktop מגרסה 4.29.0 ומעלה, אז בודקים את הגרסה. אם הגרסה ישנה יותר, מבקשים מהמנהל גרסה 4.29.0 ומעלה. אם לא יודעים איפה הסשנים רצים, שואלים את המנהל.

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

#שגיאות 403 או אימות בלשונית Code

אם מופיע Error 403: Forbidden או כשל אימות אחר בלשונית Code:

1. מתנתקים ומתחברים מחדש מתפריט האפליקציה. זה התיקון הנפוץ ביותר.
2. מוודאים שיש מנוי בתשלום פעיל: Pro, Max, Ultra, Team או Enterprise.
3. אם ה-CLI עובד והדסקטופ לא, יוצאים מהאפליקציה לגמרי, לא רק סוגרים את החלון, ואז פותחים מחדש ומתחברים.
4. בודקים את חיבור האינטרנט ואת הגדרות המתווך.

#מסך ריק או תקוע בהפעלה

אם האפליקציה נפתחת ומציגה מסך ריק או לא מגיב:

1. מפעילים מחדש את האפליקציה.
2. בודקים אם יש עדכון ממתין. ב-macOS וב-Windows האפליקציה מתעדכנת אוטומטית בהפעלה. בלינוקס מעדכנים דרך apt.
3. ברשת מנוהלת, מוודאים שחומת האש מאפשרת את מארחי ה-CDN מדרישות הגישה לרשת.
4. ב-Windows, בודקים יומני קריסה ב-Event Viewer תחת Windows Logs → Application.

#Failed to load session

אם מופיע Failed to load session, ייתכן שהתיקייה שנבחרה כבר לא קיימת, שמאגר Git דורש Git LFS שאינו מותקן, או שהרשאות קבצים חוסמות גישה. מנסים תיקייה אחרת, או מפעילים מחדש את האפליקציה.

#הסשן לא מוצא כלים מותקנים

אם Claude לא מוצא כלים כמו npm, node או פקודות CLI אחרות, מוודאים שהכלים עובדים בטרמינל הרגיל, בודקים שפרופיל המעטפת מגדיר את PATH, ומפעילים מחדש את האפליקציה כדי לטעון מחדש משתני סביבה.

#שגיאות Git ו-Git LFS

סשנים שרצים ב-worktree משלהם צריכים Git. אם מופיעה ההודעה Git is required, מתקינים את Git, וב-Windows את Git for Windows, ומנסים שוב. בגרסאות של Claude Desktop שלפני 1.49585.0 ב-Windows, האפליקציה דרשה Git לפני כל סשן מקומי. אם נתקלים בדרישה כזו בלי שמשתמשים ב-worktrees, מעדכנים את האפליקציה.

אם מופיעה השגיאה Git LFS is required by this repository but is not installed, מתקינים את Git LFS מאתר git-lfs.com, מריצים git lfs install, ומפעילים מחדש את האפליקציה.

#שרתי MCP לא עובדים ב-Windows

אם מתגי שרתי MCP לא מגיבים, או ששרתים נכשלים בחיבור ב-Windows, בודקים שהשרת מוגדר נכון בהגדרות, מפעילים מחדש את האפליקציה, מוודאים שתהליך השרת רץ ב-Task Manager, וסוקרים את יומני השרת לשגיאות חיבור.

#אימות מפתח מארח SSH נכשל

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

• SSH host key verification failed או Host denied (verification failed) תחת View details בכרטיס Couldn't connect to <host>.
• Connection failed: Host key changed or not trusted ליד תיבת השליחה או אחרי Test connection.
• <host>'s host key is not trusted או <host>'s host key has changed בסשן מנותק.

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

• ב-Windows, והדסקטופ אומר Connection failed: Host key changed or not trusted: קודם שוללים לקוח OpenSSH חסר, כמו בסעיף הסירוב למפתח מארח ב-Windows בלי לקוח OpenSSH.
• הדסקטופ אומר לקבוע UserKnownHostsFile: ב-~/.ssh/config קובעים אותו ל-~/.ssh/known_hosts, ואז בודקים את המפתח מטרמינל.
• יש כפתור Review new key: בוחרים אותו, ומשווים את טביעת האצבע שהדסקטופ מציג לזו של המכונה עצמה, כמו בסעיף בדיקת מפתח המארח. אם הן תואמות, בוחרים Trust new key כדי להחליף את המפתח השמור. אחרת בוחרים Cancel.
• אין כפתור Review new key, הדסקטופ מציג Couldn't show the new key, או שהדסקטופ מסרב למפתח שוב אחרי Trust new key: בודקים את המפתח מטרמינל.

#בדיקת מפתח המארח מטרמינל

מריצים ssh <SSH host> על המחשב, עם ערך SSH host של חיבור ה-SSH בדסקטופ. מוסיפים -p <SSH port> אם לחיבור יש ערך SSH port. ב-Windows משתמשים ב-PowerShell, כי הדסקטופ לא מתחבר עם ה-ssh שב-Git Bash או ב-WSL. אם PowerShell לא מוצא ssh, מתקינים את לקוח OpenSSH של Microsoft.

שמים לב איזו מכונה ssh מציין בהודעה שלו. זו יכולה להיות מארח קפיצה ולא <SSH host>. אחר כך לפי המקרה:

• ssh שואל אם להמשיך להתחבר: משווים את טביעת האצבע שהוא מציג לזו של המכונה עצמה. עונים yes רק אם הן תואמות.
• ssh מזהיר שמפתח המארח השתנה: משווים את טביעת האצבע באזהרה לזו של המכונה עצמה. רק אם הן תואמות, מוחקים את השורה ש-Offending <type> key in <file>:<line> מציין ומריצים שוב את ssh. אם ssh מזהיר שוב על שורה אחרת, משווים, מוחקים ומריצים שוב כמו קודם.
• ssh מסרב למפתח שהוא לא מכיר, בלי לשאול: מקבלים את שורת ה-known_hosts של המכונה הזו ממי שמנהל אותה, לא דרך החיבור שבודקים. מוסיפים את השורה לקובץ known_hosts, עם השם מההודעה של ssh כשם המארח, ומריצים שוב את ssh.
• ssh ממשיך להתחברות בלי לשאול על מפתח המארח: עדיין לא מקלידים סיסמה. בודקים את המפתחות ש-ssh כבר סומך עליהם.

אחרי ש-ssh מקבל מפתח שבדקתם או שהוספתם, מנסים שוב בדסקטופ. אם הדסקטופ מסרב למפתח שוב, ראו את סעיף יומני הדסקטופ לבעיית SSH.

#בדיקת המפתחות ש-ssh כבר סומך עליהם

מריצים שוב את אותה פקודת ssh עם -v -S none. בפלט, שורת Server host key: מציגה טביעת אצבע, והשורת Host '<name>' is known הבאה מציינת את המכונה שהיא שייכת אליה. משווים כל טביעת אצבע שמוצאים לזו של המכונה עצמה.

• למארח קפיצה אין שורת Server host key:: מריצים גם ssh -v -S none <jump host>, ומשווים את טביעת האצבע באותו אופן.
• טביעת אצבע לא תואמת, או שאי אפשר לבדוק אותה: לא מתחברים שוב. מסירים את המפתח השמור: תחת Host '<name>' is known, השורה Found key in <file>:<line> מציינת את הקובץ שמחזיק אותו. מריצים ssh-keygen -R "<name>" -f <file>. אם שומרים מפתחות מארח ביותר מקובץ אחד, מסירים את המפתח מכל אחד. אם אי אפשר לשנות קובץ, אומרים למי שמנהל את המחשב.
• כל טביעות האצבע תואמות: מנסים שוב בדסקטופ. אם הדסקטופ מסרב למפתח שוב, ראו את סעיף יומני הדסקטופ לבעיית SSH.

#סירוב למפתח מארח ב-Windows בלי לקוח OpenSSH

ב-Windows בלי לקוח OpenSSH, הדסקטופ מסרב גם למפתח מארח נכון, עם Connection failed: Host key changed or not trusted. הוא צריך את הלקוח כדי לאתר מפתחות שמורים. כדי לראות אם יש לקוח, מריצים ssh ב-PowerShell. אם PowerShell לא מזהה את ssh, מתקינים את לקוח OpenSSH של Microsoft ומפעילים מחדש את הדסקטופ.

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

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

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

לכל הודעה אחרת בודקים את דרישות המכונה המרוחקת.

#יומני הדסקטופ לבעיית SSH

מקבלים את ssh.log, הרשומה של הדסקטופ על חיבורי ה-SSH שלו, בקובץ zip של יומני הדסקטופ ששומרים מתפריט Help. כדי לשמור, פותחים Help > Troubleshooting ובוחרים את הפריט של המערכת:

• macOS: Show Logs in Finder
• Windows: Show Logs in File Explorer
• Linux: Show Logs in File Manager

עוברים על הקבצים לפני ששולחים אותם, כי הם יכולים לכלול שמות ופרטים נוספים מהסביבה. <host> ו-<user> מייצגים שמות שהדסקטופ החליף. הדסקטופ לא מחליף כל שם, ושם מארח או משתמש SSH יכול עדיין להופיע כפי שנכתב. אם שולחים את קובץ ה-zip למישהו, אומרים לו איזה מארח נכשל ומתי, כי היומנים אולי לא מציינים אותו.

קובץ ה-zip לא מחזיק את היומן של תוכנית העזר שהדסקטופ מתקין על המכונה המרוחקת. כדי לקבל גם את היומן הזה, מעתיקים את הקבצים האלה מתיקיית תוכנית העזר תחת ~/.claude/remote/run/ בתיקיית הבית של המשתמש שהתחבר:

• remote-server.log: היומן של הריצה האחרונה של תוכנית העזר.
• remote-server.log.old, אם הוא שם: היומן של הריצה שלפניה. מעתיקים אותו בהקדם, כי מאבדים אותו בפעם הבאה שהדסקטופ מתחבר וצריך להפעיל את תוכנית העזר מחדש.

עוברים גם על הקבצים האלה לפני ששולחים אותם.

#האפליקציה לא נסגרת

• macOS: לוחצים Cmd+Q. אם האפליקציה לא מגיבה, פותחים Force Quit עם Cmd+Option+Esc, בוחרים Claude, ולוחצים Force Quit.
• Windows: פותחים את Task Manager עם Ctrl+Shift+Esc ומסיימים את תהליך Claude.

#בעיות ייחודיות ל-Windows

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

#Branch doesn't exist yet כשפותחים ב-CLI

סשני ענן יכולים ליצור ענפים שלא קיימים במכונה המקומית. לוחצים על שם הענף בסשן ובוחרים Copy branch name, ואז מביאים אותו מקומית:

git fetch origin <branch-name>
git checkout <branch-name>

#עדיין תקועים

• פותחים Help → Get Support באפליקציה, או נכנסים למרכז התמיכה של Claude.
• לבעיה שמשתחזרת גם ב-CLI העצמאי claude, מחפשים או פותחים דיווח ב-GitHub Issues.

בדיווח כוללים את גרסת אפליקציית שולחן העבודה, את מערכת ההפעלה, את הודעת השגיאה המדויקת, ויומנים רלוונטיים. ב-macOS בודקים את Console.app. ב-Windows בודקים Event Viewer תחת Windows Logs → Application. לפני פרסום קטעי יומן בדיווח ציבורי, סוקרים אותם: הם יכולים לכלול נתיבי קבצים ופרטים נוספים מהסביבה.