📘 תיעוד 33

תוספים

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

#איך מרקטפלייסים עובדים

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

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

התקנה מפעילה את התוסף. ה-hooks ושרתי ה-MCP שלו נשארים לא פעילים עד שנותנים בו אמון.

#הוספת מרקטפלייס

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

grok plugin marketplace add my-org/team-plugins                  # GitHub shorthand (owner/repo)
grok plugin marketplace add https://gitlab.com/acme/plugins.git  # any git host, include https:// and .git
grok plugin marketplace add ./my-marketplace                     # a local folder

מציגים, מרעננים ומסירים מקורות עם grok plugin marketplace list, grok plugin marketplace update [<name>], ו-grok plugin marketplace remove <url>.

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

#ב-config.toml

כל מקור צריך name וגם כתובת git (עם branch אופציונלי) או path מקומי:

[[marketplace.sources]]
name = "My Team Plugins"
git = "https://github.com/my-org/plugins.git"

[[marketplace.sources]]
name = "Local Dev"
path = "~/dev/my-plugins"

#ב-settings.json

מוסיפים מקורות תחת extraKnownMarketplaces, כשהמפתח הוא השם. ה-source של כל רשומה הוא אחד מ-git (עם url), github (עם repo), או local (עם path):

{
  "extraKnownMarketplaces": {
    "my-marketplace": {
      "source": { "source": "git", "url": "[email protected]:my-org/plugins.git" }
    }
  }
}

שמים את הקובץ הזה ב-~/.grok/settings.json או ב-~/.claude/settings.json.

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

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

grok plugin install deploy-tools --trust

המקור שמתקינים מקבל כמה צורות:

• owner/repo (קיצור GitHub), owner/[email protected] (ref), owner/repo@<commit-sha> (commit מדויק, שמאומת אחרי fetch), או owner/repo#subdir
• כתובת git מלאה (https://github.com/user/repo.git) או SSH ([email protected]:user/repo.git)
• נתיב מקומי (./local-dir או /absolute/path)

מריצים grok plugin install <source> בלי --trust וגרוק מציג את המקור, מזהיר שההתקנה מפעילה את ה-hooks, שרתי ה-MCP וה-skills של התוסף, ואז עוצר. מוסיפים --trust כדי להמשיך. התקינו תוספים רק ממקורות שאתם סומכים עליהם (ראו אמון ואבטחה).

ה-skills של תוסף מופיעים בתפריט ה-slash. כששם של skill דו משמעי, גרוק מציג את הצורה המלאה עם קידומת של שם התוסף, לדוגמה /deploy-tools:release. כדי לקלוט תוסף שזה עתה הותקן, לוחצים r בלשונית Plugins או מתחילים סשן חדש.

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

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

grok plugin list [--json] [--available]   # installed plugins (--available requires --json)
grok plugin uninstall <name> [--confirm] [--keep-data]   # aliases: rm, remove
grok plugin update [<name>]               # omit the name to update every plugin
grok plugin enable <name>
grok plugin disable <name>
grok plugin details <name>                # show the plugin's component inventory

#בממשק הטרמינל

פותחים את חלון התוספים עם /plugins. יש בו שש לשוניות, Hooks, Plugins, Marketplace, Skills, Workflows ו-MCP Servers. עוברים ביניהן עם Tab / Shift+Tab. הפקודות /hooks, /marketplace, /skills, /workflows ו-/mcps פותחות את החלון בלשונית המתאימה.

בלשונית Plugins, לוחצים Enter כדי להרחיב תוסף ולראות את השם, הגרסה, ה-scope (cli, project, user, custom path, או שם מקור המרקטפלייס), skills, סוכנים, hooks, שרתי MCP (מוצגים כ-blocked כשהתוסף לא מהימן), תיאור ונתיב. אחר כך:

בלשונית Marketplace, מעיינים ומתקינים מהמקורות שלכם:

סיכומי רכיבים בלשונית Marketplace מופיעים רק למרקטפלייסים שמפרסמים קטלוג plugin-index.json. פעולות הרסניות מבקשות אישור: לוחצים y באות קטנה כדי לאשר, וכל מקש אחר (כולל Esc) כדי לבטל.

בלשונית Workflows (פותחים אותה ישירות עם /workflows, או עם Tab מהפקודות שלמעלה), מעיינים ב-workflows השמורים שגרוק גילה: מובנים, .grok/workflows/ של הפרויקט, ו-~/.grok/workflows/ של המשתמש. כל שורה מציגה את שם ה-workflow, המקור והתיאור. לוחצים Enter כדי להרחיב את הנתיב והערות מתי להשתמש, r כדי לטעון מחדש את הרשימה, ו-/ כדי לחפש. השורות מיועדות לעיון בלבד: מריצים אחד עם /workflow <name> או עם פקודת ה-slash שלו.

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

מגדירים את אלה ב-~/.grok/config.toml:

[plugins]
paths = ["~/my-plugins/custom-tools"]        # extra plugin directories
disabled = ["user/a1b2c3d4/noisy-plugin"]    # names or IDs to skip
enabled = ["project/9f8e7d6c/team-tools"]    # names or IDs to force on

תוספים כבויים כברירת מחדל, אז רושמים אחד ב-enabled כדי להפעיל אותו, או ב-disabled כדי לגלות אותו אבל לדלג על טעינתו. כל רשומה היא שם תוסף פשוט (מ-grok plugin list) או מזהה מלא (<scope>/<hash>/<name>).

כדי להסתיר לגמרי את ממשק התוספים וה-hooks, מגדירים disable_plugins = true ב-~/.grok/pager.toml.

#אמון ואבטחה

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

תוספים מופעלים דורשים אמון כדי לטעון skills, פקודות, סוכנים, hooks, שרתי MCP ושרתי LSP. גרוק נותן אמון אוטומטית בתוספים שב-~/.grok/plugins/, ותוספי פרויקט ב-.grok/plugins/ דורשים אמון. מתקינים עם --trust כדי להעניק אותו:

grok plugin install <source> --trust

שרתים של .mcp.json בתוסף מהימן מתחברים לסשן כמו שאר תצורת MCP, וסוכנים בנים יורשים אותם. סוכני תוסף (plugin-name:agent-name) משתמשים כברירת מחדל בשרתי ה-MCP של סשן ההורה, כמו סוכני משתמש תחת ~/.grok/agents/. מגבילים את זה עם ה-frontmatter של mcpInheritance (ראו סוכני משנה). לבטיחות, frontmatter של סוכן תוסף לא יכול להצהיר על mcpServers או על hooks, או לקבוע permissionMode: bypassPermissions.

#יצירת מרקטפלייס משלכם

מרקטפלייס הוא מאגר git (או תיקייה מקומית) שמפרט קבוצה של תוספים. הוספה של אחד עובדת כמו הוספת חנות אפליקציות: היא מאפשרת לאנשים לעיין בתוספים שלכם, והם בוחרים אילו להתקין. פרסום של מרקטפלייס משלכם הוא הדרך שבה צוות או ארגון משתפים את ה-skills, הפקודות, הסוכנים, ה-hooks ושרתי ה-MCP שלהם ממקום אחד.

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

#הקמת המאגר

1. צרו מאגר git. מאגר פרטי מתאים. הגישה משתמשת בפרטי הגישה ל-git של כל אדם. בדיקת העדכון בתחילת הסשן אף פעם לא מבקשת מ-git פרטי גישה (בלי דיאלוג של keychain או של credential-manager), ולכן מקור פרטי שזקוק להם מתרענן כשפותחים /plugins או מריצים grok plugin marketplace update.
2. הוסיפו כל תוסף כתיקייה. תיקיית תוסף יכולה להכיל את skills/, commands/, agents/, hooks/hooks.json, .mcp.json, ומניפסט plugin.json אופציונלי (ראו מה תוסף מכיל).
3. פרטו את התוספים ב-.grok-plugin/marketplace.json. זה האינדקס שגרוק קורא.
4. דחפו את המאגר.

פריסה טיפוסית:

my-org-plugins/
  .grok-plugin/
    marketplace.json      # the index Grok reads (required)
    plugin-index.json     # optional catalog for richer browsing
  plugins/
    gdrive/
      plugin.json         # optional manifest
      skills/gdrive/SKILL.md
      .mcp.json           # MCP servers this plugin adds

גרוק קורא את האינדקס מ-.grok-plugin/marketplace.json. הוא גם מקבל את .grok-plugin/plugin.json ואת המקבילים תחת .claude-plugin/.

#כתיבת האינדקס

marketplace.json נותן שם למרקטפלייס ומפרט כל תוסף:

{
  "name": "My Org Plugins",
  "description": "Internal skills and tools",
  "owner": { "name": "Platform Team", "email": "[email protected]" },
  "plugins": [
    {
      "name": "gdrive",
      "description": "Search and edit Google Drive, Docs, Sheets, and Slides",
      "category": "productivity",
      "source": { "type": "local", "path": "./plugins/gdrive" }
    }
  ]
}

ה-source של כל תוסף מצביע על הקבצים שלו, באחת משתי דרכים:

• במאגר הזה: { "type": "local", "path": "./plugins/gdrive" }. גם המחרוזת הפשוטה "./plugins/gdrive" עובדת.
• במאגר נפרד: { "source": "url", "url": "https://github.com/my-org/gdrive.git", "sha": "<full commit sha>" }. נועצים sha כדי שההתקנות יהיו ניתנות לשחזור (נדרש כשדורשים גרסאות נעוצות).

שדות אופציונליים לכל תוסף: version, author, homepage, tags ו-keywords.

#הוספת קטלוג (אופציונלי)

קטלוג plugin-index.json מאפשר לדפדפן המרקטפלייס להציג את ה-skills, הפקודות, ה-hooks והסוכנים של כל תוסף לפני שמישהו מתקין אותו. הוא לתצוגה בלבד, התקנות עובדות בלעדיו, וצוותים בדרך כלל מייצרים אותו ב-CI:

{
  "version": 1,
  "plugins": {
    "gdrive": {
      "components": {
        "skills": [{ "name": "gdrive", "description": "Google Drive access" }]
      }
    }
  }
}

#בדיקה ושיתוף

מאמתים תוסף לפני פרסום עם grok plugin validate [<path>], ומתייגים מהדורה לפי גרסת המניפסט עם grok plugin tag [<path>] [--push]. אחר כך מפנים אנשים אל המאגר. הם מוסיפים אותו פעם אחת ומתקינים את התוספים שהם רוצים:

grok plugin marketplace add my-org/my-org-plugins   # GitHub shorthand, a git URL, or a local path
grok plugin install gdrive --trust

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

#הפצה בארגון

מנהלים שולטים בתוספים, בשווקים ובשרתי MCP דרך שכבות ה-TOML של grok, ובנוסף דרך קובץ מדיניות אופציונלי של Claude:

• managed_config.toml / requirements.toml (וגם MDM ב-macOS) הם מדיניות מקורית. שימו כאן רשימות היתר, רשימות חסימה ונעיצות כש-grok צריך לאכוף אותן על כל שרת ושוק, כולל כאלה שמוגדרים בהגדרות של המשתמש עצמו או על ידי תוספים. requirements.toml / MDM היא השכבה העמידה לשינוי. עותקים של ~/.grok שניתנים לכתיבה על ידי המשתמש הם רק הגבלה שהמשתמש מטיל על עצמו.
• managed-settings.json של Claude הוא ייעוצי. מגבלות ה-MCP והשוק שלו מחייבות רק נושאים זרים: קבצי פרויקט (.grok/config.toml, .mcp.json), הגדרות Claude שיובאו, עקיפות CLI, ושרתים שהוזרקו על ידי לקוח. הן לעולם לא מחייבות נושאים מקוריים של grok (user/system config.toml, הגדרות שמספק תוסף, נעיצות של מנהל). grok mcp add בהיקף משתמש, או הוספה דרך /mcps של שם שקובץ פרויקט .grok/config.toml מגדיר, נשפטים כקובץ הפרויקט הזה, שגובר על הגדרות המשתמש, והסירוב מציין את שם הקובץ. הוספה של שוק או התקנה של מקור חדש תמיד נחשבות זרות, ולכן רשימה מחמירה ייעוצית עדיין מסרבת למקורות marketplace add / plugin install שלא ברשימה.

השכבות מתחברות לפי המחמיר מנצח: כל חסימה מנצחת, כל מקור מוגבל חייב לאפשר, ונעיצות בוליאניות רק מהדקות (false נשאר. true מאוחר יותר לא יכול לבטל נעיצה). מפתחות Claude ב-CamelCase ומפתחות grok ב-snake_case מתקבלים שניהם ב-TOML.

grok inspect (וגם grok inspect --json) מציג את רשימות ה-MCP והשוק שנטענו, האם allowManagedMcpServersOnly הוא off / advisory / enforced, נעיצות שוק נוספות, ונעיצות שרק מהדקות תחת Enforced by policy.

#הפצת שוק לכולם

הוסיפו את המקור, והפעילו את התוספים שאתם רוצים, ב-managed_config.toml:

[[marketplace.sources]]
name = "My Org Plugins"
git = "https://github.com/my-org/my-org-plugins.git"

# Plugins stay off until enabled. List plugin names (from `grok plugin list`)
# or full IDs (`<scope>/<hash>/<name>`).
[plugins]
enabled = ["gdrive"]

להתקנה ללא מגע וללא צעד לכל אדם, שימו גם את קבצי התוסף במקום שבו Grok מגלה אותם וסומך עליהם אוטומטית: ~/.grok/plugins/, או תיקייה שכלי ניהול המכשירים שלכם מנהל ושאתם מצביעים אליה עם [plugins].paths. אחר כך הפעילו אותם עם [plugins].enabled.

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

#הגבלת השווקים שאפשר להוסיף

רשמו את מקורות ה-git היחידים שאנשים רשאים להוסיף. כל כתובת git אחרת נדחית. רשומות שמתקבלות הן { "source": "git", "url": "…" } ו-{ "source": "github", "repo": "owner/repo" } (מנורמל ל-https://github.com/owner/repo.git). ref / branch אופציונלי נשמר על נעיצות נוספות. הוא לא חלק מזהות רשימת ההיתר. רשומות local ברשימה המחמירה נזרקות עם אזהרה. הן אף פעם לא מאפשרות דבר.

העובדה שהמפתח קיים היא מה שמגביל: רשימה ריקה (strict_known_marketplaces = []), רשימה שכל רשומה בה לא נתמכת, או מפתח מסוג שגוי, הם נעילה מלאה שמסרבת לכל הוספה והתקנה עד שזה מתוקן. השמיטו את המפתח כדי להשאיר שווקים ללא הגבלה.

הוספת נתיב מקומי כשרשימה מחמירה מחייבת קיימת נדחית (נתיבים אף פעם לא תואמים רשימת היתר של כתובות git. כשל סגור), אלא אם נעיצת מנהל extraKnownMarketplaces מציינת בדיוק את הנתיב הזה. נעיצה משכבת ~/.grok שניתנת לכתיבה על ידי המשתמש לא יכולה ליצור את החריג הזה. מקורות git קיימים שנכשלים ברשימה נזרקים בטעינה (Marketplace source blocked by allowlist).

# /etc/grok/requirements.toml  (native: binds every marketplace)
[[strict_known_marketplaces]]
source = "git"
url = "[email protected]:ACME/my-org-plugins.git"

[[strict_known_marketplaces]]
source = "github"
repo = "ACME/more-plugins"

אותן רשימות עובדות ב-managed-settings.json של Claude (ייעוצי למקורות grok מקוריים שכבר הוגדרו). השוואת כתובות מקפלת אותיות רק ב-scheme ו-host, ומסירה בדיוק .git אחד בסוף (repo.git.git הוא מאגר אחר). השתמשו ב-grok inspect כדי לראות את רשימת ההיתר שנטענה.

ספקו מקורות נוספים מהמדיניות עם extraKnownMarketplaces / extra_known_marketplaces. שכבת הנעיצה הראשונה מנצחת בשם. מקור מוגדר שכבר מחזיק בשם הזה עם כתובת אחרת לא נדרס (נרשם בלוג). autoUpdate = false על נעיצה נוספת מכבה עדכון אוטומטי של תוספים גלובלי בתחילת סשן (אין מקבילה ב-grok לכל שוק בנפרד).

[extra_known_marketplaces.acme]
source = { source = "git", url = "https://github.com/ACME/my-org-plugins.git", ref = "main" }

#הגבלת שרתי MCP שיכולים לרוץ

Grok אוכף רשימות היתר וחסימה של MCP מכל שכבת מדיניות TOML מקורית ומ-managed-settings.json של Claude (ייעוצי. ראו למעלה). grok inspect מדפיס את הרשימות הממוזגות.

כל רשומת היתר או חסימה היא אחת מאלה:

חסימה מנצחת. שרת שתואם ל-deniedMcpServers נחסם גם אם הוא תואם גם ל-allowedMcpServers. אם allowedMcpServers קיים, כל שרת שלא ברשימה נחסם. רשימה קיימת אבל ריקה (allowed_mcp_servers = []) חוסמת כל שרת שהקובץ מחייב, אז אל תשלחו אותה כשלד. קובץ של חסימה בלבד חוסם את השרתים שברשימה ומשאיר את השאר (רשימת חסימה ריקה לא מזיקה). בין שכבות, שרת חייב לעבור כל מקור מוגבל.

תצורה שגויה נועלת במקום להיכשל פתוח. מפתח מדיניות מסוג שגוי (טבלה או מחרוזת במקום שבו שייכת רשימה), מפתח שנכתב בשתי האיותים עם ערכים שונים, רשימת היתר שכל רשומה בה לא נתמכת, או רשומת חסימה שאי אפשר לאכוף (שדות לא מוכרים, serverCommand חלקי, serverUrl שלעולם לא יכול להתאים) נועלים את מדיניות ה-MCP של הקובץ הזה: כל שרת שהוא מחייב נחסם עם הסיבה locked down by policy (<file>) עד שהקובץ מתוקן. לוגי ההפעלה מציינים את הקובץ ואת המפתח הבעייתי. רשומת היתר בלתי שמישה רק לא מעניקה כלום.

allowManagedMcpServersOnly = true (או allow_managed_mcp_servers_only) הוא נעילה: נדרשת התאמה חיובית לרשומת היתר גם כשרשימת ההיתר ריקה. TOML מקורי מוצג כ-enforced ב-inspect. Claude בלבד מוצג כ-advisory (שרתי grok מקוריים פטורים).

enableAllProjectMcpServers = false משמיט MCP בהיקף פרויקט אלא אם השרת גם תואם לרשומת היתר.

# /etc/grok/requirements.toml
allow_managed_mcp_servers_only = true
enable_all_project_mcp_servers = false

[[allowed_mcp_servers]]
server_url = "https://*.example.com/*"

[[allowed_mcp_servers]]
command = "npx"

[[allowed_mcp_servers]]
server_command = ["npx", "@corp/mcp"]

[[allowed_mcp_servers]]
server_name = "linear"

[[denied_mcp_servers]]
command = "node"

[[denied_mcp_servers]]
server_url = "https://mcp.untrusted.example/*"

הרשימות חלות אחרי ש-Grok ממזג הגדרות MCP של משתמש, פרויקט, תוסף וייבוא. שרת חסום מושמט מהסשן (נרשם כ-MCP server blocked by managed settings policy) עם סיבה של התאמה ל-deniedMcpServers, אי-הימצאות ב-allowedMcpServers, נעילה על ידי מדיניות, או נעיצת MCP של פרויקט, ובנוסף נתיב קובץ המדיניות (inspect/JSON/לוגים שומרים את הנתיב המלא. סירובים שמוצגים למשתמש מציגים את שם הקובץ).

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

#כיבוי עדכון אוטומטי של תוספים בתחילת סשן

plugin_auto_update = false / pluginAutoUpdate = false הוא רק הידוק. הנעיצה הגלובלית הזו היא מפתח של Grok עצמו בלי מקבילה ב-Claude. כשהיא נעוצה, תחילת סשן לא סורקת שווקים ולא מפזרת עדכונים לכל תוסף (בלי toast). grok plugin update ידני עדיין עובד. extraKnownMarketplaces.<name>.autoUpdate: false של Claude לכל שוק נועץ את אותו מתג גלובלי.

#דרישת גרסאות נעוצות

סרבו לכל התקנה או עדכון של תוסף מרוחק שלא נעוץ ל-sha מלא של commit:

[marketplace]
require_sha = true

אפשר גם להגדיר GROK_MARKETPLACE_REQUIRE_SHA=1. שניהם רק מהדקים את המדיניות. אף אחד מהם לא מכבה אותה בחזרה. פרסמו ערכי sha ב-plugin-index.json של השוק שלכם כדי שהתקנות ממנו יעמדו בכלל. תוספים שמצורפים ישירות בתוך מאגר שוק מועתקים מה-checkout של אותו מאגר, אז נעצו אותם באותו אופן, עם ערכי sha ב-plugin-index.json.

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

כדי להסתיר את ממשק התוספים וה-hooks, הגדירו את זה ב-pager.toml:

disable_plugins = true

#מה זה לא מכסה

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

#פתרון בעיות

תוסף שהתקנתם לא מופיע. תוספים כבויים עד שמפעילים אותם. בדקו grok plugin list, ואז הוסיפו את שם התוסף או את ה-ID שלו ל-[plugins].enabled, או לחצו Space עליו בלשונית Plugins. טענו מחדש עם r בלשונית Plugins או התחילו סשן חדש.

מיומנויות, hooks או שרתי MCP של תוסף לא נטענים. הם נשארים לא פעילים עד שהתוסף מהימן. התקינו מחדש עם --trust, או שימו את התוסף תחת ~/.grok/plugins/ (מהימן אוטומטית). ראו Trust and security.

לשונית Plugins אומרת שחלק מהמיומנויות לא נטענו כי הן מקשרות מחוץ לתיקיית התוסף. מיומנות או פקודה בתוסף היא קישור סמלי, או יושבת בתיקייה מקושרת, שמצביעה מחוץ לתיקייה של התוסף עצמו. Grok טוען מיומנויות ופקודות של תוסף רק מתיקיית התוסף עצמו, התיקייה שבטחתם בה (ראו Trust and security), ולכן הוא מדלג על הקבצים האלה: הם לא נטענים ולא נספרים בין מיומנויות התוסף, וההערה סופרת אותם במקומם. קישורים שנשארים בתוך תיקיית התוסף עדיין עובדים. ב-Windows, קובץ מיומנות שהנתיב המלא שלו ארוך מ-260 תווים גם מדולג, וההערה סופרת גם אותו. עדכנו את התוסף, או בקשו מהמחבר לשמור קבצי מיומנות בתוך תיקיית התוסף, לדוגמה על ידי העתקת מיומנויות משותפות לתוך התוסף במקום קישור לתיקיית skills/ במקום אחר במאגר השוק.

מיומנות או שרת MCP משוק חסרים. רעננו את המקור עם grok plugin marketplace update, אשרו שהתוסף מותקן ומופעל, ואם הארגון שלכם מגביל מקורות, בדקו שהשוק עדיין מותר (ראו Distribute across an organization). חלק משרתי MCP דורשים התחברות ולא יופיעו עד שתזדהו.

שרת MCP מוגדר אבל אף פעם לא מתחיל. מדיניות הארגון אולי חסמה אותו. grok inspect מציג את allowedMcpServers / deniedMcpServers, את mcpManagedServersOnly, קבצי מדיניות נעולים, ואת המקור של כל שרת. התאמת חסימה, רשימת היתר / נעילה שלא מעניקה את השרת, קובץ מדיניות נעול, או enableAllProjectMcpServers = false על שרת בהיקף פרויקט משמיטים אותו לפני spawn. ראו Restrict which MCP servers can run.

הוספת שוק נדחית. רשימת strictKnownMarketplaces בתוקף. רק כתובות git / GitHub שברשימה אפשר להוסיף. הוספות של נתיב מקומי נדחות אלא אם נעיצת מנהל extraKnownMarketplaces מציינת בדיוק את הנתיב הזה. אם grok inspect מציג את הרשימה כנעולה, המפתח קיים אבל ריק, פגום, או מציין רק מקורות לא נתמכים, ואי אפשר להוסיף כלום עד שזה מתוקן.

התקנה נדחית כלא נעוצה. הפריסה שלכם דורשת commits נעוצים. התקינו commit מדויק (owner/repo@<sha>), או השתמשו בשוק ש-plugin-index.json שלו מפרסם ערכי sha. ראו Require pinned versions.

ראו בדיוק מה נטען. הריצו grok inspect (הוסיפו --json לפלט קריא למכונה) כדי לרשום כל תוסף שהתגלה ואת המיומנויות, הסוכנים, ה-hooks ושרתי ה-MCP שהוא מספק, כל אחד מסומן עם מקור plugin: <name>.

#עיון

#מה תוסף מכיל

תוסף הוא תיקייה עם כל שילוב של:

• מיומנויות: תיקיית skills/ של קבצי SKILL.md
• פקודות לוכסן: תיקיית commands/
• סוכנים: תיקיית agents/
• Hooks: קובץ hooks/hooks.json
• שרתי MCP: קובץ .mcp.json
• שרתי LSP: קובץ .lsp.json

מניפסט plugin.json אופציונלי יכול לדרוס נתיבים או להוסיף מטא-נתונים. בלי אחד כזה, Grok מגלה רכיבים מהתיקיות הסטנדרטיות האלה. לדוגמה, תוסף team-tools יכול לארוז מיומנות פריסה, סוכן סקירת קוד, hooks של pre-commit, ושרת MCP של Linear, מותקנים יחד בצעד אחד.

מיומנות או פקודה יכולות לכלול סקריפט עזר ליד ה-SKILL.md שלהן (לדוגמה קובץ Python שהן קוראות לו). שימו את הסקריפט בתוסף ותנו למיומנות להריץ אותו לפי נתיב יחסי. הוא מועתק למכונה עם התוסף. סביבת הריצה של הסקריפט וכל החבילות שהוא מייבא חייבות כבר להיות קיימות. תוספים מספקים קבצים, לא סביבות ריצה או בינאריים מקוריים (ראו What this does not cover).

#איפה Grok מחפש תוספים

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

השדה _meta.pluginDirs ב-session/new, וב-session/load במסלול ה-shell המקורי, טוען תוספים לסשן יחיד. מכיוון שהקורא מספק את התיקייה, התוספים האלה מהימנים אוטומטית ולא נשמרים אחרי הסשן. במסלול ה-daemon, לקוח יכול להדהד את השדה ב-session/load, אבל הסשן שנטען שומר את התיקיות שנוצר איתן ומתעלם מהערכים שהודהדו. --plugin-dir הוא המקבילה לכל התהליך עבור תהליך ייעודי grok agent … stdio, ניתן לחזרה (grok agent --no-leader --plugin-dir A --plugin-dir B stdio), ומתעלמים ממנו במצב leader, שבו ה-leader המשותף מגלה את התוספים שלו בעצמו.

במסלול ה-daemon, תיקיות תוספים נטענות רק על daemon שמדווח grok_session_plugin_dir_hooks.v1. שם הן נקשרות ב-session/new בסשן על המכונה הזו. רק ה-hooks שלהן נטענים שם. על daemon בלי זה, session/new מסרב ל-_meta.pluginDirs. תיקיות --plugin-dir של ההשקה מושמטות עם אזהרה אחת. session/load מקבל אבל מתעלם מ-_meta.pluginDirs. הסשן שומר את התיקיות שנקשרו ב-session/new. session/new על מכונה אחרת מסרב לתיקיות תוספים מכל אחד משני המקורות.

#משתני סביבה ב-hooks של תוסף

hooks של תוסף מקבלים שני משתנים מעבר לסביבת ה-hook הסטנדרטית:

Grok מגדיר אותם ודורס כל ערך באותו שם במפת env של ה-hook (גם הכינויים CLAUDE_PLUGIN_ROOT ו-CLAUDE_PLUGIN_DATA מוגדרים). ראו את Hooks guide לכל משתנה שמועבר ל-hooks.

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

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