prism-mcp-server 20.0.8 → 20.2.0

package/dist/connect.js

@@ -0,0 +1,560 @@
+import { accessSync, constants, existsSync, lstatSync, mkdirSync, readFileSync, realpathSync, renameSync, statSync, unlinkSync, writeFileSync, } from "node:fs";
+import { homedir } from "node:os";
+import { basename, dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { isDeepStrictEqual } from "node:util";
+import { parse as parseToml, stringify as stringifyToml } from "smol-toml";
+export const CONNECT_HOSTS = [
+    "claude-code",
+    "claude-desktop",
+    "cursor",
+    "gemini",
+    "codex",
+];
+const HOST_ALIASES = {
+    "claude-code": "claude-code",
+    claude: "claude-code",
+    code: "claude-code",
+    "claude-desktop": "claude-desktop",
+    desktop: "claude-desktop",
+    cursor: "cursor",
+    gemini: "gemini",
+    "gemini-cli": "gemini",
+    codex: "codex",
+    "codex-cli": "codex",
+};
+const CODEX_MANAGED_START = "# >>> prism connect managed: prism-mcp";
+const CODEX_MANAGED_END = "# <<< prism connect managed: prism-mcp";
+export function normalizeHostName(value) {
+    const normalized = value.trim().toLowerCase();
+    const host = HOST_ALIASES[normalized];
+    if (!host) {
+        throw new Error(`Unsupported host "${value}". Choose one of: ${CONNECT_HOSTS.join(", ")}`);
+    }
+    return host;
+}
+export function resolveInstalledServerPath(moduleUrl = import.meta.url) {
+    const manifestPath = fileURLToPath(new URL("../package.json", moduleUrl));
+    let manifest;
+    try {
+        manifest = JSON.parse(readFileSync(manifestPath, "utf8"));
+    }
+    catch (error) {
+        throw new Error(`Cannot read Prism package manifest at ${manifestPath}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    if (!isJsonObject(manifest) || typeof manifest.main !== "string" || !manifest.main.trim()) {
+        throw new Error(`Prism package manifest has no valid "main" entry: ${manifestPath}`);
+    }
+    const serverPath = resolve(dirname(manifestPath), manifest.main);
+    if (!existsSync(serverPath)) {
+        throw new Error(`Prism server entrypoint was not found: ${serverPath}. Run npm run build first.`);
+    }
+    return realpathSync(serverPath);
+}
+export function connectHosts(options = {}) {
+    if (options.all && options.hosts?.length) {
+        throw new Error("Use either --all or --host, not both.");
+    }
+    const homeDir = options.homeDir ?? homedir();
+    const platform = options.platform ?? process.platform;
+    const env = options.env ?? process.env;
+    const serverPath = options.serverPath ?? resolveInstalledServerPath();
+    const nodePath = options.nodePath ?? process.execPath;
+    const definitions = getHostDefinitions(homeDir, platform, env, options.homeDir === undefined);
+    const pathEnv = options.pathEnv ?? env.PATH ?? "";
+    let selected;
+    if (options.hosts?.length) {
+        const requested = new Set(options.hosts);
+        selected = definitions.filter((definition) => requested.has(definition.name));
+        const unavailable = options.hosts.filter((host) => !selected.some((definition) => definition.name === host));
+        if (unavailable.length > 0) {
+            throw new Error(`${unavailable.join(", ")} is not supported on ${platform}`);
+        }
+    }
+    else if (options.all) {
+        selected = definitions;
+    }
+    else {
+        selected = definitions.filter((definition) => isHostDetected(definition, platform, pathEnv));
+    }
+    const entry = buildMcpEntry(nodePath, serverPath, env);
+    const results = selected.map((definition) => registerHost(definition, entry, !!options.dryRun, !!options.refresh, options.beforeCommit));
+    return {
+        results,
+        usedApiKey: typeof env.PRISM_SYNALUX_API_KEY === "string" && env.PRISM_SYNALUX_API_KEY.length > 0,
+        serverPath,
+    };
+}
+function getHostDefinitions(homeDir, platform, env, includeSystemPaths) {
+    const claudeDesktop = claudeDesktopPath(homeDir, platform, env);
+    const cursorDetectionPaths = [join(homeDir, ".cursor")];
+    const desktopDetectionPaths = claudeDesktop ? [dirname(claudeDesktop)] : [];
+    const configuredCodexHome = includeSystemPaths && env.CODEX_HOME?.trim()
+        ? resolve(env.CODEX_HOME.trim())
+        : undefined;
+    const codexHome = configuredCodexHome ?? join(homeDir, ".codex");
+    const codexDetectionPaths = [codexHome];
+    let codexConfigurationError;
+    if (configuredCodexHome) {
+        try {
+            if (!statSync(configuredCodexHome).isDirectory()) {
+                codexConfigurationError = `CODEX_HOME must be an existing directory: ${configuredCodexHome}`;
+            }
+        }
+        catch (error) {
+            codexConfigurationError = `CODEX_HOME must be an existing directory: ${configuredCodexHome} (${error instanceof Error ? error.message : String(error)})`;
+        }
+    }
+    if (platform === "darwin") {
+        desktopDetectionPaths.push(join(homeDir, "Applications", "Claude.app"));
+        cursorDetectionPaths.push(join(homeDir, "Applications", "Cursor.app"));
+        codexDetectionPaths.push(join(homeDir, "Applications", "ChatGPT.app"));
+        if (includeSystemPaths) {
+            desktopDetectionPaths.push("/Applications/Claude.app");
+            cursorDetectionPaths.push("/Applications/Cursor.app");
+            codexDetectionPaths.push("/Applications/ChatGPT.app");
+        }
+    }
+    else if (platform === "win32") {
+        const localAppData = env.LOCALAPPDATA || join(homeDir, "AppData", "Local");
+        desktopDetectionPaths.push(join(localAppData, "Programs", "Claude", "Claude.exe"), join(localAppData, "AnthropicClaude", "Claude.exe"));
+        cursorDetectionPaths.push(join(localAppData, "Programs", "cursor", "Cursor.exe"), join(localAppData, "Cursor", "Cursor.exe"));
+        codexDetectionPaths.push(join(localAppData, "Programs", "OpenAI", "Codex", "bin", "codex.exe"), join(localAppData, "Microsoft", "WindowsApps", "ChatGPT.exe"));
+    }
+    const definitions = [
+        {
+            name: "claude-code",
+            label: "Claude Code",
+            format: "json",
+            configPath: join(homeDir, ".claude.json"),
+            detectionPaths: [join(homeDir, ".claude.json"), join(homeDir, ".claude")],
+            executables: ["claude"],
+        },
+    ];
+    if (claudeDesktop) {
+        definitions.push({
+            name: "claude-desktop",
+            label: "Claude Desktop",
+            format: "json",
+            configPath: claudeDesktop,
+            detectionPaths: desktopDetectionPaths,
+            executables: ["claude-desktop"],
+        });
+    }
+    definitions.push({
+        name: "cursor",
+        label: "Cursor",
+        format: "json",
+        configPath: join(homeDir, ".cursor", "mcp.json"),
+        detectionPaths: cursorDetectionPaths,
+        executables: ["cursor"],
+    }, {
+        name: "gemini",
+        label: "Gemini CLI",
+        format: "json",
+        configPath: join(homeDir, ".gemini", "settings.json"),
+        detectionPaths: [join(homeDir, ".gemini")],
+        executables: ["gemini"],
+    }, {
+        name: "codex",
+        label: "Codex",
+        format: "codex-toml",
+        configPath: join(codexHome, "config.toml"),
+        detectionPaths: codexDetectionPaths,
+        executables: ["codex"],
+        configurationError: codexConfigurationError,
+    });
+    return definitions;
+}
+function claudeDesktopPath(homeDir, platform, env) {
+    if (platform === "darwin") {
+        return join(homeDir, "Library", "Application Support", "Claude", "claude_desktop_config.json");
+    }
+    if (platform === "win32") {
+        const appData = env.APPDATA || join(homeDir, "AppData", "Roaming");
+        return join(appData, "Claude", "claude_desktop_config.json");
+    }
+    if (platform === "linux") {
+        const configHome = env.XDG_CONFIG_HOME || join(homeDir, ".config");
+        return join(configHome, "Claude", "claude_desktop_config.json");
+    }
+    return undefined;
+}
+function isHostDetected(definition, platform, pathEnv) {
+    return definition.configurationError !== undefined
+        || definition.detectionPaths.some(existsSync)
+        || definition.executables.some((executable) => executableExists(executable, platform, pathEnv));
+}
+function executableExists(name, platform, pathEnv) {
+    if (!pathEnv)
+        return false;
+    const separator = platform === "win32" ? ";" : ":";
+    const extensions = platform === "win32" ? [".exe", ".cmd", ".bat", ""] : [""];
+    for (const directory of pathEnv.split(separator).filter(Boolean)) {
+        for (const extension of extensions) {
+            const candidate = join(directory, `${name}${extension}`);
+            try {
+                if (!statSync(candidate).isFile())
+                    continue;
+                if (platform !== "win32")
+                    accessSync(candidate, constants.X_OK);
+                return true;
+            }
+            catch {
+                // Keep searching PATH entries when a candidate is absent or not executable.
+            }
+        }
+    }
+    return false;
+}
+function buildMcpEntry(nodePath, serverPath, env) {
+    const serverEnv = {
+        PRISM_INSTANCE: "prism-mcp",
+        PRISM_SYNALUX_BASE_URL: env.PRISM_SYNALUX_BASE_URL || "https://synalux.ai",
+        PRISM_STORAGE: "auto",
+    };
+    if (env.PRISM_SYNALUX_API_KEY) {
+        serverEnv.PRISM_SYNALUX_API_KEY = env.PRISM_SYNALUX_API_KEY;
+    }
+    return {
+        command: nodePath,
+        args: [serverPath],
+        env: serverEnv,
+    };
+}
+function registerHost(definition, entry, dryRun, refresh, beforeCommit) {
+    if (definition.configurationError) {
+        return result(definition, "error", definition.configurationError);
+    }
+    if (definition.format === "codex-toml") {
+        return registerCodexTomlHost(definition, entry, dryRun, refresh, beforeCommit);
+    }
+    return registerJsonHost(definition, entry, dryRun, refresh, beforeCommit);
+}
+function registerJsonHost(definition, entry, dryRun, refresh, beforeCommit) {
+    const { configPath } = definition;
+    let config = {};
+    let originalText;
+    let writePath = configPath;
+    let symlinkPath;
+    try {
+        const pathInfo = lstatSync(configPath);
+        if (pathInfo.isSymbolicLink()) {
+            try {
+                writePath = realpathSync(configPath);
+                symlinkPath = configPath;
+            }
+            catch (error) {
+                return result(definition, "error", `config symlink target is unavailable: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
+        try {
+            originalText = readFileSync(writePath, "utf8");
+            const parsed = JSON.parse(originalText);
+            if (!isJsonObject(parsed)) {
+                throw new Error("top-level JSON value must be an object");
+            }
+            config = parsed;
+        }
+        catch (error) {
+            return result(definition, "error", `could not parse config: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    catch (error) {
+        if (!isErrno(error, "ENOENT")) {
+            return result(definition, "error", `could not inspect config: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    const currentServers = config.mcpServers;
+    if (currentServers !== undefined && !isJsonObject(currentServers)) {
+        return result(definition, "error", '"mcpServers" must be a JSON object');
+    }
+    const mcpServers = (currentServers ?? {});
+    const existingKey = Object.prototype.hasOwnProperty.call(mcpServers, "prism-mcp")
+        ? "prism-mcp"
+        : Object.prototype.hasOwnProperty.call(mcpServers, "prism")
+            ? "prism"
+            : undefined;
+    if (existingKey) {
+        const existingEntry = mcpServers[existingKey];
+        if (!refresh || existingKey !== "prism-mcp" || !isManagedPrismEntry(existingEntry)) {
+            return result(definition, "existing", "Prism is already registered; existing entry left untouched");
+        }
+        const refreshedEntry = refreshManagedEntry(existingEntry, entry);
+        if (JSON.stringify(refreshedEntry) === JSON.stringify(existingEntry)) {
+            return result(definition, "existing", "Prism-managed entry is already current");
+        }
+        if (dryRun) {
+            return result(definition, "would-refresh");
+        }
+        mcpServers[existingKey] = refreshedEntry;
+        config.mcpServers = mcpServers;
+        try {
+            writeTextAtomically(writePath, `${JSON.stringify(config, null, 2)}\n`, originalText, beforeCommit, symlinkPath);
+            return result(definition, "refreshed");
+        }
+        catch (error) {
+            return result(definition, "error", error instanceof Error ? error.message : String(error));
+        }
+    }
+    if (dryRun) {
+        return result(definition, "would-register");
+    }
+    mcpServers["prism-mcp"] = entry;
+    config.mcpServers = mcpServers;
+    try {
+        writeTextAtomically(writePath, `${JSON.stringify(config, null, 2)}\n`, originalText, beforeCommit, symlinkPath);
+        return result(definition, "registered");
+    }
+    catch (error) {
+        return result(definition, "error", error instanceof Error ? error.message : String(error));
+    }
+}
+function registerCodexTomlHost(definition, entry, dryRun, refresh, beforeCommit) {
+    const { configPath } = definition;
+    let config = {};
+    let originalText;
+    let writePath = configPath;
+    let symlinkPath;
+    try {
+        const pathInfo = lstatSync(configPath);
+        if (pathInfo.isSymbolicLink()) {
+            try {
+                writePath = realpathSync(configPath);
+                symlinkPath = configPath;
+                if (!statSync(writePath).isFile()) {
+                    throw new Error("config symlink target is not a regular file");
+                }
+            }
+            catch (error) {
+                return result(definition, "error", `config symlink target is unavailable: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
+        try {
+            originalText = readFileSync(writePath, "utf8");
+            const parsed = parseToml(originalText);
+            if (!isJsonObject(parsed)) {
+                throw new Error("top-level TOML value must be a table");
+            }
+            config = parsed;
+        }
+        catch (error) {
+            return result(definition, "error", `could not parse config: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    catch (error) {
+        if (!isErrno(error, "ENOENT")) {
+            return result(definition, "error", `could not inspect config: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    let managedBlock;
+    try {
+        managedBlock = locateCodexManagedBlock(originalText ?? "");
+    }
+    catch (error) {
+        return result(definition, "error", error instanceof Error ? error.message : String(error));
+    }
+    const currentServers = config.mcp_servers;
+    if (currentServers !== undefined && !isJsonObject(currentServers)) {
+        return result(definition, "error", '"mcp_servers" must be a TOML table');
+    }
+    const mcpServers = (currentServers ?? {});
+    const hasCanonical = Object.prototype.hasOwnProperty.call(mcpServers, "prism-mcp");
+    const hasLegacy = Object.prototype.hasOwnProperty.call(mcpServers, "prism");
+    if (hasCanonical && hasLegacy) {
+        return result(definition, "error", "Codex config contains both prism and prism-mcp entries; resolve the duplicate before retrying");
+    }
+    if (hasCanonical || hasLegacy) {
+        const existingKey = hasCanonical ? "prism-mcp" : "prism";
+        const existingEntry = mcpServers[existingKey];
+        if (!refresh || existingKey !== "prism-mcp") {
+            return result(definition, "existing", "Prism is already registered; existing entry left untouched");
+        }
+        if (!managedBlock) {
+            return result(definition, "existing", "Prism is already registered; existing entry left untouched");
+        }
+        if (!isManagedPrismEntry(existingEntry)) {
+            return result(definition, "error", "Prism-managed Codex block has an invalid ownership marker");
+        }
+        const refreshedEntry = refreshManagedEntry(existingEntry, entry);
+        if (isDeepStrictEqual(refreshedEntry, existingEntry)) {
+            return result(definition, "existing", "Prism-managed entry is already current");
+        }
+        let nextText;
+        try {
+            nextText = `${originalText.slice(0, managedBlock.start)}${serializeCodexManagedBlock(refreshedEntry, originalText)}${originalText.slice(managedBlock.end)}`;
+            validateCodexCandidate(nextText);
+        }
+        catch (error) {
+            return result(definition, "error", `could not build valid Codex config: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        if (dryRun) {
+            return result(definition, "would-refresh");
+        }
+        try {
+            writeTextAtomically(writePath, nextText, originalText, beforeCommit, symlinkPath);
+            return result(definition, "refreshed");
+        }
+        catch (error) {
+            return result(definition, "error", error instanceof Error ? error.message : String(error));
+        }
+    }
+    if (managedBlock) {
+        return result(definition, "error", "Codex config contains a Prism-managed marker without its MCP entry");
+    }
+    let nextText;
+    try {
+        const currentText = originalText ?? "";
+        const newline = currentText.includes("\r\n") ? "\r\n" : "\n";
+        const separator = currentText.length === 0
+            ? ""
+            : currentText.endsWith("\n") || currentText.endsWith("\r")
+                ? newline
+                : `${newline}${newline}`;
+        nextText = `${currentText}${separator}${serializeCodexManagedBlock(entry, currentText)}`;
+        validateCodexCandidate(nextText);
+    }
+    catch (error) {
+        return result(definition, "error", `could not safely extend Codex config without rewriting existing TOML: ${error instanceof Error ? error.message : String(error)}. Convert an inline mcp_servers value to standard TOML tables, then retry`);
+    }
+    if (dryRun) {
+        return result(definition, "would-register");
+    }
+    try {
+        writeTextAtomically(writePath, nextText, originalText, beforeCommit, symlinkPath);
+        return result(definition, "registered");
+    }
+    catch (error) {
+        return result(definition, "error", error instanceof Error ? error.message : String(error));
+    }
+}
+function serializeCodexManagedBlock(entry, existingText) {
+    const newline = existingText.includes("\r\n") ? "\r\n" : "\n";
+    const serialized = stringifyToml({ mcp_servers: { "prism-mcp": entry } }).trimEnd();
+    return `${CODEX_MANAGED_START}\n${serialized}\n${CODEX_MANAGED_END}\n`.replaceAll("\n", newline);
+}
+function validateCodexCandidate(text) {
+    const parsed = parseToml(text);
+    if (!isJsonObject(parsed) || !isJsonObject(parsed.mcp_servers)) {
+        throw new Error("generated mcp_servers table is unavailable");
+    }
+    const entry = parsed.mcp_servers["prism-mcp"];
+    if (!isManagedPrismEntry(entry)) {
+        throw new Error("generated prism-mcp entry failed ownership validation");
+    }
+}
+function locateCodexManagedBlock(text) {
+    const starts = findExactLineRanges(text, CODEX_MANAGED_START);
+    const ends = findExactLineRanges(text, CODEX_MANAGED_END);
+    if (starts.length === 0 && ends.length === 0)
+        return undefined;
+    if (starts.length !== 1 || ends.length !== 1 || starts[0].start >= ends[0].start) {
+        throw new Error("Codex config has malformed or duplicate Prism-managed markers; no changes made");
+    }
+    return { start: starts[0].start, end: ends[0].end };
+}
+function findExactLineRanges(text, expected) {
+    const ranges = [];
+    let start = 0;
+    while (start <= text.length) {
+        const newline = text.indexOf("\n", start);
+        const lineEnd = newline === -1 ? text.length : newline;
+        const contentEnd = lineEnd > start && text[lineEnd - 1] === "\r" ? lineEnd - 1 : lineEnd;
+        if (text.slice(start, contentEnd) === expected) {
+            ranges.push({ start, end: newline === -1 ? text.length : newline + 1 });
+        }
+        if (newline === -1)
+            break;
+        start = newline + 1;
+    }
+    return ranges;
+}
+function writeTextAtomically(filePath, contents, expectedText, beforeCommit, symlinkPath) {
+    const directory = dirname(filePath);
+    mkdirSync(directory, { recursive: true, mode: 0o700 });
+    const mode = existsSync(filePath) ? statSync(filePath).mode & 0o777 : 0o600;
+    const tempPath = join(directory, `.${basename(filePath)}.prism-${process.pid}-${Date.now()}-${Math.random().toString(16).slice(2)}.tmp`);
+    try {
+        writeFileSync(tempPath, contents, {
+            encoding: "utf8",
+            flag: "wx",
+            mode,
+        });
+        beforeCommit?.(filePath);
+        if (symlinkPath) {
+            let currentTarget;
+            try {
+                currentTarget = realpathSync(symlinkPath);
+                if (currentTarget !== filePath || !statSync(currentTarget).isFile()) {
+                    throw new Error("target changed");
+                }
+            }
+            catch (error) {
+                throw new Error(`Config symlink changed while Prism was preparing the update; retry: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
+        if (expectedText === undefined) {
+            if (existsSync(filePath)) {
+                throw new Error(`Config changed while Prism was preparing the update; retry: ${filePath}`);
+            }
+        }
+        else {
+            let currentText;
+            try {
+                currentText = readFileSync(filePath, "utf8");
+            }
+            catch (error) {
+                throw new Error(`Config changed while Prism was preparing the update; retry: ${error instanceof Error ? error.message : String(error)}`);
+            }
+            if (currentText !== expectedText) {
+                throw new Error(`Config changed while Prism was preparing the update; retry: ${filePath}`);
+            }
+        }
+        // This compare-before-rename catches observable host edits and the rename
+        // itself is atomic. No portable filesystem API can make the comparison and
+        // replacement one operation against an uncooperative host, which is why the
+        // CLI also tells users to close target hosts before writing.
+        renameSync(tempPath, filePath);
+    }
+    finally {
+        if (existsSync(tempPath))
+            unlinkSync(tempPath);
+    }
+}
+function result(definition, status, message) {
+    return {
+        host: definition.name,
+        label: definition.label,
+        path: definition.configPath,
+        status,
+        message,
+    };
+}
+function isJsonObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isManagedPrismEntry(value) {
+    return isJsonObject(value)
+        && isJsonObject(value.env)
+        && value.env.PRISM_INSTANCE === "prism-mcp";
+}
+function refreshManagedEntry(existing, desired) {
+    const existingEnv = isJsonObject(existing.env) ? existing.env : {};
+    const desiredEnv = isJsonObject(desired.env) ? desired.env : {};
+    const mergedEnv = {
+        ...existingEnv,
+        ...desiredEnv,
+    };
+    if (!Object.prototype.hasOwnProperty.call(desiredEnv, "PRISM_SYNALUX_API_KEY")) {
+        delete mergedEnv.PRISM_SYNALUX_API_KEY;
+    }
+    return {
+        ...existing,
+        command: desired.command,
+        args: desired.args,
+        env: mergedEnv,
+    };
+}
+function isErrno(error, code) {
+    return error instanceof Error && error.code === code;
+}

package/dist/onboarding/wizard.js

@@ -94,41 +94,18 @@ session_save_ledger({
     };
 }
 function getIDEConfigContent(client = "claude_desktop") {
-    const configs = {
-        claude_desktop: `{
-  "mcpServers": {
-    "prism-mcp": {
-      "command": "npx",
-      "args": ["-y", "prism-mcp@latest"],
-      "env": {
-        "BRAVE_API_KEY": "your-brave-key"
-      }
-    }
-  }
-}`,
-        cursor: `{
-  "mcpServers": {
-    "prism-mcp": {
-      "command": "npx",
-      "args": ["-y", "prism-mcp@latest"],
-      "env": {
-        "BRAVE_API_KEY": "your-brave-key"
-      }
-    }
-  }
-}`,
-    };
+    const host = client === "cursor" ? "cursor" : "claude-desktop";
     return {
         step: "ide_config",
         title: "⚙️ Configure Your IDE",
-        description: "Add Prism as an MCP server in your AI coding tool's configuration.",
+        description: "Register Prism as an MCP server in your AI coding tool.",
         instructions: [
-            "Copy the config below into your IDE's MCP configuration file",
-            "For Claude Desktop: ~/Library/Application Support/Claude/claude_desktop_config.json",
-            "For Cursor: .cursor/mcp.json in your workspace",
+            "Run the command below in a terminal",
+            "Prism adds only a missing registration and never overwrites custom entries",
+            "Use --dry-run first if you want to preview the target file",
             "Restart your IDE to pick up the new MCP server",
         ],
-        codeSnippet: configs[client] || configs.claude_desktop,
+        codeSnippet: `prism connect --host ${host}`,
         nextStep: "first_save",
         progress: 43,
     };