gnosys 5.11.3 → 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,7 +36,7 @@ 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 ([mcp_servers.gnosys])",
@@ -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.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";
@@ -567,24 +568,6 @@ export async function detectIDEs(projectDir) {
     }
     return detected;
 }
-/** Remove a single `[section]` block from Grok TOML (hand-rolled; see upsertGrokMcpBlock). */
-function removeGrokTomlSection(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}\n` : "";
-}
 /**
  * Replace (or append) a `[mcp_servers.<name>]` block inside Grok Build's
  * `~/.grok/config.toml`. Preserves every line outside that block (deci-046).
@@ -596,7 +579,7 @@ function removeGrokTomlSection(existing, sectionHeader) {
  */
 export function upsertGrokMcpBlock(existing, name, entry) {
     // Drop mistaken v5.9.4 `[mcp.<name>]` sections so we don't leave dead config.
-    let content = removeGrokTomlSection(existing, `[mcp.${name}]`);
+    let content = removeTomlSection(existing, `[mcp.${name}]`);
     const sectionHeader = `[mcp_servers.${name}]`;
     const lines = content.split("\n");
     const headerIdx = lines.findIndex((line) => line.trim() === sectionHeader);
@@ -632,25 +615,6 @@ export function upsertGrokMcpBlock(existing, name, entry) {
     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 = [
@@ -666,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
@@ -719,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 {
@@ -744,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 {
@@ -772,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);
@@ -789,43 +735,19 @@ 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 MCP from `[mcp_servers.<name>]`
@@ -842,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, "~")
@@ -877,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.3",
+  "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",