nexting-cc-bridge 0.8.3

package/dist/mcp-config.js

@@ -0,0 +1,230 @@
+// Per-session MCP config writer for the device-tool proxy.
+//
+// When the bridge spawns an engine child (claude / codex) for an attached
+// session it injects the `pinclaw-device` MCP server so the agent can call the
+// phone's device tools (calendar / reminders / contacts / location / health /
+// homekit). The proxy (`mcp-device-proxy.ts`) is a standalone stdio MCP server
+// that forwards each call to the cloud, which fans it out to the phone's SSE
+// stream. This module ONLY writes / removes the per-session config that points
+// the engine at that proxy.
+//
+// claude: a JSON file at `~/.nexting/cc-mcp-{sessionId}.json`, passed via
+//   `--mcp-config <path>` (verified supported in `--print` mode, CLI 2.1.170 —
+//   `--mcp-config <configs...>` is a global flag, not interactive-only; chosen
+//   over writing `.mcp.json` into the user's repo so we never touch the project).
+// codex: app-server reads `~/.codex/config.toml` `[mcp_servers.*]`; we MERGE a
+//   marker-fenced `[mcp_servers.pinclaw-device-{sessionId}]` block in/out
+//   idempotently, leaving the rest of the (rich, user-owned) file byte-intact.
+//
+// The proxy reads its config from env (see mcp-device-proxy.ts):
+//   NEXTING_CLOUD_URL / NEXTING_BUS_TOKEN / NEXTING_ENGINE(cc|codex) /
+//   NEXTING_SESSION_ID
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+/** Map the bridge's engine label to the proxy's NEXTING_ENGINE value. */
+export function proxyEngine(engine) {
+    return engine === "codex" ? "codex" : "cc";
+}
+/** Absolute path to the compiled proxy entrypoint. The bridge runs from
+ *  `dist/<module>.js`, so the proxy sits at `dist/mcp-device-proxy.js` next to
+ *  this module. Under tsx (dev) it resolves to the `.ts` source instead — node
+ *  runs either via the shebang-less `node <path>` spawn, and tsx is already the
+ *  loader for the dev path, so both work. */
+export function resolveProxyEntry() {
+    const here = fileURLToPath(import.meta.url); // .../dist/mcp-config.js (or src/mcp-config.ts)
+    return path.join(path.dirname(here), "mcp-device-proxy.js");
+}
+const NEXTING_DIR = path.join(os.homedir(), ".nexting");
+/** Per-session claude MCP config file path. */
+export function claudeMcpConfigPath(sessionId) {
+    return path.join(NEXTING_DIR, `cc-mcp-${sanitizeId(sessionId)}.json`);
+}
+/** The codex config.toml the app-server reads. */
+export function codexConfigTomlPath() {
+    return path.join(os.homedir(), ".codex", "config.toml");
+}
+/** Server key under `[mcp_servers.*]` for a session (codex). TOML bare keys
+ *  allow `[A-Za-z0-9_-]`; we sanitize the sessionId to stay in that set. */
+export function codexServerKey(sessionId) {
+    return `pinclaw-device-${sanitizeId(sessionId)}`;
+}
+/** Keep ids filesystem- and TOML-key-safe (uuids + "new" already are, but a
+ *  resumed-session id could in theory carry odd chars). */
+function sanitizeId(id) {
+    return id.replace(/[^A-Za-z0-9_-]/g, "_");
+}
+// --- the env the proxy needs, shared by both engines -------------------------
+function proxyEnv(input) {
+    return {
+        NEXTING_CLOUD_URL: input.cloudUrl,
+        NEXTING_BUS_TOKEN: input.busToken,
+        NEXTING_ENGINE: proxyEngine(input.engine),
+        // Route to the real session id if known (post-rekey), else the file key.
+        NEXTING_SESSION_ID: input.routeSessionId ?? input.sessionId,
+    };
+}
+// --- claude (JSON file) ------------------------------------------------------
+/** Build the claude `--mcp-config` JSON object (exported for tests). */
+export function buildClaudeMcpConfig(input) {
+    return {
+        mcpServers: {
+            "pinclaw-device": {
+                type: "stdio",
+                command: process.execPath, // the node running the bridge (launchd PATH is minimal)
+                args: [resolveProxyEntry()],
+                env: proxyEnv(input),
+            },
+        },
+    };
+}
+/** Write the per-session claude MCP config file. Returns its path (to pass as
+ *  `--mcp-config <path>`). Never throws on a transient write error — a failed
+ *  config must not block the session; it just means no device tools. */
+export function writeClaudeMcpConfig(input) {
+    const p = claudeMcpConfigPath(input.sessionId);
+    try {
+        fs.mkdirSync(NEXTING_DIR, { recursive: true });
+        fs.writeFileSync(p, JSON.stringify(buildClaudeMcpConfig(input), null, 2));
+        return p;
+    }
+    catch {
+        return null;
+    }
+}
+/** Remove the per-session claude MCP config file (session end / cleanup). */
+export function removeClaudeMcpConfig(sessionId) {
+    try {
+        fs.unlinkSync(claudeMcpConfigPath(sessionId));
+    }
+    catch {
+        /* already gone */
+    }
+}
+// --- codex (config.toml merge) -----------------------------------------------
+/** TOML-escape a basic string value (double-quoted). */
+function tomlString(value) {
+    return `"${value.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
+}
+const FENCE_START = (key) => `# >>> pinclaw-device ${key} >>>`;
+const FENCE_END = (key) => `# <<< pinclaw-device ${key} <<<`;
+/** Build the fenced `[mcp_servers.<key>]` block for codex (exported for tests).
+ *  Fenced so it can be removed idempotently without a TOML parser. */
+export function buildCodexMcpBlock(input) {
+    const key = codexServerKey(input.sessionId);
+    const env = proxyEnv(input);
+    const envLines = Object.entries(env)
+        .map(([k, v]) => `${k} = ${tomlString(v)}`)
+        .join("\n");
+    return [
+        FENCE_START(key),
+        `[mcp_servers.${key}]`,
+        `command = ${tomlString(process.execPath)}`,
+        `args = [${tomlString(resolveProxyEntry())}]`,
+        ``,
+        `[mcp_servers.${key}.env]`,
+        envLines,
+        FENCE_END(key),
+    ].join("\n");
+}
+/** Strip a previously-written fenced block for `key` out of `toml` content.
+ *  Pure (exported for tests) — handles missing block (no-op) and trailing
+ *  newline hygiene so repeated write/remove cycles don't accrete blank lines. */
+export function stripCodexMcpBlock(toml, key) {
+    const start = FENCE_START(key);
+    const end = FENCE_END(key);
+    const lines = toml.split("\n");
+    const out = [];
+    let skipping = false;
+    for (const line of lines) {
+        if (line.trim() === start) {
+            skipping = true;
+            continue;
+        }
+        if (skipping) {
+            if (line.trim() === end)
+                skipping = false;
+            continue;
+        }
+        out.push(line);
+    }
+    // collapse any double-blank seam left where the block was removed
+    return out.join("\n").replace(/\n{3,}/g, "\n\n");
+}
+/** Merge the codex MCP block into `existing` toml content (pure, for tests).
+ *  Idempotent: strips any prior block for this session first, then appends the
+ *  fresh one (token/sessionId may have changed across reconnects). */
+export function mergeCodexMcpToml(existing, input) {
+    const key = codexServerKey(input.sessionId);
+    const base = stripCodexMcpBlock(existing, key).replace(/\s+$/, "");
+    const block = buildCodexMcpBlock(input);
+    return base.length > 0 ? `${base}\n\n${block}\n` : `${block}\n`;
+}
+/** Merge the pinclaw-device server into the codex config.toml on disk. Never
+ *  throws — a failed merge just means no device tools for this session. */
+export function writeCodexMcpConfig(input) {
+    const p = codexConfigTomlPath();
+    try {
+        fs.mkdirSync(path.dirname(p), { recursive: true });
+        let existing = "";
+        try {
+            existing = fs.readFileSync(p, "utf8");
+        }
+        catch {
+            /* new file */
+        }
+        fs.writeFileSync(p, mergeCodexMcpToml(existing, input));
+    }
+    catch {
+        /* leave config untouched on error */
+    }
+}
+/** Remove this session's pinclaw-device block from the codex config.toml. */
+export function removeCodexMcpConfig(sessionId) {
+    const p = codexConfigTomlPath();
+    try {
+        const existing = fs.readFileSync(p, "utf8");
+        const stripped = stripCodexMcpBlock(existing, codexServerKey(sessionId));
+        if (stripped !== existing)
+            fs.writeFileSync(p, stripped);
+    }
+    catch {
+        /* nothing to strip */
+    }
+}
+// --- unified write / cleanup -------------------------------------------------
+/** Write the per-session MCP config for the given engine. For claude, returns
+ *  the config file path to append as `--mcp-config <path>`; for codex returns
+ *  null (the config lives in the shared config.toml the app-server reads). */
+export function writeMcpConfig(input) {
+    if (input.engine === "codex") {
+        writeCodexMcpConfig(input);
+        return null;
+    }
+    return writeClaudeMcpConfig(input);
+}
+/** Tear down the per-session MCP config (session end). Engine-aware. */
+export function cleanupMcpConfig(engine, sessionId) {
+    if (engine === "codex")
+        removeCodexMcpConfig(sessionId);
+    else
+        removeClaudeMcpConfig(sessionId);
+}
+/** Derive the cloud HTTP base from the bridge's WS connect url.
+ *  `wss://api.nexting.ai/cc-bridge/connect` → `https://api.nexting.ai`. */
+export function cloudHttpBaseFromWsUrl(wsUrl) {
+    try {
+        const u = new URL(wsUrl);
+        const proto = u.protocol === "ws:" ? "http:" : "https:";
+        return `${proto}//${u.host}`;
+    }
+    catch {
+        // Fallback: best-effort scheme swap + strip the path.
+        return wsUrl
+            .replace(/^wss:/, "https:")
+            .replace(/^ws:/, "http:")
+            .replace(/\/cc-bridge\/connect.*$/, "")
+            .replace(/\/codex-bridge\/connect.*$/, "");
+    }
+}