@echomem/mcp 1.4.16 → 1.4.18

package/dist/hud/session-launcher.js

@@ -0,0 +1,395 @@
+import { spawn } from "node:child_process";
+import { randomUUID } from "node:crypto";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import readline from "node:readline";
+const RPC_TIMEOUT_MS = 8_000;
+const MAX_CONTEXT_CHARS = 512_000;
+/**
+ * Open a fresh agent session and send the EchoMem carryover as its first user message.
+ * Codex starts a real app-server turn; Claude Code seeds a persisted session from stdin, then resumes
+ * it interactively. Neither path places the (potentially sensitive) carryover in process arguments.
+ */
+export async function launchWarmSession(input, deps = {}) {
+    const prompt = input.prompt.trim();
+    if (!prompt || prompt.length > MAX_CONTEXT_CHARS)
+        return { ok: false, reason: "invalid_context" };
+    if (!path.isAbsolute(input.cwd) || !isDirectory(input.cwd))
+        return { ok: false, reason: "workspace_missing" };
+    if (input.client === "codex")
+        return launchCodexAppSession({ ...input, prompt }, deps);
+    if (input.client === "claude-code")
+        return launchClaudeCodeSession({ ...input, prompt }, deps);
+    return { ok: false, reason: "claude_desktop_requires_paste" };
+}
+export function codexFirstUserMessage(prompt) {
+    return { type: "text", text: prompt };
+}
+export function buildClaudeLaunchScript(args) {
+    const claude = args.claudeCommand || "claude";
+    return [
+        "#!/bin/zsh -l",
+        "set -u",
+        `PROMPT_FILE=${shellQuote(args.promptFile)}`,
+        `SCRIPT_FILE=${shellQuote(args.scriptFile)}`,
+        `SESSION_ID=${shellQuote(args.sessionId)}`,
+        'cleanup() { rm -f -- "$PROMPT_FILE" "$SCRIPT_FILE"; }',
+        "trap cleanup EXIT HUP INT TERM",
+        `cd -- ${shellQuote(args.cwd)} || exit 1`,
+        'echo "EchoMem is sending the carryover as this session\'s first message…"',
+        `if ! ${shellQuote(claude)} -p --session-id "$SESSION_ID" --name ${shellQuote(args.sessionName)} < "$PROMPT_FILE" >/dev/null; then`,
+        '  echo "EchoMem could not seed the Claude Code session."',
+        "  exit 1",
+        "fi",
+        "cleanup",
+        "trap - EXIT HUP INT TERM",
+        `exec ${shellQuote(claude)} --resume "$SESSION_ID"`,
+    ].join("\n") + "\n";
+}
+/** Read the real workspace path from the transcript metadata without trusting a renderer payload. */
+export function readSessionWorkingDirectory(filePath) {
+    let fd = null;
+    try {
+        fd = fs.openSync(filePath, "r");
+        const buffer = Buffer.alloc(512 * 1024);
+        const bytes = fs.readSync(fd, buffer, 0, buffer.length, 0);
+        let latest = null;
+        for (const line of buffer.subarray(0, bytes).toString("utf8").split("\n")) {
+            if (!line.trim())
+                continue;
+            let value;
+            try {
+                value = JSON.parse(line);
+            }
+            catch {
+                continue;
+            }
+            if (!isRecord(value))
+                continue;
+            const payload = isRecord(value.payload) ? value.payload : null;
+            const candidate = typeof value.cwd === "string" ? value.cwd : payload && typeof payload.cwd === "string" ? payload.cwd : "";
+            if (path.isAbsolute(candidate))
+                latest = candidate;
+        }
+        return latest;
+    }
+    catch {
+        return null;
+    }
+    finally {
+        if (fd !== null)
+            fs.closeSync(fd);
+    }
+}
+async function launchCodexAppSession(input, deps) {
+    if (!deps.openExternal)
+        return { ok: false, reason: "no_desktop" };
+    const command = deps.codexCommand || resolveCodexCommand();
+    let child = null;
+    let rpc = null;
+    let threadId = "";
+    try {
+        child = spawn(command, ["app-server"], { stdio: ["pipe", "pipe", "pipe"], env: processEnv() });
+        rpc = new JsonRpcClient(child);
+        await rpc.request("initialize", {
+            clientInfo: { name: "echomem_hud", title: "EchoMem HUD", version: "1" },
+            capabilities: { experimentalApi: true },
+        });
+        rpc.notify("initialized", {});
+        const started = await rpc.request("thread/start", { cwd: input.cwd, threadSource: "echomem" });
+        threadId = nestedString(started, "thread", "id");
+        if (!threadId)
+            throw new Error("thread_start_failed");
+        await rpc.request("thread/name/set", { threadId, name: sessionName(input) });
+        const completion = rpc.waitForNotification("turn/completed", 30 * 60 * 1_000);
+        const turnStarted = await rpc.request("turn/start", {
+            threadId,
+            cwd: input.cwd,
+            input: [codexFirstUserMessage(input.prompt)],
+        }, 20_000);
+        const turnId = nestedString(turnStarted, "turn", "id");
+        if (!turnId)
+            throw new Error("turn_start_failed");
+        // Codex desktop does not live-refresh a thread that another app-server process opened before
+        // its first turn was persisted. Wait for the auto-sent carryover turn and a graceful app-server
+        // shutdown before deep-linking, so the task loads with the message already present.
+        await completion;
+        await rpc.closeAndWait();
+        rpc = null;
+        child = null;
+        const link = `codex://threads/${threadId}`;
+        try {
+            await deps.openExternal(link);
+        }
+        catch {
+            return { ok: false, mode: "codex-app", threadId, turnId, messageSent: true, link, reason: "open_failed" };
+        }
+        return { ok: true, mode: "codex-app", threadId, turnId, messageSent: true, link };
+    }
+    catch (error) {
+        if (rpc && threadId) {
+            try {
+                await rpc.request("thread/delete", { threadId }, 1_000);
+            }
+            catch {
+                /* best-effort cleanup of a partially created warm-start */
+            }
+        }
+        rpc?.close();
+        if (child && !child.killed)
+            child.kill();
+        return { ok: false, reason: launchErrorReason(error, "codex_launch_failed") };
+    }
+}
+async function launchClaudeCodeSession(input, deps) {
+    if (!deps.openPath)
+        return { ok: false, reason: "no_desktop" };
+    const dir = deps.launchDir || path.join(os.homedir(), ".echomem", "warm-starts");
+    const id = randomUUID();
+    const promptFile = path.join(dir, `${id}.md`);
+    const scriptFile = path.join(dir, `${id}.command`);
+    try {
+        fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+        pruneLaunchDir(dir);
+        fs.writeFileSync(promptFile, input.prompt, { encoding: "utf8", mode: 0o600 });
+        fs.writeFileSync(scriptFile, buildClaudeLaunchScript({
+            cwd: input.cwd,
+            promptFile,
+            scriptFile,
+            claudeCommand: deps.claudeCommand || process.env.ECHO_CLAUDE_BIN,
+            sessionId: id,
+            sessionName: sessionName(input),
+        }), { encoding: "utf8", mode: 0o700 });
+        fs.chmodSync(promptFile, 0o600);
+        fs.chmodSync(scriptFile, 0o700);
+        const openError = await deps.openPath(scriptFile);
+        if (openError)
+            throw new Error("open_failed");
+        return { ok: true, mode: "claude-code", threadId: id, messageSent: true };
+    }
+    catch (error) {
+        safeRemove(promptFile);
+        safeRemove(scriptFile);
+        return { ok: false, reason: launchErrorReason(error, "claude_launch_failed") };
+    }
+}
+class JsonRpcClient {
+    child;
+    nextId = 1;
+    pending = new Map();
+    lines;
+    notificationWaiters = new Set();
+    closed = false;
+    constructor(child) {
+        this.child = child;
+        this.lines = readline.createInterface({ input: child.stdout });
+        this.lines.on("line", (line) => this.onLine(line));
+        // Drain diagnostics without logging them: this prevents a full stderr pipe from stalling the
+        // app-server and keeps local context/error details out of HUD stdout.
+        child.stderr.resume();
+        child.stdin.on("error", () => this.failAll(new Error("codex_app_server_write_failed")));
+        child.once("error", () => this.failAll(new Error("codex_not_found")));
+        child.once("exit", () => this.failAll(new Error("codex_app_server_exited")));
+    }
+    request(method, params, timeoutMs = RPC_TIMEOUT_MS) {
+        if (this.closed)
+            return Promise.reject(new Error("codex_app_server_closed"));
+        const id = this.nextId++;
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                this.pending.delete(id);
+                reject(new Error("codex_app_server_timeout"));
+            }, timeoutMs);
+            this.pending.set(id, { resolve, reject, timer });
+            this.write({ method, id, params });
+        });
+    }
+    notify(method, params) {
+        this.write({ method, params });
+    }
+    waitForNotification(method, timeoutMs) {
+        if (this.closed)
+            return Promise.reject(new Error("codex_app_server_closed"));
+        return new Promise((resolve, reject) => {
+            const waiter = {
+                method,
+                resolve,
+                reject,
+                timer: setTimeout(() => {
+                    this.notificationWaiters.delete(waiter);
+                    reject(new Error("codex_app_server_timeout"));
+                }, timeoutMs),
+            };
+            waiter.timer.unref();
+            this.notificationWaiters.add(waiter);
+        });
+    }
+    close() {
+        if (this.closed)
+            return;
+        this.beginClose();
+        const child = this.child;
+        const timer = setTimeout(() => {
+            if (child.exitCode === null && child.signalCode === null)
+                child.kill();
+        }, 500);
+        timer.unref();
+    }
+    async closeAndWait(timeoutMs = 1_500) {
+        this.beginClose();
+        if (await waitForChildExit(this.child, timeoutMs))
+            return;
+        this.child.kill();
+        await waitForChildExit(this.child, 500);
+    }
+    beginClose() {
+        if (this.closed)
+            return;
+        this.closed = true;
+        this.failAll(new Error("codex_app_server_closed"));
+        this.lines.close();
+        this.child.stdin.end();
+    }
+    write(message) {
+        try {
+            this.child.stdin.write(`${JSON.stringify(message)}\n`);
+        }
+        catch {
+            this.failAll(new Error("codex_app_server_write_failed"));
+        }
+    }
+    onLine(line) {
+        let message;
+        try {
+            message = JSON.parse(line);
+        }
+        catch {
+            return;
+        }
+        if (!isRecord(message))
+            return;
+        if (typeof message.method === "string" && typeof message.id !== "number") {
+            for (const waiter of this.notificationWaiters) {
+                if (waiter.method !== message.method)
+                    continue;
+                this.notificationWaiters.delete(waiter);
+                clearTimeout(waiter.timer);
+                waiter.resolve(message);
+            }
+            return;
+        }
+        if (typeof message.id !== "number")
+            return;
+        const pending = this.pending.get(message.id);
+        if (!pending)
+            return;
+        this.pending.delete(message.id);
+        clearTimeout(pending.timer);
+        if (isRecord(message.error)) {
+            pending.reject(new Error(typeof message.error.message === "string" ? message.error.message : "codex_rpc_error"));
+        }
+        else {
+            pending.resolve(message.result);
+        }
+    }
+    failAll(error) {
+        for (const pending of this.pending.values()) {
+            clearTimeout(pending.timer);
+            pending.reject(error);
+        }
+        this.pending.clear();
+        for (const waiter of this.notificationWaiters) {
+            clearTimeout(waiter.timer);
+            waiter.reject(error);
+        }
+        this.notificationWaiters.clear();
+    }
+}
+function resolveCodexCommand() {
+    if (process.env.ECHO_CODEX_BIN)
+        return process.env.ECHO_CODEX_BIN;
+    const bundled = "/Applications/ChatGPT.app/Contents/Resources/codex";
+    return fs.existsSync(bundled) ? bundled : "codex";
+}
+function sessionName(input) {
+    const project = path.basename(input.cwd) || "workspace";
+    return (`EchoMem carryover · ${project}`).slice(0, 80);
+}
+function waitForChildExit(child, timeoutMs) {
+    if (child.exitCode !== null || child.signalCode !== null)
+        return Promise.resolve(true);
+    return new Promise((resolve) => {
+        let settled = false;
+        const finish = (exited) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            child.off("exit", onExit);
+            resolve(exited);
+        };
+        const onExit = () => finish(true);
+        const timer = setTimeout(() => finish(false), timeoutMs);
+        timer.unref();
+        child.once("exit", onExit);
+    });
+}
+function processEnv() {
+    return { ...process.env, NO_COLOR: "1" };
+}
+function nestedString(value, outer, inner) {
+    if (!isRecord(value) || !isRecord(value[outer]))
+        return "";
+    return typeof value[outer][inner] === "string" ? value[outer][inner] : "";
+}
+function shellQuote(value) {
+    return `'${value.replace(/'/g, `'\\''`)}'`;
+}
+function isDirectory(value) {
+    try {
+        return fs.statSync(value).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+function pruneLaunchDir(dir) {
+    const cutoff = Date.now() - 7 * 24 * 60 * 60 * 1000;
+    try {
+        for (const name of fs.readdirSync(dir)) {
+            if (!/^[0-9a-f-]+\.(?:md|command)$/i.test(name))
+                continue;
+            const file = path.join(dir, name);
+            if (fs.statSync(file).mtimeMs < cutoff)
+                safeRemove(file);
+        }
+    }
+    catch {
+        /* cleanup is best-effort */
+    }
+}
+function safeRemove(file) {
+    try {
+        fs.rmSync(file, { force: true });
+    }
+    catch {
+        /* best-effort */
+    }
+}
+function launchErrorReason(error, fallback) {
+    if (!(error instanceof Error))
+        return fallback;
+    const known = new Set([
+        "codex_not_found",
+        "codex_app_server_exited",
+        "codex_app_server_timeout",
+        "thread_start_failed",
+        "turn_start_failed",
+        "open_failed",
+    ]);
+    return known.has(error.message) ? error.message : fallback;
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}