@minhspark/codex-mcp-bridge 1.27.1 → 2.0.0

package/src/claude-session-creation.mjs

@@ -1,306 +0,0 @@
-import fs from "node:fs";
-import path from "node:path";
-
-const REQUEST_ID = /^(?:[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}|[0-9a-f]{32,128})$/i;
-const PENDING = new Set(["awaiting_user", "awaiting_session", "submission_uncertain", "launch_uncertain", "ambiguous", "awaiting_project_confirmation"]);
-const STATUSES = new Set([...PENDING, "created", "abandoned"]);
-const MAX_REQUESTS = 32;
-const MAX_TASKS = 8192;
-
-function fail(code, message) {
-  throw Object.assign(new Error(message), { code });
-}
-
-function string(value, max = 1024) {
-  return typeof value === "string" && value.length > 0 && value.length <= max && !value.includes("\0");
-}
-
-function accountIdentity(account) {
-  if (account?.status !== "verified" || !string(account.fingerprint) || !string(account.root, 8192)) {
-    fail("CLAUDE_ACCOUNT_UNVERIFIED", "The current Claude Desktop account must be verified.");
-  }
-  return { fingerprint: account.fingerprint, root: account.root };
-}
-
-function sameAccount(left, right) {
-  return left.fingerprint === right.fingerprint && left.root === right.root;
-}
-
-function augmentedPrompt(prompt, requestId) {
-  if (!string(prompt, 14000) || !prompt.trim()) fail("CLAUDE_CREATION_PROMPT_INVALID", "Provide a nonempty prompt of at most 14000 characters.");
-  const submitted = `${prompt.trim()}\n\n[Codex creation request: ${requestId}]`;
-  if (submitted.length > 14000) fail("CLAUDE_CREATION_PROMPT_TOO_LONG", "The prompt including its correlation marker exceeds 14000 characters.");
-  return submitted;
-}
-
-function matchesInitialMessage(text, expected) {
-  if (text === expected) return true;
-  const normalized = (value) => typeof value === "string" ? value.replace(/\r\n/g, "\n").split("\n").filter((line) => line !== "").join("\n") : null;
-  if (normalized(text) === normalized(expected)) return true;
-  if (typeof text !== "string" || !/^<system-reminder>\r?\nThe user started this session without choosing a project folder,/.test(text)) return false;
-  const closing = text.indexOf("</system-reminder>");
-  if (closing < 0 || closing > 32768) return false;
-  const body = text.slice("<system-reminder>".length, closing);
-  if (body.includes("<system-reminder") || body.includes("</system-reminder")) return false;
-  const suffix = text.slice(closing + "</system-reminder>".length);
-  const separator = /^\r?\n\r?\n/.exec(suffix);
-  return separator !== null && normalized(suffix.slice(separator[0].length)) === normalized(expected);
-}
-
-function receipt(request) {
-  const submitted = request.status === "created" || request.submissionObserved === true;
-  return structuredClone({ requestId: request.requestId, status: request.status, cwd: request.cwd,
-    // false means no verified observation, not proof that Desktop did not submit.
-    promptSubmitted: submitted, submissionStatus: submitted ? "observed" : "not_observed",
-    reason: request.reason, ...(request.observedCwd ? { observedCwd: request.observedCwd } : {}), ...(request.sessionId ? { sessionId: request.sessionId, taskId: request.taskId, title: request.title } : {}),
-    ...(PENDING.has(request.status) ? { directoryVerification: {
-      required: true, expectedCwd: request.cwd, verified: false,
-      detail: "The prefilled folder chip is not evidence of the actual session directory. Claude Desktop may create a No folder scratch session. An unobserved submission may be outside the authorized discovery scope; do not expand scope or resend to find it. Inspect Desktop before taking further action. For a fresh setup, prefer the intended project's sidebar New session button, verify the actual cwd with a read-only bootstrap, then dispatch work to the verified task. Do not replace a pending request without explicit cancellation.",
-    } } : {}) });
-}
-
-export class ClaudeSessionCreation {
-  constructor({ open, submit, trust, settle = async () => {}, listTasks, listSessions, readContext, readTranscript, readAccount, assertProcess, resolveProject, realpath = (directory) => {
-    const canonical = fs.realpathSync.native(directory);
-    if (!fs.statSync(canonical).isDirectory()) throw new Error("Not a directory");
-    return canonical;
-  }, platform = process.platform }) {
-    for (const [name, dependency] of Object.entries({ open, listTasks, listSessions, readContext, readTranscript, readAccount, assertProcess, realpath })) {
-      if (typeof dependency !== "function") throw new TypeError(`${name} must be a function`);
-    }
-    Object.assign(this, { open, submit, trust, settle, listTasks, listSessions, readContext, readTranscript, readAccount, assertProcess, resolveProject, realpath, platform });
-    this.requests = new Map();
-    this.queue = Promise.resolve();
-  }
-
-  async canonical(directory) {
-    const paths = this.platform === "win32" ? path.win32 : path.posix;
-    if (!string(directory, 8192) || !paths.isAbsolute(directory)) fail("CLAUDE_CREATION_CWD_INVALID", "The project directory must be an existing absolute directory.");
-    let canonical;
-    try { canonical = await this.realpath(directory); } catch { fail("CLAUDE_CREATION_CWD_INVALID", "The project directory does not exist or cannot be resolved."); }
-    if (!string(canonical, 8192) || !paths.isAbsolute(canonical)) fail("CLAUDE_CREATION_CWD_INVALID", "The canonical project directory is invalid.");
-    return canonical;
-  }
-
-  sameCwd(left, right) {
-    if (typeof left !== "string" || typeof right !== "string") return false;
-    return this.platform === "win32" ? left.toLowerCase() === right.toLowerCase() : left === right;
-  }
-
-  async checkAccount(account, expected) {
-    const provided = accountIdentity(account);
-    const current = accountIdentity(await this.readAccount());
-    if (!sameAccount(provided, current) || (expected && !sameAccount(provided, expected))) fail("CLAUDE_CREATION_ACCOUNT_CHANGED", "Claude Desktop account changed; this creation request cannot be used in another account.");
-    return provided;
-  }
-
-  start(args) {
-    const pending = this.queue.then(() => this.startLocked(args));
-    this.queue = pending.catch(() => {});
-    return pending;
-  }
-
-  async startLocked({ requestId, cwd, prompt, account, senderThreadId, beforeOpen, autoSubmit = false, trustProject = false }) {
-    if (!REQUEST_ID.test(requestId ?? "") || typeof requestId !== "string") fail("CLAUDE_CREATION_REQUEST_INVALID", "requestId must be a UUID or 32–128 hexadecimal characters.");
-    if (!string(senderThreadId, 256)) fail("CLAUDE_CREATION_SENDER_INVALID", "A verified sender thread identity is required.");
-    const identity = await this.checkAccount(account);
-    const canonical = await this.canonical(cwd);
-    const initialMessage = augmentedPrompt(prompt, requestId);
-    const prior = this.requests.get(requestId);
-    if (prior) {
-      if (!sameAccount(identity, prior.account) || prior.senderThreadId !== senderThreadId || !this.sameCwd(prior.cwd, canonical) || prior.prompt !== prompt) {
-        fail("CLAUDE_CREATION_REQUEST_CONFLICT", "This requestId is already bound to a different creation payload.");
-      }
-      if (autoSubmit && !prior.submissionAttempted && ["awaiting_user", "launch_uncertain"].includes(prior.status)) {
-        const observed = await this.inspect(requestId, { account, senderThreadId });
-        if (observed.promptSubmitted) return observed;
-        return this.completeRequest(prior, { account, senderThreadId, beforeOpen, trustProject });
-      }
-      return receipt(prior);
-    }
-    if (this.requests.size >= MAX_REQUESTS) fail("CLAUDE_CREATION_LIMIT", "The creation receipt limit has been reached; existing requests remain available for inspection.");
-    for (const existing of this.requests.values()) {
-      const composerReleased = existing.status === "awaiting_project_confirmation" && existing.submissionObserved === true;
-      if (sameAccount(existing.account, identity) && PENDING.has(existing.status) && !composerReleased) fail("CLAUDE_CREATION_PENDING", "A creation request is already pending for this account; inspect or explicitly abandon that request before opening another project in the shared composer.");
-    }
-    const tasks = await this.listTasks(account);
-    const validTasks = value => Array.isArray(value) && value.length <= MAX_TASKS && value.every(task => string(task?.taskId, 256) && (task.fileTaskId === undefined || task.fileTaskId === task.taskId)) && new Set(value.map(task => task.taskId)).size === value.length;
-    if (!validTasks(tasks)) fail("CLAUDE_CREATION_TASKS_INVALID", "The existing native task baseline cannot be verified.");
-    const baseline = new Set(tasks.map(task => task.taskId));
-    const projectCwd = async task => this.resolveProject ? this.resolveProject(task) : this.canonical(task.cwd);
-    let existingProject;
-    for (const task of tasks) {
-      if (task.isArchived !== false) continue;
-      try { if (this.sameCwd(await projectCwd(task), canonical)) { existingProject = task; break; } } catch {}
-    }
-    if (!existingProject) fail("CLAUDE_CREATION_PROJECT_NOT_FOUND", "The canonical directory must already belong to a nonarchived Claude Desktop task.");
-    if (autoSubmit && typeof this.submit !== "function") fail("CLAUDE_CREATION_SUBMIT_UNAVAILABLE", "Native composer submission is not available.");
-    if (trustProject && typeof this.trust !== "function") fail("CLAUDE_CREATION_TRUST_UNAVAILABLE", "Authorized project trust preparation is not available.");
-    const url = `claude://code/new?q=${encodeURIComponent(initialMessage)}&folder=${encodeURIComponent(canonical)}`;
-    if (url.length > 30000) fail("CLAUDE_CREATION_URL_TOO_LONG", "The encoded Claude Desktop link exceeds 30000 characters.");
-    await this.checkAccount(account, identity);
-    if (beforeOpen !== undefined) {
-      if (typeof beforeOpen !== "function") fail("CLAUDE_CREATION_PREFLIGHT_INVALID", "beforeOpen must be a function.");
-      await beforeOpen();
-    }
-    if (this.resolveProject) {
-      const currentTasks = await this.listTasks(account);
-      if (!validTasks(currentTasks)) fail("CLAUDE_CREATION_TASKS_INVALID", "The current native task baseline cannot be verified.");
-      const matches = currentTasks.filter(task => task.taskId === existingProject.taskId && task.fileTaskId === existingProject.fileTaskId && task.cwd === existingProject.cwd && task.isArchived === false);
-      if (matches.length !== 1 || !this.sameCwd(await projectCwd(matches[0]), canonical)) {
-        fail("CLAUDE_CREATION_PROJECT_NOT_FOUND", "The saved project or its authorized current directory changed before opening Desktop.");
-      }
-      for (const task of currentTasks) baseline.add(task.taskId);
-      if (baseline.size > MAX_TASKS) fail("CLAUDE_CREATION_TASKS_INVALID", "The native task baseline exceeds the creation limit.");
-      if (beforeOpen) await beforeOpen();
-    }
-    const projectSource = this.resolveProject ? { taskId: existingProject.taskId, fileTaskId: existingProject.fileTaskId, cwd: existingProject.cwd } : undefined;
-    const request = { requestId, cwd: canonical, prompt, initialMessage, account: identity, senderThreadId, baseline: [...baseline], ...(projectSource ? { projectSource } : {}), status: "launch_uncertain", reason: "The Desktop launch outcome is uncertain; inspect this request before taking further action." };
-    await this.revalidateProjectSource(request, account);
-    this.requests.set(requestId, request);
-    try {
-      await this.open(url);
-      if (autoSubmit) await this.settle();
-      request.status = "awaiting_user";
-      request.reason = "Claude Desktop was asked to prefill a new session; the bridge did not press Send. The folder chip alone does not confirm the actual directory. Verify the created task's cwd before dispatching work; absence of a discovered task does not prove that the prompt was not submitted.";
-    } catch {
-      request.reason = "The Desktop launcher failed or returned an uncertain outcome. This request will not be launched again; inspect it to check whether the session was created.";
-    }
-    if (request.status === "awaiting_user" && autoSubmit) {
-      return this.completeRequest(request, { account, senderThreadId, beforeOpen, trustProject });
-    }
-    return receipt(request);
-  }
-
-  async revalidateProjectSource(request, account) {
-    if (!this.resolveProject) return;
-    const source = request.projectSource;
-    if (!source) fail("CLAUDE_CREATION_PROJECT_NOT_FOUND", "The original saved project source is unavailable; submission is not authorized.");
-    const tasks = await this.listTasks(account);
-    if (!Array.isArray(tasks) || tasks.length > MAX_TASKS) fail("CLAUDE_CREATION_TASKS_INVALID", "The saved project source cannot be verified.");
-    const matches = tasks.filter(task => task?.taskId === source.taskId);
-    if (matches.length !== 1 || matches[0].fileTaskId !== source.fileTaskId || matches[0].cwd !== source.cwd || matches[0].isArchived !== false ||
-        !this.sameCwd(await this.resolveProject(matches[0]), request.cwd)) {
-      fail("CLAUDE_CREATION_PROJECT_NOT_FOUND", "The original saved project or its authorization changed; submission is not authorized.");
-    }
-  }
-
-  async completeRequest(request, { account, senderThreadId, beforeOpen, trustProject }) {
-    if (typeof this.submit !== "function") fail("CLAUDE_CREATION_SUBMIT_UNAVAILABLE", "Native composer submission is not available.");
-    if (trustProject && typeof this.trust !== "function") fail("CLAUDE_CREATION_TRUST_UNAVAILABLE", "Authorized project trust preparation is not available.");
-    await this.checkAccount(account, request.account);
-    if (beforeOpen) await beforeOpen();
-    await this.revalidateProjectSource(request, account);
-    if (trustProject) {
-      const trusted = await this.trust({ cwd: request.cwd, prompt: request.initialMessage });
-      if (!["trusted", "absent"].includes(trusted?.status)) {
-        request.status = "awaiting_user";
-        request.reason = trusted?.reason ?? "Native workspace trust is not confirmed; inspect the exact project composer.";
-        return receipt(request);
-      }
-      if (trusted.status === "trusted") await this.settle();
-    }
-    await this.checkAccount(account, request.account);
-    if (beforeOpen) await beforeOpen();
-    await this.revalidateProjectSource(request, account);
-    request.submissionAttempted = true;
-    request.status = "submission_uncertain";
-    request.reason = "Native submission was attempted; inspect this request before retrying. The bridge will not press Send again.";
-    try {
-      const submission = await this.submit({ prompt: request.initialMessage, cwd: request.cwd, beforeSubmit: async () => {
-        await this.checkAccount(account, request.account);
-        if (beforeOpen) await beforeOpen();
-        await this.revalidateProjectSource(request, account);
-      } });
-      if (submission?.status === "blocked" && submission.submissionAttempted === false) delete request.submissionAttempted;
-      request.status = submission?.status === "submitted" ? "awaiting_session" : submission?.status === "blocked" ? "awaiting_user" : "submission_uncertain";
-      request.reason = submission?.reason ?? "Inspect the original native composer and creation receipt; submission has not been verified.";
-    } catch {}
-    return this.inspect(request.requestId, { account, senderThreadId });
-  }
-
-  async inspect(requestId, { account, senderThreadId }) {
-    const request = this.requests.get(requestId);
-    if (!request) fail("CLAUDE_CREATION_REQUEST_NOT_FOUND", "No retained creation request has this requestId.");
-    if (request.senderThreadId !== senderThreadId) fail("CLAUDE_CREATION_SENDER_MISMATCH", "This creation request belongs to another sender thread.");
-    await this.checkAccount(account, request.account);
-    if (request.status === "created") return receipt(request);
-    const sessions = await this.listSessions(account);
-    if (!Array.isArray(sessions) || sessions.length > MAX_TASKS) fail("CLAUDE_CREATION_SESSIONS_INVALID", "Live native sessions could not be inspected within the limit.");
-    const matches = new Map();
-    for (const session of sessions) {
-      if (!session?.alive || session.entrypoint !== "claude-desktop" || !string(session.sessionId, 256)) continue;
-      try {
-        const observedCwd = await this.canonical(session.cwd);
-        if (await this.assertProcess(session) === false) continue;
-        const context = await this.readContext(session, account);
-        if (context?.status !== "matched" || context.isArchived || !string(context.taskId, 256) || request.baseline.includes(context.taskId)) continue;
-        if (context.fileTaskId !== undefined && context.fileTaskId !== context.taskId) continue;
-        if (context.accountFingerprint && context.accountFingerprint !== request.account.fingerprint) continue;
-        if (!this.sameCwd(await this.canonical(context.cwd), observedCwd)) continue;
-        const transcript = await this.readTranscript(session.sessionId, observedCwd, 1000);
-        if (transcript?.truncated || transcript?.incomplete) continue;
-        const firstUser = transcript?.messages?.find((message) => message.role === "user");
-        if (!matchesInitialMessage(firstUser?.text, request.initialMessage)) continue;
-        if (await this.assertProcess(session) === false) continue;
-        matches.set(JSON.stringify([context.taskId, session.sessionId]), { sessionId: session.sessionId, taskId: context.taskId, title: string(context.title, 65536) && context.title.trim() ? context.title.trim().slice(0, 4096) : null, observedCwd });
-      } catch {}
-    }
-    await this.checkAccount(account, request.account);
-    if (matches.size > 1) {
-      request.submissionObserved = true;
-      request.ambiguitySeen = true;
-      request.status = "ambiguous";
-      for (const key of ["sessionId", "taskId", "title", "observedCwd"]) delete request[key];
-      request.reason = "Multiple new native sessions contain the exact creation message; no session was selected.";
-    } else if (matches.size === 1 && request.status !== "ambiguous" && !request.ambiguitySeen) {
-      const match = [...matches.values()][0];
-      const projectConfirmed = this.sameCwd(match.observedCwd, request.cwd);
-      Object.assign(request, match, { submissionObserved: true, status: projectConfirmed ? "created" : "awaiting_project_confirmation", reason: projectConfirmed ? "A new live native Claude Desktop task has the exact initial user message, verified project, account, and process identity." : "The prompt was submitted in a new native Claude Desktop task, but its actual directory differs from the requested project. Select or adopt the requested project folder in Claude Desktop and inspect this request again; project creation is not confirmed." });
-    }
-    return receipt(request);
-  }
-
-  abandon(requestId, args) {
-    const pending = this.queue.then(() => this.abandonLocked(requestId, args));
-    this.queue = pending.catch(() => {});
-    return pending;
-  }
-
-  async abandonLocked(requestId, { account, senderThreadId }) {
-    const request = this.requests.get(requestId);
-    if (!request) fail("CLAUDE_CREATION_REQUEST_NOT_FOUND", "No retained creation request has this requestId.");
-    if (request.senderThreadId !== senderThreadId) fail("CLAUDE_CREATION_SENDER_MISMATCH", "This creation request belongs to another sender thread.");
-    await this.checkAccount(account, request.account);
-    if (request.status === "created") return receipt(request);
-    if (request.status === "ambiguous") request.ambiguitySeen = true;
-    request.status = "abandoned";
-    request.reason = "The creation request was abandoned and its composer lock released. Claude Desktop and its composer may still be open, and the prompt could still be submitted later. The receipt is retained for inspection and will never relaunch.";
-    return receipt(request);
-  }
-
-  exportState() {
-    return structuredClone({ version: 1, requests: [...this.requests.values()] });
-  }
-
-  restoreState(state) {
-    if (this.requests.size || state?.version !== 1 || !Array.isArray(state.requests) || state.requests.length > MAX_REQUESTS) fail("CLAUDE_CREATION_STATE_INVALID", "Creation state cannot be restored.");
-    const restored = new Map();
-    const paths = this.platform === "win32" ? path.win32 : path.posix;
-    for (const request of state.requests) {
-      if (!request || typeof request.requestId !== "string" || !REQUEST_ID.test(request.requestId) || restored.has(request.requestId) || !string(request.cwd, 8192) || !paths.isAbsolute(request.cwd) || !string(request.senderThreadId, 256) || !string(request.account?.fingerprint) || !string(request.account?.root, 8192) || !STATUSES.has(request.status) || !string(request.reason, 4096) || !Array.isArray(request.baseline) || request.baseline.length > MAX_TASKS || request.baseline.some((id) => !string(id, 256)) || request.initialMessage !== augmentedPrompt(request.prompt, request.requestId)) fail("CLAUDE_CREATION_STATE_INVALID", "A retained creation receipt is invalid.");
-      const hasSession = ["created", "awaiting_project_confirmation"].includes(request.status) || request.sessionId !== undefined;
-      if (hasSession && (!string(request.sessionId, 256) || !string(request.taskId, 256) || request.baseline.includes(request.taskId) || (request.title !== null && !string(request.title, 4096)))) fail("CLAUDE_CREATION_STATE_INVALID", "A submitted creation receipt is invalid.");
-      if (request.submissionObserved !== undefined && typeof request.submissionObserved !== "boolean") fail("CLAUDE_CREATION_STATE_INVALID", "A retained submission marker is invalid.");
-      if (request.submissionAttempted !== undefined && typeof request.submissionAttempted !== "boolean") fail("CLAUDE_CREATION_STATE_INVALID", "A retained submission attempt is invalid.");
-      if ((request.status === "awaiting_project_confirmation" || request.observedCwd !== undefined) && (!string(request.observedCwd, 8192) || !paths.isAbsolute(request.observedCwd))) fail("CLAUDE_CREATION_STATE_INVALID", "A retained observed directory is invalid.");
-      if (request.status === "awaiting_project_confirmation" && (request.submissionObserved !== true || this.sameCwd(request.cwd, request.observedCwd))) fail("CLAUDE_CREATION_STATE_INVALID", "A pending project confirmation is invalid.");
-      if (request.ambiguitySeen !== undefined && typeof request.ambiguitySeen !== "boolean") fail("CLAUDE_CREATION_STATE_INVALID", "A retained ambiguity marker is invalid.");
-      if (request.projectSource !== undefined && (!string(request.projectSource?.taskId, 256) || !request.baseline.includes(request.projectSource.taskId) ||
-          (request.projectSource.fileTaskId !== undefined && request.projectSource.fileTaskId !== request.projectSource.taskId) ||
-          !string(request.projectSource.cwd, 8192) || !paths.isAbsolute(request.projectSource.cwd))) fail("CLAUDE_CREATION_STATE_INVALID", "A retained project source is invalid.");
-      restored.set(request.requestId, structuredClone({ requestId: request.requestId, cwd: request.cwd, prompt: request.prompt, initialMessage: request.initialMessage, account: { fingerprint: request.account.fingerprint, root: request.account.root }, senderThreadId: request.senderThreadId, baseline: request.baseline, ...(request.projectSource ? { projectSource: { taskId: request.projectSource.taskId, fileTaskId: request.projectSource.fileTaskId, cwd: request.projectSource.cwd } } : {}), status: request.status, reason: request.reason, ...(request.submissionAttempted ? { submissionAttempted: true } : {}), ...(request.ambiguitySeen || request.status === "ambiguous" ? { ambiguitySeen: true } : {}), ...(request.submissionObserved ? { submissionObserved: true } : {}), ...(request.observedCwd ? { observedCwd: request.observedCwd } : {}), ...(hasSession ? { sessionId: request.sessionId, taskId: request.taskId, title: request.title } : {}) }));
-    }
-    this.requests = restored;
-  }
-}