@cabane/companion 0.6.155 → 0.6.157

package/dist/pairing-config.js

@@ -1,3 +1,108 @@
+// 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`
+};
+function companionInstall(execPath = process.execPath, home = homedir()) {
+  const real = (path) => {
+    try {
+      return realpathSync(path);
+    } catch {
+      return path;
+    }
+  };
+  const scriptNode = join(real(home), ".cabane", "node") + sep;
+  return real(execPath).startsWith(scriptNode) ? "script" : "npm";
+}
+
+// src/cli-entry.ts
+import { existsSync } from "fs";
+import { fileURLToPath as fileURLToPath2 } from "url";
+var RELATIVE_CANDIDATES = ["./cli.js", "../dist/cli.js", "../cli.js"];
+function companionCliEntry(deps = {}) {
+  const exists = deps.exists ?? existsSync;
+  const candidates = deps.candidates ?? RELATIVE_CANDIDATES.map((rel) => fileURLToPath2(new URL(rel, import.meta.url)));
+  for (const candidate of candidates) {
+    if (exists(candidate)) return candidate;
+  }
+  const argv1 = "argv1" in deps ? deps.argv1 : process.argv[1];
+  if (argv1 && exists(argv1)) return argv1;
+  return candidates[0] ?? "";
+}
+
+// src/term.ts
+import { createInterface } from "readline";
+import { homedir as homedir2 } from "os";
+import pc from "picocolors";
+function tildePath(path, home = homedir2()) {
+  if (home && path.startsWith(home + "/")) return `~${path.slice(home.length)}`;
+  return path;
+}
+
+// src/cabane-command.ts
+function installedCommandPath(deps = {}) {
+  const install = deps.install ?? companionInstall();
+  const home = deps.home ?? homedir3();
+  if (install === "script") return join2(home, ".cabane", "bin", "cabane");
+  const entry = deps.cliEntry ?? companionCliEntry();
+  const marker = `${sep2}lib${sep2}node_modules${sep2}@cabane${sep2}companion${sep2}`;
+  const at = entry.indexOf(marker);
+  if (at < 0) return null;
+  return join2(entry.slice(0, at), "bin", "cabane");
+}
+function cabaneCommand(deps = {}) {
+  const own = installedCommandPath(deps);
+  if (!own) return "cabane";
+  const realpath = deps.realpath ?? safeRealpath;
+  const isExecutable = deps.isExecutable ?? executable;
+  const ownReal = realpath(own);
+  if (!ownReal) return "cabane";
+  const onPath = firstOnPath("cabane", "path" in deps ? deps.path : process.env.PATH, isExecutable);
+  if (onPath && realpath(onPath) === ownReal) return "cabane";
+  return tildePath(own, deps.home);
+}
+function cabane(rest, deps) {
+  return `${cabaneCommand(deps)} ${rest}`;
+}
+function firstOnPath(name, path, isExecutable = executable) {
+  for (const dir of (path ?? "").split(delimiter)) {
+    if (!dir) continue;
+    const candidate = join2(dir, name);
+    if (isExecutable(candidate)) return candidate;
+  }
+  return null;
+}
+function executable(path) {
+  try {
+    accessSync(path, constants.X_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function safeRealpath(path) {
+  try {
+    return realpathSync2(path);
+  } catch {
+    return null;
+  }
+}
+
 // src/config.ts
 import {
   chmodSync,
@@ -6,10 +111,10 @@ import {
   renameSync,
   rmSync,
   writeFileSync,
-  existsSync
+  existsSync as existsSync2
 } from "fs";
-import { homedir, userInfo } from "os";
-import { dirname, join } from "path";
+import { homedir as homedir4, userInfo } from "os";
+import { dirname as dirname2, join as join3 } from "path";
 import { z as z2 } from "zod";
 
 // src/errors.ts
@@ -102,10 +207,10 @@ function realAccountHome() {
   return realHomeCache;
 }
 function cabaneDir() {
-  const dir = join(process.env.CABANE_COMPANION_HOME || homedir(), ".cabane");
+  const dir = join3(process.env.CABANE_COMPANION_HOME || homedir4(), ".cabane");
   if (process.env.VITEST) {
     const real = realAccountHome();
-    if (real && dir === join(real, ".cabane")) {
+    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).`
       );
@@ -114,7 +219,7 @@ function cabaneDir() {
   return dir;
 }
 function configPath() {
-  return join(cabaneDir(), "config.json");
+  return join3(cabaneDir(), "config.json");
 }
 var localAgentConfigSchema = z2.object({
   cwd: z2.string().optional(),
@@ -188,15 +293,33 @@ var companionConfigSchema = z2.object({
   // the Agent SDK's bundled executable resolves (not `claude` on PATH, which the
   // SDK never runs).
   //
-  // The block's PRESENCE is also the migration marker
-  // (`migrateConnectedHarnesses`): absent means a config whose user was never
-  // asked. So every config written carries it, a fresh pair at `enabled: false`.
+  // 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
@@ -250,7 +373,7 @@ var companionConfigSchema = z2.object({
 });
 function loadConfig() {
   const path = configPath();
-  if (!existsSync(path)) return null;
+  if (!existsSync2(path)) return null;
   let raw;
   try {
     raw = readFileSync(path, "utf8");
@@ -277,7 +400,7 @@ function loadConfig() {
       );
     }
     throw new ConfigError(
-      `${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.`
+      `${path} is from an incompatible or older version of the companion, or was hand-edited. Run \`${cabane("pair")}\` to re-pair, or \`${cabane("logout --purge")}\` to reset.`
     );
   }
   return result.data;
@@ -286,7 +409,7 @@ function loadConfigTolerant() {
   const path = configPath();
   const empty = {};
   const fresh = { local: empty, note: null, hadPriorConfig: false };
-  if (!existsSync(path)) return fresh;
+  if (!existsSync2(path)) return fresh;
   let raw;
   try {
     raw = readFileSync(path, "utf8");
@@ -306,7 +429,19 @@ function loadConfigTolerant() {
   }
   const strict = companionConfigSchema.safeParse(parsed);
   if (strict.success) {
-    const { agents: agents2, prepareHook: prepareHook2, dashboardPort, autoOpen, logLevel, logFormat, claudeCode: claudeCode2 } = strict.data;
+    const {
+      agents: agents2,
+      prepareHook: prepareHook2,
+      dashboardPort,
+      autoOpen,
+      logLevel,
+      logFormat,
+      claudeCode: claudeCode2,
+      codex: codex2,
+      opencode: opencode2,
+      opencodeDeclined,
+      harnessesChosen
+    } = strict.data;
     return {
       local: {
         ...agents2 !== void 0 ? { agents: agents2 } : {},
@@ -315,7 +450,11 @@ function loadConfigTolerant() {
         ...autoOpen !== void 0 ? { autoOpen } : {},
         ...logLevel !== void 0 ? { logLevel } : {},
         ...logFormat !== void 0 ? { logFormat } : {},
-        ...claudeCode2 !== void 0 ? { claudeCode: claudeCode2 } : {}
+        ...claudeCode2 !== void 0 ? { claudeCode: claudeCode2 } : {},
+        ...codex2 !== void 0 ? { codex: codex2 } : {},
+        ...opencode2 !== void 0 ? { opencode: opencode2 } : {},
+        ...opencodeDeclined !== void 0 ? { opencodeDeclined } : {},
+        ...harnessesChosen !== void 0 ? { harnessesChosen } : {}
       },
       note: null,
       hadPriorConfig: true
@@ -335,6 +474,12 @@ function loadConfigTolerant() {
   }
   const claudeCode = companionConfigSchema.shape.claudeCode.safeParse(obj.claudeCode);
   if (claudeCode.success && claudeCode.data !== void 0) local.claudeCode = claudeCode.data;
+  const codex = companionConfigSchema.shape.codex.safeParse(obj.codex);
+  if (codex.success && codex.data !== void 0) local.codex = codex.data;
+  const opencode = companionConfigSchema.shape.opencode.safeParse(obj.opencode);
+  if (opencode.success && opencode.data !== void 0) local.opencode = opencode.data;
+  if (obj.opencodeDeclined === true) local.opencodeDeclined = true;
+  if (obj.harnessesChosen === true) local.harnessesChosen = true;
   return {
     local,
     note: `the existing ${path} was from an older or incompatible companion; re-pairing rewrote it.`,
@@ -343,7 +488,7 @@ function loadConfigTolerant() {
 }
 function saveConfig(cfg) {
   const path = configPath();
-  mkdirSync(dirname(path), { recursive: true });
+  mkdirSync(dirname2(path), { recursive: true });
   try {
     chmodSync(cabaneDir(), 448);
   } catch {
@@ -406,7 +551,7 @@ async function postJson(baseUrl, path, body) {
   if (res.status >= 400) {
     if (res.status === 404 && path.endsWith("/code")) {
       throw new CompanionError(
-        `no device-flow pairing endpoint at ${baseUrl}. Either that server predates \`cabane-companion pair\`, or it isn't a Cabane API origin \u2014 the hosted app is https://app.cabane.ai (pass \`--server <url>\` for your own instance).`
+        `no device-flow pairing endpoint at ${baseUrl}. Either that server predates \`${cabane("pair")}\`, or it isn't a Cabane API origin \u2014 the hosted app is https://app.cabane.ai (pass \`--server <url>\` for your own instance).`
       );
     }
     const msg = parsed && typeof parsed === "object" && "error" in parsed ? String(parsed.error) : `${res.status}`;
@@ -481,7 +626,7 @@ function resolvePairBaseUrl(server) {
   const raw = (server ?? process.env.CABANE_BASE_URL ?? DEFAULT_BASE_URL).trim();
   if (!isAllowedBaseUrl(raw)) {
     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\`.`
+      `invalid server URL "${raw}": must be an https URL (loopback http is allowed for local dev). Pass it as \`${cabane("start --server https://your-cabane")}\`.`
     );
   }
   return raw;
@@ -489,12 +634,13 @@ function resolvePairBaseUrl(server) {
 function writePairedConfig(paired) {
   const { local, note, hadPriorConfig } = loadConfigTolerant();
   const config = {
-    // A device pairs connected to NOTHING: `claudeCode: { enabled: false }`
-    // written explicitly, since absence is what the harness migration reads.
-    // Omitted, a new device is auto-connected on first start; stamped on a
-    // RE-pair, an upgrading user's working device is disconnected. So only when
-    // there was no config before; `local` spreads after, keeping a prior answer.
-    ...hadPriorConfig ? {} : { claudeCode: { enabled: false } },
+    // A device pairs connected to NOTHING, and its agents are chosen from here
+    // on: `harnessesChosen` tells the harness migration that an absent
+    // `claudeCode` block means "never offered", not a legacy Claude device.
+    // Only when there was no config before: stamped on a RE-pair, an upgrading
+    // user's working device would be disconnected. `local` spreads after,
+    // keeping a prior answer.
+    ...hadPriorConfig ? {} : { harnessesChosen: true },
     ...local,
     baseUrl: paired.baseUrl,
     deviceToken: paired.deviceToken,