vault-go 0.23.0 → 0.23.2

package/dist/mcp-clients.d.ts

@@ -0,0 +1,12 @@
+import { type InstallResult, type McpClient } from "./installer.js";
+export declare const MCP_CLIENT_LABELS: Record<McpClient, string>;
+export interface McpClientState {
+    client: McpClient;
+    name: string;
+    detected: boolean;
+    connected: boolean;
+    evidence?: string;
+}
+export declare function mcpClientConnected(client: McpClient, home?: string, cwd?: string): boolean;
+export declare function listMcpClients(home?: string, cwd?: string): McpClientState[];
+export declare function connectMcpClient(client: McpClient, home?: string, cwd?: string): InstallResult;

package/dist/mcp-clients.js

@@ -0,0 +1,146 @@
+import { existsSync, readFileSync } from "node:fs";
+import { homedir, platform } from "node:os";
+import { join } from "node:path";
+import { spawnSync } from "node:child_process";
+import { detectMcpClients, installMcpClient, MCP_CLIENTS, vaultDesktopDotMcpPath, vaultDesktopMcpPath, } from "./installer.js";
+export const MCP_CLIENT_LABELS = {
+    codex: "Codex",
+    claude: "Claude Code",
+    "claude-desktop": "Claude Desktop",
+    cursor: "Cursor",
+    vscode: "VS Code",
+    copilot: "GitHub Copilot",
+    windsurf: "Windsurf",
+    roo: "Roo Code",
+    opencode: "OpenCode",
+    grok: "Grok",
+    agy: "Antigravity",
+    gemini: "Gemini CLI",
+    "vault-desktop": "Vault Desktop",
+};
+function vscodeMcpPaths(home) {
+    if (platform() === "darwin") {
+        return [join(home, "Library", "Application Support", "Code", "User", "mcp.json")];
+    }
+    if (platform() === "win32") {
+        return [join(process.env["APPDATA"] ?? join(home, "AppData", "Roaming"), "Code", "User", "mcp.json")];
+    }
+    return [join(home, ".config", "Code", "User", "mcp.json")];
+}
+function claudeDesktopConfigPath(home) {
+    if (platform() === "darwin") {
+        return join(home, "Library", "Application Support", "Claude", "claude_desktop_config.json");
+    }
+    if (platform() === "win32") {
+        return join(process.env["APPDATA"] ?? join(home, "AppData", "Roaming"), "Claude", "claude_desktop_config.json");
+    }
+    return join(home, ".config", "Claude", "claude_desktop_config.json");
+}
+/** Where the installer writes the vault-go entry per client; toml is matched by text. */
+function configLocations(client, home, cwd) {
+    switch (client) {
+        case "codex":
+        case "claude":
+            return [];
+        case "claude-desktop":
+            return [[claudeDesktopConfigPath(home), "mcpServers"]];
+        case "cursor":
+            return [[join(home, ".cursor", "mcp.json"), "mcpServers"]];
+        case "copilot":
+            return [[join(home, ".copilot", "mcp-config.json"), "mcpServers"]];
+        case "windsurf":
+            return [[join(home, ".codeium", "windsurf", "mcp_config.json"), "mcpServers"]];
+        case "roo":
+            return [[join(cwd, ".roo", "mcp.json"), "mcpServers"]];
+        case "vscode":
+            return vscodeMcpPaths(home).map((path) => [path, "mcpServers"]);
+        case "opencode":
+            return [[join(home, ".config", "opencode", "opencode.json"), "mcp"]];
+        case "grok":
+            return [[join(home, ".grok", "config.toml"), "toml"]];
+        case "agy":
+            return [
+                [join(home, ".gemini", "config", "mcp_config.json"), "mcpServers"],
+                [join(home, ".gemini", "antigravity", "mcp_config.json"), "mcpServers"],
+            ];
+        case "gemini":
+            return [[join(home, ".gemini", "settings.json"), "mcpServers"]];
+        case "vault-desktop":
+            return [
+                [vaultDesktopMcpPath(home), "mcpServers"],
+                [vaultDesktopDotMcpPath(home), "mcpServers"],
+            ];
+    }
+}
+function serverConfiguredInJson(path, rootKey) {
+    if (!existsSync(path))
+        return false;
+    try {
+        const parsed = JSON.parse(readFileSync(path, "utf8"));
+        const servers = parsed && typeof parsed === "object" ? parsed[rootKey] : undefined;
+        return Boolean(servers && typeof servers === "object" && "vault-go" in servers);
+    }
+    catch {
+        return false;
+    }
+}
+function serverConfiguredInToml(path) {
+    if (!existsSync(path))
+        return false;
+    try {
+        return readFileSync(path, "utf8").includes("mcp_servers.vault-go");
+    }
+    catch {
+        return false;
+    }
+}
+function clientCliInstalled(client, home) {
+    if (home === homedir())
+        return clientCliWithEnv(client, process.env);
+    // Why: tests point home at a temp dir; pin each CLI's config env so the
+    // check reads the temp config, not the real one.
+    return clientCliWithEnv(client, {
+        ...process.env,
+        HOME: home,
+        CODEX_HOME: join(home, ".codex"),
+        CLAUDE_CONFIG_DIR: join(home, ".claude"),
+    });
+}
+function clientCliWithEnv(client, env) {
+    try {
+        return spawnSync(client, ["mcp", "get", "vault-go"], {
+            timeout: 4000,
+            stdio: "ignore",
+            env,
+        }).status === 0;
+    }
+    catch {
+        return false;
+    }
+}
+export function mcpClientConnected(client, home = homedir(), cwd = process.cwd()) {
+    if (client === "codex" || client === "claude")
+        return clientCliInstalled(client, home);
+    for (const [path, rootKey] of configLocations(client, home, cwd)) {
+        if (rootKey === "toml" ? serverConfiguredInToml(path) : serverConfiguredInJson(path, rootKey)) {
+            return true;
+        }
+    }
+    return false;
+}
+export function listMcpClients(home = homedir(), cwd = process.cwd()) {
+    const detected = new Map(detectMcpClients(home).map((item) => [item.client, item]));
+    return MCP_CLIENTS.map((client) => {
+        const evidence = detected.get(client);
+        return {
+            client,
+            name: MCP_CLIENT_LABELS[client],
+            detected: evidence?.detected ?? false,
+            connected: mcpClientConnected(client, home, cwd),
+            ...(evidence?.evidence ? { evidence: evidence.evidence } : {}),
+        };
+    });
+}
+export function connectMcpClient(client, home = homedir(), cwd = process.cwd()) {
+    return installMcpClient(client, { home, cwd });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vault-go",
-  "version": "0.23.0",
+  "version": "0.23.2",
   "description": "MCP server and installer for Vault Memory: search, capture, and use account memory across AI clients.",
   "type": "module",
   "bin": {
@@ -79,6 +79,8 @@
     "assets/",
     "README.md",
     "LICENSE",
+    "dist/mcp-clients.js",
+    "dist/mcp-clients.d.ts",
     "dist/mcp-result.js",
     "dist/mcp-result.d.ts",
     "dist/parity-tools.js",