syndai 0.0.0 → 0.1.1

package/README.md

@@ -1,5 +1,62 @@
-# syndai
+# syndai connect
 
-`npx syndai connect <code>` will link your Claude or ChatGPT plan to [Syndai](https://syndai.ai) so hosted coding runs use your own plan.
+Connect your **Claude** and **ChatGPT** plans to a Syndai workspace with one
+command:
 
-This version is a placeholder that holds the name. It does nothing but print a message. The source for every release lives in this repo so you can read what the command does before you run it.
+```bash
+npx -y syndai connect <code>
+```
+
+Get `<code>` from your Syndai portal → **Connections → Connect a plan**. It is a
+single-use code with a 15-minute TTL.
+
+## What it does
+
+1. **Claims** the code and shows you where it will connect:
+   `Connect to workspace "Acme" (s••@acme.com)? Phrase: amber-falcon-42 [y/N]` —
+   default **No**, no `--yes` flag. Confirm the phrase matches what the portal
+   shows, then the portal owner clicks **Approve**.
+2. **Claude:** if `claude` is on your PATH, mints a fresh plan token with
+   `claude setup-token` (under a PTY, so its full-screen UI works) and verifies it
+   with the official CLI before uploading. If `claude` is not installed, it tells
+   you to run `claude setup-token` yourself and paste the `sk-ant-oat01-…` value —
+   the paste is hidden.
+3. **ChatGPT:** if `codex` is on your PATH, runs `codex login` into a throwaway
+   `CODEX_HOME` (Syndai keeps its own login lineage — copying your laptop's
+   `auth.json` would log one of you out), captures the resulting `auth.json`, and
+   deletes the temp directory.
+4. **Uploads** whatever it collected in exactly one call. The portal flips to
+   **Connected ✓**.
+
+One code connects both providers if both CLIs are present.
+
+## It stores nothing, and echoes no token
+
+The tool holds your token only in memory for the single upload. It never writes it
+to disk, never puts it on the clipboard, and never prints it to your terminal or
+scrollback. Pasted tokens are read with terminal echo off.
+
+## Configuration
+
+- `SYNDAI_API_URL` — override the API base (default `https://api.syndai.ai`).
+
+## Requirements
+
+- Node.js **>= 18** (dependency-free — Node builtins only).
+- `claude` and/or `codex` on your PATH for the one-command path; otherwise the
+  Claude paste fallback still works.
+
+## Source & provenance
+
+This package is developed in the Syndai monorepo under `tools/syndai-connect/`
+and **mirrored to the public repo
+[`solozerolabs/syndai-connect`](https://github.com/solozerolabs/syndai-connect)**
+for the npm provenance publish (owner action **O1**) — a private monorepo cannot
+publish with sigstore provenance. Published as `syndai` with
+`publishConfig.provenance`.
+
+## Development
+
+```bash
+node --test test/     # pure-helper unit tests (no network, no subprocess)
+```

package/bin/syndai.js

@@ -0,0 +1,33 @@
+#!/usr/bin/env node
+// Entrypoint for the `syndai` CLI. One subcommand today: `connect <code>`.
+
+import { runConnect } from "../src/connect.js";
+
+async function main(argv) {
+  const [subcommand, ...rest] = argv;
+  switch (subcommand) {
+    case "connect":
+      return runConnect(rest[0]);
+    case undefined:
+    case "-h":
+    case "--help":
+    case "help":
+      console.log("syndai — connect your Claude and ChatGPT plans to a Syndai workspace");
+      console.log("");
+      console.log("usage: npx -y syndai connect <code>");
+      console.log("");
+      console.log("Get <code> from your Syndai portal: Connections → Connect a plan.");
+      return subcommand ? 0 : 2;
+    default:
+      console.error(`syndai: unknown command "${subcommand}"`);
+      console.error("usage: npx -y syndai connect <code>");
+      return 2;
+  }
+}
+
+main(process.argv.slice(2))
+  .then((code) => process.exit(code || 0))
+  .catch((e) => {
+    console.error(`syndai: ${e && e.message ? e.message : e}`);
+    process.exit(1);
+  });

package/package.json

@@ -1,11 +1,30 @@
 {
   "name": "syndai",
-  "version": "0.0.0",
-  "description": "Connect your Claude or ChatGPT plan to Syndai with one command. Placeholder — the connect command ships soon.",
-  "bin": { "syndai": "cli.js" },
-  "files": ["cli.js", "README.md", "LICENSE"],
+  "version": "0.1.1",
+  "description": "Connect your Claude and ChatGPT plans to a Syndai workspace with one command. Stores nothing locally; never echoes a token.",
+  "type": "module",
+  "bin": {
+    "syndai": "bin/syndai.js"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/solozerolabs/syndai-connect.git"
+  },
+  "homepage": "https://github.com/solozerolabs/syndai-connect#readme",
   "license": "MIT",
-  "homepage": "https://syndai.ai",
-  "repository": { "type": "git", "url": "git+https://github.com/solozerolabs/syndai-connect.git" },
-  "engines": { "node": ">=18" }
+  "files": [
+    "bin/",
+    "src/",
+    "README.md"
+  ],
+  "scripts": {
+    "test": "node --test test/"
+  },
+  "publishConfig": {
+    "provenance": true,
+    "access": "public"
+  }
 }

package/src/api.js

@@ -0,0 +1,70 @@
+// Minimal JSON-over-HTTPS client for the pairing routes, built on node:https so
+// the package stays dependency-free. Every helper returns { status, body } where
+// body is the parsed JSON (or the raw string when it isn't JSON) — callers decide
+// what a non-2xx means, per route.
+
+import https from "node:https";
+import http from "node:http";
+import { URL } from "node:url";
+
+// Production API host. Overridable with SYNDAI_API_URL for staging/dev. Matches
+// tools/syndai-pickup (_DEFAULT_API_BASE) and apps/portal (NEXT_PUBLIC_API_BASE).
+export function apiBase() {
+  return (process.env.SYNDAI_API_URL || "https://api.syndai.ai").replace(/\/+$/, "");
+}
+
+function request(method, path, payload) {
+  const url = new URL(apiBase() + path);
+  const body = payload === undefined ? undefined : JSON.stringify(payload);
+  const transport = url.protocol === "http:" ? http : https;
+  const options = {
+    method,
+    hostname: url.hostname,
+    port: url.port || undefined,
+    path: url.pathname + url.search,
+    headers: {
+      accept: "application/json",
+      "user-agent": "syndai-connect",
+    },
+  };
+  if (body !== undefined) {
+    options.headers["content-type"] = "application/json";
+    options.headers["content-length"] = Buffer.byteLength(body);
+  }
+  return new Promise((resolve, reject) => {
+    const req = transport.request(options, (res) => {
+      const chunks = [];
+      res.on("data", (c) => chunks.push(c));
+      res.on("end", () => {
+        const text = Buffer.concat(chunks).toString("utf8");
+        let parsed = text;
+        try {
+          parsed = text ? JSON.parse(text) : {};
+        } catch {
+          /* leave as raw text */
+        }
+        resolve({ status: res.statusCode || 0, body: parsed });
+      });
+    });
+    req.on("error", reject);
+    if (body !== undefined) req.write(body);
+    req.end();
+  });
+}
+
+export function post(path, payload) {
+  return request("POST", path, payload);
+}
+
+/** True for any 2xx status. */
+export function ok(status) {
+  return status >= 200 && status < 300;
+}
+
+/** Best-effort human message out of a JSON error body. */
+export function errorMessage(body) {
+  if (body && typeof body === "object") {
+    return body.detail || body.message || body.error || JSON.stringify(body);
+  }
+  return String(body || "unknown error");
+}

package/src/claude.js

@@ -0,0 +1,145 @@
+// 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

@@ -0,0 +1,71 @@
+// 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

@@ -0,0 +1,122 @@
+// 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

@@ -0,0 +1,36 @@
+// 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

@@ -0,0 +1,43 @@
+// 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

@@ -0,0 +1,45 @@
+// 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, "");
+}

package/cli.js

@@ -1,2 +0,0 @@
-#!/usr/bin/env node
-console.log("syndai: the connect command is not released yet. See https://syndai.ai");