gnosys 5.11.2 → 5.11.4

package/dist/cli.js

@@ -974,7 +974,14 @@ setupCmd
 setupCmd
     .command("ides")
     .description("Configure IDE MCP integrations (Claude Code/Desktop, Cursor, Codex, Grok Build, Gemini CLI, Antigravity)")
-    .action(async () => {
+    .option("--all", "Configure MCP for all supported IDEs (non-interactive)")
+    .action(async (opts) => {
+    if (opts.all) {
+        const { runIdesSetupAll } = await import("./lib/setup/sections/ides.js");
+        const { configured, errors } = await runIdesSetupAll(process.cwd());
+        console.log(`\n${configured} ides configured · ${errors} errors`);
+        return;
+    }
     const readline = await import("readline/promises");
     const { runIdesSetup } = await import("./lib/setup/sections/ides.js");
     const rl = readline.createInterface({ input: process.stdin, output: process.stdout });

package/dist/lib/ideMcpInstall.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Shared stdio MCP install helpers for IDE setup (`gnosys setup ides`).
+ */
+/** IDE keys handled by `setupIDE()`. */
+export declare const SUPPORTED_IDE_KEYS: readonly ["claude", "claude-desktop", "cursor", "codex", "gemini-cli", "antigravity", "grok-build"];
+export type SupportedIde = (typeof SUPPORTED_IDE_KEYS)[number];
+/** User-facing aliases → canonical IDE key. */
+export declare const IDE_ALIASES: Record<string, SupportedIde>;
+export declare function normalizeIdeKey(ide: string): SupportedIde | null;
+/** Absolute path to `gnosys-mcp` when on PATH, else bare name. */
+export declare function resolveGnosysMcpCommand(): string;
+export declare function gnosysStdioMcpEntry(): {
+    command: string;
+    args: string[];
+};
+/** True when an existing JSON MCP entry still points at broken `gnosys serve`. */
+export declare function isStaleGnosysMcpEntry(entry: unknown): boolean;
+/** Merge (or replace) the gnosys stdio entry in a JSON MCP config file. */
+export declare function installStdioMcpJson(file: string): Promise<void>;
+/** Project + user-global Cursor MCP paths. */
+export declare function cursorMcpPaths(projectDir: string): {
+    project: string;
+    user: string;
+};
+/** Run a CLI with argv (safe for paths containing spaces). */
+export declare function runCli(command: string, args: string[], opts?: {
+    allowFailure?: boolean;
+}): string;
+/** Remove a `[section]` block from hand-rolled TOML text. */
+export declare function removeTomlSection(existing: string, sectionHeader: string): string;

package/dist/lib/ideMcpInstall.js

@@ -0,0 +1,102 @@
+/**
+ * Shared stdio MCP install helpers for IDE setup (`gnosys setup ides`).
+ */
+import { execFileSync, execSync } from "child_process";
+import path from "path";
+import os from "os";
+import { mergeJsonMcpServer } from "./mcpClientConfig.js";
+/** IDE keys handled by `setupIDE()`. */
+export const SUPPORTED_IDE_KEYS = [
+    "claude",
+    "claude-desktop",
+    "cursor",
+    "codex",
+    "gemini-cli",
+    "antigravity",
+    "grok-build",
+];
+/** User-facing aliases → canonical IDE key. */
+export const IDE_ALIASES = {
+    grok: "grok-build",
+    "grok-build": "grok-build",
+};
+export function normalizeIdeKey(ide) {
+    const key = ide.toLowerCase();
+    if (SUPPORTED_IDE_KEYS.includes(key)) {
+        return key;
+    }
+    return IDE_ALIASES[key] ?? null;
+}
+/** Absolute path to `gnosys-mcp` when on PATH, else bare name. */
+export function resolveGnosysMcpCommand() {
+    try {
+        const p = execSync("command -v gnosys-mcp", { encoding: "utf-8" }).trim();
+        if (p)
+            return p;
+    }
+    catch {
+        // Fall back to bare name on PATH.
+    }
+    return "gnosys-mcp";
+}
+export function gnosysStdioMcpEntry() {
+    return { command: resolveGnosysMcpCommand(), args: [] };
+}
+/** True when an existing JSON MCP entry still points at broken `gnosys serve`. */
+export function isStaleGnosysMcpEntry(entry) {
+    if (!entry || typeof entry !== "object")
+        return false;
+    const e = entry;
+    const cmd = String(e.command ?? "");
+    const args = Array.isArray(e.args) ? e.args.map(String) : [];
+    if (cmd.includes("gnosys-mcp"))
+        return false;
+    if (cmd.endsWith("/gnosys") || cmd === "gnosys") {
+        return args.includes("serve") || args.length === 0;
+    }
+    return false;
+}
+/** Merge (or replace) the gnosys stdio entry in a JSON MCP config file. */
+export async function installStdioMcpJson(file) {
+    await mergeJsonMcpServer(file, gnosysStdioMcpEntry());
+}
+/** Project + user-global Cursor MCP paths. */
+export function cursorMcpPaths(projectDir) {
+    return {
+        project: path.join(projectDir, ".cursor", "mcp.json"),
+        user: path.join(os.homedir(), ".cursor", "mcp.json"),
+    };
+}
+/** Run a CLI with argv (safe for paths containing spaces). */
+export function runCli(command, args, opts) {
+    try {
+        return execFileSync(command, args, {
+            encoding: "utf-8",
+            stdio: ["pipe", "pipe", "pipe"],
+        });
+    }
+    catch (err) {
+        if (opts?.allowFailure) {
+            return err instanceof Error && "stdout" in err ? String(err.stdout ?? "") : "";
+        }
+        throw err;
+    }
+}
+/** Remove a `[section]` block from hand-rolled TOML text. */
+export function removeTomlSection(existing, sectionHeader) {
+    const lines = existing.split("\n");
+    const headerIdx = lines.findIndex((line) => line.trim() === sectionHeader);
+    if (headerIdx === -1)
+        return existing;
+    let endIdx = lines.length;
+    for (let i = headerIdx + 1; i < lines.length; i++) {
+        if (/^\s*\[/.test(lines[i])) {
+            endIdx = i;
+            break;
+        }
+    }
+    const before = lines.slice(0, headerIdx).join("\n");
+    const after = lines.slice(endIdx).join("\n");
+    const merged = [before, after].filter((s) => s.length > 0).join("\n");
+    return merged.length > 0 ? `${merged.replace(/\n{3,}/g, "\n\n")}\n` : "";
+}

package/dist/lib/setup/sections/ides.d.ts

@@ -25,3 +25,10 @@ export interface IdesSetupOptions {
  * Returns true if at least one IDE config was written.
  */
 export declare function runIdesSetup(opts: IdesSetupOptions): Promise<boolean>;
+/**
+ * Non-interactive: wire MCP for every supported IDE (user-level + project cursor).
+ */
+export declare function runIdesSetupAll(directory: string): Promise<{
+    configured: number;
+    errors: number;
+}>;

package/dist/lib/setup/sections/ides.js

@@ -9,6 +9,7 @@
 import fs from "fs/promises";
 import path from "path";
 import { detectIDEs, setupIDE } from "../../setup.js";
+import { SUPPORTED_IDE_KEYS } from "../../ideMcpInstall.js";
 import { safeQuestion } from "../ui/safePrompt.js";
 import { renderTable } from "../ui/table.js";
 const DIM = "\x1b[2m";
@@ -18,7 +19,7 @@ const RESET = "\x1b[0m";
 const CHECK = `${GREEN}✓${RESET}`;
 const CROSS = `${RED}✗${RESET}`;
 const IDE_LABELS = {
-    claude: "Claude Code",
+    claude: "Claude Code + Desktop",
     "claude-desktop": "Claude Desktop",
     cursor: "Cursor",
     codex: "Codex",
@@ -35,10 +36,10 @@ const IDE_TARGET_DISPLAY = {
     claude: "claude mcp add (CLI)",
     "claude-desktop": "~/Library/.../claude_desktop_config.json",
     cursor: ".cursor/mcp.json",
-    codex: ".codex/mcp.json",
+    codex: "codex mcp add (CLI registry)",
     "gemini-cli": "~/.gemini/settings.json",
     antigravity: "~/.gemini/antigravity/mcp_config.json",
-    "grok-build": "~/.grok/config.toml",
+    "grok-build": "~/.grok/config.toml ([mcp_servers.gnosys])",
 };
 function ideTarget(ide) {
     return IDE_TARGET_DISPLAY[ide] ?? `.${ide}/mcp.json`;
@@ -178,3 +179,24 @@ export async function runIdesSetup(opts) {
     console.log(`   ${color(c.textDim, `${configured} ides configured · ${errors} errors`)}`);
     return configured > 0;
 }
+/**
+ * Non-interactive: wire MCP for every supported IDE (user-level + project cursor).
+ */
+export async function runIdesSetupAll(directory) {
+    let configured = 0;
+    let errors = 0;
+    // Claude setup also wires Claude Desktop — skip duplicate pass.
+    const idesToRun = SUPPORTED_IDE_KEYS.filter((k) => k !== "claude-desktop");
+    for (const ide of idesToRun) {
+        const result = await setupIDE(ide, directory);
+        if (result.success) {
+            console.log(`  ${CHECK} ${IDE_LABELS[ide] ?? ide}: ${result.message}`);
+            configured++;
+        }
+        else {
+            console.log(`  ${CROSS} ${IDE_LABELS[ide] ?? ide}: ${result.message}`);
+            errors++;
+        }
+    }
+    return { configured, errors };
+}

package/dist/lib/setup.d.ts

@@ -56,14 +56,11 @@ export declare function writeApiKey(provider: string, key: string): Promise<void
  */
 export declare function detectIDEs(projectDir: string): Promise<string[]>;
 /**
- * Replace (or append) a `[mcp.<name>]` block inside the TOML text for
- * Grok Build's config file. Preserves every line outside that block —
- * deci-046 read-then-merge rule. We can't pull in a TOML dependency
- * without adding to package.json, so we ship a minimal hand-rolled
- * updater scoped exactly to the `[mcp.gnosys]` use case.
+ * Replace (or append) a `[mcp_servers.<name>]` block inside Grok Build's
+ * `~/.grok/config.toml`. Preserves every line outside that block (deci-046).
  *
- * Spec assumption: TOML headers we touch are simple `[a.b]` lines with
- * no inline tables or nested arrays. Any other content is left alone.
+ * Grok Build reads `mcp_servers.*` only — legacy `[mcp.*]` blocks are ignored
+ * by `grok mcp list` / the agent runtime (see ~/.grok/README.md).
  *
  * Exported for tests.
  */

package/dist/lib/setup.js

@@ -19,6 +19,7 @@ import { validateModel } from "./modelValidation.js";
 import { resolveActiveStorePath, ensureActiveStorePath } from "./setup/storePath.js";
 import { safeQuestion } from "./setup/ui/safePrompt.js";
 import { getClaudeDesktopConfigPath, getApiKeySkipHints } from "./platform.js";
+import { gnosysStdioMcpEntry, installStdioMcpJson, normalizeIdeKey, resolveGnosysMcpCommand, cursorMcpPaths, runCli, removeTomlSection, } from "./ideMcpInstall.js";
 // ─── ANSI Colors ────────────────────────────────────────────────────────────
 const BOLD = "\x1b[1m";
 const DIM = "\x1b[2m";
@@ -568,32 +569,29 @@ export async function detectIDEs(projectDir) {
     return detected;
 }
 /**
- * Replace (or append) a `[mcp.<name>]` block inside the TOML text for
- * Grok Build's config file. Preserves every line outside that block —
- * deci-046 read-then-merge rule. We can't pull in a TOML dependency
- * without adding to package.json, so we ship a minimal hand-rolled
- * updater scoped exactly to the `[mcp.gnosys]` use case.
+ * Replace (or append) a `[mcp_servers.<name>]` block inside Grok Build's
+ * `~/.grok/config.toml`. Preserves every line outside that block (deci-046).
  *
- * Spec assumption: TOML headers we touch are simple `[a.b]` lines with
- * no inline tables or nested arrays. Any other content is left alone.
+ * Grok Build reads `mcp_servers.*` only — legacy `[mcp.*]` blocks are ignored
+ * by `grok mcp list` / the agent runtime (see ~/.grok/README.md).
  *
  * Exported for tests.
  */
 export function upsertGrokMcpBlock(existing, name, entry) {
-    const sectionHeader = `[mcp.${name}]`;
-    const lines = existing.split("\n");
+    // Drop mistaken v5.9.4 `[mcp.<name>]` sections so we don't leave dead config.
+    let content = removeTomlSection(existing, `[mcp.${name}]`);
+    const sectionHeader = `[mcp_servers.${name}]`;
+    const lines = content.split("\n");
     const headerIdx = lines.findIndex((line) => line.trim() === sectionHeader);
     const blockBody = renderGrokMcpBlock(entry);
     if (headerIdx === -1) {
-        // Append a fresh block, separated by a blank line if the file has content.
-        const prefix = existing.length === 0 || existing.endsWith("\n\n")
-            ? existing
-            : existing.endsWith("\n") ? `${existing}\n` : `${existing}\n\n`;
+        const prefix = content.length === 0 || content.endsWith("\n\n")
+            ? content
+            : content.endsWith("\n")
+                ? `${content}\n`
+                : `${content}\n\n`;
         return `${prefix}${sectionHeader}\n${blockBody}`;
     }
-    // Replace the existing block — everything from sectionHeader up to the
-    // next `[` header (or EOF). Count blank lines immediately after the block
-    // so we can preserve the original spacing before the next section.
     let endIdx = lines.length;
     for (let i = headerIdx + 1; i < lines.length; i++) {
         if (/^\s*\[/.test(lines[i])) {
@@ -611,32 +609,12 @@ export function upsertGrokMcpBlock(existing, name, entry) {
     const beforeBlock = lines.slice(0, headerIdx).join("\n");
     const head = beforeBlock.length > 0 ? `${beforeBlock}\n` : "";
     if (!hasFollowingSection) {
-        // No following section — drop trailing blank lines and end with a single \n.
         return `${head}${sectionHeader}\n${blockBody}`;
     }
     const gap = "\n".repeat(Math.max(1, trailingBlankBeforeNext));
     const afterBlock = afterLines.join("\n");
     return `${head}${sectionHeader}\n${blockBody}${gap}${afterBlock}`;
 }
-/**
- * Absolute path to the `gnosys-mcp` stdio entry (dist/index.js).
- * Prefer this over `gnosys serve` — v5.11.0 `gnosys serve` imported index.js but
- * did not call startMcpServer(), so MCP hosts saw "connection closed" on init.
- */
-function resolveGnosysMcpCommand() {
-    try {
-        const p = execSync("command -v gnosys-mcp", { encoding: "utf-8" }).trim();
-        if (p)
-            return p;
-    }
-    catch {
-        // Fall back to bare name on PATH.
-    }
-    return "gnosys-mcp";
-}
-function gnosysMcpServerEntry() {
-    return { command: resolveGnosysMcpCommand(), args: [] };
-}
 function renderGrokMcpBlock(entry) {
     const argsStr = `[${entry.args.map((a) => JSON.stringify(a)).join(", ")}]`;
     const lines = [
@@ -652,48 +630,45 @@ function renderGrokMcpBlock(entry) {
  * Set up Gnosys MCP integration for a specific IDE.
  */
 export async function setupIDE(ide, projectDir) {
+    const canonical = normalizeIdeKey(ide);
+    if (!canonical) {
+        return { success: false, message: `Unknown IDE: ${ide}` };
+    }
     try {
-        switch (ide) {
+        switch (canonical) {
             case "claude": {
                 const mcpCmd = resolveGnosysMcpCommand();
+                let codeMsg = `Claude Code MCP registered (${mcpCmd})`;
                 try {
-                    try {
-                        execSync("claude mcp remove gnosys", { stdio: "pipe" });
-                    }
-                    catch {
-                        // Not registered yet — fine.
-                    }
-                    execSync(`claude mcp add -s user gnosys -- ${mcpCmd}`, {
-                        stdio: "pipe",
-                    });
+                    runCli("claude", ["mcp", "remove", "gnosys"], { allowFailure: true });
+                    runCli("claude", ["mcp", "add", "-s", "user", "gnosys", "--", mcpCmd]);
                 }
                 catch (e) {
                     const msg = e instanceof Error ? e.message : String(e);
                     if (msg.includes("already exists")) {
-                        return { success: true, message: "Claude Code MCP server already configured" };
+                        codeMsg = "Claude Code MCP server already configured";
+                    }
+                    else {
+                        codeMsg = `Claude Code MCP skipped (is \`claude\` on PATH?): ${msg}`;
                     }
-                    throw e;
                 }
-                return { success: true, message: `Claude Code MCP server registered (${mcpCmd})` };
+                const desktop = await setupIDE("claude-desktop", projectDir);
+                return {
+                    success: desktop.success,
+                    message: desktop.success
+                        ? `${codeMsg}; ${desktop.message}`
+                        : `${codeMsg}; Claude Desktop: ${desktop.message}`,
+                };
             }
             case "cursor": {
-                const cursorDir = path.join(projectDir, ".cursor");
-                const mcpPath = path.join(cursorDir, "mcp.json");
-                await fs.mkdir(cursorDir, { recursive: true });
-                let config = {};
-                try {
-                    const existing = await fs.readFile(mcpPath, "utf-8");
-                    config = JSON.parse(existing);
-                }
-                catch {
-                    // File doesn't exist or is invalid — start fresh
-                }
-                // Merge gnosys entry
-                const servers = (config.mcpServers ?? {});
-                servers.gnosys = gnosysMcpServerEntry();
-                config.mcpServers = servers;
-                await fs.writeFile(mcpPath, JSON.stringify(config, null, 2) + "\n", "utf-8");
-                return { success: true, message: "Cursor MCP config updated (.cursor/mcp.json)" };
+                const paths = cursorMcpPaths(projectDir);
+                await fs.mkdir(path.dirname(paths.project), { recursive: true });
+                await installStdioMcpJson(paths.project);
+                await installStdioMcpJson(paths.user);
+                return {
+                    success: true,
+                    message: "Cursor MCP updated (project .cursor/mcp.json and ~/.cursor/mcp.json)",
+                };
             }
             case "codex": {
                 // v5.8.5: register via `codex mcp add` (the real Codex CLI registration
@@ -705,19 +680,13 @@ export async function setupIDE(ide, projectDir) {
                 //
                 // We also migrate away from those legacy blocks in
                 // `~/.codex/config.toml` so users on stale configs get cleaned up.
-                const os = await import("os");
-                // 1. Migrate (strip) legacy hand-written blocks in ~/.codex/config.toml.
+                // 1. Strip legacy hand-written sections in ~/.codex/config.toml.
                 const userCodexConfig = path.join(os.homedir(), ".codex", "config.toml");
                 try {
                     let existing = await fs.readFile(userCodexConfig, "utf-8");
-                    const before = existing;
-                    // Old shape (pre-v5.8.4): [gnosys] command/args
-                    existing = existing.replace(/\n?\[gnosys\][^[]*?command\s*=\s*"gnosys"[^[]*?args\s*=\s*\[[^\]]*\]\s*\n?/, "\n");
-                    // v5.8.4 shape: [mcp.gnosys] type/command
-                    existing = existing.replace(/\n?\[mcp\.gnosys\][^[]*?type\s*=\s*"local"[^[]*?command\s*=\s*\[[^\]]*\]\s*\n?/, "\n");
-                    if (existing !== before) {
-                        existing = existing.replace(/\n{3,}/g, "\n\n");
-                        await fs.writeFile(userCodexConfig, existing, "utf-8");
+                    const cleaned = removeTomlSection(removeTomlSection(existing, "[mcp.gnosys]"), "[gnosys]");
+                    if (cleaned !== existing) {
+                        await fs.writeFile(userCodexConfig, cleaned, "utf-8");
                     }
                 }
                 catch {
@@ -730,25 +699,16 @@ export async function setupIDE(ide, projectDir) {
                 //    remove and re-add.
                 let alreadyCorrect = false;
                 try {
-                    const existing = execSync("codex mcp get gnosys 2>/dev/null", {
-                        encoding: "utf-8",
-                    });
+                    const existing = runCli("codex", ["mcp", "get", "gnosys"], { allowFailure: true });
                     if (existing && existing.includes(gnosysCmd) && !existing.includes(" serve")) {
                         alreadyCorrect = true;
                     }
                     else if (existing) {
-                        // Different command — remove so we can re-add with the right one.
-                        try {
-                            execSync("codex mcp remove gnosys", { stdio: "pipe" });
-                        }
-                        catch {
-                            // Non-fatal — `mcp add` below will overwrite or fail loudly.
-                        }
+                        runCli("codex", ["mcp", "remove", "gnosys"], { allowFailure: true });
                     }
                 }
                 catch {
-                    // `codex mcp get` returns non-zero when the server isn't registered —
-                    // that's the common case on first install; proceed to add.
+                    // `codex mcp get` failed — proceed to add.
                 }
                 if (alreadyCorrect) {
                     return {
@@ -758,7 +718,7 @@ export async function setupIDE(ide, projectDir) {
                 }
                 // 4. Register via the canonical Codex CLI command.
                 try {
-                    execSync(`codex mcp add gnosys -- ${gnosysCmd}`, { stdio: "pipe" });
+                    runCli("codex", ["mcp", "add", "gnosys", "--", gnosysCmd]);
                 }
                 catch (err) {
                     const msg = err instanceof Error ? err.message : String(err);
@@ -775,49 +735,24 @@ export async function setupIDE(ide, projectDir) {
                 };
             }
             case "gemini-cli": {
-                // Gemini CLI reads MCP servers from ~/.gemini/settings.json (user-level)
-                const geminiDir = path.join(os.homedir(), ".gemini");
-                const settingsPath = path.join(geminiDir, "settings.json");
-                await fs.mkdir(geminiDir, { recursive: true });
-                let config = {};
-                try {
-                    const existing = await fs.readFile(settingsPath, "utf-8");
-                    config = JSON.parse(existing);
-                }
-                catch {
-                    // File doesn't exist or is invalid — start fresh
-                }
-                const servers = (config.mcpServers ?? {});
-                servers.gnosys = gnosysMcpServerEntry();
-                config.mcpServers = servers;
-                await fs.writeFile(settingsPath, JSON.stringify(config, null, 2) + "\n", "utf-8");
+                const settingsPath = path.join(os.homedir(), ".gemini", "settings.json");
+                await fs.mkdir(path.dirname(settingsPath), { recursive: true });
+                await installStdioMcpJson(settingsPath);
                 return { success: true, message: "Gemini CLI MCP config updated (~/.gemini/settings.json)" };
             }
             case "antigravity": {
-                // Antigravity reads MCP servers from ~/.gemini/antigravity/mcp_config.json
-                // (separate file from Gemini CLI's settings.json, even though they share the parent dir)
-                const antigravityDir = path.join(os.homedir(), ".gemini", "antigravity");
-                const configPath = path.join(antigravityDir, "mcp_config.json");
-                await fs.mkdir(antigravityDir, { recursive: true });
-                let config = {};
-                try {
-                    const existing = await fs.readFile(configPath, "utf-8");
-                    config = JSON.parse(existing);
-                }
-                catch {
-                    // File doesn't exist or is invalid — start fresh
-                }
-                const servers = (config.mcpServers ?? {});
-                servers.gnosys = gnosysMcpServerEntry();
-                config.mcpServers = servers;
-                await fs.writeFile(configPath, JSON.stringify(config, null, 2) + "\n", "utf-8");
-                return { success: true, message: "Antigravity MCP config updated (~/.gemini/antigravity/mcp_config.json)" };
+                const configPath = path.join(os.homedir(), ".gemini", "antigravity", "mcp_config.json");
+                await fs.mkdir(path.dirname(configPath), { recursive: true });
+                await installStdioMcpJson(configPath);
+                return {
+                    success: true,
+                    message: "Antigravity MCP config updated (~/.gemini/antigravity/mcp_config.json)",
+                };
             }
             case "grok-build": {
-                // v5.9.4 Bug 12 — Grok Build reads its MCP servers from a
-                // `[mcp.<name>]` block in ~/.grok/config.toml. We never clobber
-                // unrelated TOML content (per deci-046 read-then-merge rule); the
-                // helper preserves every line outside the `[mcp.gnosys]` block.
+                // v5.9.4 Bug 12 — Grok Build reads MCP from `[mcp_servers.<name>]`
+                // in ~/.grok/config.toml (not `[mcp.<name>]`). We never clobber
+                // unrelated TOML content (per deci-046 read-then-merge rule).
                 const grokDir = path.join(os.homedir(), ".grok");
                 const configPath = path.join(grokDir, "config.toml");
                 await fs.mkdir(grokDir, { recursive: true });
@@ -829,32 +764,16 @@ export async function setupIDE(ide, projectDir) {
                     // File doesn't exist yet — start fresh
                 }
                 const updated = upsertGrokMcpBlock(existing, "gnosys", {
-                    ...gnosysMcpServerEntry(),
+                    ...gnosysStdioMcpEntry(),
                     startup_timeout_sec: 90,
                 });
                 await fs.writeFile(configPath, updated, "utf-8");
                 return { success: true, message: "Grok Build MCP config updated (~/.grok/config.toml)" };
             }
             case "claude-desktop": {
-                // Claude Desktop reads MCP servers from claude_desktop_config.json
-                // in a platform-specific app data directory. Distinct from Claude
-                // Code CLI which uses `claude mcp add`.
                 const configPath = getClaudeDesktopConfigPath();
-                const configDir = path.dirname(configPath);
-                await fs.mkdir(configDir, { recursive: true });
-                let config = {};
-                try {
-                    const existing = await fs.readFile(configPath, "utf-8");
-                    config = JSON.parse(existing);
-                }
-                catch {
-                    // File doesn't exist or is invalid — start fresh
-                }
-                const servers = (config.mcpServers ?? {});
-                servers.gnosys = gnosysMcpServerEntry();
-                config.mcpServers = servers;
-                await fs.writeFile(configPath, JSON.stringify(config, null, 2) + "\n", "utf-8");
-                // Display path with ~ prefix when inside HOME for clarity
+                await fs.mkdir(path.dirname(configPath), { recursive: true });
+                await installStdioMcpJson(configPath);
                 const home = os.homedir();
                 const displayPath = configPath.startsWith(home)
                     ? configPath.replace(home, "~")
@@ -864,9 +783,8 @@ export async function setupIDE(ide, projectDir) {
                     message: `Claude Desktop MCP config updated (${displayPath}). Restart Claude Desktop for the change to take effect.`,
                 };
             }
-            default:
-                return { success: false, message: `Unknown IDE: ${ide}` };
         }
+        return { success: false, message: `Unhandled IDE: ${canonical}` };
     }
     catch (err) {
         const msg = err instanceof Error ? err.message : String(err);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gnosys",
-  "version": "5.11.2",
+  "version": "5.11.4",
   "description": "Gnosys — Persistent Memory for AI Agents. Sandbox-first runtime, central SQLite brain, federated search, Dream Mode, Web Knowledge Base, Obsidian export.",
   "type": "module",
   "main": "dist/index.js",
@@ -34,7 +34,7 @@
     "docs:mcp-tools": "node scripts/gen-mcp-tools.mjs --write",
     "docs:cli": "node scripts/gen-cli-docs.mjs --write",
     "postinstall": "node dist/postinstall.js || true",
-    "prepublishOnly": "npm run build:publish"
+    "prepublishOnly": "npm run build:publish && node -e \"const fs=require('fs');for (const f of ['dist/cli.js','dist/index.js']) fs.chmodSync(f,0o755)\""
   },
   "dependencies": {
     "@anthropic-ai/sdk": "^0.78.0",