syndai 0.1.0 → 0.3.0

package/src/store.js

@@ -0,0 +1,134 @@
+// Local files, all outside any repository (`.syndai/**` in a repo is a protected path):
+//   $XDG_CONFIG_HOME/syndai/credentials.json  keys, by workspace (customer), mode 0600
+//   $XDG_CONFIG_HOME/syndai/links.json        directory -> project
+//   $XDG_STATE_HOME/syndai/pending/*.json     a change's request id, written BEFORE its POST
+
+import fs from "node:fs";
+import { homedir } from "node:os";
+import path from "node:path";
+import { CliError, EXIT } from "./errors.js";
+
+const PENDING_TTL_MS = 24 * 60 * 60 * 1000;
+
+export function storePaths(env) {
+  const home = env.HOME || homedir();
+  const config = path.join(env.XDG_CONFIG_HOME || path.join(home, ".config"), "syndai");
+  const state = path.join(env.XDG_STATE_HOME || path.join(home, ".local", "state"), "syndai");
+  return {
+    home,
+    credentials: path.join(config, "credentials.json"),
+    links: path.join(config, "links.json"),
+    pending: path.join(state, "pending"),
+  };
+}
+
+export function readJson(file, fallback) {
+  let text;
+  try {
+    text = fs.readFileSync(file, "utf8");
+  } catch (err) {
+    if (err.code === "ENOENT") return fallback;
+    throw err;
+  }
+  try {
+    return JSON.parse(text);
+  } catch {
+    throw new CliError(EXIT.FAILED, `${file} is not valid JSON; fix or delete it.`);
+  }
+}
+
+/** Atomic write (temp file + rename) with an exact mode, whatever the umask. */
+export function writeFileAtomic(file, text, mode = 0o600) {
+  fs.mkdirSync(path.dirname(file), { recursive: true, mode: 0o700 });
+  const tmp = `${file}.${process.pid}.${Date.now()}.tmp`;
+  fs.writeFileSync(tmp, text, { mode });
+  fs.chmodSync(tmp, mode);
+  fs.renameSync(tmp, file);
+}
+
+export function writeJson(file, data, mode = 0o600) {
+  writeFileAtomic(file, `${JSON.stringify(data, null, 2)}\n`, mode);
+}
+
+// --- credentials -------------------------------------------------------------------------
+
+export function loadCredentials(paths) {
+  const data = readJson(paths.credentials, null);
+  return data && typeof data.customers === "object" ? data : { default: null, customers: {} };
+}
+
+export function saveCredential(paths, { customer_id, api_key, key_id, expires_at }) {
+  const data = loadCredentials(paths);
+  data.customers[customer_id] = { api_key, key_id, expires_at };
+  data.default = customer_id;
+  writeJson(paths.credentials, data);
+}
+
+export function removeCredential(paths, customerId) {
+  const data = loadCredentials(paths);
+  delete data.customers[customerId];
+  if (data.default === customerId) data.default = Object.keys(data.customers)[0] ?? null;
+  writeJson(paths.credentials, data);
+}
+
+// --- links -------------------------------------------------------------------------------
+
+/** The link for `cwd` or its nearest linked parent, or null. */
+export function findLink(paths, cwd) {
+  const links = readJson(paths.links, {});
+  let dir = path.resolve(cwd);
+  for (;;) {
+    if (links[dir]) return { dir, ...links[dir] };
+    const parent = path.dirname(dir);
+    if (parent === dir) return null;
+    dir = parent;
+  }
+}
+
+export function saveLink(paths, dir, link) {
+  const links = readJson(paths.links, {});
+  links[path.resolve(dir)] = link;
+  writeJson(paths.links, links);
+}
+
+// --- pending change requests -------------------------------------------------------------
+
+function pendingFile(paths, requestId) {
+  return path.join(paths.pending, `${requestId.replace(/[^\w-]/g, "_")}.json`);
+}
+
+/** A not-yet-confirmed request for the same project and text (a crash or a retry), or null. */
+export function findPending(paths, { app, text }, now = Date.now()) {
+  let names;
+  try {
+    names = fs.readdirSync(paths.pending);
+  } catch (err) {
+    if (err.code === "ENOENT") return null;
+    throw err;
+  }
+  let match = null;
+  for (const name of names.filter((n) => n.endsWith(".json"))) {
+    const file = path.join(paths.pending, name);
+    let record;
+    try {
+      record = JSON.parse(fs.readFileSync(file, "utf8"));
+    } catch {
+      fs.rmSync(file, { force: true });
+      continue;
+    }
+    if (now - Date.parse(record.created_at) > PENDING_TTL_MS) {
+      fs.rmSync(file, { force: true });
+    } else if (record.app === app && record.text === text) {
+      match = record;
+    }
+  }
+  return match;
+}
+
+export function writePending(paths, record) {
+  writeJson(pendingFile(paths, record.request_id), record);
+}
+
+export function clearPending(paths, requestId) {
+  fs.rmSync(pendingFile(paths, requestId), { force: true });
+}

package/src/ui.js

@@ -0,0 +1,133 @@
+// 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 { 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;
+  }
+}

package/src/watch.js

@@ -0,0 +1,292 @@
+// 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: cli.mdx "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);
+  for (const [i, option] of options.entries()) ui.progress(`  ${i + 1}. ${option.label}`);
+  const multi = input.kind === "multi_choice";
+  const hint = multi ? "numbers, comma-separated" : "a number";
+  for (;;) {
+    const answer = await ask(io, `Pick ${hint}${textAllowed ? " or type an answer" : ""}${optional}: `);
+    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/api.js

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