@cabane/companion 0.6.156 → 0.6.157

package/dist/launch.js

@@ -0,0 +1,411 @@
+// src/launch.ts
+import { readFileSync as readFileSync3 } from "fs";
+import { join as join5 } from "path";
+import { pathToFileURL } from "url";
+
+// src/cabane-command.ts
+import { accessSync, constants, realpathSync as realpathSync2 } from "fs";
+import { homedir as homedir3 } from "os";
+import { delimiter, join as join2, sep as sep2 } from "path";
+
+// src/bundled-binaries.ts
+import { realpathSync, statSync } from "fs";
+import { createRequire } from "module";
+import { homedir } from "os";
+import { dirname, join, sep } from "path";
+import { fileURLToPath } from "url";
+var CODEX_CLI = "@openai/codex";
+var CODEX_PACKAGE_BY_TRIPLE = {
+  "x86_64-unknown-linux-musl": `${CODEX_CLI}-linux-x64`,
+  "aarch64-unknown-linux-musl": `${CODEX_CLI}-linux-arm64`,
+  "x86_64-apple-darwin": `${CODEX_CLI}-darwin-x64`,
+  "aarch64-apple-darwin": `${CODEX_CLI}-darwin-arm64`,
+  "x86_64-pc-windows-msvc": `${CODEX_CLI}-win32-x64`,
+  "aarch64-pc-windows-msvc": `${CODEX_CLI}-win32-arm64`
+};
+
+// src/cli-entry.ts
+import { existsSync } from "fs";
+import { fileURLToPath as fileURLToPath2 } from "url";
+
+// src/term.ts
+import { createInterface } from "readline";
+import { homedir as homedir2 } from "os";
+import pc from "picocolors";
+
+// src/config.ts
+import {
+  chmodSync,
+  mkdirSync,
+  readFileSync,
+  renameSync,
+  rmSync,
+  writeFileSync,
+  existsSync as existsSync2
+} from "fs";
+import { homedir as homedir4, userInfo } from "os";
+import { dirname as dirname2, join as join3 } from "path";
+import { z as z2 } from "zod";
+
+// src/pairing.ts
+function isAllowedBaseUrl(raw) {
+  let url;
+  try {
+    url = new URL(raw);
+  } catch {
+    return false;
+  }
+  if (url.protocol === "https:") return true;
+  if (url.protocol === "http:") {
+    const host = url.hostname.toLowerCase();
+    return host === "localhost" || host.endsWith(".localhost") || host === "127.0.0.1" || host === "::1" || host === "[::1]";
+  }
+  return false;
+}
+
+// src/prepare-hook.ts
+import { spawn } from "child_process";
+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: 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 companion.
+  timeoutMs: z.number().int().positive().optional(),
+  // Re-invoke the hook when a prepared result already exists, in VALIDATE
+  // mode: the cached result is handed back as `prepared` and stdout is
+  // ignored, so the cwd cannot move. Its only power is to exit non-zero and
+  // fail the turn. The hook resolves once per (conversation, agent), so a
+  // later message asking for a different environment is otherwise silently
+  // ignored; this lets a hook refuse it out loud.
+  //
+  // Default OFF: a hook that provisions unconditionally must not start
+  // running on every turn because the companion upgraded.
+  validateCached: z.boolean().optional(),
+  // Independent operator-owned reporter. Receives sanitized failure metadata
+  // on stdin; never re-enters this hook and cannot change the turn outcome.
+  failureReporter: z.object({
+    command: z.string().min(1),
+    args: z.array(z.string()).optional(),
+    env: z.record(z.string(), z.string()).optional(),
+    timeoutMs: z.number().int().positive().max(3e4).optional()
+  }).strict().optional()
+}).strict();
+var DEFAULT_TIMEOUT_MS = 10 * 6e4;
+var prepareResultSchema = z.object({
+  cwd: z.string().min(1),
+  env: z.record(z.string(), z.string()).optional()
+});
+
+// src/config.ts
+var realHomeCache;
+function realAccountHome() {
+  if (realHomeCache === void 0) {
+    try {
+      realHomeCache = userInfo().homedir;
+    } catch {
+      realHomeCache = null;
+    }
+  }
+  return realHomeCache;
+}
+function cabaneDir() {
+  const dir = join3(process.env.CABANE_COMPANION_HOME || homedir4(), ".cabane");
+  if (process.env.VITEST) {
+    const real = realAccountHome();
+    if (real && dir === join3(real, ".cabane")) {
+      throw new Error(
+        `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).`
+      );
+    }
+  }
+  return dir;
+}
+var localAgentConfigSchema = z2.object({
+  cwd: z2.string().optional(),
+  prepareHook: prepareHookSchema.optional(),
+  // The Claude Code auto-memory escape hatch. Auto-memory is forced OFF by
+  // default (memory belongs in the Cabane workspace, and a shared companion
+  // would pool one cwd-keyed memory dir across users). On a companion you run
+  // yourself, `claudeCode: { autoMemory: true }` hands 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: z2.object({ autoMemory: z2.boolean().optional() }).strict().optional(),
+  // This agent's exception to `runners.sandbox`: an ops agent that runs with
+  // the machine on a sandboxed device, or one sandboxed agent on a device that
+  // isn't. Absent is "inherit". Only on a row keyed by the agent's id.
+  sandbox: z2.enum(["os", "none"]).optional()
+}).strict();
+var AGENT_ID_KEY = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+var agentsConfigSchema = z2.record(z2.string(), localAgentConfigSchema).superRefine((agents, ctx) => {
+  for (const [key, row] of Object.entries(agents)) {
+    if (row.sandbox === void 0) continue;
+    if (AGENT_ID_KEY.test(key)) continue;
+    ctx.addIssue({
+      code: z2.ZodIssueCode.custom,
+      path: [key, "sandbox"],
+      message: "a sandbox exception must name one agent \u2014 key the row by the agent's id (shown in Cabane), not a username or workspace-slug/username"
+    });
+  }
+});
+var companionConfigSchema = z2.object({
+  // https-enforced (loopback exempt), so a hand-edited config can't put the
+  // device token and prompt on a plaintext channel.
+  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 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: 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: 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 companion
+  // never writes this (it only persists credentials + the device, elsewhere).
+  agents: agentsConfigSchema.optional(),
+  // The DEVICE-LEVEL prepare hook, for every agent assigned here unless its own
+  // `agents` row names one. Per-agent hooks alone make the config a second
+  // silent roster: an agent nobody listed gets no hook and no error, and starts
+  // in the operator's `$HOME` (an agent woke in `/home/joshed` this way on
+  // 2026-08-17).
+  prepareHook: prepareHookSchema.optional(),
+  // `dashboardPort` and `autoOpen` are IGNORED by the CLI (no port, no browser)
+  // but stay in the schema so an existing file still parses; the Electron shell
+  // reads them. `logLevel` is pino's level, live-editable.
+  dashboardPort: z2.number().int().min(1).max(65535).optional(),
+  autoOpen: z2.boolean().optional(),
+  logLevel: z2.enum(["warn", "info", "debug"]).optional(),
+  logFormat: z2.enum(["human", "json"]).optional(),
+  // An `opencode serve` the operator runs here (auth via opencode's own
+  // `/connect`; Cabane never sees provider keys). Set, the device advertises the
+  // `opencode` runtime and registers its adapter.
+  opencode: z2.object({
+    serverUrl: z2.string().url()
+  }).strict().optional(),
+  // Whether the user connected Claude Code on this machine: consent, opted into
+  // like codex. The manifest advertises claude-code only when this says so AND
+  // the Agent SDK's bundled executable resolves (not `claude` on PATH, which the
+  // SDK never runs).
+  //
+  // Absent means one of two things, told apart by `harnessesChosen`: a legacy
+  // config whose user was never asked (`migrateConnectedHarnesses`), or a
+  // device that has never been offered Claude Code. `enabled: false` is a
+  // decline, and `start` doesn't offer it again.
+  //
+  // Not the per-agent `agents.<key>.claudeCode.autoMemory`, one agent's memory
+  // switch.
+  claudeCode: z2.object({
+    enabled: z2.boolean().optional()
+  }).strict().optional(),
+  // Written by every pairing that asks which agents to connect. With it, an
+  // absent `claudeCode` block means "never offered"; without it, the block's
+  // absence marks a config from before connectors were chosen.
+  harnessesChosen: z2.boolean().optional(),
+  // Whether this companion keeps itself current: installs the version Cabane names, between
+  // turns, and rolls back one that doesn't come up (`updater.ts`). Absent means never asked,
+  // which `start` offers; off either way until someone says yes.
+  update: z2.object({
+    auto: z2.boolean()
+  }).strict().optional(),
+  // The answer to `start`'s "start at boot?" when it was no, so it isn't asked again.
+  // `cabane service install` still installs it.
+  serviceDeclined: z2.boolean().optional(),
+  // OpenCode's decline. Its block is an address, so a decline can't live there
+  // the way `claudeCode`/`codex` `enabled: false` does; without it a declined
+  // serve would be offered again on every `start`.
+  opencodeDeclined: z2.boolean().optional(),
+  // Codex is a local CLI the SDK spawns per turn, so this is an opt-in flag, not
+  // an address. The operator logs in (`codex login` or `CODEX_API_KEY`; Cabane
+  // never sees the key). The block's presence enables it; `enabled: false` turns
+  // it off. Half the answer: advertising also requires the SDK's vendored
+  // `codex` binary to resolve.
+  codex: z2.object({
+    enabled: z2.boolean().optional()
+  }).strict().optional(),
+  // Run each turn in a child runner process. Absent or `enabled: false` is the
+  // in-process path. `sandbox: 'os'` wraps the runner in an OS sandbox where the
+  // host supports one; `'none'` (the default) is a plain child, supported in its
+  // own right. `policy` is what the sandbox lets a turn reach, read and hold,
+  // validated in `runner/sandbox-policy.ts` so a bad policy refuses the turns it
+  // governs, field named, instead of stopping the companion starting.
+  runners: z2.object({
+    enabled: z2.boolean().optional(),
+    provider: z2.enum(["local-process", "docker"]).optional(),
+    sandbox: z2.enum(["os", "none"]).optional(),
+    // A container per conversation and agent, from one image, on a network
+    // whose only way out is an allow-listed proxy.
+    docker: z2.object({
+      // The base image a container runs. Default: the one this companion
+      // builds from its own Dockerfile on first use. One named here must
+      // have that one's layout (the `runner` user, `cabane-companion` on
+      // PATH reading `CABANE_COMPANION_ROOT`).
+      image: z2.string().min(1).optional(),
+      // The companion install mounted into every container. Default, on
+      // Linux: this companion's own. Needed for one run from a checkout
+      // (a `pnpm --filter @cabane/companion deploy --prod <dir>`).
+      companionDir: z2.string().min(1).optional(),
+      // Hosts a turn may reach besides the Cabane API, the model providers
+      // and the git host. `*.example.com` matches any subdomain.
+      egressAllow: z2.array(z2.string().min(1)).optional(),
+      // Keep a turn's container between turns and start it again for the
+      // next one. Off by default: the container goes after every turn and
+      // the runtime's session files are restored into the next.
+      keepContainers: z2.boolean().optional(),
+      // The Cabane URL as a container reaches it, for a device whose own
+      // `baseUrl` is a loopback address the container can't see.
+      apiUrl: z2.string().url().refine(isAllowedBaseUrl).optional(),
+      // Env set on each turn's runner, `${NAME}` resolved from secrets.json
+      // at exec: the runtime's own auth, which the image never carries.
+      env: z2.record(z2.string(), z2.string()).optional(),
+      // A git credential helper run on this device to answer the
+      // container's git for an allowed host, e.g. `!gh auth git-credential`.
+      // Absent: git's own configured helpers on this device.
+      gitCredentialHelper: z2.string().min(1).optional()
+    }).strict().optional(),
+    policy: z2.unknown().optional()
+  }).strict().optional()
+});
+
+// src/install-layout.ts
+import {
+  existsSync as existsSync3,
+  lstatSync,
+  mkdirSync as mkdirSync2,
+  readFileSync as readFileSync2,
+  readdirSync,
+  realpathSync as realpathSync3,
+  renameSync as renameSync2,
+  rmSync as rmSync2,
+  symlinkSync
+} from "fs";
+import { dirname as dirname3, join as join4 } from "path";
+import { fileURLToPath as fileURLToPath3 } from "url";
+function currentLink() {
+  return join4(cabaneDir(), "current");
+}
+function ownPackageRoot(moduleUrl = import.meta.url) {
+  return dirname3(dirname3(fileURLToPath3(moduleUrl)));
+}
+function packageVersion(root) {
+  try {
+    const pkg = JSON.parse(readFileSync2(join4(root, "package.json"), "utf8"));
+    return typeof pkg.version === "string" ? pkg.version : null;
+  } catch {
+    return null;
+  }
+}
+function currentRoot() {
+  try {
+    const root = realpathSync3(currentLink());
+    return existsSync3(join4(root, "dist", "cli.js")) ? root : null;
+  } catch {
+    return null;
+  }
+}
+function pointCurrentAt(root) {
+  const link = currentLink();
+  mkdirSync2(dirname3(link), { recursive: true });
+  const fresh = `${link}.${process.pid}.${Date.now()}`;
+  symlinkSync(root, fresh);
+  try {
+    renameSync2(fresh, link);
+  } catch (err) {
+    rmSync2(fresh, { force: true });
+    throw err;
+  }
+}
+function currentIsLink() {
+  try {
+    return lstatSync(currentLink()).isSymbolicLink();
+  } catch {
+    return false;
+  }
+}
+function compareVersions(a, b) {
+  const parts = (v) => /^\d+(\.\d+)*$/.test(v) ? v.split(".").map(Number) : null;
+  const pa = parts(a);
+  const pb = parts(b);
+  if (!pa || !pb) return pa ? 1 : pb ? -1 : 0;
+  for (let i = 0; i < Math.max(pa.length, pb.length); i++) {
+    const d = (pa[i] ?? 0) - (pb[i] ?? 0);
+    if (d !== 0) return d;
+  }
+  return 0;
+}
+
+// src/launch.ts
+var SOURCE_BUILD_VERSION = "0.0.0";
+function chooseInstall(own, current) {
+  if (own.version === SOURCE_BUILD_VERSION || !current || current.root === own.root)
+    return { install: own, repoint: false };
+  if (compareVersions(current.version, own.version) >= 0)
+    return { install: current, repoint: false };
+  return { install: own, repoint: true };
+}
+function parseEnvFile(text) {
+  const out = {};
+  for (const raw of text.split("\n")) {
+    const line = raw.trim();
+    if (!line || line.startsWith("#")) continue;
+    const eq = line.indexOf("=");
+    if (eq <= 0) continue;
+    const key = line.slice(0, eq).trim();
+    if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(key)) continue;
+    let value = line.slice(eq + 1).trim();
+    if (value.length >= 2 && /^(['"]).*\1$/.test(value)) value = value.slice(1, -1);
+    out[key] = value;
+  }
+  return out;
+}
+function loadServiceEnv() {
+  let text;
+  try {
+    text = readFileSync3(join5(cabaneDir(), "service.env"), "utf8");
+  } catch {
+    return;
+  }
+  for (const [key, value] of Object.entries(parseEnvFile(text))) {
+    if (process.env[key] === void 0) process.env[key] = value;
+  }
+}
+async function launch(argv = process.argv.slice(2)) {
+  const ownRoot = ownPackageRoot();
+  if (process.env.CABANE_LAUNCH_SELF === "1") {
+    await import("./cli.js");
+    return;
+  }
+  const own = { root: ownRoot, version: packageVersion(ownRoot) ?? SOURCE_BUILD_VERSION };
+  const curRoot = currentRoot();
+  const curVersion = curRoot ? packageVersion(curRoot) : null;
+  const choice = chooseInstall(
+    own,
+    curRoot && curVersion ? { root: curRoot, version: curVersion } : null
+  );
+  if (choice.repoint && currentIsLink()) {
+    try {
+      pointCurrentAt(own.root);
+    } catch {
+    }
+  }
+  const run = choice.install;
+  if (argv[0] === "start" && process.env.CABANE_COMPANION_SUPERVISED === "1") loadServiceEnv();
+  if (run.root === ownRoot) {
+    await import("./cli.js");
+    return;
+  }
+  await import(pathToFileURL(join5(run.root, "dist", "cli.js")).href);
+}
+export {
+  chooseInstall,
+  launch,
+  parseEnvFile
+};

package/dist/pairing-config.js

@@ -307,6 +307,15 @@ var companionConfigSchema = z2.object({
   // absent `claudeCode` block means "never offered"; without it, the block's
   // absence marks a config from before connectors were chosen.
   harnessesChosen: z2.boolean().optional(),
+  // Whether this companion keeps itself current: installs the version Cabane names, between
+  // turns, and rolls back one that doesn't come up (`updater.ts`). Absent means never asked,
+  // which `start` offers; off either way until someone says yes.
+  update: z2.object({
+    auto: z2.boolean()
+  }).strict().optional(),
+  // The answer to `start`'s "start at boot?" when it was no, so it isn't asked again.
+  // `cabane service install` still installs it.
+  serviceDeclined: z2.boolean().optional(),
   // OpenCode's decline. Its block is an address, so a decline can't live there
   // the way `claudeCode`/`codex` `enabled: false` does; without it a declined
   // serve would be offered again on every `start`.