synorch 0.2.0 → 0.4.0-beta.0

package/dist/harness/cli/extensions-command.js

@@ -0,0 +1,639 @@
+import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { Document, isMap, parseDocument } from "yaml";
+import { addMarketplace, approveHooks, claudeHome as resolveClaudeHome, createExtensions, describeContents, describeHookConfig, hookCount, hookDigest, personaBaseRole, personaModelTier, revokeHooks, marketplacePlugins, PluginError, readPluginStore, removeMarketplace, removePlugin, stagePlugin, } from "./extensions/index.js";
+import { createWorkspaceTrustStore } from "../policy/index.js";
+import { loadCanonicalStructure } from "./canonical.js";
+import { CONFIG_FILE, extensionsConfigOf, isSynorchHome, loadRuntimeConfig, validateUserConfigText } from "./config.js";
+/**
+ * K7 `syn skills`, `syn plugin`, `/skills` and `/plugins`: list skills and markdown commands with
+ * their source and state, turn one off or on (user configuration only; Claude's files are never
+ * touched), install / remove / enable / disable plugins and add marketplaces (Claude Code formats).
+ */
+export const SKILLS_HELP = `syn skills — skills and slash commands (Claude Code SKILL.md format)
+
+Usage:
+  syn skills [list] [--json]       Every skill and markdown command: source, state, description.
+  syn skills show <name>           Where it comes from, what shadows it, its frontmatter.
+  syn skills enable|disable <name> Turn one on or off for Synorch (saved in your user config).
+
+Sources (highest first on a name clash):
+  project   .synorch/skills, .claude/skills, .agents/skills, .claude/commands, .synorch/commands
+            (repository content: used once the workspace is trusted)
+  user      ~/.synorch/skills/<name>/SKILL.md, ~/.synorch/commands/<name>.md
+  plugin    plugins installed with syn plugin install (as <plugin>:<name>)
+  claude    ~/.claude/skills, ~/.claude/commands and plugins enabled in Claude Code
+            (skills.include_claude / plugins.include_claude: false turns them off)
+  builtin   the Synorch skills
+In a session every skill and command is also /<name> [args].
+`;
+export const PLUGIN_HELP = `syn plugin — plugins in the Claude Code plugin format
+
+Usage:
+  syn plugin [list] [--json]                 Synorch and Claude Code plugins, what each contains.
+  syn plugin install <path|git-url|name@marketplace> [--yes] [--disabled]
+                                             Show what it contains, then install it into
+                                             ~/.synorch/plugins (skills, commands, MCP servers).
+  syn plugin remove <name>                   Uninstall a Synorch plugin.
+  syn plugin enable|disable <name>           Turn a plugin on or off for Synorch (Claude plugins:
+                                             name@marketplace; Claude's own settings stay as they are).
+  syn plugin marketplace add <git-url|path>  Register a marketplace (.claude-plugin/marketplace.json).
+  syn plugin marketplace list|remove <name>
+  syn plugin show <name>                     Contents, hook commands and agents of one plugin.
+  syn plugin hooks [list]                    Hook sources and whether they run.
+  syn plugin hooks approve|revoke <name>     Let a plugin's hooks run (or stop them); a changed
+                                             plugin needs a new approval.
+  syn plugin agents                          Plugin agents (orchestration worker personas).
+
+Plugin hooks run commands on your machine: they run only after you approve them (install asks;
+--allow-hooks approves at install). Claude Code plugins' hooks stay off until approved and never
+run on Claude Code routes, where Claude runs them itself.
+`;
+export class ExtensionCommandError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "ExtensionCommandError";
+    }
+}
+// ---- user configuration --------------------------------------------------------------------------
+async function readUserDocument(file) {
+    let text;
+    try {
+        text = await readFile(file, "utf8");
+    }
+    catch {
+        text = undefined;
+    }
+    const document = text === undefined ? new Document({}) : parseDocument(text);
+    if (document.errors.length > 0)
+        throw new ExtensionCommandError(`${file} is not valid YAML (${document.errors[0]?.message.split("\n")[0] ?? ""}); fix it with syn config edit`);
+    if (!isMap(document.contents))
+        document.contents = document.createNode({});
+    return document;
+}
+/** Adds `key` to (or removes it from) `skills.disabled` / `plugins.disabled`; returns the new settings. */
+export async function setExtensionDisabled(home, block, key, disabled) {
+    const file = path.join(home, CONFIG_FILE);
+    const document = await readUserDocument(file);
+    const current = document.toJS()?.[block]?.disabled;
+    const list = new Set(Array.isArray(current) ? current : []);
+    if (disabled)
+        list.add(key);
+    else
+        list.delete(key);
+    if (list.size === 0) {
+        if (!document.hasIn([block, "disabled"]))
+            return extensionsConfigOf(document.toJS() ?? undefined);
+        document.deleteIn([block, "disabled"]);
+        const rest = document.getIn([block]);
+        if (isMap(rest) && rest.items.length === 0)
+            document.deleteIn([block]);
+    }
+    else
+        document.setIn([block, "disabled"], document.createNode([...list].sort()));
+    const text = document.toString({ lineWidth: 0 });
+    const parsed = validateUserConfigText(text, file);
+    await mkdir(home, { recursive: true });
+    const temporary = `${file}.${process.pid}.tmp`;
+    await writeFile(temporary, text, "utf8");
+    await rename(temporary, file);
+    return extensionsConfigOf(parsed);
+}
+// ---- formatting ----------------------------------------------------------------------------------
+const STATE_LABEL = { active: "on", shadowed: "shadowed", disabled: "off", "needs-trust": "needs trust" };
+function oneLine(text, width) {
+    const flat = text.replace(/\s+/g, " ").trim();
+    return flat.length <= width ? flat : `${flat.slice(0, width - 1)}…`;
+}
+export function describeSkills(statuses, sep = "·") {
+    if (statuses.length === 0)
+        return ["No skills or commands."];
+    const width = Math.min(34, Math.max(...statuses.map((status) => status.item.name.length + (status.item.kind === "command" ? 1 : 0))));
+    const lines = [];
+    for (const kind of ["skill", "command"]) {
+        const rows = statuses.filter((status) => status.item.kind === kind);
+        if (rows.length === 0)
+            continue;
+        const active = rows.filter((status) => status.state === "active").length;
+        lines.push(`${kind === "skill" ? "Skills" : "Commands"} ${sep} ${active} on of ${rows.length}`);
+        for (const status of rows) {
+            const name = kind === "command" ? `/${status.item.name}` : status.item.name;
+            const state = status.state === "shadowed" && status.shadowedBy !== undefined ? `shadowed by ${status.shadowedBy.source}` : STATE_LABEL[status.state];
+            lines.push(`  ${name.padEnd(width + 2)}${status.item.source.padEnd(9)}${state.padEnd(20)}${oneLine(status.item.meta.description, 70)}`);
+        }
+    }
+    return lines;
+}
+export function describeSkill(name, statuses) {
+    const matches = statuses.filter((status) => status.item.name === name || status.item.name.toLowerCase() === name.toLowerCase());
+    if (matches.length === 0)
+        return [`No skill or command ${name}.`];
+    const lines = [];
+    for (const status of matches) {
+        const entry = status.item;
+        lines.push(`${entry.kind} ${entry.name} ${status.state === "active" ? "(on)" : `(${status.state === "shadowed" ? `shadowed by ${status.shadowedBy?.source ?? "?"}` : STATE_LABEL[status.state]})`}`);
+        lines.push(`  source       ${entry.source}${entry.plugin === undefined ? "" : ` (plugin ${entry.plugin})`}`);
+        lines.push(`  location     ${entry.location}`);
+        lines.push(`  description  ${oneLine(entry.meta.description, 200)}`);
+        if (entry.meta.whenToUse !== undefined)
+            lines.push(`  when to use  ${oneLine(entry.meta.whenToUse, 200)}`);
+        if (entry.meta.argumentHint !== undefined)
+            lines.push(`  arguments    ${entry.meta.argumentHint}`);
+        if (entry.meta.allowedTools.length > 0)
+            lines.push(`  allowed-tools ${entry.meta.allowedTools.join(" ")} (informational: Synorch's permission mode decides)`);
+        if (!entry.meta.modelInvocable)
+            lines.push("  model        never loads it on its own (disable-model-invocation)");
+        if (!entry.meta.userInvocable)
+            lines.push("  palette      hidden (user-invocable: false)");
+        if (entry.claudeNative)
+            lines.push("  Claude Code  loads it itself on Claude routes (not duplicated there)");
+        if (status.state === "needs-trust")
+            lines.push("  trust        repository content: /trust (or syn trust) activates it");
+    }
+    return lines;
+}
+const HOOK_STATE_LABEL = {
+    active: "hooks approved (they run)",
+    pending: "hooks not approved (never run)",
+    changed: "hooks changed since you approved them (not run until approved again)",
+};
+function hookStateLine(source, key) {
+    if (source === undefined || source.origin === "user")
+        return undefined;
+    const hint = source.state === "active" ? `/plugins hooks revoke ${key}` : `/plugins hooks approve ${key}`;
+    return `${HOOK_STATE_LABEL[source.state]}${source.origin === "claude" ? "; never on Claude Code routes (Claude runs them)" : ""} · ${hint}`;
+}
+export function describePlugins(plugins, sep = "·", hooks = []) {
+    if (plugins.length === 0)
+        return ["No plugins. Install one: syn plugin install <path|git-url|name@marketplace>"];
+    const lines = [];
+    for (const plugin of plugins) {
+        const state = plugin.enabled ? "on" : plugin.shadowed ? "shadowed by the Synorch plugin" : plugin.offReason === "claude" ? "disabled in Claude Code" : "off in Synorch";
+        lines.push(`${plugin.key}${plugin.contents.version === undefined ? "" : ` ${plugin.contents.version}`} ${sep} ${plugin.origin === "claude" ? "claude" : "synorch"} ${sep} ${state}`);
+        if (plugin.contents.description !== "")
+            lines.push(`  ${oneLine(plugin.contents.description, 100)}`);
+        for (const line of describeContents(plugin.contents))
+            lines.push(`  ${line}`);
+        const hookLine = hookStateLine(hooks.find((source) => source.key === plugin.key), plugin.key);
+        if (hookLine !== undefined)
+            lines.push(`  ${hookLine}`);
+    }
+    return lines;
+}
+/** `/plugins hooks`: every hook source (user configuration and plugins) and whether it runs. */
+export function describeHookSources(sources) {
+    if (sources.length === 0)
+        return ["No hooks. Plugins may bring hooks/hooks.json; your own go under hooks: in ~/.synorch/config.yaml."];
+    const lines = [];
+    for (const source of sources) {
+        lines.push(`${source.key} ${source.origin === "user" ? "(your config: runs)" : `(${source.origin} plugin: ${HOOK_STATE_LABEL[source.state]})`}`);
+        for (const line of describeHookConfig(source.config))
+            lines.push(`  ${line}`);
+    }
+    return lines;
+}
+/** `/agents`: plugin agents with their base role and model hint. */
+export function describeAgents(agents) {
+    if (agents.length === 0)
+        return ["No plugin agents. A plugin's agents/*.md become worker personas the orchestrator can assign to a task."];
+    const lines = [`Plugin agents (worker personas) · ${agents.length}`];
+    for (const agent of agents) {
+        const tier = personaModelTier(agent.model);
+        lines.push(`  ${agent.id.padEnd(32)}${personaBaseRole(agent).padEnd(12)}${(tier ?? "orchestrator's tier").padEnd(22)}${oneLine(agent.description, 70)}`);
+    }
+    lines.push("The orchestrator names one on a plan task (agent); its instructions are layered on that task's role.");
+    return lines;
+}
+function describeAgent(agent) {
+    const tier = personaModelTier(agent.model);
+    return [
+        `agent ${agent.id} (${agent.origin} plugin ${agent.plugin})`,
+        `  file         ${agent.file}`,
+        `  description  ${oneLine(agent.description, 200)}`,
+        `  base role    ${personaBaseRole(agent)}${agent.tools.length === 0 ? " (all tools)" : ` (tools: ${agent.tools.join(", ")})`}`,
+        `  model        ${agent.model ?? "inherit"}${tier === undefined ? "" : ` → tier ${tier} (your routes for that tier decide)`}`,
+        `  instructions ${oneLine(agent.body, 200)}`,
+    ];
+}
+function hookApprovalContext(source) {
+    return [
+        `Plugin ${source.key} (${source.origin === "claude" ? "installed in Claude Code" : "Synorch plugin"}) wants to run these commands on your machine:`,
+        ...describeHookConfig(source.config).map((line) => `  ${line}`),
+        "They run in the workspace with your user permissions and environment (timeout 60 s by default, output capped).",
+        "A hook can block or narrow a tool call, never widen your permission mode.",
+        ...(source.origin === "claude" ? ["On Claude Code routes they are never run by Synorch (Claude runs them itself)."] : []),
+    ];
+}
+function claudeHomeOf(io) {
+    return io.claudeHome === null ? undefined : (io.claudeHome ?? resolveClaudeHome(io.env));
+}
+export async function standaloneExtensions(io, root) {
+    const config = await loadRuntimeConfig(io.home, root, [], { platform: io.platform, ...(io.discovery ?? {}) });
+    const canonical = await loadCanonicalStructure(root);
+    const trusted = createWorkspaceTrustStore(io.home, { platform: io.platform }).status(root).trusted;
+    return createExtensions({
+        home: io.home,
+        workspaceRoot: root,
+        env: io.env,
+        platform: io.platform,
+        claudeHome: claudeHomeOf(io),
+        settings: config.extensions,
+        trusted: () => trusted,
+        canonicalCatalog: canonical.skills,
+        canonical: { origin: canonical.origin, skills: canonical.skillEntries },
+        skipProjectSynorch: isSynorchHome(path.join(root, ".synorch"), io.home, io.platform),
+    });
+}
+function statusJson(status) {
+    const entry = status.item;
+    return {
+        name: entry.name,
+        kind: entry.kind,
+        source: entry.source,
+        state: status.state,
+        ...(status.shadowedBy === undefined ? {} : { shadowed_by: status.shadowedBy.source }),
+        description: entry.meta.description,
+        location: entry.location,
+        ...(entry.plugin === undefined ? {} : { plugin: entry.plugin }),
+    };
+}
+/** `syn skills …`; returns the exit code. */
+export async function skillsCommand(args, target, json, io) {
+    const root = path.resolve(io.cwd, target ?? ".");
+    const [verb = "list", name] = args;
+    try {
+        switch (verb) {
+            case "list": {
+                const extensions = await standaloneExtensions(io, root);
+                const statuses = extensions.statuses();
+                if (json)
+                    io.stdout(`${JSON.stringify({ items: statuses.map(statusJson), problems: extensions.problems() }, null, 2)}\n`);
+                else
+                    io.stdout(`${[...describeSkills(statuses), ...extensions.problems().map((problem) => `warning: ${problem}`)].join("\n")}\n`);
+                return 0;
+            }
+            case "show": {
+                if (name === undefined)
+                    throw new ExtensionCommandError("syn skills show <name>");
+                const extensions = await standaloneExtensions(io, root);
+                io.stdout(`${describeSkill(name, extensions.statuses()).join("\n")}\n`);
+                return 0;
+            }
+            case "enable":
+            case "disable": {
+                if (name === undefined)
+                    throw new ExtensionCommandError(`syn skills ${verb} <name>`);
+                await setExtensionDisabled(io.home, "skills", name, verb === "disable");
+                io.stdout(`${name} is ${verb === "disable" ? "off" : "on"} for Synorch (${path.join(io.home, CONFIG_FILE)}).\n`);
+                return 0;
+            }
+            default:
+                throw new ExtensionCommandError(`Unknown skills sub-command: ${verb}. Expected list, show, enable or disable.`);
+        }
+    }
+    catch (error) {
+        if (error instanceof ExtensionCommandError || error instanceof PluginError) {
+            io.stderr(`Error: ${error.message}\n`);
+            return 2;
+        }
+        throw error;
+    }
+}
+/** `syn plugin …`; returns the exit code. */
+export async function pluginCommand(args, target, json, io) {
+    const root = path.resolve(io.cwd, target ?? ".");
+    const flags = new Set(args.filter((arg) => arg.startsWith("--")));
+    const words = args.filter((arg) => !arg.startsWith("--"));
+    const [verb = "list", name, extra] = words;
+    const options = { home: io.home, cwd: io.cwd, env: io.env, ...(io.git === undefined ? {} : { git: io.git }), ...(claudeHomeOf(io) === undefined ? {} : { claudeHome: claudeHomeOf(io) }) };
+    try {
+        switch (verb) {
+            case "list": {
+                const extensions = await standaloneExtensions(io, root);
+                const plugins = extensions.state().plugins;
+                if (json)
+                    io.stdout(`${JSON.stringify(plugins.map((plugin) => ({ key: plugin.key, origin: plugin.origin, enabled: plugin.enabled, version: plugin.contents.version, root: plugin.contents.root, skills: plugin.contents.skills.map((skill) => skill.name), commands: plugin.contents.commands.map((command) => command.name), mcp_servers: Object.keys(plugin.contents.mcpServers), agents: plugin.contents.agents, hooks: plugin.contents.hooks })), null, 2)}\n`);
+                else
+                    io.stdout(`${describePlugins(plugins, "·", extensions.hooks.sources()).join("\n")}\n`);
+                return 0;
+            }
+            case "show": {
+                if (name === undefined)
+                    throw new ExtensionCommandError("syn plugin show <name>");
+                const extensions = await standaloneExtensions(io, root);
+                const plugin = extensions.state().plugins.find((entry) => entry.key === name || entry.contents.name === name);
+                if (plugin === undefined)
+                    throw new ExtensionCommandError(`No plugin ${name} (syn plugin list).`);
+                io.stdout(`${[...describePlugins([plugin], "·", extensions.hooks.sources()), ...plugin.contents.agentDefs.length === 0 ? [] : ["", ...describeAgents(extensions.personas.list().filter((agent) => agent.plugin === plugin.key))]].join("\n")}\n`);
+                return 0;
+            }
+            case "agents": {
+                const extensions = await standaloneExtensions(io, root);
+                io.stdout(`${describeAgents(extensions.personas.list()).join("\n")}\n`);
+                return 0;
+            }
+            case "hooks": {
+                const action = name ?? "list";
+                const extensions = await standaloneExtensions(io, root);
+                if (action === "list") {
+                    io.stdout(`${describeHookSources(extensions.hooks.sources()).join("\n")}\n`);
+                    return 0;
+                }
+                if (action !== "approve" && action !== "revoke")
+                    throw new ExtensionCommandError(`Unknown hooks action: ${action}. Expected list, approve or revoke.`);
+                if (extra === undefined)
+                    throw new ExtensionCommandError(`syn plugin hooks ${action} <name>`);
+                if (action === "revoke") {
+                    io.stdout((await revokeHooks(io.home, extra)) ? `Hooks of ${extra} no longer run.\n` : `Hooks of ${extra} were not approved.\n`);
+                    return 0;
+                }
+                const source = extensions.hooks.sources().find((entry) => entry.key === extra && entry.origin !== "user");
+                if (source === undefined)
+                    throw new ExtensionCommandError(`${extra} is not an enabled plugin with hooks (syn plugin hooks list).`);
+                io.stdout(`${hookApprovalContext(source).join("\n")}\n`);
+                let proceed = flags.has("--yes");
+                if (!proceed && io.confirm !== undefined)
+                    proceed = await io.confirm(`Let ${extra}'s hooks run?`);
+                if (!proceed) {
+                    io.stdout(io.confirm === undefined ? "Not approved: pass --yes to approve without a question.\n" : "Not approved.\n");
+                    return io.confirm === undefined ? 2 : 0;
+                }
+                await approveHooks(io.home, extra, source.digest);
+                io.stdout(`Hooks of ${extra} approved; they run from the next session (in a running session: /plugins hooks approve).\n`);
+                return 0;
+            }
+            case "install": {
+                if (name === undefined)
+                    throw new ExtensionCommandError("syn plugin install <path|git-url|name@marketplace>");
+                const staged = await stagePlugin(name, options);
+                io.stdout(`${previewLines(staged).join("\n")}\n`);
+                let proceed = flags.has("--yes");
+                if (!proceed && io.confirm !== undefined)
+                    proceed = await io.confirm(`Install ${staged.contents.name}?`);
+                if (!proceed) {
+                    await staged.discard();
+                    io.stdout(io.confirm === undefined ? "Not installed: pass --yes to install without a question.\n" : "Not installed.\n");
+                    return io.confirm === undefined ? 2 : 0;
+                }
+                const record = await staged.commit();
+                await setExtensionDisabled(io.home, "plugins", record.name, flags.has("--disabled"));
+                io.stdout(`Installed ${record.name} in ${record.dir}${flags.has("--disabled") ? " (off: syn plugin enable " + record.name + ")" : ""}.\n`);
+                if (hookCount(staged.contents.hookConfig) > 0) {
+                    let allow = flags.has("--allow-hooks");
+                    if (!allow && !flags.has("--yes") && io.confirm !== undefined)
+                        allow = await io.confirm(`Let ${record.name}'s hooks run (the commands listed above)?`);
+                    if (allow)
+                        await approveHooks(io.home, record.name, hookDigest(staged.contents.hookConfig, record.dir));
+                    io.stdout(allow ? "Its hooks are approved.\n" : `Its hooks do not run until you approve them: syn plugin hooks approve ${record.name}\n`);
+                }
+                return 0;
+            }
+            case "remove":
+            case "uninstall": {
+                if (name === undefined)
+                    throw new ExtensionCommandError("syn plugin remove <name>");
+                const removed = await removePlugin(io.home, name);
+                if (removed === undefined)
+                    throw new ExtensionCommandError(`${name} is not a Synorch plugin (syn plugin list); a Claude plugin is turned off with syn plugin disable <name@marketplace>`);
+                await setExtensionDisabled(io.home, "plugins", name, false);
+                io.stdout(`Removed ${name}.\n`);
+                return 0;
+            }
+            case "enable":
+            case "disable": {
+                if (name === undefined)
+                    throw new ExtensionCommandError(`syn plugin ${verb} <name>`);
+                await setExtensionDisabled(io.home, "plugins", name, verb === "disable");
+                io.stdout(`${name} is ${verb === "disable" ? "off" : "on"} for Synorch.\n`);
+                return 0;
+            }
+            case "marketplace": {
+                const action = name ?? "list";
+                if (action === "add") {
+                    if (extra === undefined)
+                        throw new ExtensionCommandError("syn plugin marketplace add <git-url|path>");
+                    const added = await addMarketplace(extra, options);
+                    io.stdout(`Added marketplace ${added.marketplace.name} (${added.plugins.length} plugin${added.plugins.length === 1 ? "" : "s"}: ${added.plugins.join(", ") || "none"}).\nInstall one: syn plugin install <name>@${added.marketplace.name}\n`);
+                    return 0;
+                }
+                if (action === "remove") {
+                    if (extra === undefined)
+                        throw new ExtensionCommandError("syn plugin marketplace remove <name>");
+                    if (!(await removeMarketplace(io.home, extra)))
+                        throw new ExtensionCommandError(`No marketplace ${extra}.`);
+                    io.stdout(`Removed marketplace ${extra}.\n`);
+                    return 0;
+                }
+                if (action === "list") {
+                    const store = await readPluginStore(io.home);
+                    if (store.marketplaces.length === 0)
+                        io.stdout("No marketplaces. Add one: syn plugin marketplace add <git-url|path>\n");
+                    for (const market of store.marketplaces) {
+                        const plugins = await marketplacePlugins(market.dir);
+                        io.stdout(`${market.name} · ${market.source}\n${plugins.map((plugin) => `  ${plugin.name}${plugin.description === "" ? "" : ` — ${oneLine(plugin.description, 90)}`}`).join("\n")}\n`);
+                    }
+                    return 0;
+                }
+                throw new ExtensionCommandError(`Unknown marketplace action: ${action}. Expected add, list or remove.`);
+            }
+            default:
+                throw new ExtensionCommandError(`Unknown plugin sub-command: ${verb}. Expected list, show, install, remove, enable, disable, hooks, agents or marketplace.`);
+        }
+    }
+    catch (error) {
+        if (error instanceof ExtensionCommandError || error instanceof PluginError) {
+            io.stderr(`Error: ${error.message}\n`);
+            return 2;
+        }
+        throw error;
+    }
+}
+function previewLines(staged) {
+    const contents = staged.contents;
+    return [`Plugin ${contents.name}${contents.version === undefined ? "" : ` ${contents.version}`} (${staged.source})`, ...(contents.description === "" ? [] : [`  ${oneLine(contents.description, 100)}`]), ...describeContents(contents).map((line) => `  ${line}`)];
+}
+/** `/skills [list | show <name> | enable <name> | disable <name>]`. */
+export async function runSkillsSlash(host, argument) {
+    const [verb = "list", name] = argument.trim().split(/\s+/).filter((word) => word !== "");
+    const extensions = host.extensions;
+    if (verb === "list") {
+        host.print([...describeSkills(extensions.statuses(), host.sep), ...extensions.problems().map((problem) => `warning: ${problem}`), `/<name> [args] runs one ${host.sep} /skills show|enable|disable <name> ${host.sep} /plugins`]);
+        return;
+    }
+    if (name === undefined) {
+        host.print([`/skills ${verb} <name>`]);
+        return;
+    }
+    if (verb === "show") {
+        host.print(describeSkill(name, extensions.statuses()));
+        return;
+    }
+    if (verb === "enable" || verb === "disable") {
+        const known = extensions.statuses().some((status) => status.item.name === name);
+        if (!known) {
+            host.print([`No skill or command ${name}; /skills lists them.`]);
+            return;
+        }
+        const settings = await setExtensionDisabled(host.home, "skills", name, verb === "disable");
+        await extensions.reload(settings);
+        await host.changed();
+        host.print([`${name} is ${verb === "disable" ? "off" : "on"} (saved in your user config).`]);
+        return;
+    }
+    host.print(["/skills [list | show <name> | enable <name> | disable <name>]"]);
+}
+/**
+ * Asks in the choice modal whether a plugin's hooks may run (each command shown); an approval
+ * stores the digest of the definitions, so a changed plugin asks again. Returns whether approved.
+ */
+export async function askHookApproval(host, source) {
+    const answer = await host.choose({
+        question: source.state === "changed" ? `The hooks of ${source.key} changed. Let them run?` : `Let the hooks of ${source.key} run?`,
+        header: "Hooks",
+        context: hookApprovalContext(source),
+        options: [
+            { label: "Allow", description: "these commands run on the listed events until the plugin changes" },
+            { label: "Not now", description: "they do not run; /plugins hooks approve asks again", recommended: true },
+        ],
+        allowOther: false,
+        escapeLabel: "not now",
+        tone: "attention",
+    });
+    if (answer?.kind !== "selected" || answer.indices[0] !== 0)
+        return false;
+    await approveHooks(host.home, source.key, source.digest);
+    await host.extensions.reload();
+    return true;
+}
+/** `/plugins [list | show <name> | install <spec> | remove <name> | enable <name> | disable <name> | hooks [approve|revoke <name>] | agents]`. */
+export async function runPluginsSlash(host, argument) {
+    const [verb = "list", name, extra] = argument.trim().split(/\s+/).filter((word) => word !== "");
+    const extensions = host.extensions;
+    const options = { home: host.home, cwd: host.workspaceRoot, env: host.env, ...(extensions.claudeHome === undefined ? {} : { claudeHome: extensions.claudeHome }) };
+    switch (verb) {
+        case "list":
+            host.print([...describePlugins(extensions.state().plugins, host.sep, extensions.hooks.sources()), `/plugins show|enable|disable|remove <name> ${host.sep} /plugins install <spec> ${host.sep} /plugins hooks ${host.sep} /agents`]);
+            return;
+        case "show": {
+            const plugin = extensions.state().plugins.find((entry) => entry.key === name || entry.contents.name === name);
+            if (plugin === undefined) {
+                host.print([name === undefined ? "/plugins show <name>" : `No plugin ${name}; /plugins lists them.`]);
+                return;
+            }
+            const agents = extensions.personas.list().filter((agent) => agent.plugin === plugin.key);
+            host.print([...describePlugins([plugin], host.sep, extensions.hooks.sources()), ...(agents.length === 0 ? [] : ["", ...describeAgents(agents)])]);
+            return;
+        }
+        case "agents": {
+            const agent = name === "show" && extra !== undefined ? extensions.personas.find(extra) : undefined;
+            if (name === "show")
+                host.print(agent === undefined ? [`No plugin agent ${extra ?? ""}; /agents lists them.`] : describeAgent(agent));
+            else
+                host.print(describeAgents(extensions.personas.list()));
+            return;
+        }
+        case "hooks": {
+            const action = name ?? "list";
+            if (action === "list") {
+                host.print([...describeHookSources(extensions.hooks.sources()), `/plugins hooks approve|revoke <plugin>`]);
+                return;
+            }
+            if ((action !== "approve" && action !== "revoke") || extra === undefined) {
+                host.print(["/plugins hooks [list | approve <plugin> | revoke <plugin>]"]);
+                return;
+            }
+            if (action === "revoke") {
+                const revoked = await revokeHooks(host.home, extra);
+                await extensions.reload();
+                host.print([revoked ? `Hooks of ${extra} no longer run.` : `Hooks of ${extra} were not approved.`]);
+                return;
+            }
+            const source = extensions.hooks.sources().find((entry) => entry.key === extra && entry.origin !== "user");
+            if (source === undefined) {
+                host.print([`${extra} is not an enabled plugin with hooks; /plugins hooks lists them.`]);
+                return;
+            }
+            host.print([(await askHookApproval(host, source)) ? `Hooks of ${extra} approved; they run from now on.` : `Hooks of ${extra} stay off.`]);
+            return;
+        }
+        case "install": {
+            if (name === undefined) {
+                host.print(["/plugins install <path|git-url|name@marketplace>"]);
+                return;
+            }
+            host.print([`Fetching ${name}…`]);
+            let staged;
+            try {
+                staged = await stagePlugin(name, options);
+            }
+            catch (error) {
+                host.print([`Not installed: ${error instanceof Error ? error.message : String(error)}`]);
+                return;
+            }
+            const answer = await host.choose({
+                question: `Install plugin ${staged.contents.name}?`,
+                header: "Plugin",
+                context: previewLines(staged),
+                options: [
+                    { label: "Install and enable", description: "its skills, commands and MCP servers become available", recommended: true },
+                    { label: "Install, keep it off", description: "/plugins enable turns it on later" },
+                    { label: "Cancel", description: "nothing is installed" },
+                ],
+                allowOther: false,
+                escapeLabel: "cancel",
+                tone: "neutral",
+            });
+            const index = answer?.kind === "selected" ? answer.indices[0] : undefined;
+            if (index !== 0 && index !== 1) {
+                await staged.discard();
+                host.print(["Not installed."]);
+                return;
+            }
+            const record = await staged.commit();
+            const settings = await setExtensionDisabled(host.home, "plugins", record.name, index === 1);
+            await extensions.reload(settings);
+            await host.changed();
+            host.print([`Installed ${record.name}${index === 1 ? " (off)" : ""}.`]);
+            const hookSource = extensions.hooks.sources().find((entry) => entry.key === record.name && entry.origin === "synorch");
+            if (hookSource !== undefined && hookSource.state !== "active")
+                host.print([(await askHookApproval(host, hookSource)) ? "Its hooks are approved." : `Its hooks stay off (/plugins hooks approve ${record.name}).`]);
+            return;
+        }
+        case "remove":
+        case "uninstall": {
+            if (name === undefined) {
+                host.print(["/plugins remove <name>"]);
+                return;
+            }
+            const removed = await removePlugin(host.home, name);
+            if (removed === undefined) {
+                host.print([`${name} is not a Synorch plugin; a Claude plugin is turned off with /plugins disable <name@marketplace>.`]);
+                return;
+            }
+            const settings = await setExtensionDisabled(host.home, "plugins", name, false);
+            await extensions.reload(settings);
+            await host.changed();
+            host.print([`Removed ${name}.`]);
+            return;
+        }
+        case "enable":
+        case "disable": {
+            if (name === undefined) {
+                host.print([`/plugins ${verb} <name>`]);
+                return;
+            }
+            if (!extensions.state().plugins.some((plugin) => plugin.key === name)) {
+                host.print([`No plugin ${name}; /plugins lists them.`]);
+                return;
+            }
+            const settings = await setExtensionDisabled(host.home, "plugins", name, verb === "disable");
+            await extensions.reload(settings);
+            await host.changed();
+            host.print([`${name} is ${verb === "disable" ? "off" : "on"} for Synorch.`]);
+            return;
+        }
+        default:
+            host.print(["/plugins [list | show <name> | install <spec> | remove <name> | enable <name> | disable <name> | hooks | agents]"]);
+    }
+}
+//# sourceMappingURL=extensions-command.js.map