@spacefast/common 0.0.24 → 0.2.1

package/dist/agents/registry/core.js

@@ -0,0 +1,1388 @@
+/**
+ * Canonical, browser-safe agent integration registry.
+ *
+ * Keep this module free of Node built-ins, filesystem access, and environment
+ * reads. Runtime-specific path and config mechanics live in ./node.ts.
+ */
+import { serviceOrigin } from "../../config/domains.js";
+import { DEEPLINK_PROBE_RESULTS } from "./deeplink-probes.js";
+export const AGENT_IDS = [
+    "claude-code",
+    "claude-app",
+    "claude-desktop",
+    "cursor",
+    "codex",
+    "chatgpt",
+    "vscode",
+    "github-copilot",
+    "devin-desktop",
+    "devin-cloud",
+    "zed",
+    "gemini-cli",
+    "opencode",
+    "amp",
+    "warp",
+    "factory-droid",
+    "cline",
+    "continue",
+    "raycast",
+    "poke",
+    "pi",
+    "indent",
+    "hermes",
+    "openclaw",
+];
+// Setup commands are durable instructions, not release snapshots. Let npx
+// resolve the current installer instead of baking a stale version into every
+// dashboard page, generated guide, and agent fixture.
+export const SKILLS_CLI_PACKAGE_SPEC = "skills";
+export const SPACEFAST_CLI_PACKAGE_SPEC = "spacefast";
+export const PLUGINS_CLI_PACKAGE_SPEC = "plugins";
+/**
+ * The complete `-t` target set the universal plugin installer implements.
+ * Anything outside this list has no install
+ * mechanics upstream: `npx plugins add … -t <id>` either errors or synthesizes a
+ * manifest, so `sf plugins` must refuse it rather than run a command that cannot
+ * work. Capability flags are NOT a substitute — several entries carry a `plugin`
+ * capability because a vendor-native plugin lane exists, not because this
+ * installer can drive it.
+ */
+export const PLUGINS_CLI_INSTALLER_TARGETS = [
+    "claude-code",
+    "cursor",
+    "codex",
+    "github-copilot",
+    "vscode",
+    "grok",
+    "kimi",
+];
+export const AGENT_DISTRIBUTION_PROFILE = {
+    author: { name: "Automattic", url: "https://spacefast.com" },
+    description: "Spacefast publishes files and folders to permanent web URLs with immutable versions, scoped access, and resumable MCP workflows.",
+    displayName: "Spacefast",
+    homepage: "https://spacefast.com",
+    keywords: ["spacefast", "publish-to-spacefast", "artifact-sharing", "hosting"],
+    license: "MIT",
+    name: "spacefast",
+    privacyPolicyUrl: "https://automattic.com/privacy/",
+    repository: "https://github.com/spacefast/plugins",
+    reviewerAccount: {
+        environment: "marketplace-reviewers",
+        secret: "SPACEFAST_REVIEWER_ACCOUNT",
+    },
+    shortDescription: "Publish files and folders to the web instantly.",
+    termsOfServiceUrl: "https://wordpress.com/tos/",
+};
+export const AGENTS_MD_SPACEFAST_START = "<!-- SPACEFAST START -->";
+export const AGENTS_MD_SPACEFAST_END = "<!-- SPACEFAST END -->";
+export const AGENTS_MD_SPACEFAST_SNIPPET = [
+    AGENTS_MD_SPACEFAST_START,
+    "Spacefast agent index: CHECK existing `.spacefast/space.json` or receipt before creating; PUBLISH only the intended files from the output root; SAVE `.spacefast/state.json` as private credential cache; UPDATE by reusing `spaceId` plus bearer auth; CONTINUE after claim by exchanging the saved claim token once.",
+    "",
+    "State contract: `.spacefast/space.json` is non-secret and can name the space; `.spacefast/state.json` can contain claim tokens or API keys and must not be printed, committed, archived, or published.",
+    "",
+    "Links ladder: error recovery uses the problem document's `type`; capability discovery uses `execute` with the OpenAPI catalog; Markdown docs use `.md` suffix; publish contract is https://spacefast.com/publish-spec.json; API is https://spacefast.com/openapi.json.",
+    AGENTS_MD_SPACEFAST_END,
+].join("\n");
+export const SOURCE_LANES = [
+    {
+        id: "drop",
+        label: "Drop files",
+        description: "Drop a folder or archive and put it live now.",
+        href: "/drop",
+        icon: "upload",
+    },
+    {
+        id: "push",
+        label: "Push directly",
+        description: "Push a Git repository to Spacefast and publish every update.",
+        href: "/push",
+        icon: "git",
+    },
+    {
+        id: "github",
+        label: "Connect a GitHub repository",
+        description: "Connect GitHub and build and publish on every push.",
+        href: "https://spacefast.com/docs/builds",
+        icon: "github",
+    },
+    {
+        id: "terminal",
+        label: "Command line",
+        description: "Publish from the terminal with the Spacefast CLI.",
+        // The CLI setup sheet — install, sign in, publish. Not `/terminal`, which
+        // is the in-browser shell: a different surface that assumes you already
+        // have the CLI story.
+        href: "/start?step=terminal",
+        icon: "terminal",
+    },
+    {
+        id: "api",
+        label: "API",
+        description: "Publish or automate with the REST API and OpenAPI.",
+        href: "https://spacefast.com/docs/api",
+        icon: "api",
+    },
+];
+const CHECKED_AT = "2026-08-23";
+const SPACEFAST_PLUGINS_REPO = "https://github.com/spacefast/plugins";
+const SPACEFAST_DOCS = "https://spacefast.com/docs/agents";
+const SPACEFAST_SKILL = "https://spacefast.com/SKILL.md";
+/**
+ * Interactive-primary ranking is the conversion ladder, stated once as data:
+ * a button beats a paste beats a terminal. An explicit full setup command may
+ * lead when it is the cleanest client path; raw client-specific MCP commands
+ * stay out of the interactive context.
+ */
+const PRIMARY_RANK = {
+    deeplink: 10,
+    download: 15,
+    plugin: 20,
+    nativeFlow: 30,
+    /** Only where the skill IS the client's whole integration (Continue). */
+    skill: 35,
+    config: 50,
+    /** A listing that is not live yet: rendered as a "soon" chip, never leading. */
+    soon: 60,
+};
+/**
+ * The terminal lane, ordered by the npx priority rule: our own installer leads
+ * for clients the CLI drives as machine clients, the universal skills installer
+ * carries the long tail, and the client's own commands sit between them.
+ */
+const TERMINAL_RANK = {
+    cliSetup: 5,
+    npxSetup: 7,
+    npxPlugin: 8,
+    plugin: 10,
+    command: 20,
+    config: 30,
+    skill: 40,
+    // Last of the terminal lanes: it publishes rather than sets anything up, so
+    // it is what a reader reaches after the lanes that make `sf` exist.
+    gitPush: 50,
+};
+function verification(sourceUrl, evidence) {
+    const result = {
+        checkedAt: CHECKED_AT,
+        sourceUrl,
+        status: "declared",
+    };
+    if (evidence !== undefined)
+        result.evidence = evidence;
+    return result;
+}
+function methodBase(input) {
+    const listing = {
+        checkedAt: CHECKED_AT,
+        status: input.listingStatus ?? "live",
+    };
+    if (input.listingUrl !== undefined)
+        listing.url = input.listingUrl;
+    const method = {
+        authLane: input.authLane,
+        availability: { clients: [input.agentId] },
+        docsUrl: input.docsUrl ?? SPACEFAST_DOCS,
+        id: input.id,
+        label: input.label,
+        listing,
+        rank: input.rank,
+        summary: input.summary,
+        verification: verification(input.sourceUrl),
+    };
+    if (input.tokenSlot !== undefined)
+        method.tokenSlot = input.tokenSlot;
+    if (input.vendorDocs !== undefined)
+        method.vendorDocs = input.vendorDocs;
+    return method;
+}
+function hostedConfig(agentId, path, language, build, sourceUrl) {
+    return {
+        ...methodBase({
+            agentId,
+            authLane: "oauth",
+            id: "hosted-mcp-config",
+            label: `Configure ${path}`,
+            rank: {
+                "interactive-primary": PRIMARY_RANK.config,
+                "machine-installer": 20,
+                "static-docs": 30,
+                "terminal-alternates": TERMINAL_RANK.config,
+            },
+            sourceUrl,
+            summary: "Merge the hosted Spacefast server into the client MCP configuration.",
+        }),
+        build,
+        kind: "config",
+        language,
+        path,
+    };
+}
+/**
+ * A client whose only first-party lane is its own settings form (Raycast,
+ * Indent). The value is the endpoint the user pastes; `path` names where. It
+ * outranks the generic prompt because it is the best method that actually
+ * completes setup for that client, and it sits below deeplinks and plugins.
+ */
+function hostedFormConfig(agentId, path, sourceUrl, summary) {
+    return {
+        ...methodBase({
+            agentId,
+            authLane: "oauth",
+            id: "hosted-mcp-form",
+            label: "Add the hosted MCP server",
+            rank: {
+                "interactive-primary": PRIMARY_RANK.nativeFlow,
+                "static-docs": 12,
+            },
+            sourceUrl,
+            summary: summary ?? `Paste the Spacefast endpoint into ${path} and approve OAuth in the browser.`,
+        }),
+        build: (context) => context.mcpEndpoint,
+        kind: "config",
+        language: "text",
+        path,
+    };
+}
+/**
+ * A client's own plugin install, in that client's own commands.
+ *
+ * BOOTSTRAP RULE: nothing rendered here may assume `sf` is already installed.
+ * A page that answers "how do I connect this?" with `sf plugins …` has answered
+ * a different question — how do I connect this, given I already installed the
+ * thing I am trying to install. So the shell commands are the vendor's
+ * (`claude plugin …`, `codex plugin …`, `droid plugin …`) or a pinned `npx`
+ * invocation. `installerTargets` is separate metadata: it is the `sf plugins`
+ * gate, not the rendered command.
+ */
+function plugin(input) {
+    const method = {
+        ...methodBase({
+            agentId: input.agentId,
+            authLane: "oauth",
+            id: "plugin",
+            label: "Install the Spacefast plugin",
+            rank: {
+                "interactive-primary": PRIMARY_RANK.plugin,
+                "machine-installer": 30,
+                "static-docs": 10,
+                "terminal-alternates": TERMINAL_RANK.plugin,
+            },
+            sourceUrl: input.sourceUrl,
+            summary: input.summary,
+            vendorDocs: input.vendorDocs,
+        }),
+        authPolicy: "on-install",
+        commands: { inSession: [], shell: input.shell },
+        kind: "plugin",
+        marketplace: { id: "spacefast", url: input.marketplaceUrl ?? SPACEFAST_PLUGINS_REPO },
+    };
+    return input.installerTargets === undefined
+        ? method
+        : { ...method, installerTargets: input.installerTargets };
+}
+/** The universal plugin installer, for the targets it actually implements. */
+function npxPluginInstall(agentId, sourceUrl) {
+    return {
+        ...methodBase({
+            agentId,
+            authLane: "oauth",
+            id: "npx-plugin-install",
+            label: "Install with npx plugins",
+            rank: { "terminal-alternates": TERMINAL_RANK.npxPlugin },
+            sourceUrl,
+            summary: "Install the plugin with the universal installer — nothing to install first.",
+        }),
+        authPolicy: "on-install",
+        commands: {
+            inSession: [],
+            shell: [`npx -y ${PLUGINS_CLI_PACKAGE_SPEC} add spacefast/plugins -t ${agentId} -y`],
+        },
+        installerTargets: [agentId],
+        kind: "plugin",
+        marketplace: { id: "spacefast", url: SPACEFAST_PLUGINS_REPO },
+    };
+}
+function cliSetup(agentId, options = {}) {
+    const rank = {
+        "machine-installer": 5,
+        "terminal-alternates": TERMINAL_RANK.cliSetup,
+    };
+    return {
+        ...methodBase({
+            agentId,
+            authLane: "oauth",
+            id: "cli-setup",
+            label: "Set up with the Spacefast CLI",
+            rank: options.interactive
+                ? { ...rank, "interactive-primary": PRIMARY_RANK.nativeFlow }
+                : rank,
+            sourceUrl: "https://spacefast.com/docs/cli",
+            summary: options.skillOnly
+                ? "Install the CLI once, then let it install the Spacefast skill for this agent."
+                : "Install the CLI once, then let it write MCP config, install the skill, and sign you in.",
+        }),
+        build: () => ["npm install -g spacefast", `sf setup agent --agent ${agentId}`],
+        kind: "command",
+    };
+}
+/** The same setup with nothing installed globally. */
+function npxSetup(agentId, options = {}) {
+    return {
+        ...methodBase({
+            agentId,
+            authLane: "oauth",
+            id: "npx-setup",
+            label: "Set up without installing",
+            rank: {
+                "machine-installer": 7,
+                "terminal-alternates": TERMINAL_RANK.npxSetup,
+            },
+            sourceUrl: "https://spacefast.com/docs/cli",
+            summary: options.skillOnly
+                ? "Install the same Spacefast skill in one shot, with nothing left behind."
+                : "One-shot setup with no global install — same work, nothing left behind.",
+        }),
+        build: (context) => [
+            `npx -y ${context.packageSpecs?.spacefastCli ?? SPACEFAST_CLI_PACKAGE_SPEC} setup agent --agent ${agentId} -y`,
+        ],
+        kind: "command",
+    };
+}
+/**
+ * Push to deploy: the space's git remote is a real remote, and a push to it
+ * publishes.
+ *
+ * This is the one terminal lane that is not a setup step — nothing is
+ * installed and nothing is configured. It belongs here because for an agent
+ * already working in a git checkout it is the shortest path to a live URL, and
+ * because the push's own output carries the receipt back (live URL, version
+ * URL, and for an anonymous space the claim link), so the agent does not have
+ * to make a second call to learn where the site went.
+ *
+ * The remote is credential-free by design; the token rides in the HTTP Basic
+ * password slot as user `t`, which is why this method declares a token slot.
+ * The exact URL for a given space is on every publish receipt and on the Space
+ * resource as `git.remoteUrl` — this rendering shows its shape.
+ */
+function gitPushDeploy(agentId) {
+    return {
+        ...methodBase({
+            agentId,
+            authLane: "token-slot",
+            id: "git-push",
+            label: "Push to deploy",
+            // Terminal lane only. This method connects nothing and installs nothing,
+            // so it must not compete in `machine-installer` (which picks what `sf
+            // setup agent` runs) or in `static-docs` (whose per-client table answers
+            // "connect with what?" — an answer this is not). The machine artifacts
+            // carry push-to-deploy as its own prose section instead.
+            rank: { "terminal-alternates": TERMINAL_RANK.gitPush },
+            sourceUrl: "https://spacefast.com/docs/git-push",
+            summary: "Push to deploy — output returns your live and claim links.",
+            tokenSlot: { accepts: ["api-key"], location: "command", placeholder: "{{token}}" },
+        }),
+        build: (context) => [
+            `git remote add spacefast ${pushRemoteTemplate(context)}`,
+            "git push spacefast main",
+        ],
+        kind: "command",
+    };
+}
+/**
+ * The shape of a space's push remote. `{{space}}` is the space slug and
+ * `{{token}}` a space key or API key; a publish receipt hands back the resolved
+ * URL in `git.remoteUrl`, so nothing has to reconstruct this by hand.
+ */
+function pushRemoteTemplate(context) {
+    const origin = context.pushOrigin ?? serviceOrigin("push", "prod");
+    return `${origin.replace(/\/$/, "")}/{{space}}.git`.replace("://", "://t:{{token}}@");
+}
+/** Every terminal lane a machine client supports, ordered by the npx priority rule. */
+function terminalLanes(agentId, options = {}) {
+    return [cliSetup(agentId, options), npxSetup(agentId, options), gitPushDeploy(agentId)];
+}
+/**
+ * A store listing that is not live yet. It carries no commands on purpose — it
+ * presents as a disabled "soon" affordance and is ranked below every working
+ * method, so a page always leads with something that works (spec §8.2).
+ */
+function pluginMarketplace(agentId, sourceUrl, listingStatus) {
+    return {
+        ...methodBase({
+            agentId,
+            authLane: "oauth",
+            id: "plugin-marketplace",
+            label: "Install from the plugin marketplace",
+            listingStatus,
+            listingUrl: sourceUrl,
+            rank: { "interactive-primary": PRIMARY_RANK.soon, "static-docs": 15 },
+            sourceUrl,
+            summary: "The public marketplace listing is not live yet.",
+        }),
+        authPolicy: "on-install",
+        commands: { inSession: [], shell: [] },
+        kind: "plugin",
+        marketplace: { id: "spacefast", url: sourceUrl },
+    };
+}
+// TODO(skill-ids): spec §5.9 wants verb-noun skill ids for skills.sh ranking
+// (`publish-to-spacefast`, mirroring `deploy-to-vercel`). The shipped skill is
+// named `spacefast` — frontmatter `name:`, `plugins/*/skills/spacefast/`, and
+// every install command — so this reference names what we actually ship. Renaming
+// the skill is a coordinated change across the generators and both plugin trees.
+const SHIPPED_SKILL_ID = "spacefast";
+function skill(agentId, options = {}) {
+    // Continue reads `.claude/skills` natively and offers nothing else — for it
+    // the skill is not an alternate, it is the integration.
+    const rank = {
+        "machine-installer": 40,
+        "static-docs": 40,
+        "terminal-alternates": TERMINAL_RANK.skill,
+    };
+    const presentedRank = options.interactive
+        ? { ...rank, "interactive-primary": PRIMARY_RANK.skill }
+        : rank;
+    return {
+        ...methodBase({
+            agentId,
+            authLane: "anonymous",
+            id: "skill",
+            label: "Install the Spacefast skill",
+            rank: presentedRank,
+            sourceUrl: options.sourceUrl ?? SPACEFAST_SKILL,
+            summary: "Install publish and hosting guidance using the Agent Skills standard.",
+        }),
+        kind: "skill",
+        lane: "cli",
+        source: { id: SHIPPED_SKILL_ID, url: SPACEFAST_SKILL },
+    };
+}
+function universalPrompt(agentId, options = {}) {
+    const rank = { "static-docs": 50 };
+    const presentedRank = options.interactive
+        ? { ...rank, "interactive-primary": PRIMARY_RANK.nativeFlow }
+        : rank;
+    return {
+        ...methodBase({
+            agentId,
+            authLane: "anonymous",
+            id: "universal-prompt",
+            label: "Copy setup prompt",
+            // Usually the universal dock owns this one-paste affordance. Skill-native
+            // clients with no direct Spacefast integration use it as their registry
+            // primary too; the setup page leaves prompt primaries to the dock.
+            rank: presentedRank,
+            docsUrl: "https://spacefast.com/setup.md",
+            sourceUrl: "https://spacefast.com/setup.md",
+            summary: "Give the agent one prompt that lets it choose and complete the best setup lane.",
+        }),
+        build: (context) => `Fetch ${context.wwwOrigin}/setup.md`,
+        kind: "prompt",
+    };
+}
+function deeplink(input) {
+    const baseInput = {
+        agentId: input.agentId,
+        authLane: "oauth",
+        id: "deeplink",
+        label: input.label,
+        rank: { "interactive-primary": PRIMARY_RANK.deeplink, "static-docs": 15 },
+        sourceUrl: input.sourceUrl,
+        summary: input.summary,
+    };
+    if (input.listingStatus !== undefined)
+        baseInput.listingStatus = input.listingStatus;
+    return {
+        ...methodBase(baseInput),
+        build: input.build,
+        // The kind is a placeholder: entry() resolves it against the sibling method
+        // that `fallbackId` names, and throws when nothing resolves.
+        fallback: { id: input.fallbackId, kind: "deeplink" },
+        kind: "deeplink",
+    };
+}
+/**
+ * The generic hosted-MCP entry, for any client whose config is an `mcpServers`
+ * map. `type: "http"` is load-bearing and not decoration: Claude Code rejects a
+ * bare `{ url }` outright and VS Code reads one as a stdio command, so a bare
+ * url is not a smaller version of this — it is a broken version of it.
+ */
+export function hostedMcpServersConfig(context) {
+    return jsonHostedConfig("mcpServers")(context);
+}
+function jsonHostedConfig(root) {
+    return (context) => JSON.stringify({
+        [root]: {
+            spacefast: root === "mcp"
+                ? { enabled: true, type: "remote", url: context.mcpEndpoint }
+                : root === "context_servers"
+                    ? { settings: {}, source: "custom", url: context.mcpEndpoint }
+                    : { type: "http", url: context.mcpEndpoint },
+        },
+    }, null, 2);
+}
+/**
+ * Applies the two invariants a hand-written method array cannot hold on its own:
+ * every deeplink's declared fallback resolves to a sibling method (and takes that
+ * sibling's real kind), and any probe result recorded for a deeplink overrides
+ * its `declared` verification status.
+ */
+function resolveMethods(agentId, methods) {
+    return methods.map((method) => {
+        if (method.kind !== "deeplink")
+            return method;
+        const target = methods.find((candidate) => candidate.id === method.fallback.id);
+        if (!target || target === method) {
+            throw new TypeError(`Agent ${agentId} deeplink "${method.id}" declares fallback "${method.fallback.id}", which is not one of its methods.`);
+        }
+        const probe = DEEPLINK_PROBE_RESULTS[`${agentId}:${method.id}`];
+        const probed = { ...method.verification };
+        if (probe) {
+            probed.checkedAt = probe.checkedAt;
+            probed.status = probe.status;
+            if (probe.evidence !== undefined)
+                probed.evidence = probe.evidence;
+        }
+        return {
+            ...method,
+            fallback: { id: target.id, kind: target.kind },
+            verification: probed,
+        };
+    });
+}
+function entry(input) {
+    return {
+        ...input,
+        icon: input.icon ?? input.id,
+        legacyResultAliases: input.legacyResultAliases ?? [],
+        methods: resolveMethods(input.id, input.methods),
+        monogram: input.monogram ?? input.name.slice(0, 2),
+        verification: verification(input.docs.vendor),
+    };
+}
+const claudeCodeSource = "https://docs.anthropic.com/en/docs/claude-code/mcp";
+const claudeAppSource = "https://claude.com/docs/connectors/building/directory-vs-custom";
+const cursorSource = "https://docs.cursor.com/context/model-context-protocol";
+const codexSource = "https://developers.openai.com/codex/mcp";
+const chatgptSource = "https://platform.openai.com/docs/guides/developer-mode";
+const vscodeSource = "https://code.visualstudio.com/docs/copilot/chat/mcp-servers";
+export const AGENT_REGISTRY = [
+    entry({
+        id: "claude-code",
+        aliases: ["claude", "claude cli", "claude-code-cli"],
+        name: "Claude Code",
+        vendor: "Anthropic",
+        description: "Publish, host, and operate Spacefast artifacts from Claude Code.",
+        detectionHints: ["CLAUDECODE", ".claude"],
+        kind: "coding-agent",
+        tier: "featured",
+        wizardGroup: "claude",
+        capabilities: ["skills", "mcp-local", "mcp-oauth", "plugin"],
+        skills: { agentsDirs: true, claudeDirs: true },
+        agentsMd: "native",
+        docs: { spacefast: "https://spacefast.com/setup/claude-code", vendor: claudeCodeSource },
+        machineClient: true,
+        redeemableClientTargetId: "claude-code",
+        legacyResultAliases: ["claude-code", "claude"],
+        methods: [
+            plugin({
+                agentId: "claude-code",
+                installerTargets: ["claude-code"],
+                shell: [
+                    "claude plugin marketplace add spacefast/plugins",
+                    "claude plugin install spacefast@spacefast",
+                ],
+                sourceUrl: "https://docs.anthropic.com/en/docs/claude-code/plugin-marketplaces",
+                summary: "Add the Spacefast marketplace and install the plugin with Claude Code itself.",
+                vendorDocs: {
+                    href: "https://docs.anthropic.com/en/docs/claude-code/plugin-marketplaces",
+                    label: "Claude's official docs",
+                },
+            }),
+            npxPluginInstall("claude-code", "https://docs.anthropic.com/en/docs/claude-code/plugin-marketplaces"),
+            ...terminalLanes("claude-code"),
+            skill("claude-code"),
+            universalPrompt("claude-code"),
+        ],
+    }),
+    entry({
+        id: "claude-app",
+        aliases: ["claude ai", "claude.ai", "claude web", "claude cowork"],
+        name: "Claude",
+        vendor: "Anthropic",
+        description: "Connect Spacefast to Claude on the web, mobile, and Cowork with one click.",
+        detectionHints: [],
+        kind: "chat-app",
+        tier: "featured",
+        wizardGroup: "claude",
+        capabilities: ["mcp-oauth", "deeplink-only", "plugin"],
+        skills: { agentsDirs: false, claudeDirs: false },
+        agentsMd: "none",
+        docs: { spacefast: "https://spacefast.com/setup/claude-app", vendor: claudeAppSource },
+        legacyResultAliases: ["claude-ai", "claude-cowork"],
+        methods: [
+            deeplink({
+                agentId: "claude-app",
+                build: (context) => `https://claude.ai/customize/connectors?modal=add-custom-connector&connectorName=Spacefast&connectorUrl=${encodeURIComponent(context.mcpEndpoint)}`,
+                fallbackId: "universal-prompt",
+                label: "Add to Claude",
+                sourceUrl: claudeAppSource,
+                summary: "Open Claude's connector form with Spacefast filled in.",
+            }),
+            universalPrompt("claude-app"),
+        ],
+    }),
+    entry({
+        id: "claude-desktop",
+        aliases: ["claude desktop", "claude for mac", "claude for windows"],
+        name: "Claude Desktop",
+        vendor: "Anthropic",
+        description: "Install Spacefast in Claude Desktop as a signed local extension.",
+        detectionHints: [],
+        kind: "chat-app",
+        tier: "featured",
+        wizardGroup: "claude",
+        capabilities: ["mcp-oauth", "mcp-local"],
+        skills: { agentsDirs: false, claudeDirs: false },
+        agentsMd: "none",
+        docs: {
+            spacefast: "https://spacefast.com/setup/claude-desktop",
+            vendor: "https://github.com/modelcontextprotocol/mcpb",
+        },
+        notes: [
+            "Connectors added on claude.ai sync down to Desktop; the bundle is the desktop-only lane.",
+        ],
+        methods: [
+            {
+                ...methodBase({
+                    agentId: "claude-desktop",
+                    authLane: "oauth",
+                    id: "desktop-extension",
+                    label: "Download desktop extension",
+                    rank: {
+                        "interactive-primary": PRIMARY_RANK.download,
+                        "static-docs": 10,
+                        "terminal-alternates": 15,
+                    },
+                    sourceUrl: "https://github.com/modelcontextprotocol/mcpb",
+                    summary: "Install the signed Spacefast MCP bundle — double-click, nothing to configure.",
+                }),
+                kind: "download",
+                url: () => "https://github.com/spacefast/plugins/releases/latest/download/claude-desktop.mcpb",
+            },
+            hostedConfig("claude-desktop", "claude_desktop_config.json", "json", jsonHostedConfig("mcpServers"), "https://support.claude.com/en/articles/10949351-getting-started-with-local-mcp-servers-on-claude-desktop"),
+            universalPrompt("claude-desktop"),
+        ],
+    }),
+    entry({
+        id: "cursor",
+        aliases: ["cursor editor"],
+        name: "Cursor",
+        vendor: "Cursor",
+        description: "Publish and host from Cursor with its plugin, skills, and hosted MCP.",
+        detectionHints: ["CURSOR_TRACE_ID", ".cursor"],
+        kind: "editor",
+        tier: "featured",
+        wizardGroup: "coding-agents",
+        capabilities: ["skills", "mcp-local", "mcp-oauth", "plugin"],
+        skills: { agentsDirs: true, claudeDirs: true },
+        agentsMd: "native",
+        docs: { spacefast: "https://spacefast.com/setup/cursor", vendor: cursorSource },
+        machineClient: true,
+        redeemableClientTargetId: "cursor",
+        legacyResultAliases: ["cursor"],
+        methods: [
+            plugin({
+                agentId: "cursor",
+                installerTargets: ["cursor"],
+                shell: [`npx -y ${PLUGINS_CLI_PACKAGE_SPEC} add spacefast/plugins -t cursor -y`],
+                sourceUrl: "https://docs.cursor.com/plugins",
+                summary: "Install the plugin, its rules, and MCP into Cursor with nothing installed first.",
+            }),
+            ...terminalLanes("cursor"),
+            pluginMarketplace("cursor", "https://docs.cursor.com/plugins", "planned"),
+            deeplink({
+                agentId: "cursor",
+                build: (context) => `https://cursor.com/install-mcp?name=spacefast&config=${encodeURIComponent(base64Utf8(JSON.stringify({ url: context.mcpEndpoint })))}`,
+                fallbackId: "hosted-mcp-config",
+                label: "Add to Cursor",
+                sourceUrl: cursorSource,
+                summary: "Add Spacefast hosted MCP to Cursor in one click.",
+            }),
+            hostedConfig("cursor", "~/.cursor/mcp.json", "json", jsonHostedConfig("mcpServers"), cursorSource),
+            skill("cursor"),
+            universalPrompt("cursor"),
+        ],
+    }),
+    entry({
+        id: "codex",
+        aliases: ["codex cli", "openai codex"],
+        name: "Codex",
+        vendor: "OpenAI",
+        description: "Publish and host from Codex locally or in the cloud.",
+        detectionHints: ["CODEX_HOME", ".codex"],
+        kind: "coding-agent",
+        tier: "featured",
+        wizardGroup: "openai",
+        capabilities: ["skills", "mcp-local", "mcp-oauth", "plugin"],
+        skills: { agentsDirs: true, claudeDirs: false },
+        agentsMd: "native",
+        docs: { spacefast: "https://spacefast.com/setup/codex", vendor: codexSource },
+        machineClient: true,
+        redeemableClientTargetId: "codex",
+        legacyResultAliases: ["codex"],
+        methods: [
+            plugin({
+                agentId: "codex",
+                installerTargets: ["codex"],
+                shell: [
+                    "codex plugin marketplace add spacefast/plugins",
+                    "codex plugin add spacefast@spacefast",
+                ],
+                sourceUrl: "https://developers.openai.com/codex/plugins",
+                summary: "Add the Spacefast marketplace and install the plugin with Codex itself.",
+            }),
+            npxPluginInstall("codex", "https://developers.openai.com/codex/plugins"),
+            ...terminalLanes("codex"),
+            hostedConfig("codex", "~/.codex/config.toml", "toml", (context) => `[mcp_servers.spacefast]\nurl = ${JSON.stringify(context.mcpEndpoint)}`, codexSource),
+            skill("codex"),
+            universalPrompt("codex"),
+        ],
+    }),
+    entry({
+        id: "chatgpt",
+        aliases: ["chat gpt", "chatgpt work", "chatgpt-work", "custom gpt", "openai apps"],
+        name: "ChatGPT",
+        vendor: "OpenAI",
+        description: "Use Spacefast from ChatGPT and ChatGPT Work through the app directory.",
+        detectionHints: [],
+        kind: "chat-app",
+        tier: "featured",
+        wizardGroup: "openai",
+        capabilities: ["mcp-oauth", "deeplink-only", "plugin"],
+        skills: { agentsDirs: false, claudeDirs: false },
+        agentsMd: "none",
+        docs: { spacefast: "https://spacefast.com/setup/chatgpt", vendor: chatgptSource },
+        methods: [
+            deeplink({
+                agentId: "chatgpt",
+                build: () => "https://chatgpt.com/plugins",
+                fallbackId: "hosted-mcp-form",
+                label: "Find Spacefast in ChatGPT",
+                listingStatus: "submitted",
+                sourceUrl: "https://platform.openai.com/plugins",
+                summary: "Install from the ChatGPT and Codex plugin directory — the only lane that reaches consumer accounts with write tools.",
+            }),
+            // The dev-mode connector is a settings form, not a config file: ChatGPT has
+            // no `mcpServers` file to merge into. The workspace restriction lives on
+            // THIS method, not on the directory listing above — a published app is
+            // exactly what escapes it, so putting the caveat on the listing inverts it.
+            hostedFormConfig("chatgpt", "Settings → Connectors → Advanced → Developer mode → Add custom connector", chatgptSource, "Add Spacefast as a custom connector and approve OAuth in the browser. Web only; write tools need a Business or Enterprise workspace, and consumer Pro is read-only."),
+            universalPrompt("chatgpt"),
+        ],
+    }),
+    entry({
+        id: "vscode",
+        aliases: ["visual studio code", "copilot chat"],
+        name: "VS Code",
+        vendor: "Microsoft",
+        description: "Add Spacefast MCP to VS Code and Copilot agent mode.",
+        detectionHints: ["VSCODE_PID", ".vscode"],
+        kind: "editor",
+        tier: "featured",
+        wizardGroup: "coding-agents",
+        capabilities: ["skills", "mcp-local", "mcp-oauth", "deeplink-only"],
+        skills: { agentsDirs: true, claudeDirs: false },
+        agentsMd: "native",
+        docs: { spacefast: "https://spacefast.com/setup/vscode", vendor: vscodeSource },
+        machineClient: true,
+        redeemableClientTargetId: "vscode",
+        legacyResultAliases: ["vscode", "copilot"],
+        methods: [
+            deeplink({
+                agentId: "vscode",
+                build: (context) => `https://vscode.dev/redirect/mcp/install?name=spacefast&config=${encodeURIComponent(JSON.stringify({ type: "http", url: context.mcpEndpoint }))}`,
+                fallbackId: "hosted-mcp-config",
+                label: "Add to VS Code",
+                sourceUrl: vscodeSource,
+                summary: "Add Spacefast hosted MCP to VS Code in one click.",
+            }),
+            plugin({
+                agentId: "vscode",
+                installerTargets: ["vscode"],
+                shell: [`npx -y ${PLUGINS_CLI_PACKAGE_SPEC} add spacefast/plugins -t vscode -y`],
+                sourceUrl: vscodeSource,
+                summary: "Install the plugin and its MCP server into VS Code with nothing installed first.",
+            }),
+            ...terminalLanes("vscode"),
+            hostedConfig("vscode", ".vscode/mcp.json", "jsonc", jsonHostedConfig("servers"), vscodeSource),
+            skill("vscode"),
+            universalPrompt("vscode"),
+        ],
+    }),
+    entry({
+        id: "github-copilot",
+        aliases: ["copilot", "github copilot", "copilot cli"],
+        name: "GitHub Copilot",
+        vendor: "GitHub",
+        description: "Publish from Copilot CLI and coding agent with native plugin and MCP support.",
+        detectionHints: [".copilot"],
+        kind: "coding-agent",
+        tier: "listed",
+        wizardGroup: "coding-agents",
+        capabilities: ["skills", "mcp-local", "mcp-oauth", "plugin"],
+        skills: { agentsDirs: true, claudeDirs: true },
+        agentsMd: "native",
+        docs: {
+            spacefast: "https://spacefast.com/setup/github-copilot",
+            vendor: "https://docs.github.com/copilot/customizing-copilot/extending-copilot-chat-with-mcp",
+        },
+        machineClient: true,
+        methods: [
+            plugin({
+                agentId: "github-copilot",
+                installerTargets: ["github-copilot"],
+                shell: [`npx -y ${PLUGINS_CLI_PACKAGE_SPEC} add spacefast/plugins -t github-copilot -y`],
+                sourceUrl: "https://github.com/github/awesome-copilot",
+                summary: "Install the plugin's skills and MCP into Copilot with nothing installed first.",
+            }),
+            ...terminalLanes("github-copilot"),
+            pluginMarketplace("github-copilot", "https://github.com/github/awesome-copilot", "planned"),
+            skill("github-copilot"),
+            universalPrompt("github-copilot"),
+        ],
+    }),
+    entry({
+        id: "devin-desktop",
+        aliases: ["windsurf", "devin cli", "devin-desktop"],
+        name: "Devin Desktop",
+        vendor: "Cognition",
+        description: "Connect the local Devin desktop and CLI configuration plane.",
+        detectionHints: [".devin", ".codeium/windsurf"],
+        kind: "editor",
+        tier: "listed",
+        wizardGroup: "coding-agents",
+        capabilities: ["skills", "mcp-local", "mcp-oauth"],
+        skills: { agentsDirs: true, claudeDirs: false },
+        agentsMd: "native",
+        docs: {
+            spacefast: "https://spacefast.com/setup/devin-desktop",
+            vendor: "https://docs.devin.ai/work-with-devin/devin-desktop/mcp",
+        },
+        machineClient: true,
+        methods: [
+            hostedConfig("devin-desktop", "~/.devin/mcp_config.json", "json", jsonHostedConfig("mcpServers"), "https://docs.devin.ai/work-with-devin/devin-desktop/mcp"),
+            ...terminalLanes("devin-desktop"),
+            skill("devin-desktop"),
+            universalPrompt("devin-desktop"),
+        ],
+    }),
+    entry({
+        id: "devin-cloud",
+        aliases: ["devin", "devin ai", "app.devin.ai"],
+        name: "Devin Cloud",
+        vendor: "Cognition",
+        description: "Connect Spacefast in Devin's cloud-only integrations plane.",
+        detectionHints: [],
+        kind: "chat-app",
+        tier: "listed",
+        wizardGroup: "mcp-apps",
+        capabilities: ["skills", "mcp-oauth"],
+        skills: { agentsDirs: true, claudeDirs: false },
+        agentsMd: "native",
+        docs: {
+            spacefast: "https://spacefast.com/setup/devin-cloud",
+            vendor: "https://docs.devin.ai/integrations/mcp",
+        },
+        methods: [
+            hostedFormConfig("devin-cloud", "Settings \u2192 Connections \u2192 MCP servers \u2192 Add custom MCP", "https://docs.devin.ai/integrations/mcp"),
+            skill("devin-cloud"),
+            universalPrompt("devin-cloud"),
+        ],
+    }),
+    entry({
+        id: "zed",
+        aliases: ["zed editor"],
+        name: "Zed",
+        vendor: "Zed Industries",
+        description: "Connect Spacefast as a custom context server in Zed.",
+        detectionHints: [".config/zed"],
+        kind: "editor",
+        tier: "listed",
+        wizardGroup: "coding-agents",
+        capabilities: ["skills", "mcp-oauth"],
+        skills: { agentsDirs: true, claudeDirs: false },
+        agentsMd: "opt-in",
+        docs: {
+            spacefast: "https://spacefast.com/setup/zed",
+            vendor: "https://zed.dev/docs/assistant/model-context-protocol",
+        },
+        machineClient: true,
+        methods: [
+            hostedConfig("zed", "~/.config/zed/settings.json", "jsonc", jsonHostedConfig("context_servers"), "https://zed.dev/docs/assistant/model-context-protocol"),
+            ...terminalLanes("zed"),
+            skill("zed"),
+            universalPrompt("zed"),
+        ],
+    }),
+    entry({
+        id: "gemini-cli",
+        aliases: ["gemini", "google gemini cli"],
+        name: "Gemini CLI",
+        vendor: "Google",
+        description: "Use the Spacefast extension, skills, and OAuth MCP from Gemini CLI.",
+        detectionHints: [".gemini"],
+        kind: "coding-agent",
+        tier: "listed",
+        wizardGroup: "coding-agents",
+        capabilities: ["skills", "mcp-local", "mcp-oauth", "plugin"],
+        skills: { agentsDirs: true, claudeDirs: false },
+        agentsMd: "opt-in",
+        docs: {
+            spacefast: "https://spacefast.com/setup/gemini-cli",
+            vendor: "https://geminicli.com/docs/tools/mcp-server",
+        },
+        machineClient: true,
+        methods: [
+            pluginMarketplace("gemini-cli", "https://geminicli.com/docs/extensions", "planned"),
+            hostedConfig("gemini-cli", "~/.gemini/settings.json", "json", (context) => JSON.stringify({
+                mcpServers: { spacefast: { httpUrl: context.mcpEndpoint, oauth: { enabled: true } } },
+            }, null, 2), "https://geminicli.com/docs/tools/mcp-server"),
+            ...terminalLanes("gemini-cli"),
+            skill("gemini-cli"),
+            universalPrompt("gemini-cli"),
+        ],
+    }),
+    entry({
+        id: "opencode",
+        aliases: ["open code"],
+        name: "OpenCode",
+        vendor: "Anomaly",
+        description: "Connect Spacefast to OpenCode with native OAuth MCP and skills.",
+        detectionHints: [".config/opencode"],
+        kind: "coding-agent",
+        tier: "listed",
+        wizardGroup: "coding-agents",
+        capabilities: ["skills", "mcp-local", "mcp-oauth"],
+        skills: { agentsDirs: true, claudeDirs: true },
+        agentsMd: "native",
+        docs: {
+            spacefast: "https://spacefast.com/setup/opencode",
+            vendor: "https://opencode.ai/docs/mcp-servers",
+        },
+        machineClient: true,
+        methods: [
+            hostedConfig("opencode", "~/.config/opencode/opencode.json", "jsonc", jsonHostedConfig("mcp"), "https://opencode.ai/docs/mcp-servers"),
+            ...terminalLanes("opencode"),
+            skill("opencode"),
+            universalPrompt("opencode"),
+        ],
+    }),
+    entry({
+        id: "amp",
+        aliases: ["sourcegraph amp"],
+        name: "Amp",
+        vendor: "Amp",
+        description: "Install Spacefast skills with bundled MCP support in Amp.",
+        detectionHints: [".config/amp"],
+        kind: "coding-agent",
+        tier: "listed",
+        wizardGroup: "coding-agents",
+        capabilities: ["skills", "mcp-local", "mcp-oauth", "plugin"],
+        skills: { agentsDirs: true, claudeDirs: true },
+        agentsMd: "native",
+        docs: {
+            spacefast: "https://spacefast.com/setup/amp",
+            vendor: "https://ampcode.com/manual#mcp",
+        },
+        machineClient: true,
+        methods: [
+            hostedConfig("amp", "~/.config/amp/mcp.json", "json", jsonHostedConfig("mcpServers"), "https://ampcode.com/manual#mcp"),
+            ...terminalLanes("amp", { interactive: true }),
+            skill("amp"),
+            universalPrompt("amp"),
+        ],
+    }),
+    entry({
+        id: "warp",
+        aliases: ["warp terminal"],
+        name: "Warp",
+        vendor: "Warp",
+        description: "Use Spacefast skills and MCP in Warp agents.",
+        detectionHints: [".warp"],
+        kind: "coding-agent",
+        tier: "listed",
+        wizardGroup: "coding-agents",
+        capabilities: ["skills", "mcp-local", "mcp-oauth", "deeplink-only"],
+        skills: { agentsDirs: true, claudeDirs: false },
+        agentsMd: "opt-in",
+        docs: {
+            spacefast: "https://spacefast.com/setup/warp",
+            vendor: "https://docs.warp.dev/knowledge-and-collaboration/mcp",
+        },
+        machineClient: true,
+        methods: [
+            deeplink({
+                agentId: "warp",
+                build: () => "warp://settings/mcp",
+                fallbackId: "hosted-mcp-config",
+                label: "Open Warp MCP settings",
+                sourceUrl: "https://docs.warp.dev/knowledge-and-collaboration/mcp",
+                summary: "Open Warp's MCP settings and add Spacefast.",
+            }),
+            hostedConfig("warp", "~/.warp/mcp.json", "json", jsonHostedConfig("mcpServers"), "https://docs.warp.dev/knowledge-and-collaboration/mcp"),
+            ...terminalLanes("warp"),
+            skill("warp"),
+            universalPrompt("warp"),
+        ],
+    }),
+    entry({
+        id: "factory-droid",
+        aliases: ["droid", "factory"],
+        name: "Factory Droid",
+        vendor: "Factory",
+        description: "Install Spacefast as a Droid plugin or native OAuth MCP server.",
+        detectionHints: [".factory"],
+        kind: "coding-agent",
+        tier: "listed",
+        wizardGroup: "coding-agents",
+        capabilities: ["skills", "mcp-local", "mcp-oauth", "plugin"],
+        skills: { agentsDirs: true, claudeDirs: true },
+        agentsMd: "native",
+        docs: {
+            spacefast: "https://spacefast.com/setup/factory-droid",
+            vendor: "https://docs.factory.ai/cli/configuration/mcp",
+        },
+        machineClient: true,
+        methods: [
+            plugin({
+                agentId: "factory-droid",
+                shell: [
+                    "droid plugin marketplace add spacefast/plugins",
+                    "droid plugin install spacefast@spacefast",
+                ],
+                sourceUrl: "https://docs.factory.ai/cli/configuration/plugins",
+                summary: "Add the Spacefast marketplace to Droid and install the plugin.",
+            }),
+            ...terminalLanes("factory-droid"),
+            skill("factory-droid"),
+            universalPrompt("factory-droid"),
+        ],
+    }),
+    entry({
+        id: "cline",
+        aliases: ["cline vscode"],
+        name: "Cline",
+        vendor: "Cline",
+        description: "Install Spacefast from the Cline marketplace or connect OAuth MCP.",
+        detectionHints: [".cline"],
+        kind: "editor",
+        tier: "listed",
+        wizardGroup: "coding-agents",
+        capabilities: ["skills", "mcp-oauth", "plugin"],
+        skills: { agentsDirs: true, claudeDirs: true },
+        agentsMd: "native",
+        docs: { spacefast: "https://spacefast.com/setup/cline", vendor: "https://docs.cline.bot/mcp" },
+        machineClient: true,
+        methods: [
+            pluginMarketplace("cline", "https://github.com/cline/marketplace", "planned"),
+            hostedConfig("cline", "~/.cline/data/settings/cline_mcp_settings.json", "json", jsonHostedConfig("mcpServers"), "https://docs.cline.bot/mcp"),
+            ...terminalLanes("cline"),
+            skill("cline"),
+            universalPrompt("cline"),
+        ],
+    }),
+    entry({
+        id: "continue",
+        aliases: ["continue dev"],
+        name: "Continue",
+        vendor: "Continue",
+        description: "Use the Spacefast skill in discontinued Continue installations.",
+        detectionHints: [".continue"],
+        kind: "editor",
+        tier: "listed",
+        wizardGroup: "prompt-first",
+        capabilities: ["skills"],
+        skills: { agentsDirs: false, claudeDirs: true },
+        agentsMd: "none",
+        docs: {
+            spacefast: "https://spacefast.com/setup/continue",
+            vendor: "https://github.com/continuedev/continue",
+        },
+        notes: ["Continue is discontinued; active MCP support is not advertised."],
+        machineClient: true,
+        methods: [
+            skill("continue", { interactive: true }),
+            ...terminalLanes("continue"),
+            universalPrompt("continue"),
+        ],
+    }),
+    entry({
+        id: "raycast",
+        aliases: ["raycast ai"],
+        name: "Raycast",
+        vendor: "Raycast",
+        description: "Connect Spacefast to Raycast AI using its native OAuth MCP form.",
+        detectionHints: [],
+        kind: "mcp-app",
+        tier: "listed",
+        wizardGroup: "mcp-apps",
+        capabilities: ["mcp-oauth", "deeplink-only"],
+        skills: { agentsDirs: false, claudeDirs: false },
+        agentsMd: "none",
+        docs: {
+            spacefast: "https://spacefast.com/setup/raycast",
+            vendor: "https://manual.raycast.com/model-context-protocol",
+        },
+        methods: [
+            hostedFormConfig("raycast", "Raycast Settings \u2192 AI \u2192 MCP Servers \u2192 Install MCP Server", "https://manual.raycast.com/model-context-protocol"),
+            hostedConfig("raycast", "an MCP client configuration", "json", jsonHostedConfig("mcpServers"), "https://manual.raycast.com/model-context-protocol"),
+            universalPrompt("raycast"),
+        ],
+    }),
+    entry({
+        id: "poke",
+        aliases: ["poke ai"],
+        name: "Poke",
+        vendor: "Interaction",
+        description: "Prefill a Spacefast integration in Poke and authorize with OAuth.",
+        detectionHints: [],
+        kind: "mcp-app",
+        // Poke connects over MCP, but people reach for it the way they reach for
+        // Hermes or OpenClaw — as their own assistant, not as an app they are
+        // configuring. `kind` keeps the wire truth; the wizard groups it by use.
+        tier: "listed",
+        wizardGroup: "personal-agents",
+        capabilities: ["mcp-oauth", "deeplink-only"],
+        skills: { agentsDirs: false, claudeDirs: false },
+        agentsMd: "none",
+        docs: {
+            spacefast: "https://spacefast.com/setup/poke",
+            vendor: "https://poke.com/docs/mcp-servers",
+        },
+        methods: [
+            deeplink({
+                agentId: "poke",
+                build: (context) => `https://poke.com/integrations/new?name=Spacefast&url=${encodeURIComponent(context.mcpEndpoint)}`,
+                fallbackId: "universal-prompt",
+                label: "Add to Poke",
+                sourceUrl: "https://poke.com/docs/mcp-servers",
+                summary: "Open Poke's editable integration form with Spacefast filled in.",
+            }),
+            universalPrompt("poke"),
+        ],
+    }),
+    entry({
+        id: "pi",
+        aliases: ["pi.dev", "earendil"],
+        name: "Pi",
+        vendor: "Pi",
+        description: "Install the third-party Pi MCP extension for Spacefast.",
+        detectionHints: [".pi"],
+        kind: "coding-agent",
+        tier: "listed",
+        wizardGroup: "prompt-first",
+        capabilities: ["skills"],
+        skills: { agentsDirs: true, claudeDirs: false },
+        agentsMd: "none",
+        docs: { spacefast: "https://spacefast.com/setup/pi", vendor: "https://pi.dev" },
+        machineClient: true,
+        methods: [
+            hostedConfig("pi", "~/.pi/agent/mcp.json", "json", (context) => JSON.stringify({
+                mcpServers: { spacefast: { transport: "streamable-http", url: context.mcpEndpoint } },
+            }, null, 2), "https://pi.dev"),
+            ...terminalLanes("pi"),
+            skill("pi"),
+            universalPrompt("pi"),
+        ],
+    }),
+    entry({
+        id: "indent",
+        aliases: ["indent ai"],
+        name: "Indent",
+        vendor: "Indent",
+        description: "Connect Spacefast through Indent's native OAuth MCP integration.",
+        detectionHints: [],
+        kind: "mcp-app",
+        tier: "listed",
+        wizardGroup: "mcp-apps",
+        capabilities: ["mcp-oauth", "deeplink-only"],
+        skills: { agentsDirs: false, claudeDirs: false },
+        agentsMd: "none",
+        docs: {
+            spacefast: "https://spacefast.com/setup/indent",
+            vendor: "https://indent.com/docs/integrations/mcp",
+        },
+        methods: [
+            hostedFormConfig("indent", "Indent Settings \u2192 Integrations \u2192 Add custom MCP", "https://indent.com/docs/integrations/mcp"),
+            hostedConfig("indent", "an MCP client configuration", "json", jsonHostedConfig("mcpServers"), "https://indent.com/docs/integrations/mcp"),
+            universalPrompt("indent"),
+        ],
+    }),
+    entry({
+        id: "hermes",
+        aliases: ["hermes agent", "nous hermes"],
+        name: "Hermes",
+        vendor: "Nous Research",
+        description: "Give Hermes the Spacefast setup guide, or install its skill with the CLI.",
+        detectionHints: [".hermes"],
+        kind: "coding-agent",
+        tier: "listed",
+        wizardGroup: "personal-agents",
+        capabilities: ["skills"],
+        skills: { agentsDirs: true, claudeDirs: false },
+        agentsMd: "native",
+        docs: {
+            spacefast: "https://spacefast.com/setup.md",
+            vendor: "https://github.com/NousResearch/hermes-agent/blob/main/website/docs/guides/work-with-skills.md",
+        },
+        machineClient: true,
+        methods: [
+            ...terminalLanes("hermes", { skillOnly: true }),
+            universalPrompt("hermes", { interactive: true }),
+        ],
+    }),
+    entry({
+        id: "openclaw",
+        aliases: ["open claw", "clawhub"],
+        name: "OpenClaw",
+        vendor: "OpenClaw",
+        description: "Give OpenClaw the Spacefast setup guide, or install its skill with the CLI.",
+        detectionHints: [".openclaw"],
+        kind: "coding-agent",
+        tier: "listed",
+        wizardGroup: "personal-agents",
+        capabilities: ["skills"],
+        skills: { agentsDirs: true, claudeDirs: false },
+        agentsMd: "none",
+        docs: {
+            spacefast: "https://spacefast.com/setup.md",
+            vendor: "https://docs.openclaw.ai/tools/skills",
+        },
+        machineClient: true,
+        methods: [
+            ...terminalLanes("openclaw", { skillOnly: true }),
+            universalPrompt("openclaw", { interactive: true }),
+        ],
+    }),
+];
+const registryById = new Map(AGENT_REGISTRY.map((agent) => [agent.id, agent]));
+const idByAlias = new Map();
+for (const agent of AGENT_REGISTRY) {
+    idByAlias.set(agent.id, agent.id);
+    for (const alias of agent.aliases)
+        idByAlias.set(normalizeLookup(alias), agent.id);
+}
+export function getAgentEntry(id) {
+    const agent = registryById.get(id);
+    if (!agent)
+        throw new TypeError(`Unknown agent: ${id}`);
+    return agent;
+}
+export function resolveAgentId(value) {
+    return idByAlias.get(normalizeLookup(value)) ?? null;
+}
+/**
+ * The ranking rule, as a pure function so the demote path is testable without a
+ * registry entry: a deeplink whose last probe failed is dropped from the
+ * interactive lane, and everything else sorts by its per-context rank.
+ */
+export function methodsForContext(methods, context) {
+    return methods
+        .filter((method) => method.rank[context] !== undefined)
+        .filter((method) => method.kind !== "deeplink" ||
+        method.verification.status !== "failed" ||
+        context !== "interactive-primary")
+        .toSorted((left, right) => (left.rank[context] ?? 0) - (right.rank[context] ?? 0));
+}
+export function agentMethodsForContext(agentId, context) {
+    return methodsForContext(getAgentEntry(agentId).methods, context);
+}
+/**
+ * The `sf plugins` gate. Returns the universal-installer targets this agent can
+ * actually be installed into — empty for every agent whose plugin lane is
+ * vendor-native or not live, including entries that carry a `plugin` capability.
+ */
+export function pluginInstallerTargetsFor(agentId) {
+    return [
+        ...new Set(getAgentEntry(agentId).methods.flatMap((method) => method.kind === "plugin" && method.listing.status === "live"
+            ? [...(method.installerTargets ?? [])]
+            : [])),
+    ];
+}
+export function presentAgentEntry(agentId, context) {
+    const agent = getAgentEntry(agentId);
+    return {
+        ...agent,
+        methods: agentMethodsForContext(agent.id, "interactive-primary").map((method) => presentMethod(method, context, "interactive-primary")),
+        staticDocs: agentMethodsForContext(agent.id, "static-docs").map((method) => presentMethod(method, context, "static-docs")),
+        terminalAlternates: agentMethodsForContext(agent.id, "terminal-alternates").map((method) => presentMethod(method, context, "terminal-alternates")),
+    };
+}
+export function base64Utf8(value) {
+    const bytes = new TextEncoder().encode(value);
+    let binary = "";
+    for (const byte of bytes)
+        binary += String.fromCharCode(byte);
+    return btoa(binary);
+}
+function presentMethod(method, context, presentation) {
+    const action = methodAction(method, context);
+    const presented = {
+        action,
+        docsUrl: method.docsUrl,
+        id: method.id,
+        kind: method.kind,
+        label: method.label,
+        language: methodLanguage(method),
+        listing: method.listing,
+        rank: method.rank[presentation] ?? 0,
+        summary: method.summary,
+    };
+    if (method.kind === "deeplink")
+        presented.fallbackMethodId = method.fallback.id;
+    if (method.kind === "config")
+        presented.path = method.path;
+    if (method.vendorDocs !== undefined)
+        presented.vendorDocs = method.vendorDocs;
+    return presented;
+}
+function methodLanguage(method) {
+    if (method.kind === "config")
+        return method.language;
+    if (method.kind === "command" || method.kind === "plugin" || method.kind === "skill") {
+        return "bash";
+    }
+    return "text";
+}
+function methodAction(method, context) {
+    if (method.kind === "deeplink") {
+        return { kind: "link", label: method.label, value: method.build(context) };
+    }
+    if (method.kind === "download") {
+        return { kind: "download", label: method.label, value: method.url(context) };
+    }
+    if (method.kind === "plugin") {
+        // A listing with no install command yet is disabled AT THE REGISTRY, so no
+        // consumer has to discover emptiness by inspecting the copy string.
+        if (method.commands.shell.length === 0) {
+            return { kind: "disabled", label: method.label, value: "" };
+        }
+        return { kind: "copy", label: method.label, value: method.commands.shell.join(" && ") };
+    }
+    if (method.kind === "command") {
+        return { kind: "copy", label: method.label, value: method.build(context).join(" && ") };
+    }
+    if (method.kind === "config" || method.kind === "prompt") {
+        return { kind: "copy", label: method.label, value: method.build(context) };
+    }
+    return {
+        kind: "copy",
+        label: method.label,
+        value: `npx -y ${context.packageSpecs?.skillsCli ?? SKILLS_CLI_PACKAGE_SPEC} add ${method.source.url} -y`,
+    };
+}
+function normalizeLookup(value) {
+    return value.trim().toLowerCase().replaceAll("_", "-").replace(/\s+/g, " ");
+}