syndai 0.1.1 → 0.4.0

package/src/ui.js

@@ -0,0 +1,156 @@
+// Terminal I/O: progress on stderr, the result on stdout, prompts, the browser and the pager.
+//
+// The result is JSON when `--json` is passed or stdout is not a terminal (an agent or a
+// pipe), human text otherwise. Colour only on a terminal, never with NO_COLOR.
+
+import { spawn } from "node:child_process";
+import { getRandomValues } from "node:crypto";
+import { readFileSync } from "node:fs";
+import path from "node:path";
+import { createInterface } from "node:readline";
+import { CliError, EXIT } from "./errors.js";
+import { interrupted } from "./http.js";
+
+export function createUi(io, { json = false, noInput = false } = {}) {
+  const colour = Boolean(io.stderr.isTTY) && !io.env.NO_COLOR && io.env.TERM !== "dumb";
+  const paint = (code) => (text) => (colour ? `\x1b[${code}m${text}\x1b[0m` : String(text));
+  return {
+    json: json || !io.stdout.isTTY,
+    interactive: !noInput && Boolean(io.stdin.isTTY) && Boolean(io.stderr.isTTY),
+    dim: paint("2"),
+    bold: paint("1"),
+    green: paint("32"),
+    yellow: paint("33"),
+    red: paint("31"),
+    progress(line) {
+      io.stderr.write(`${line}\n`);
+    },
+    /** Print the result: `data` as one JSON line, or `human` text. */
+    result(data, human) {
+      io.stdout.write(this.json ? `${JSON.stringify(data)}\n` : `${human}\n`);
+    },
+  };
+}
+
+// One line reader per stdin for the whole run: its async iterator buffers lines, so answers
+// typed (or piped) ahead of a prompt are never dropped between questions.
+const readers = new WeakMap();
+
+export async function ask(io, question) {
+  io.stderr.write(question);
+  let reader = readers.get(io.stdin);
+  if (!reader) {
+    const rl = createInterface({ input: io.stdin, terminal: false, crlfDelay: Number.POSITIVE_INFINITY });
+    reader = { rl, lines: rl[Symbol.asyncIterator]() };
+    readers.set(io.stdin, reader);
+  }
+  let onAbort;
+  const aborted = new Promise((_, reject) => {
+    onAbort = () => reject(interrupted());
+    if (io.signal.aborted) onAbort();
+    io.signal.addEventListener("abort", onAbort, { once: true });
+  });
+  try {
+    const next = await Promise.race([reader.lines.next(), aborted]);
+    if (next.done) throw new CliError(EXIT.NEEDS_YOU, "No answer: input closed.");
+    return next.value.trim();
+  } finally {
+    io.signal.removeEventListener("abort", onAbort);
+  }
+}
+
+/** Release stdin so the process can exit (called once a command is done). */
+export function closeInput(io) {
+  readers.get(io.stdin)?.rl.close();
+  readers.delete(io.stdin);
+}
+
+/** Open an http(s) URL in the default browser; the caller always prints it too. */
+export function openBrowser(url) {
+  if (!/^https?:\/\//.test(url)) return;
+  const [cmd, args] =
+    process.platform === "darwin"
+      ? ["open", [url]]
+      : process.platform === "win32"
+        ? ["rundll32", ["url.dll,FileProtocolHandler", url]]
+        : ["xdg-open", [url]];
+  try {
+    const child = spawn(cmd, args, { stdio: "ignore", detached: true });
+    child.on("error", () => {});
+    child.unref();
+  } catch {
+    // No browser here (SSH, container): the printed URL is the fallback.
+  }
+}
+
+/** Show long text through $PAGER on a terminal; print it plainly otherwise. */
+export function page(proc, text) {
+  if (!proc.stdout.isTTY) {
+    proc.stdout.write(text);
+    return Promise.resolve();
+  }
+  return new Promise((resolve) => {
+    const child = spawn(proc.env.PAGER || "less", {
+      shell: true,
+      stdio: ["pipe", "inherit", "inherit"],
+      env: { LESS: "FRX", ...proc.env },
+    });
+    child.on("error", () => {
+      proc.stdout.write(text);
+      resolve();
+    });
+    child.on("close", resolve);
+    child.stdin.on("error", () => {}); // EPIPE when the reader quits early
+    child.stdin.end(text);
+  });
+}
+
+const CROCKFORD = "0123456789ABCDEFGHJKMNPQRSTVWXYZ";
+
+/** A ULID: 48-bit millisecond time + 80 random bits, Crockford base32 (26 chars). */
+export function ulid(now = Date.now()) {
+  let time = "";
+  for (let t = now, i = 0; i < 10; i++, t = Math.floor(t / 32)) time = CROCKFORD[t % 32] + time;
+  let rand = "";
+  for (const byte of getRandomValues(new Uint8Array(16))) rand += CROCKFORD[byte % 32];
+  return time + rand;
+}
+
+/** "90", "90s", "10m", "2h" -> milliseconds. */
+export function parseDuration(text) {
+  const match = /^(\d+(?:\.\d+)?)(ms|s|m|h)?$/.exec(String(text).trim());
+  if (!match) {
+    throw new CliError(EXIT.USAGE, `--timeout takes a duration like 90s, 10m or 1h, not "${text}".`);
+  }
+  const unit = { ms: 1, s: 1000, m: 60_000, h: 3_600_000 }[match[2] ?? "s"];
+  return Math.round(Number(match[1]) * unit);
+}
+
+export function hostOf(url) {
+  try {
+    return new URL(url).host;
+  } catch {
+    return null;
+  }
+}
+
+export async function readAll(stream) {
+  let text = "";
+  for await (const chunk of stream) text += chunk;
+  return text;
+}
+
+/** `--input FILE|-` as parsed JSON (`-` reads stdin). */
+export async function readJsonInput(io, source) {
+  let text;
+  try {
+    text = source === "-" ? await readAll(io.stdin) : readFileSync(path.resolve(io.cwd, source), "utf8");
+  } catch (err) {
+    throw new CliError(EXIT.USAGE, `Cannot read --input ${source} (${err.code ?? err.message}).`);
+  }
+  try {
+    return JSON.parse(text);
+  } catch {
+    throw new CliError(EXIT.USAGE, `--input ${source} is not valid JSON.`);
+  }
+}

package/src/watch.js

@@ -0,0 +1,299 @@
+// Following a change to its outcome.
+//
+// One loop long-polls `GET runs/{id}/change?wait=45&cursor=` (ChangeState). Long-polling
+// survives proxies and deploys (the server returns early while it drains) and resumes by
+// cursor. Ctrl-C only detaches: it never sends a cancel. `--logs` also tails the run's SSE
+// events (resuming with Last-Event-ID) next to the loop.
+
+import { ApiError, CliError, EXIT, explain } from "./errors.js";
+import { backoffMs } from "./http.js";
+import { ask, ulid } from "./ui.js";
+
+const POLL_WAIT_S = 45;
+const MIN_POLL_GAP_MS = 1000;
+const DEADLINE_GRACE_MS = 2000;
+const TIMED_OUT = Symbol("timed out");
+
+// Exit code per ChangeState state (docs: syndai.ai/docs/cli, "Exit codes").
+const STATE_EXIT = {
+  needs_input: EXIT.NEEDS_YOU,
+  held: EXIT.NEEDS_YOU,
+  ready: EXIT.OK,
+  live: EXIT.OK,
+  live_unverified: EXIT.UNVERIFIED,
+  failed: EXIT.FAILED,
+  reverted: EXIT.FAILED,
+  cancelled: EXIT.FAILED,
+};
+
+export function exitFor(state) {
+  return STATE_EXIT[state.state] ?? (Number.isInteger(state.exit_code) ? state.exit_code : EXIT.FAILED);
+}
+
+/** The command (or URL) that moves this change on, or null. */
+export function nextFor(state) {
+  const id = state.run_id;
+  if (state.state === "needs_input") return `syndai answer ${id}`;
+  if (state.state === "held") return `syndai review ${id}`;
+  if (state.state === "ready") return `syndai go-live ${id}`;
+  if (state.state === "live_unverified") return `syndai watch ${id}`;
+  return state.done ? null : `syndai watch ${id}`;
+}
+
+export function describe(state) {
+  const headline = state.headline ? `: ${state.headline}` : "";
+  switch (state.state) {
+    case "queued":
+      return `Queued${state.queue_position ? ` (#${state.queue_position} in line)` : ""}`;
+    case "working":
+      return `Working${headline}`;
+    case "needs_input":
+      return `Needs you: ${state.needs_input?.[0]?.summary ?? "a question"}`;
+    case "landing":
+      return `Checking and going live${headline}`;
+    case "held":
+      return `Held: ${state.held?.message ?? state.held?.reason ?? "needs your review"}`;
+    case "ready":
+      return `Ready for review${headline}`;
+    case "live":
+      return `Live: ${state.live_url ?? state.project?.live_url ?? ""}`.trim();
+    case "live_unverified":
+      return `Live, but the live check could not confirm it: ${state.live_url ?? ""}`.trim();
+    default:
+      return `${state.state[0].toUpperCase()}${state.state.slice(1).replace(/_/g, " ")}${headline}`;
+  }
+}
+
+/** Print the final state (JSON ChangeState + `next`, or a line) and return its exit code. */
+export function finish(ctx, state, { exitCode = exitFor(state), next = nextFor(state) } = {}) {
+  const { ui } = ctx;
+  const lines = [describe(state)];
+  if (state.run_url) lines.push(ui.dim(state.run_url));
+  ui.result({ ...state, ...(next ? { next } : {}) }, lines.join("\n"));
+  if (next && !ui.json) ui.progress(`Next: ${next}`);
+  return exitCode;
+}
+
+export async function getChange(ctx, runId) {
+  return ctx.client.call("changeState", { params: { run_id: runId }, query: { wait: 0 } });
+}
+
+/**
+ * Follow `runId` until it is done (or, with `untilNot`, until it leaves that state).
+ * Returns the exit code.
+ */
+export async function watchChange(ctx, runId, { timeoutMs = null, untilNot = null, logs = false } = {}) {
+  const { client, ui, io } = ctx;
+  const deadline = timeoutMs === null ? null : io.now() + timeoutMs;
+  const deadlineCtl = new AbortController();
+  const timer =
+    deadline === null ? null : setTimeout(() => deadlineCtl.abort(TIMED_OUT), timeoutMs + DEADLINE_GRACE_MS);
+  timer?.unref?.();
+  const logsCtl = new AbortController();
+  const logsDone = logs ? tailEvents(ctx, runId, logsCtl.signal) : null;
+  let cursor;
+  let last = null;
+  let lastLine = null;
+  const answered = new Set(); // a state read before our answer landed must not ask again
+  try {
+    for (;;) {
+      const remaining = deadline === null ? Number.POSITIVE_INFINITY : deadline - io.now();
+      if (remaining <= 0) return timedOut(ctx, runId, last);
+      const wait = Math.max(0, Math.min(POLL_WAIT_S, Math.floor(remaining / 1000)));
+      const started = io.now();
+      let state;
+      try {
+        state = await client.call("changeState", {
+          params: { run_id: runId },
+          query: { wait, cursor },
+          timeoutMs: (wait + 20) * 1000,
+          signal: deadlineCtl.signal,
+        });
+      } catch (err) {
+        if (err === TIMED_OUT) return timedOut(ctx, runId, last);
+        throw err;
+      }
+      const line = describe(state);
+      const changed = line !== lastLine || state.cursor !== cursor;
+      const final =
+        (state.done && state.state !== untilNot) || (state.state === "needs_input" && !ui.interactive);
+      if (final) return finish(ctx, state);
+      if (line !== lastLine) ui.progress(`${ui.dim("·")} ${line}`);
+      lastLine = line;
+      cursor = state.cursor ?? cursor;
+      last = state;
+
+      const open = (state.needs_input ?? []).filter((q) => !answered.has(q.hitl_request_id));
+      if (state.state === "needs_input" && open.length) {
+        await answerInteractively(ctx, runId, open);
+        for (const q of open) answered.add(q.hitl_request_id);
+        continue;
+      }
+      // A server that answers at once without news (draining, a proxy) must not make us spin.
+      if (!changed && io.now() - started < MIN_POLL_GAP_MS) {
+        const left = deadline === null ? MIN_POLL_GAP_MS : Math.max(0, deadline - io.now());
+        await io.sleep(Math.min(MIN_POLL_GAP_MS, left), io.signal);
+      }
+    }
+  } catch (err) {
+    if (io.signal.aborted || (err instanceof CliError && err.exitCode === EXIT.INTERRUPTED)) {
+      throw new CliError(EXIT.INTERRUPTED, "Stopped watching; the change keeps going.", {
+        next: `syndai watch ${runId}`,
+      });
+    }
+    throw err;
+  } finally {
+    if (timer) clearTimeout(timer);
+    logsCtl.abort();
+    await logsDone;
+  }
+}
+
+function timedOut(ctx, runId, last) {
+  const state = last ?? { run_id: runId, state: "unknown", done: false };
+  const next = `syndai watch ${runId}`;
+  ctx.ui.result({ ...state, next }, `Still going (timeout reached): ${describe(state)}`);
+  if (!ctx.ui.json) ctx.ui.progress(`Next: ${next}`);
+  return EXIT.TIMEOUT;
+}
+
+// --- questions -----------------------------------------------------------------------------
+
+export async function answerInteractively(ctx, runId, questions) {
+  for (const question of questions) {
+    ctx.ui.progress(ctx.ui.bold(question.summary ?? "A question about your change"));
+    const entries = [];
+    for (const input of question.inputs ?? []) {
+      const entry = await askInput(ctx, input);
+      if (entry) entries.push(entry);
+    }
+    await respond(ctx, runId, question.hitl_request_id, entries);
+    ctx.ui.progress(ctx.ui.green("Answered."));
+  }
+}
+
+export function respond(ctx, runId, hitlRequestId, entries) {
+  return ctx.client.call("respond", {
+    params: { run_id: runId },
+    body: { hitl_request_id: hitlRequestId, entries, idempotency_key: `cli:${ulid()}` },
+    retry: true,
+  });
+}
+
+async function askInput(ctx, input) {
+  const { io, ui } = ctx;
+  if (input.context) ui.progress(ui.dim(input.context));
+  const optional = input.required ? "" : ui.dim(" (Enter to skip)");
+  if (input.kind === "approval") {
+    for (;;) {
+      const answer = (await ask(io, `${input.prompt} [y/n]${optional} `)).toLowerCase();
+      if (!answer && !input.required) return null;
+      if (["y", "yes", "n", "no"].includes(answer)) {
+        return { input_id: input.input_id, approved: answer.startsWith("y") };
+      }
+    }
+  }
+  const options = input.options ?? [];
+  const textAllowed = input.kind === "free_text" || Boolean(input.free_text?.enabled);
+  if (options.length === 0) {
+    for (;;) {
+      const text = await ask(io, `${input.prompt}${optional} `);
+      if (text || !input.required) return text ? { input_id: input.input_id, text } : null;
+    }
+  }
+  ui.progress(input.prompt);
+  const defaults = new Set(input.default_option_ids ?? []);
+  for (const [i, option] of options.entries()) {
+    ui.progress(`  ${i + 1}. ${defaults.has(option.id) ? "[x] " : ""}${option.label}`);
+  }
+  const multi = input.kind === "multi_choice";
+  const hint = multi ? "numbers, comma-separated" : "a number";
+  const keep = defaults.size ? ", Enter keeps [x]" : "";
+  for (;;) {
+    const answer = await ask(io, `Pick ${hint}${textAllowed ? " or type an answer" : ""}${keep}${optional}: `);
+    if (!answer && defaults.size) {
+      return { input_id: input.input_id, selected_option_ids: options.filter((o) => defaults.has(o.id)).map((o) => o.id) };
+    }
+    if (!answer && !input.required) return null;
+    const picks = answer.split(",").map((part) => Number(part.trim()) - 1);
+    const valid = picks.every((i) => Number.isInteger(i) && options[i]) && (multi || picks.length === 1);
+    if (answer && valid) {
+      return { input_id: input.input_id, selected_option_ids: picks.map((i) => options[i].id) };
+    }
+    if (answer && textAllowed) return { input_id: input.input_id, text: answer };
+  }
+}
+
+// --- logs ----------------------------------------------------------------------------------
+
+async function tailEvents(ctx, runId, signal) {
+  const { client, ui, io } = ctx;
+  let lastEventId = null;
+  for (let attempt = 0; !signal.aborted; ) {
+    try {
+      const res = await client.stream("runEvents", {
+        params: { run_id: runId },
+        headers: lastEventId ? { "last-event-id": lastEventId } : {},
+        signal,
+      });
+      attempt = 0;
+      for await (const event of parseSse(res.body)) {
+        if (event.id) lastEventId = event.id;
+        if (event.event === "stream_heartbeat") continue;
+        if (ui.json) {
+          io.stdout.write(`${JSON.stringify({ id: event.id, event: event.event, data: event.data })}\n`);
+        } else {
+          const payload = event.data?.payload ?? event.data ?? {};
+          const text = payload.summary ?? payload.message ?? payload.title ?? "";
+          ui.progress(ui.dim(`  [${event.event}] ${String(text).slice(0, 200)}`));
+        }
+      }
+    } catch (err) {
+      if (signal.aborted || io.signal.aborted) return;
+      if (err instanceof ApiError && err.status < 500 && err.status !== 429) {
+        ui.progress(ui.yellow(`Logs stopped: ${explain(err).message}`));
+        return;
+      }
+    }
+    attempt = Math.min(attempt + 1, 5);
+    try {
+      await io.sleep(backoffMs(attempt), signal);
+    } catch {
+      return;
+    }
+  }
+}
+
+/** Server-sent events from a byte stream: yields `{id, event, data}` (data JSON-parsed). */
+export async function* parseSse(body) {
+  const decoder = new TextDecoder();
+  let buffer = "";
+  for await (const chunk of body) {
+    buffer += decoder.decode(chunk, { stream: true });
+    let split = buffer.search(/\r?\n\r?\n/);
+    while (split !== -1) {
+      const block = buffer.slice(0, split);
+      buffer = buffer.slice(split).replace(/^\r?\n\r?\n/, "");
+      const event = { id: null, event: "message", data: "" };
+      const data = [];
+      for (const line of block.split(/\r?\n/)) {
+        const colon = line.indexOf(":");
+        if (colon === 0) continue; // comment
+        const field = colon === -1 ? line : line.slice(0, colon);
+        const value = colon === -1 ? "" : line.slice(colon + 1).replace(/^ /, "");
+        if (field === "data") data.push(value);
+        else if (field === "id") event.id = value;
+        else if (field === "event") event.event = value;
+      }
+      if (data.length) {
+        try {
+          event.data = JSON.parse(data.join("\n"));
+        } catch {
+          event.data = data.join("\n");
+        }
+        yield event;
+      }
+      split = buffer.search(/\r?\n\r?\n/);
+    }
+  }
+}

package/LICENSE

@@ -1,9 +0,0 @@
-MIT License
-
-Copyright (c) 2026 Solo Zero Labs
-
-Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/src/claude.js

@@ -1,145 +0,0 @@
-// Claude plan connect: mint a fresh setup-token, verify it with the official CLI,
-// or fall back to a hidden paste when `claude` isn't installed. The token is never
-// printed, never written to disk, never put on the clipboard.
-
-import { spawnSync } from "node:child_process";
-import fs from "node:fs";
-import os from "node:os";
-import path from "node:path";
-import { extractOatToken, stripInternalWhitespace } from "./tokens.js";
-import { onPath, isBsdScript } from "./proc.js";
-import { readHidden } from "./prompt.js";
-
-// `claude setup-token` draws a full-screen terminal UI, so it needs a PTY; we get
-// one from script(1). BSD (macOS) and util-linux take different argument shapes —
-// both handled. Injected in tests via `deps` so the pure extraction stays testable.
-export function buildScriptArgv() {
-  if (isBsdScript()) {
-    return ["script", ["-q", "/dev/null", "claude", "setup-token"]];
-  }
-  return ["script", ["-qec", "claude setup-token", "/dev/null"]];
-}
-
-function runSetupToken(deps) {
-  const [cmd, args] = deps.buildScriptArgv();
-  const res = deps.spawnSync(cmd, args, { encoding: "utf8", stdio: ["inherit", "pipe", "inherit"] });
-  const out = (res.stdout || "") + (res.stderr || "");
-  return deps.extractOatToken(out);
-}
-
-/**
- * Verify a Claude plan token by asking the official CLI to answer a one-word
- * prompt. A rate-limited token still exits 0, so we DO NOT trust the exit code —
- * success is a `result` frame with `is_error === false`. A throwaway
- * CLAUDE_CONFIG_DIR and blanked ANTHROPIC_* keep the check hermetic and force the
- * token (not a stray key) to authenticate.
- */
-export function verifyClaudeToken(token, deps = {}) {
-  const _spawnSync = deps.spawnSync || spawnSync;
-  const _mkdtemp = deps.mkdtempSync || ((p) => fs.mkdtempSync(p));
-  const configDir = _mkdtemp(path.join(os.tmpdir(), "syndai-claude-"));
-  try {
-    const res = _spawnSync("claude", ["-p", "ping", "--output-format", "json"], {
-      encoding: "utf8",
-      stdio: ["ignore", "pipe", "pipe"],
-      env: {
-        ...process.env,
-        CLAUDE_CODE_OAUTH_TOKEN: token,
-        ANTHROPIC_API_KEY: "",
-        ANTHROPIC_AUTH_TOKEN: "",
-        ANTHROPIC_BASE_URL: "",
-        CLAUDE_CONFIG_DIR: configDir,
-      },
-    });
-    return resultIsError(res.stdout) === false;
-  } finally {
-    try {
-      fs.rmSync(configDir, { recursive: true, force: true });
-    } catch {
-      /* ignore */
-    }
-  }
-}
-
-// Parse `claude -p --output-format json` stdout and report the result frame's
-// is_error. Returns true/false when found, or null when no result frame parsed.
-export function resultIsError(stdout) {
-  const text = String(stdout || "").trim();
-  if (!text) return null;
-  // Try a single JSON object first, then fall back to JSON-lines (stream-json).
-  const candidates = [];
-  try {
-    candidates.push(JSON.parse(text));
-  } catch {
-    for (const line of text.split(/\r?\n/)) {
-      const t = line.trim();
-      if (!t) continue;
-      try {
-        candidates.push(JSON.parse(t));
-      } catch {
-        /* skip noise */
-      }
-    }
-  }
-  for (const frame of candidates) {
-    if (frame && typeof frame === "object" && (frame.type === "result" || "is_error" in frame)) {
-      return Boolean(frame.is_error);
-    }
-  }
-  return null;
-}
-
-/**
- * Obtain a verified Claude plan token, or null if the user declines / it fails.
- * - `claude` on PATH: mint via setup-token (PTY), then verify.
- * - not installed: print the paste-fallback instruction, read a HIDDEN paste in
- *   this same command, strip wrapping whitespace, then verify.
- * The token is returned to the caller for the single upload; nothing else touches it.
- */
-export async function connectClaude(deps = {}) {
-  const _onPath = deps.onPath || onPath;
-  const _readHidden = deps.readHidden || readHidden;
-  const log = deps.log || console.log;
-
-  const scriptOnPath = deps.scriptOnPath ?? _onPath("script");
-
-  if (_onPath("claude") && scriptOnPath) {
-    log("Claude: minting a fresh plan token (approve in your browser when Claude asks)…");
-    const token = runSetupToken({
-      buildScriptArgv: deps.buildScriptArgv || buildScriptArgv,
-      spawnSync: deps.spawnSync || spawnSync,
-      extractOatToken,
-    });
-    if (!token) {
-      log("Claude: could not read a token from setup-token. Skipping Claude.");
-      return null;
-    }
-    log("Claude: verifying the token with the official CLI…");
-    if (!verifyClaudeToken(token, deps)) {
-      log("Claude: the minted token did not verify. Skipping Claude.");
-      return null;
-    }
-    log("Claude: token verified ✓");
-    return token;
-  }
-
-  // Paste fallback (no `claude`, or no PTY via script(1) — e.g. Windows w/o WSL).
-  log("");
-  log("Claude CLI not found. To connect your Claude plan, in another terminal run:");
-  log("    claude setup-token");
-  log("then paste the sk-ant-oat01-… value below (it is hidden and not stored):");
-  const raw = await _readHidden("Claude plan token: ");
-  const token = stripInternalWhitespace(raw);
-  if (!token) {
-    log("Claude: nothing pasted. Skipping Claude.");
-    return null;
-  }
-  if (deps.onPath ? _onPath("claude") : onPath("claude")) {
-    // If claude showed up we can still verify; otherwise trust the server verify.
-    if (!verifyClaudeToken(token, deps)) {
-      log("Claude: that token did not verify. Skipping Claude.");
-      return null;
-    }
-  }
-  return token;
-}

package/src/codex.js

@@ -1,71 +0,0 @@
-// ChatGPT plan connect: give Syndai its OWN Codex login lineage — `codex login`
-// into a throwaway CODEX_HOME, confirm, read the resulting auth.json, then delete
-// the directory. Copying the laptop's ~/.codex/auth.json is deliberately NOT done:
-// two machines sharing one rotating refresh token log each other out (spec §Q3a).
-
-import { spawnSync } from "node:child_process";
-import fs from "node:fs";
-import os from "node:os";
-import path from "node:path";
-import { onPath } from "./proc.js";
-
-/**
- * Run the Codex own-lineage login and return the parsed auth.json OBJECT, or null if the
- * user declines / it fails. The temp CODEX_HOME is always removed. OPENAI_API_KEY
- * is unset so a stray key can't shadow the plan login; stdin is closed for any
- * non-interactive step.
- */
-export function connectCodex(deps = {}) {
-  const _onPath = deps.onPath || onPath;
-  const _spawnSync = deps.spawnSync || spawnSync;
-  const log = deps.log || console.log;
-
-  if (!_onPath("codex")) {
-    return null; // no ChatGPT plan connect without the official CLI
-  }
-
-  const home = fs.mkdtempSync(path.join(os.tmpdir(), "syndai-codex-"));
-  const env = { ...process.env, CODEX_HOME: home };
-  delete env.OPENAI_API_KEY;
-
-  try {
-    log("ChatGPT: opening a Codex login for Syndai (approve in your browser)…");
-    const login = _spawnSync("codex", ["login"], { stdio: "inherit", env });
-    if (login.status !== 0) {
-      log("ChatGPT: codex login did not complete. Skipping ChatGPT.");
-      return null;
-    }
-    // Confirm the session landed; stdin closed so `status` can't block.
-    const status = _spawnSync("codex", ["login", "status"], {
-      stdio: ["ignore", "pipe", "pipe"],
-      encoding: "utf8",
-      env,
-    });
-    if (status.status !== 0) {
-      log("ChatGPT: login status check failed. Skipping ChatGPT.");
-      return null;
-    }
-    const authPath = path.join(home, "auth.json");
-    if (!fs.existsSync(authPath)) {
-      log("ChatGPT: no auth.json produced. Skipping ChatGPT.");
-      return null;
-    }
-    // Return the PARSED object: the server's upload DTO types codex_auth_json as an object,
-    // so sending the raw string would be rejected at decode (400) before the credential lands.
-    let parsed;
-    try {
-      parsed = JSON.parse(fs.readFileSync(authPath, "utf8"));
-    } catch {
-      log("ChatGPT: auth.json was not valid JSON. Skipping ChatGPT.");
-      return null;
-    }
-    log("ChatGPT: login captured ✓");
-    return parsed;
-  } finally {
-    try {
-      fs.rmSync(home, { recursive: true, force: true });
-    } catch {
-      /* ignore */
-    }
-  }
-}