@cabane/companion 0.5.0 → 0.6.1

package/dist/pairing-config.js

@@ -10,16 +10,16 @@ import {
 } from "fs";
 import { homedir, userInfo } from "os";
 import { dirname, join } from "path";
-import { z as z3 } from "zod";
+import { z as z2 } from "zod";
 
 // src/errors.ts
-var BridgeError = class extends Error {
+var CompanionError = class extends Error {
   constructor(message) {
     super(message);
-    this.name = "BridgeError";
+    this.name = "CompanionError";
   }
 };
-var ApiError = class extends BridgeError {
+var ApiError = class extends CompanionError {
   constructor(status, message, body) {
     super(message);
     this.status = status;
@@ -29,7 +29,7 @@ var ApiError = class extends BridgeError {
   status;
   body;
 };
-var ConfigError = class extends BridgeError {
+var ConfigError = class extends CompanionError {
   constructor(message) {
     super(message);
     this.name = "ConfigError";
@@ -37,9 +37,6 @@ var ConfigError = class extends BridgeError {
 };
 
 // src/pairing.ts
-import { z } from "zod";
-var PAIRING_VERSION = 1;
-var DEVICE_TOKEN_PREFIX = "cabdev_";
 function isAllowedBaseUrl(raw) {
   let url;
   try {
@@ -54,40 +51,24 @@ function isAllowedBaseUrl(raw) {
   }
   return false;
 }
-var pairingSchema = z.object({
-  // Bumped if the wire shape changes incompatibly. We only accept v1.
-  v: z.literal(PAIRING_VERSION),
-  baseUrl: z.string().url().refine(isAllowedBaseUrl, {
-    message: "baseUrl must be https (loopback http is allowed for local dev only)"
-  }),
-  // The `cabdev_` device token plaintext — the bridge's one durable credential.
-  deviceToken: z.string().min(1).startsWith(DEVICE_TOKEN_PREFIX, {
-    message: 'deviceToken must be a cabane device token (starts with "cabdev_")'
-  }),
-  // Optional identity hints the app may include for nicer local display. The
-  // bridge also learns these from the first assignments pull, so they're not
-  // required.
-  deviceId: z.string().min(1).optional(),
-  deviceLabel: z.string().min(1).optional()
-});
 
 // src/prepare-hook.ts
 import { spawn } from "child_process";
-import { z as z2 } from "zod";
-var prepareHookSchema = z2.object({
-  command: z2.string().min(1),
-  args: z2.array(z2.string()).optional(),
+import { z } from "zod";
+var prepareHookSchema = z.object({
+  command: z.string().min(1),
+  args: z.array(z.string()).optional(),
   // Extra env handed to the hook process itself (merged over process.env).
-  env: z2.record(z2.string(), z2.string()).optional(),
+  env: z.record(z.string(), z.string()).optional(),
   // Wall-clock cap for the hook. Provisioning is slow (minutes), so the
   // default is generous; a hook that hangs past this is killed and the turn
-  // fails with a clear timeout message rather than pinning the bridge.
-  timeoutMs: z2.number().int().positive().optional()
+  // fails with a clear timeout message rather than pinning the companion.
+  timeoutMs: z.number().int().positive().optional()
 }).strict();
 var DEFAULT_TIMEOUT_MS = 10 * 6e4;
-var prepareResultSchema = z2.object({
-  cwd: z2.string().min(1),
-  env: z2.record(z2.string(), z2.string()).optional()
+var prepareResultSchema = z.object({
+  cwd: z.string().min(1),
+  env: z.record(z.string(), z.string()).optional()
 });
 
 // src/config.ts
@@ -103,12 +84,12 @@ function realAccountHome() {
   return realHomeCache;
 }
 function cabaneDir() {
-  const dir = join(process.env.CABANE_BRIDGE_HOME || homedir(), ".cabane");
+  const dir = join(process.env.CABANE_COMPANION_HOME || homedir(), ".cabane");
   if (process.env.VITEST) {
     const real = realAccountHome();
     if (real && dir === join(real, ".cabane")) {
       throw new Error(
-        `cabaneDir() resolved to the real ${dir} during a test run. Bridge tests must swap process.env.HOME to a tmp dir before touching the config dir; this guard prevents wiping the operator's real bridge config (see apps/bridge/test/setup-home.ts).`
+        `cabaneDir() resolved to the real ${dir} during a test run. Companion tests must swap process.env.HOME to a tmp dir before touching the config dir; this guard prevents wiping the operator's real companion config (see apps/companion/test/setup-home.ts).`
       );
     }
   }
@@ -117,55 +98,55 @@ function cabaneDir() {
 function configPath() {
   return join(cabaneDir(), "config.json");
 }
-var localAgentConfigSchema = z3.object({
-  cwd: z3.string().optional(),
+var localAgentConfigSchema = z2.object({
+  cwd: z2.string().optional(),
   prepareHook: prepareHookSchema.optional(),
   // CT289: the Claude Code auto-memory escape hatch. Auto-memory is forced OFF
-  // by default on every bridge (memory belongs in the Cabane workspace, and the
-  // house bridge would otherwise share one cwd-keyed memory dir across users).
-  // On a bridge you run yourself, set `claudeCode: { autoMemory: true }` to hand
+  // by default on every companion (memory belongs in the Cabane workspace, and a
+  // shared companion would otherwise pool one cwd-keyed memory dir across users).
+  // On a companion you run yourself, set `claudeCode: { autoMemory: true }` to hand
   // auto-memory back to your own `~/.claude/settings.json` — Cabane then stops
   // injecting the off switch and your normal Claude Code memory workflow applies
   // (in coding mode, where the checkout's project settings are read).
-  claudeCode: z3.object({ autoMemory: z3.boolean().optional() }).strict().optional()
+  claudeCode: z2.object({ autoMemory: z2.boolean().optional() }).strict().optional()
 }).strict();
-var bridgeConfigSchema = z3.object({
+var companionConfigSchema = z2.object({
   // The cabane instance this device is paired with. SJ515: https-enforced
   // (loopback exempt) so a hand-edited config can't smuggle a plaintext-http
   // base URL onto the MITM-able channel the device token + prompt ride.
-  baseUrl: z3.string().url().refine(isAllowedBaseUrl, {
+  baseUrl: z2.string().url().refine(isAllowedBaseUrl, {
     message: "baseUrl must be https (loopback http is allowed for local dev only)"
   }),
-  // The `cabdev_` device token plaintext — the bridge's one durable credential,
+  // The `cabdev_` device token plaintext — the companion's one durable credential,
   // presented as `Authorization: Bearer <token>` on the device-facing pull +
   // heartbeat endpoints. Optional so `cabane-companion logout` can strip it (a
   // "paired but logged out" state the supervisor refuses to run) while keeping
   // the rest of the config; `pair` always writes one.
-  deviceToken: z3.string().optional(),
-  // Identity hints, learned from the pairing string and refreshed on the first
+  deviceToken: z2.string().optional(),
+  // Identity hints, learned from the device flow and refreshed on the first
   // assignments pull. Cosmetic — used for `status`/dashboard display only.
-  deviceId: z3.string().optional(),
-  deviceLabel: z3.string().optional(),
+  deviceId: z2.string().optional(),
+  deviceLabel: z2.string().optional(),
   // Optional per-agent machine-local overrides (cwd / prepareHook), keyed by
-  // agentId / username / `slug/username`. Hand-added by the operator; the bridge
+  // agentId / username / `slug/username`. Hand-added by the operator; the companion
   // never writes this (it only persists credentials + the device, elsewhere).
-  agents: z3.record(z3.string(), localAgentConfigSchema).optional(),
+  agents: z2.record(z2.string(), localAgentConfigSchema).optional(),
   // Dashboard settings (all optional). dashboardPort: preferred bind port (next
   // free one if taken); autoOpen: whether `start` opens the browser (the
-  // `--no-open` flag / `BRIDGE_NO_OPEN=1` override per-run); logLevel: pino
+  // `--no-open` flag / `COMPANION_NO_OPEN=1` override per-run); logLevel: pino
   // level, live-editable from the dashboard settings panel.
-  dashboardPort: z3.number().int().min(1).max(65535).optional(),
-  autoOpen: z3.boolean().optional(),
-  logLevel: z3.enum(["warn", "info", "debug"]).optional(),
+  dashboardPort: z2.number().int().min(1).max(65535).optional(),
+  autoOpen: z2.boolean().optional(),
+  logLevel: z2.enum(["warn", "info", "debug"]).optional(),
   // CT270: the opencode runtime, when the operator runs one on this machine. The
   // operator installs opencode, starts `opencode serve` (auth via opencode's own
-  // `/connect` — Cabane never sees provider keys), and points the bridge at it
+  // `/connect` — Cabane never sees provider keys), and points the companion at it
   // here. Setting this makes the device advertise the `opencode` runtime on its
   // heartbeat manifest (so the server offers DeepSeek/opencode models here and
   // routes those turns to this device) AND registers the opencode adapter in the
   // dispatcher. Absent → the device is claude-code-only, exactly as before.
-  opencode: z3.object({
-    serverUrl: z3.string().url()
+  opencode: z2.object({
+    serverUrl: z2.string().url()
   }).strict().optional(),
   // CT481: the codex runtime, when the operator runs Codex on this machine. Unlike
   // opencode (a long-lived `opencode serve` addressed by URL), Codex is a local CLI
@@ -176,8 +157,8 @@ var bridgeConfigSchema = z3.object({
   // keeps the block but turns it off). Enabling makes the device advertise the
   // `codex` runtime on its heartbeat manifest AND registers the codex adapter in
   // the dispatcher. Absent → the device doesn't offer codex, exactly as before.
-  codex: z3.object({
-    enabled: z3.boolean().optional()
+  codex: z2.object({
+    enabled: z2.boolean().optional()
   }).strict().optional()
 });
 function loadConfig() {
@@ -200,7 +181,7 @@ function loadConfig() {
       `${path} is not valid JSON: ${err instanceof Error ? err.message : String(err)}`
     );
   }
-  const result = bridgeConfigSchema.safeParse(parsed);
+  const result = companionConfigSchema.safeParse(parsed);
   if (!result.success) {
     const agentIssue = result.error.issues.find((i) => i.path[0] === "agents");
     if (agentIssue) {
@@ -209,7 +190,7 @@ function loadConfig() {
       );
     }
     throw new ConfigError(
-      `${path} is from an incompatible or older version of the bridge, or was hand-edited. Run \`cabane-companion pair\` to re-pair, or \`cabane-companion logout --purge\` to reset.`
+      `${path} is from an incompatible or older version of the companion, or was hand-edited. Run \`cabane-companion pair\` to re-pair, or \`cabane-companion logout --purge\` to reset.`
     );
   }
   return result.data;
@@ -231,7 +212,7 @@ function loadConfigTolerant() {
   } catch {
     return { local: empty, note: `${path} was unreadable (invalid JSON) and has been reset.` };
   }
-  const strict = bridgeConfigSchema.safeParse(parsed);
+  const strict = companionConfigSchema.safeParse(parsed);
   if (strict.success) {
     const { agents: agents2, dashboardPort, autoOpen, logLevel } = strict.data;
     return {
@@ -246,7 +227,7 @@ function loadConfigTolerant() {
   }
   const obj = parsed && typeof parsed === "object" ? parsed : {};
   const local = {};
-  const agents = z3.record(z3.string(), localAgentConfigSchema).safeParse(obj.agents);
+  const agents = z2.record(z2.string(), localAgentConfigSchema).safeParse(obj.agents);
   if (agents.success) local.agents = agents.data;
   if (typeof obj.dashboardPort === "number") local.dashboardPort = obj.dashboardPort;
   if (typeof obj.autoOpen === "boolean") local.autoOpen = obj.autoOpen;
@@ -255,7 +236,7 @@ function loadConfigTolerant() {
   }
   return {
     local,
-    note: `the existing ${path} was from an older or incompatible bridge; re-pairing rewrote it.`
+    note: `the existing ${path} was from an older or incompatible companion; re-pairing rewrote it.`
   };
 }
 function saveConfig(cfg) {
@@ -295,7 +276,7 @@ async function postJson(baseUrl, path, body) {
       body: JSON.stringify(body)
     });
   } catch (err) {
-    throw new BridgeError(
+    throw new CompanionError(
       `couldn't reach cabane at ${baseUrl}: ${err instanceof Error ? err.message : String(err)}. Check the server URL (pass --server <url>) and your connection.`
     );
   }
@@ -310,8 +291,8 @@ async function postJson(baseUrl, path, body) {
   }
   if (res.status >= 400) {
     if (res.status === 404 && path.endsWith("/code")) {
-      throw new BridgeError(
-        `this cabane server (${baseUrl}) doesn't support device-flow pairing yet. Update the server, or use \`cabane-companion pair --legacy\` with a pairing string from the app.`
+      throw new CompanionError(
+        `this cabane server (${baseUrl}) doesn't support device-flow pairing yet. Update the server to a version that supports \`cabane-companion pair\`.`
       );
     }
     const msg = parsed && typeof parsed === "object" && "error" in parsed ? String(parsed.error) : `${res.status}`;
@@ -320,16 +301,16 @@ async function postJson(baseUrl, path, body) {
   return parsed;
 }
 function requestEnrollmentCode(baseUrl) {
-  return postJson(baseUrl, "/api/bridge-enrollment/code", {});
+  return postJson(baseUrl, "/api/device-enrollment/code", {});
 }
 function pollOnce(baseUrl, deviceCode) {
-  return postJson(baseUrl, "/api/bridge-enrollment/poll", { deviceCode });
+  return postJson(baseUrl, "/api/device-enrollment/poll", { deviceCode });
 }
 var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 async function runDeviceFlow(baseUrl, print, opts = {}) {
   const now = opts.now ?? (() => Date.now());
   const wait = opts.sleepMs ?? sleep;
-  if (opts.signal?.aborted) throw new BridgeError("pairing was cancelled.");
+  if (opts.signal?.aborted) throw new CompanionError("pairing was cancelled.");
   const code = await requestEnrollmentCode(baseUrl);
   if (opts.onCode) await opts.onCode(code);
   print("");
@@ -344,11 +325,11 @@ async function runDeviceFlow(baseUrl, print, opts = {}) {
   let intervalMs = Math.max(1, code.interval) * 1e3;
   while (now() < deadline) {
     await wait(intervalMs);
-    if (opts.signal?.aborted) throw new BridgeError("pairing was cancelled.");
+    if (opts.signal?.aborted) throw new CompanionError("pairing was cancelled.");
     const res = await pollOnce(baseUrl, code.deviceCode);
     if (res.status === "complete") {
       if (!res.deviceToken || !res.baseUrl) {
-        throw new BridgeError("the server reported the pairing complete but returned no token.");
+        throw new CompanionError("the server reported the pairing complete but returned no token.");
       }
       return {
         baseUrl: res.baseUrl,
@@ -358,13 +339,13 @@ async function runDeviceFlow(baseUrl, print, opts = {}) {
       };
     }
     if (res.status === "expired") {
-      throw new BridgeError(
+      throw new CompanionError(
         "this pairing code expired before it was confirmed. Run `cabane-companion pair` again for a fresh one."
       );
     }
     if (res.status === "slow_down") intervalMs += 1e3;
   }
-  throw new BridgeError(
+  throw new CompanionError(
     "this pairing code expired before it was confirmed. Run `cabane-companion pair` again for a fresh one."
   );
 }
@@ -374,7 +355,7 @@ var DEFAULT_BASE_URL = "https://cabane.ai";
 function resolvePairBaseUrl(server) {
   const raw = (server ?? process.env.CABANE_BASE_URL ?? DEFAULT_BASE_URL).trim();
   if (!isAllowedBaseUrl(raw)) {
-    throw new BridgeError(
+    throw new CompanionError(
       `invalid server URL "${raw}": must be an https URL (loopback http is allowed for local dev). Pass it as \`cabane-companion pair --server https://your-cabane\`.`
     );
   }
@@ -401,7 +382,7 @@ function isDevicePaired() {
 }
 export {
   ApiError,
-  BridgeError,
+  CompanionError,
   isDevicePaired,
   requestEnrollmentCode,
   resolvePairBaseUrl,