syndai 0.1.1 → 0.3.0

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 */
-    }
-  }
-}

package/src/connect.js

@@ -1,122 +0,0 @@
-// Orchestrates `syndai connect <code>`: claim the pairing, confirm the workspace
-// + phrase, wait for the owner's Approve click, mint/capture whatever plans are
-// present locally, and upload them in exactly ONE call. No token is ever printed.
-
-import os from "node:os";
-import { post, ok, errorMessage } from "./api.js";
-import { confirm } from "./prompt.js";
-import { connectClaude } from "./claude.js";
-import { connectCodex } from "./codex.js";
-
-const BASE = "/api/v1/coding/auth/pairings";
-const POLL_INTERVAL_MS = 3000;
-const POLL_TIMEOUT_MS = 5 * 60 * 1000; // 5 min — the owner has to click Approve.
-
-const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
-
-// The code-authed routes: possession of the code is the credential (spec §4.1).
-// Poll re-uses /claim — the only code-authed status read the CLI can make; it
-// returns the current pairing state each time.
-// ponytail: if the backend adds a dedicated code-authed poll route, swap the path
-// in pollState — the shape ({code, hostname} -> {state, ...}) is unchanged.
-function claim(code) {
-  return post(`${BASE}/claim`, { code, hostname: os.hostname() });
-}
-
-async function pollForApproval(code, deps) {
-  const log = deps.log || console.log;
-  const started = deps.now ? deps.now() : Date.now();
-  log('Waiting for the workspace owner to click "Approve"…');
-  for (;;) {
-    const { status, body } = await claim(code);
-    if (!ok(status)) return { ok: false, message: errorMessage(body) };
-    const state = body && body.state;
-    if (state === "approved" || state === "uploaded" || state === "verified") {
-      return { ok: true };
-    }
-    if (state === "failed") return { ok: false, message: "the pairing was rejected or expired" };
-    const elapsed = (deps.now ? deps.now() : Date.now()) - started;
-    if (elapsed >= POLL_TIMEOUT_MS) {
-      return { ok: false, message: "timed out waiting for approval (15-min code TTL — mint a new one)" };
-    }
-    await sleep(deps.pollIntervalMs ?? POLL_INTERVAL_MS);
-  }
-}
-
-/**
- * Run the full connect flow. `deps` lets tests inject the network/prompt seams;
- * defaults use the real ones. Returns a process exit code.
- */
-export async function runConnect(code, deps = {}) {
-  const log = deps.log || console.log;
-  const err = deps.error || console.error;
-  const askConfirm = deps.confirm || confirm;
-
-  if (!code || typeof code !== "string") {
-    err("usage: syndai connect <code>");
-    return 2;
-  }
-
-  // 1. Claim — learn the destination workspace + phrase before anything is minted.
-  const claimed = await (deps.claim ? deps.claim(code) : claim(code));
-  if (!ok(claimed.status)) {
-    err(`connect: ${errorMessage(claimed.body)}`);
-    return 1;
-  }
-  const info = claimed.body || {};
-  const name = info.workspace_name || "your workspace";
-  const email = info.owner_email_masked || "the owner";
-  const phrase = info.phrase || "(no phrase)";
-
-  // 2. Two-sided confirm (default No, no --yes flag).
-  const yes = await askConfirm(
-    `Connect to workspace "${name}" (${email})? Phrase: ${phrase} [y/N] `,
-  );
-  if (!yes) {
-    log("Aborted. Nothing was sent.");
-    return 1;
-  }
-
-  // 3. Wait for the owner's Approve click.
-  const approval = deps.pollForApproval
-    ? await deps.pollForApproval(code, deps)
-    : await pollForApproval(code, deps);
-  if (!approval.ok) {
-    err(`connect: ${approval.message}`);
-    return 1;
-  }
-
-  // 4. Collect whatever plans are present on this machine.
-  const claudeToken = deps.connectClaude ? await deps.connectClaude(deps) : await connectClaude(deps);
-  const codexAuthJson = deps.connectCodex ? deps.connectCodex(deps) : connectCodex(deps);
-
-  if (!claudeToken && !codexAuthJson) {
-    err("connect: no Claude or ChatGPT plan could be connected. Nothing uploaded.");
-    return 1;
-  }
-
-  // 5. Exactly one upload, carrying whatever was collected.
-  const payload = { code };
-  if (claudeToken) payload.claude_oauth_token = claudeToken;
-  if (codexAuthJson) payload.codex_auth_json = codexAuthJson;
-
-  const uploaded = deps.upload ? await deps.upload(payload) : await post(`${BASE}/upload`, payload);
-  if (!ok(uploaded.status)) {
-    err(`connect: upload failed — ${errorMessage(uploaded.body)}`);
-    return 1;
-  }
-
-  // Report the SERVER's outcome, not what we sent: a token can be uploaded but fail server-side
-  // verification (a dead ChatGPT plan), and only the server knows which providers actually landed.
-  const body = uploaded.body || {};
-  const labels = { claude_max: "Claude plan", chatgpt: "ChatGPT plan" };
-  const connected = Array.isArray(body.connected) ? body.connected : [];
-  const failed = Array.isArray(body.failed) ? body.failed : [];
-  for (const p of connected) log(`Connected ✓ · ${labels[p] || p}`);
-  for (const p of failed) err(`Not connected · ${labels[p] || p} — the token could not be verified`);
-  if (connected.length === 0) {
-    err("connect: nothing was connected.");
-    return 1;
-  }
-  return 0;
-}

package/src/proc.js

@@ -1,36 +0,0 @@
-// Small process helpers shared by the Claude and Codex flows. Node builtins only.
-
-import fs from "node:fs";
-import path from "node:path";
-
-/**
- * Is `name` an executable on PATH? A dependency-free `which`: scan PATH dirs for
- * an executable file. Windows PATHEXT is honored for the .exe/.cmd case.
- */
-export function onPath(name) {
-  const parts = (process.env.PATH || "").split(path.delimiter).filter(Boolean);
-  const exts = process.platform === "win32" ? (process.env.PATHEXT || ".EXE;.CMD;.BAT").split(";") : [""];
-  for (const dir of parts) {
-    for (const ext of exts) {
-      const candidate = path.join(dir, name + ext.toLowerCase());
-      const candidateUpper = path.join(dir, name + ext);
-      for (const c of new Set([candidate, candidateUpper])) {
-        try {
-          fs.accessSync(c, fs.constants.X_OK);
-          return true;
-        } catch {
-          /* keep scanning */
-        }
-      }
-    }
-  }
-  return false;
-}
-
-/**
- * True on the BSD family (macOS included), where script(1) takes
- * `script -q <file> <cmd...>`; util-linux takes `script -qec "<cmd>" <file>`.
- */
-export function isBsdScript() {
-  return ["darwin", "freebsd", "openbsd", "netbsd"].includes(process.platform);
-}

package/src/prompt.js

@@ -1,43 +0,0 @@
-// Terminal prompts: a default-No confirm and a no-echo paste. Both read one line
-// from the TTY using node:readline. The paste path disables terminal echo with
-// stty(1) so the token never reaches the scrollback — and never the clipboard,
-// because it is typed/pasted straight into the process, not through a copy.
-
-import readline from "node:readline";
-import { spawnSync } from "node:child_process";
-
-/** Ask a yes/no question; returns true ONLY for y/Y. Default (empty, EOF) is No. */
-export function confirm(question) {
-  return new Promise((resolve) => {
-    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
-    rl.question(question, (answer) => {
-      rl.close();
-      resolve(/^y(es)?$/i.test(String(answer).trim()));
-    });
-  });
-}
-
-function setEcho(on) {
-  // Best effort; on a non-TTY (or Windows without stty) this is a no-op and the
-  // paste simply echoes, which is still correct — just not hidden.
-  try {
-    spawnSync("stty", [on ? "echo" : "-echo"], { stdio: "inherit" });
-  } catch {
-    /* ignore */
-  }
-}
-
-/** Read one line WITHOUT echoing it. Used for the Claude token paste fallback. */
-export function readHidden(promptText) {
-  return new Promise((resolve) => {
-    process.stdout.write(promptText);
-    setEcho(false);
-    const rl = readline.createInterface({ input: process.stdin, output: process.stdout, terminal: false });
-    rl.question("", (answer) => {
-      rl.close();
-      setEcho(true);
-      process.stdout.write("\n");
-      resolve(String(answer));
-    });
-  });
-}

package/src/tokens.js

@@ -1,45 +0,0 @@
-// Pure, dependency-free string helpers for the connect flow. Kept apart from the
-// network/PTY code (api.js, claude.js, codex.js) so the parsing logic that turns
-// terminal output and pasted values into credentials is unit-testable without a
-// subprocess or a socket. Node builtins only; no state, no side effects.
-
-// Matches the escape sequences `claude setup-token` draws its full-screen UI with:
-// CSI (`ESC [ … final`), the two-char sequences (`ESC =`, `ESC >`), and OSC strings
-// (`ESC ] … BEL` or `ESC ] … ST`). Broad on purpose — the token we extract afterward
-// is validated by its own strict prefix regex, so over-stripping here is harmless.
-const ANSI = new RegExp(
-  [
-    "[\\u001B\\u009B][[\\]()#;?]*(?:(?:(?:[a-zA-Z0-9]*;)*[a-zA-Z0-9]*)?\\u0007)", // OSC … BEL
-    "(?:[\\u001B\\u009B][[\\]()#;?]*(?:(?:\\d{1,4}(?:;\\d{0,4})*)?[0-9A-ORZcf-nqry=><~]))", // CSI/private
-    "[\\u001B\\u009B][=>]", // keypad mode toggles
-  ].join("|"),
-  "g",
-);
-
-/** Strip ANSI/VT escape codes from terminal output. */
-export function stripAnsi(text) {
-  return String(text).replace(ANSI, "");
-}
-
-// A Claude plan OAuth token minted by `claude setup-token`. Prefix `sk-ant-oat`
-// then the version + payload; the char class is exactly the plan's spec.
-const OAT = /sk-ant-oat[0-9a-zA-Z_-]+/;
-
-/**
- * Pull the first `sk-ant-oat…` token out of (already ANSI-stripped) text.
- * Returns the token string, or null when none is present.
- */
-export function extractOatToken(text) {
-  const match = OAT.exec(stripAnsi(text));
-  return match ? match[0] : null;
-}
-
-/**
- * Remove ALL internal whitespace from a single pasted token. Terminals wrap the
- * 108-char Claude token across lines, so a copy carries a newline (often plus a
- * leading space); the provider then reports only "Invalid auth token". Callers
- * paste one token, so collapsing every space/newline/tab is always safe here.
- */
-export function stripInternalWhitespace(value) {
-  return String(value).replace(/\s+/g, "");
-}