📘 תיעוד 2

יישום שולחן העבודה

קבלו יותר מ-Claude Code Desktop: סשנים מקבילים עם בידוד Git, פריסת חלוניות בגרירה ושחרור, מסוף ועורך קבצים משולבים, צ'אטים צדדיים, שימוש במחשב, סשני Dispatch מהטלפון, סקירת diff חזותית, תצוגות מקדימות של אפליקציות, מעקב אחרי PR, מחברים, והגדרות ארגוניות.

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

• הורדה ל-macOS: בנייה אוניברסלית ל-Intel ול-Apple Silicon
• הורדה ל-Windows: למעבדי x64
• קבלו את Claude ל-Linux (בטא): apt או .deb ל-Ubuntu ול-Debian

ל-Windows ARM64, הורידו את מתקין ARM64. ב-Linux, התקינו עם apt. ראו Claude Desktop ב-Linux.

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

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

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

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

#התחלת סשן

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

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

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

#עבודה עם קוד

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

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

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

לחץ על כפתור + ליד תיבת ההנחיה עבור צירוף קבצים, מיומנויות, מחברים ותוספים.

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

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

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

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

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

כדי לתת לקלוד קובץ, אזכר אותו עם @ או צרף אותו בתיבת ההנחיה:

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

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

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

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

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

מצב ההרשאות dontAsk זמין רק ב-CLI.

[!TIP]

התחל משימות מורכבות ב-Plan כדי שקלוד ימפה גישה לפני ביצוע שינויים. אחרי שאתה מאשר את התוכנית, עבור אל Accept edits או Manual כדי לבצע אותה. ראה מצב plan למידע נוסף על תהליך העבודה הזה.

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

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

#זמינות מצב Auto

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

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

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

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

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

[!NOTE]

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

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

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

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

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

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

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

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

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

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

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

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

#אישור פעולות של קלוד באתר

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

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

#בחירה בין Browser לתוסף Chrome

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

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

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

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

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

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

כדי להגיב על שורות מסוימות, רחף מעל שורה ולחץ על + שמופיע ליד מספר השורה כדי לפתוח תיבת תגובה. הקלד את המשוב ולחץ על Enter כדי להוסיף את התגובה. אחרי הוספת תגובות לכמה שורות, שלח את כל התגובות בבת אחת:

• macOS: לחץ על Cmd+Enter
• Windows: לחץ על Ctrl+Enter

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

#סקירת הקוד שלך

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

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

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

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

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

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

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

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

[!NOTE]

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

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

#ארגון סביבת העבודה

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

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

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

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

[!NOTE]

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

#הצגת פרטי הסשן

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

#הסתרה או הצגה של לוח פרטי הסשן

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

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

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

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

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

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

#הרצת פקודות במסוף

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

אם לסשן WSL אין מסוף, ראו אם המסוף או המחברים לא זמינים. המסוף זמין בסשנים מקומיים ובסשני SSH, עם מגבלה על מכונות מרוחקות של Windows.

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

כדי לפתוח קובץ ש-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 וב-Linux, שנו את המקשים האלה:

• Cmd+Option: לחצו על Alt
• Cmd+Ctrl: לחצו על Ctrl+Alt
• Cmd: לחצו על Ctrl

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

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

#בדיקת שימוש

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

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

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

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

#לאפשר ל-Claude להשתמש במחשב

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

[!NOTE]

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

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

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

[!WARNING]

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

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

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

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

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

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

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

1. עדכון אפליקציית שולחן העבודה

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

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 לראות מה על המסך

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

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

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

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

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

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

• Denied apps: הוסיפו כאן אפליקציות כדי לדחות אותן בלי הנחיה. Claude עדיין יכול להשפיע על אפליקציה שנדחתה בעקיפין דרך פעולות באפליקציה מותרת, אבל הוא לא יכול ליצור איתה אינטראקציה ישירה.
• Unhide apps when Claude finishes: כששימוש במחשב לא רץ ברקע, Claude מסתיר את החלונות האחרים בזמן שהוא עובד כדי ליצור אינטראקציה רק עם האפליקציה שאושרה. כש-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. Desktop מוסיף אותו בתחילת כל שם ענף של worktree, וזה שימושי לשמירה על סדר בענפים ש-Claude יוצר.

כדי לכלול קבצים ש-git מתעלם מהם כמו .env ב-worktrees חדשים, צרו קובץ .worktreeinclude בשורש הפרויקט. ראו מה worktrees חולקים עם ה-checkout הראשי לגבי המקום שבו סשן worktree קורא הגדרות פרויקט, hooks ו-skills.

[!NOTE]

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

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

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

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

#ארכוב סשן

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

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

#שמירה על שינויים שלא בוצע להם commit כשסשן מאוחסן בארכיון

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

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

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

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

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

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

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

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

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

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

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

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

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

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

#מעקב אחרי משימות רקע

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

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

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

Claude יכול לרשום את שאר סשני לשונית Code שלכם, לקרוא מה כל אחד עשה, ולשלוח הודעות ביניהם. שואלים בשפה רגילה: "which session touched the auth refactor?", "what did the API session conclude?", או "tell the payments session the schema changed".

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

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

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

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

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

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

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

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

[!NOTE]

משימה בסשן SSH יכולה גם להמשיך בזמן ש-Desktop מנותק, אבל עם חשבון 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. אם מעולם לא שיניתם את ההגדרה הזאת, Desktop פועל לפי 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 בשורה הזאת כדי לנתק.
• סשני Desktop חדשים במחשב הזה: מכבים את Connect new sessions to Remote Control ב-Settings > Code או ב-Settings > Claude Code. אם זה כבר מוצג ככבוי, מפעילים ואז מכבים כדי ש-Desktop ישמור את הבחירה. אחרי השמירה, זה גובר על remoteControlAtStartup ועל ברירות המחדל.
• כל סשן במחשב הזה, כולל ה-CLI: מגדירים את disableRemoteControl ל-true ב-~/.claude/settings.json כדי לעצור סשנים מלהתחבר. סשן שכבר היה מחובר כששמרתם את הקובץ נשאר מחובר עד שמכבים עבורו את Remote Control.

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

#סשנים מ-Dispatch

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

משימה יכולה להסתיים כסשן Code בשתי דרכים: מבקשים סשן כזה ישירות, למשל "open a Claude Code session and fix the login bug", או ש-Dispatch מחליט שהמשימה היא עבודת פיתוח ויוצר סשן כזה בעצמו. משימות שבדרך כלל מנותבות ל-Code כוללות תיקון באגים, עדכון תלויות, הרצת בדיקות, או פתיחת בקשות משיכה. מחקר, עריכת מסמכים ועבודה בגיליונות אלקטרוניים נשארים ב-Cowork.

#מעקב אחרי סשן ש-Dispatch התחיל

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

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

#הגדרת Dispatch

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

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

#הרחבת Claude Code

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

Claude Code גם טוען את המיומנויות והתוספים שמופעלים עבור חשבון claude.ai שלך בסשנים במסוף שבהם אתה נכנס עם אותו חשבון. ראה Skills synced from claude.ai ו-Plugins synced from claude.ai.

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

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

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

[!NOTE]

המקרים האלה מכוסים בדפים אחרים:

• Connectors מואפר בסשן WSL: ראה If the terminal or connectors are unavailable
• סשני Cloud: ראה How connectors reach Claude Code

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

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

#שימוש במיומנויות

מיומנויות מרחיבות את מה ש-Claude יכול לעשות. Claude טוען אותן אוטומטית כשהן רלוונטיות, או שאפשר להפעיל אחת ישירות: הקלד / בתיבת ההנחיה, או לחץ על כפתור + ובחר Slash commands כדי לעיין במה שזמין. זה כולל פקודות מובנות, מיומנויות מותאמות אישית, מיומנויות פרויקט מבסיס הקוד שלך, ומיומנויות מכל תוסף מותקן. בחר אחת והיא מופיעה מודגשת בשדה הקלט. הקלד את המשימה אחריה ושלח כרגיל.

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

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

סשנים מקומיים וסשני cloud גם טוענים את המיומנויות שמופעלות עבור חשבון claude.ai שלך, למעט סשנים מקומיים כשהארגון שלך מגדיר disableSideloadFlags. סשני Cloud טוענים אותן במקום ~/.claude/skills/, כפי שמתואר ב-Skills in Cowork and cloud sessions.

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

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

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

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

דפדפן התוספים אינו זמין בסשני cloud, ותוספים שמתקינים מאפליקציית שולחן העבודה אינם זמינים לסשני cloud. סשן cloud גם אינו מתקין תוספים ש-.claude/settings.json של המאגר מצהיר עליהם, כפי שמוסבר ב-What carries over from your setup. תוספים אינם זמינים בסשני WSL. למדריך המלא לתוספים, כולל יצירת תוספים משלך, ראה plugins.

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

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
    }
  ]
}

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

לכל כתובת אחרת, Desktop מבקש את ההרשאה שלך בפעם הראשונה שהתצוגה המקדימה פותחת אותה, כמו כשגולשים לאתר חדש בתצוגה המקדימה. כתובות חיצוניות יכולות לכלול נתיבים. בחר 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 v2.37337.0, Claude שואל אם השרת צריך את הפורט המדויק הזה, ואז שומר את התשובה שלך ב-launch.json.

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

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

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

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

#דוגמאות

התצורות האלה מציגות הגדרות נפוצות לסוגי פרויקטים שונים:

Next.js

תצורה זו מריצה אפליקציית Next.js באמצעות Yarn בפורט 3000:

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

Multiple servers

עבור monorepo עם frontend ושרת API, הגדר כמה תצורות. ה-frontend משתמש ב-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 script

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

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

#תצורת סביבה

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

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

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

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

1. פתיחת תיבת הדו שיח New environment

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

2. בחירה איפה Claude רץ

בחר את הלשונית Local, SSH, או Cloud ומלא את הטופס בלשונית זו. בלשונית SSH, בחר חיבור ותיקייה במחשב המרוחק.

3. שמירת הסביבה

בחר Create environment, או Add environment בלשונית Cloud.

#סביבות ש-Desktop יוצר עבורך

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

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

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

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

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

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

למשתנים כמו PATH ו-CLAUDE_CONFIG_DIR יש הנחיות משלהם:

ב-macOS או ב-Linux, אם משתנה שהגדרתם עם export חסר או שגוי בפקודה ש-Claude מריץ, ראו משתנה שיוצא חסר או שגוי בפקודות ש-Claude מריץ.

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

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

[!NOTE]

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

1. פתחו את הטופס של סביבה מקומית

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

2. הזינו את המשתנים

בחרו Environment variables, הזינו KEY=value אחד בכל שורה, ובחרו Done.

3. שמרו את הסביבה

בחרו Create environment או Save.

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

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

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

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

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

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

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

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

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

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

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

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

1. התחילו סשן חדש

בקשו מ-Claude להריץ את הפקודה שוב.

2. צאו מ-Desktop ופתחו אותו מחדש

ואז התחילו סשן חדש.

3. בדקו את המשתנים השמורים

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

4. השתמשו בסביבה שמורה

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

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

#משתני סביבה ש-Desktop מגדיר בעצמו

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

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

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

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

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

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

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

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

#סשני ענן

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

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

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

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

#סשני SSH

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

[!NOTE]

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

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

1. פתחו את תיבת הדו-שיח New environment

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

2. הוסיפו את החיבור

בלשונית SSH של תיבת הדו-שיח New environment, פתחו את הרשימה Host, בחרו Add SSH connection…, ומלאו את פרטי החיבור:

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

ואז בחרו Add SSH connection.

3. התחילו סשן בחיבור

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

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

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

מכונה מרוחקת עם Linux או macOS צריכה מעבד נתמך, שרת SSH עם SFTP, תיקיית התקנה שאינה mounted עם noexec, מעטפת עובדת, וגישת רשת. בדקו כל דרישה לפני שמתחברים, או כשחיבור נכשל אחרי ההתחברות:

• מערכת: מעבד x86_64 או arm64. המכונה צריכה גם לעמוד בדרישות המערכת של Claude Code. ב-Linux, 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 או Linux: עדכנו ל-Claude Desktop v3.1623.0 או חדש יותר
  • המחשב שלכם מריץ Windows: ודאו ש-Desktop מתחבר דרך לקוח OpenSSH, כי לקוח ה-SSH המובנה של Desktop לא יכול להתחבר לשרת הזה
  • אפשר לשנות את השרת: העלו את MaxSessions, למשל לברירת המחדל של OpenSSH שהיא 10
• התחברויות עם MaxSessions 1: השתמשו בהתחברות שעובדת בלי הנחיה, כמו מפתח שסוכן ה-SSH מחזיק. Desktop מתחבר לפחות פעמיים בכל פעם שהוא מתחבר או מתחבר מחדש. צפו לפחות להתחברות נוספת אחת לכל לשונית מסוף, ולכל סשן Desktop שבו מריצים פקודות שמתחילות ב-!. צפו לאפס עבור פקודות ש-Claude מריץ.
• קודים חד-פעמיים עם MaxSessions 1: אם כל התחברות מבקשת מכם, כמו עם קודים חד-פעמיים, פקודות ! נכשלות. הריצו את הפקודות האלה בלשונית מסוף במקום, שמבקשת בחלונית משלה.
• תיקיית התקנה: Desktop מתקין תוכנית עזר ואת Claude Code תחת ~/.claude/remote/ בתיקיית הבית. הוא מריץ אותם משם, אז התיקייה הזאת לא יכולה להיות על מערכת קבצים ש-mounted עם noexec. הקצו בערך 1 GB של שטח דיסק בתיקיית הבית של כל משתמש שמתחבר. למה שהתיקייה הזאת מכילה, ראו קבצים ותהליכים במכונה המרוחקת.
• מעטפת: המעטפת שמוגדרת לחשבון שלכם במכונה המרוחקת צריכה להריץ פקודות שנשלחות דרך SSH, כמו ש-Bash, Zsh ו-sh עושים
• רשת: Claude Code רץ במכונה המרוחקת ומבצע את בקשות הרשת שלו משם, אז המכונה צריכה את גישת הרשת ש-Claude Code דורש. אם המכונה לא יכולה להוריד את Claude Code, Desktop מוריד אותו במחשב שלכם ומעלה אותו. שאר הבקשות של Claude Code עדיין יוצאות מהמכונה המרוחקת. אם מכונה מרוחקת עם Linux צריכה פרוקסי או אישור CA, הגדירו אותו לסשני SSH.

#בדיקת מפתח מארח של מכונה מרוחקת

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

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

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

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

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

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

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

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

#הגדרת פרוקסי או אישור CA להפעלות SSH

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

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

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

#שימוש בתצורת ה-SSH שלכם

אפשר להשתמש בתצורת ה-SSH שלכם ב-macOS, ב-Linux וב-Windows כש-Desktop מתחבר דרך לקוח OpenSSH במחשב שלכם:

• macOS ו-Linux: Desktop מתחבר על ידי הרצת לקוח OpenSSH במחשב שלכם, ולכן הוא משתמש ב-~/.ssh/config. חיבור דרך לקוח OpenSSH דורש Claude Desktop בגרסה v1.37937.0 או חדשה יותר.

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

  • Claude Desktop בגרסה v2.2553.0 או חדשה יותר. כדי למצוא את הגרסה שלכם, ראו בדיקת הגרסה.
  • OpenSSH של Microsoft בגרסה 9.4 או חדשה יותר
  • Desktop מותקן עם כפתורי ההורדה בראש העמוד הזה, כי Desktop מחנות Microsoft לא מתחבר דרך לקוח OpenSSH

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

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

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

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

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

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

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

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

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

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

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

כדי להגיע למכונה מאחורי מארח קפיצה, שנקרא גם 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, כי Desktop לא מריץ את 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 בטרמינל במחשב שלכם. בקשו מהם לאפשר את ה-hostname שהפקודה מדפיסה, כאן devbox-container, ב-sshHostAllowlist. כשהם מאפשרים את השם הזה, הם מאפשרים את כל מה ש-ProxyCommand של הרשומה מתחבר אליו.

4. בדיקת הרשומה, ואז התחברות

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

• אם ssh מבקש סיסמה, ביטוי סיסמה או קוד: עברו להתחברות שעובדת בלי בקשה, למשל מפתח שסוכן ה-SSH מחזיק
• אם 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 וב-Linux, כדי להשתמש במשתנה סביבה משלכם בפקודת ProxyCommand או Match exec, ייצאו אותו בקובץ הפעלה של המעטפת, למשל ~/.zshrc. אחר כך צאו מ-Desktop ופתחו אותו מחדש. כש-Desktop מופעל, הוא קורא את מה שמעטפת הכניסה מייצאת, והוא שומר את הערכים האלה עד שיוצאים.

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

[!NOTE]

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

#שימוש באישורי AWS ב-ProxyCommand ב-macOS וב-Linux

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

אם ל-AWS CLI אין מקור אחר לאזור או לאישורים, הוא נכשל עם You must specify a region או Unable to locate credentials. כדי להתחבר מ-Desktop, תנו ל-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 עם המארח בטרמינל כדי לאשר שהרשומה עדיין מתחברת שם, ואחר כך התחברו מ-Desktop.

#העלאת הזמן הקצוב לחיבור SSH

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

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

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

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

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

#תיקון בלוק Match host שרק Desktop מחיל

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

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

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

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

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

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

#הגדרות העברה ש-Desktop משאיר כבויות

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

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

כדי למנוע מ-Desktop להעביר את סוכן ה-SSH או יציאה, הריצו ssh -G devbox בטרמינל במחשב שלכם. אחר כך הריצו אותו שוב כמו ש-Desktop יכול להריץ אותו, עם ערכי 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 מגרסה v2.31226.0 ואילך.

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

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

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

• Terminal: המסוף לא נפתח בסשן שהתיקייה שלו היא נתיב Windows, כמו C:/projects/app
• Sandbox: Claude Code רץ שם על Windows מקורי, ושם הוא מריץ פקודות בלי sandbox. ראו היכן ה-sandbox רץ.
• Plugins: Desktop לא מעתיק תוסף שמכיל שם קובץ או תיקייה ש-Windows לא יכול לאחסן, כמו שם עם :. הסשן מציג את התוספים ש-Desktop השאיר בחוץ.
• MCP servers: בחלק מהמכונות המרוחקות של Windows, הקריאות של Claude לשרתי MCP מתוך claude_desktop_config.json עוברות דרך Desktop, כך ש-Claude לא יכול לקרוא לכלים שלהם בזמן ש-Desktop מנותק. לפני Claude Desktop v2.37337.0, זה נכון בכל מכונה מרוחקת של Windows.
• Worktrees: worktrees נמצאים ב-<project-root>/.claude/worktrees/. אם בוחרים תיקייה אחרת, Desktop מתעלם ממנה.
• Earlier messages: אם המעטפת של שרת ה-SSH היא cmd.exe או Windows PowerShell, ייתכן שתצטרכו להתחבר לפני שתראו הודעות קודמות של סשן
• Forks: אם המעטפת של שרת ה-SSH היא cmd.exe או Windows PowerShell, אפשר לעשות fork לסשן רק בהודעה הראשונה שלו
• Running while disconnected: משימה ממשיכה לרוץ בזמן ש-Desktop מנותק רק אם שרת ה-SSH מאפשר לתוכנית להמשיך אחרי החיבור שהפעיל אותה. כדי לברר, בדקו את המכונה המרוחקת.
• Leftover processes: אחרי שסשן מסתיים, בדקו במכונה תוכניות ש-Claude Code הפעיל, כי הן יכולות להמשיך לרוץ. עוזר הרקע ש-Desktop מתקין לא נעצר שם מעצמו.

#שמירה על משימה רצה בזמן ש-Desktop מנותק

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

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

[!WARNING]

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

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

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

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

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

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

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

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

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

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

#מגבלות בזמן ש-Desktop מנותק

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

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

עריכות קבצים וחלק מהכלים יכולים להיכשל בזמן ש-Desktop מנותק. אם המשימה צריכה אותם, השאירו את Desktop מחובר:

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

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

במכונה מרוחקת של Linux או macOS, הבדיקה לא עוברת דרך Desktop, ולכן עריכות בתוך ה-worktree ממשיכות לעבוד בזמן ש-Desktop מנותק. לפני Claude Desktop v2.37337.0, זה נכון במכונה מרוחקת של Linux בלבד.

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

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

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

#טיפול בבקשות שמגיעות בזמן שאתם לא נמצאים

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

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

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

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

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

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

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

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

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

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

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

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

#פתיחה מחדש של סשן אחרי שיוצאים מ-Desktop

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

• Desktop ב-Windows, משימה שהתחילה בגרסה לפני v3.1623.0: לא מקבלים את המשימה בחזרה, גם אם Desktop עודכן מאז. הפעל את Desktop שוב רק כשאתה מצפה שהמשימה הסתיימה, כי הסשן יכול להיפתח עם הפעלת Desktop, והמשימה נעצרת כשהסשן נפתח. אם אינך יודע באיזו גרסה התחלת את המשימה, גם אז המתן עד שאתה מצפה שהיא הסתיימה.
• ספק צד שלישי ב-macOS או ב-Linux, משימה שהתחילה בגרסה לפני v2.42304.0: לא מקבלים את המשימה בחזרה. הפעל את Desktop שוב רק כשאתה מצפה שהמשימה הסתיימה.
• כל משימה אחרת: הפעל את Desktop ופתח את הסשן, והמשימה ממשיכה אם Desktop חוזר לתהליך. הוא לא תמיד יכול לחזור, למשל אחרי חלק מעדכוני Desktop, לכן עדכן לפני משימה ארוכה.

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

לפריסות צד שלישי, ראה סשני SSH מרוחקים ב-Claude Desktop ב-3P.

[!WARNING]

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

#הגדרת תיקיית ה-worktree בחיבור קיים

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

1. מציאת החיבור

פתח את בורר הסביבה ומצא את החיבור תחת SSH.

2. פתיחת הגדרות החיבור

רחף מעל החיבור ולחץ על סמל גלגל השיניים. אם תיבת הדו שיח שנפתחת מציגה Edit connection… ליד Host, בחר Edit connection….

3. הגדרת התיקייה

ב-Worktree folder, הזן תיקייה על המכונה המרוחקת, למשל ~/worktrees, ובחר Save changes.

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

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

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

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

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

למקרה שהעוזר נעצר מעצמו, ראה גבולות בזמן ש-Desktop מנותק.

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

1. יציאה מ-Desktop

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

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, ראה הסרת קבצי הגדרות.

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

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

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

#בדיקה באיזה משתמש התהליכים רצים

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

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

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

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

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

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

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

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

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

#זיהוי בדיקה בלוג של שרת ה-SSH

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

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

לשורות של 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 עצמו מסרב לכתובת

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

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

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

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

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

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

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

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

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

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

כדי ש-fail2ban לא יחסום כתובת בגלל הבדיקות של Desktop, שנה אחת משתי הגדרות של ה-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, ראה גבולות בזמן ש-Desktop מנותק.

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

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

קישורי SSH דורשים את Claude Desktop בגרסה v2.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 מקבל את הפרמטרים האלה, ורק ssh_host נדרש:

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

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

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

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

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

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

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

קישור לא עוקף את sshHostAllowlist. Desktop בודק את רשימת ההיתר כשהוא מתחבר.

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

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

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

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

[!NOTE]

חיבורים מפקודה דורשים את Claude Desktop בגרסה v3.6556.0 או חדשה יותר ב-macOS או ב-Linux, או v4.16336.0 או חדשה יותר ב-Windows, כשמחוברים עם חשבון Claude. ב-Windows, Desktop צריך גם להתחבר דרך לקוח OpenSSH. מנהלי מערכת יכולים להפיץ פקודות לצוות.

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

[!WARNING]

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

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

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

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

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

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

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

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

ב-Windows, התחילו ב-כתיבת הפקודה ב-Windows, שמציין אילו מהכללים האלה חלים שם.

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

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

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

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

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

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

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

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

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

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

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

ב-Windows, התחילו את command בנתיב המלא של קובץ .exe, .cmd או .bat, מאות הכונן. Desktop לא מחפש שם חשוף ב-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, ש-Desktop מריץ דרך cmd.exe. גם בתוך מרכאות, נתיב הקובץ לא יכול להכיל &, ^, או ;. בקובץ שאתם כותבים, קראו את הארגומנטים עם %*, כי %1 עד %9 מפצלים ארגומנט ב-, וב-=.
• סביבה: התוכנית מקבלת את משתני הסביבה של אפליקציית Desktop, לא של פרופיל מעטפת. אחרי שמשנים משתנה, צאו ופתחו מחדש את Desktop.
• בדיקה: כדי לראות את הפלט ש-Desktop קורא, הריצו את הפקודה ב-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, שום דבר לא רושם את המפתח. כשהכלי שלכם משתמש שוב בשם, אפשר להתחבר למכונה אחרת בלי אזהרה.

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

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

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

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

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

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

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

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

#הסרת רשומה

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

מנהלים יכולים להפיץ חיבורי 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, Desktop מתחבר בתור ה-User ש-~/.ssh/config של כל מפתח מגדיר למארח, או אחרת בתור שם המשתמש שלהם במחשב שלהם.

#הגבלת מארחי SSH שאליהם משתמשים יכולים להתחבר

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

הדוגמה הבאה מתירה חיבורים לכל מארח תחת devboxes.example.com ולמארח bastion יחיד בשם:

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

[!WARNING]

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

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

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

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

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

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

[!WARNING]

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

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

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

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

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

[!NOTE]

ההגדרה הזו מיועדת למשתמשים שנכנסים עם חשבון Claude. עם ספק צד שלישי, סשני SSH כבויים כברירת מחדל, והגדרת sshHostAllowlist יכולה להפעיל אותם. קראו את סשני SSH מרוחקים ב-Claude Desktop ב-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 תחת בקרות מסוף הניהול.

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

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

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

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

1. בדיקת בורר הסביבה

צאו מ-Desktop ופתחו אותו מחדש, ואז פתחו את בורר הסביבה. ההגדרות חלו אם הוא מציג:

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

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

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

2. הוספת מארח שאינו ברשימת ההיתר

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

#תצורת ארגון

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

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

ההגדרות האלה מוגדרות דרך מסוף הגדרות הניהול:

• Desktop: שליטה בשאלה אם משתמשים בארגון יכולים לגשת אל Claude Code באפליקציית שולחן העבודה
• Cloud sessions: הפעלה או כיבוי של cloud sessions עבור הארגון
• Remote Control: הפעלה או כיבוי של Remote Control עבור הארגון

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

[!NOTE]

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

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

כדי לברר על איזו מכונה מרוחקת רץ סשן SSH, ראו שיוך telemetry לסשני SSH של Desktop.

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

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

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

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

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

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

למפתחות הרשאה, תוסף ומסירה שרק מקור מנוהל יכול להגדיר, ראו מפתחות שרק הגדרות ניהול יכולות להגדיר.

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

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

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

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

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

#הגבלת התחברות לארגון שלכם

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

המפתח דורש Claude Desktop מגרסה v1.2581.0 ואילך.

ב-Linux, קובץ מדיניות שמגדיר רק את המפתח הזה נקרא כך:

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

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

[!WARNING]

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

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

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

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.

עבור שרתי proxy, רשויות אישורים מותאמות, mTLS, והדומיינים ש-CLI העצמאי צריך, ראו תצורת רשת.

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

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

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

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

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

#אימות ו-SSO

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

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

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

#פריסה

אפשר להפיץ את Desktop באמצעות כלי פריסה ארגוניים:

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

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

לעיון המלא בהגדרות ארגוניות, ראה את מדריך ההגדרות הארגוניות.

#מגיעים מה-CLI?

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

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

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

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

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

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

כדי להמשיך סשן טרמינל ב-Desktop:

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

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

[!TIP]

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

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

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

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

Desktop וה-CLI קוראים את אותם קבצי הגדרות, כך שההגדרה שלך עוברת:

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

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

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

[!NOTE]

ה-CLI העצמאי לא קורא את claude_desktop_config.json. ב-macOS וב-WSL, הרץ claude mcp add-from-claude-desktop כדי להעתיק את השרתים האלה אל ~/.claude.json. ראה ייבוא שרתי MCP מ-Claude Desktop לזרימת הייבוא ולאפשרויות ההיקף.

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

הטבלה הזו משווה יכולות ליבה בין ה-CLI ל-Desktop. לרשימה מלאה של דגלי CLI, ראה את הפניה ל-CLI.

#מה לא זמין ב-Desktop

היכולות הבאות לא זמינות ב-Desktop, חוץ מהמקומות שצוינו:

• ספקי צד שלישי: Desktop מתחבר ל-API של Anthropic כברירת מחדל. כדי לנתב את Desktop דרך שער, או כדי להריץ את לשונית Code על Amazon Bedrock, Google Cloud's Agent Platform, Microsoft Foundry, או שער LLM באירוח עצמי, עקוב אחרי הקישורים בשורה של ספקי צד שלישי.
• Linux (בטא): שימוש במחשב (Computer Use) עדיין לא זמין באפליקציית שולחן העבודה ל-Linux. ראה Claude Desktop ב-Linux.
• הצעות קוד בשורה: Desktop לא מציע השלמות קוד בסגנון השלמה אוטומטית. הוא עובד דרך הנחיות שיחה ושינויי קוד מפורשים, ויכול להציע את ההנחיה הבאה שלך אחרי ש-Claude עונה.
• צוותי סוכנים: צוותים מתואמים, שבהם Claude כמוביל הצוות מקצה משימות לחברי צוות מרשימת משימות משותפת, זמינים ב-CLI, לא ב-Desktop. לעבודה מרובת סוכנים בתוך סשן אחד, השתמש בזרימות עבודה דינמיות, שרצות ב-Desktop. 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, ראו את מדריך השגיאות.

#בדיקת הגרסה

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

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

#בדיקה איזו פריסה יש לכם

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

• Desktop ישן מ-v2.37337.0: עדכנו כדי לקבל את הפריסה הנוכחית. בחרו Claude > Check for Updates… ב-macOS או Help > Check for Updates… ב-Windows.
• ספק צד שלישי עם סשנים במחשב שלכם: הפריסה הנוכחית דורשת Claude Desktop בגרסה v3.1623.0 או חדשה יותר, לכן בדקו את הגרסה. כדי לעדכן, בחרו Claude > Check for Updates… ב-macOS או Help > Check for Updates… ב-Windows. אם הארגון שלכם מכבה עדכונים אוטומטיים, Check for Updates… מוסתר, ולכן בקשו מהמנהל גרסה v3.1623.0 או חדשה יותר.
• ספק צד שלישי עם סשנים בתשתית של הארגון: הפריסה הנוכחית דורשת Claude Desktop בגרסה v4.29.0 או חדשה יותר, לכן בדקו את הגרסה. אם אתם בגרסה ישנה יותר, בקשו מהמנהל גרסה v4.29.0 או חדשה יותר. אם אינכם יודעים איפה הסשנים רצים, שאלו את המנהל.

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

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

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

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

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

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

1. הפעילו מחדש את האפליקציה.
2. בדקו אם יש עדכונים ממתינים. ב-macOS וב-Windows האפליקציה מתעדכנת אוטומטית בהפעלה. ב-Linux, עדכנו דרך apt כמתואר ב-Claude Desktop on Linux.
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, או Git for Windows ב-Windows, ונסו שוב. ב-Windows, גרסאות Claude Desktop שלפני 1.49585.0 ביקשו 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 נכשל

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

• 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 בסשן מנותק

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

#קבלת יומני Desktop לבעיית SSH

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

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

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

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

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

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

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

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