@cabane/companion 0.6.235 → 0.6.237

package/README.md

@@ -10,16 +10,16 @@ Pairing supplies a device token, not your Cabane password or a full-account toke
 
 ## Install
 
-On the device, in a terminal. One of:
+On the device, in a terminal. Copy the line from Your settings → Devices → Add a device in your Cabane: it carries your Cabane's address, shown here as `https://cabane.example.com`. One of:
 
 ```sh
-curl -fsSL https://cabane.ai/install.sh | bash
+curl -fsSL https://cabane.example.com/install.sh | bash
 ```
 
-The script brings its own Node (checksum-checked, into `~/.cabane`) and needs no sudo. Or, with Node 22 or newer already there (the only route on Windows):
+Your Cabane serves the script, with its own address written in. It brings its own Node (checksum-checked, into `~/.cabane`) and needs no sudo. Or, with Node 22 or newer already there (the only route on Windows):
 
 ```sh
-npm i -g @cabane/companion && cabane setup
+npm i -g @cabane/companion && cabane setup --server https://cabane.example.com
 ```
 
 `cabane setup` on an unpaired device prints a code and a link:
@@ -29,14 +29,14 @@ Pair this device
 Enter this code in Cabane, or press Return to open the page:
 
   WXYZ-2345
-  https://app.cabane.ai/pair/enter-code
+  https://cabane.example.com/pair/enter-code
 
 ⠋ Waiting for you to confirm in Cabane… (the code is good for 15 minutes)
 ```
 
-Enter the code in Cabane, signed in as yourself: from your own Settings → Devices → Add a device, from a workspace's Settings → Devices → Set up a new device, or on the page the link opens. Cabane shows which device asked; confirming pairs it to your account and nothing else. A workspace's dialog then adds the device to that workspace; from anywhere else, add it to a workspace from that workspace's Settings → Devices. Pairing from a workspace you're setting up places its default agent on the device once a harness there is usable.
+Enter the code in Cabane, signed in as yourself: from Your settings → Devices → Add a device, from a workspace's Settings → Devices → Set up a new device, or on the page the link opens. Cabane shows which device asked; confirming pairs it to your account and nothing else. A workspace's dialog then adds the device to that workspace; from anywhere else, add it to a workspace from that workspace's Settings → Devices. Pairing from a workspace you're setting up places its default agent on the device once a harness there is usable.
 
-Without a terminal, setup prints the same lines once and waits, so a container's logs carry the code. An expired code is replaced by a fresh one, up to three; Ctrl-C stops cleanly. The link is on the server the device pairs with: pass `--server <url>` for your own Cabane.
+Without a terminal, setup prints the same lines once and waits, so a container's logs carry the code. An expired code is replaced by a fresh one, up to three; Ctrl-C stops cleanly. The link is on the Cabane the device pairs with. There is no default: setup pairs with the Cabane named by `--server <url>`, by `CABANE_BASE_URL`, or by the device's config, and stops if none names one. Once a Cabane has issued a code, setup keeps its address, so after a cancelled or expired pairing a bare `cabane setup` pairs with the same one.
 
 From an interactive terminal, setup then starts the Companion in the background, waits for its first check-in and reports the device's state. Without an interactive terminal, setup stays attached to the running Companion.
 
@@ -54,7 +54,7 @@ If no harness is usable, interactive setup asks which one you want to set up. Fo
   Status  cabane status     Stop  cabane stop     Log  cabane logs
   Start at login and keep Cabane updating itself:  cabane service install
 
-  In Cabane: https://app.cabane.ai/settings/devices
+  In Cabane: https://cabane.example.com/settings/devices
 ```
 
 Setup never installs the service. On macOS or Linux, run `cabane service install` when you want the Companion to start at login and keep itself updated; the closing block names it. Native Windows uses the background process and has no service installer.

package/dist/bin.js

@@ -4,8 +4,12 @@
 var MIN_NODE_MAJOR = 22;
 var major = Number(process.versions.node.split(".")[0]);
 if (!(major >= MIN_NODE_MAJOR)) {
+  const found = `Cabane needs Node ${MIN_NODE_MAJOR} or newer, and this is Node ${process.versions.node}.`;
   process.stderr.write(
-    `Cabane needs Node ${MIN_NODE_MAJOR} or newer, and this is Node ${process.versions.node}. Install Node 22 or newer, or use the install script, which brings its own: curl -fsSL https://cabane.ai/install.sh | bash
+    process.platform === "win32" ? `${found} Install Node 22 or newer.
+` : `${found}
+Install Node 22 or newer. Or, to install Cabane with its own Node, run the
+installer line from Your settings \u2192 Devices \u2192 Add a device in your Cabane.
 `
   );
   process.exit(1);

package/dist/cli.js

@@ -14,6 +14,13 @@ import { realpathSync } from "fs";
 import { homedir } from "os";
 import { dirname, join, sep } from "path";
 import { fileURLToPath } from "url";
+function installScriptCommand(address) {
+  return `curl -fsSL ${address.replace(/\/+$/, "")}/install.sh | bash`;
+}
+function installLineWords(install = companionInstall()) {
+  const line = install === "script" ? "installer line" : "npm line";
+  return `the ${line} from Your settings \u2192 Devices \u2192 Add a device in your Cabane`;
+}
 function companionInstall(execPath = process.execPath, home = homedir()) {
   const real = (path) => {
     try {
@@ -36,11 +43,9 @@ function repairRoute(packageRoot = ownRoot(), install = companionInstall()) {
 function ownRoot() {
   return dirname(dirname(fileURLToPath(import.meta.url)));
 }
-var INSTALL_SCRIPT_COMMAND;
 var init_install_kind = __esm({
   "src/install-kind.ts"() {
     "use strict";
-    INSTALL_SCRIPT_COMMAND = "curl -fsSL https://cabane.ai/install.sh | bash";
   }
 });
 
@@ -222,7 +227,7 @@ var init_cabane_command = __esm({
 });
 
 // src/errors.ts
-var CompanionError, ApiError, EdgeBlockError, ConfigError, PrepareHookError;
+var CompanionError, StandaloneError, ApiError, EdgeBlockError, ConfigError, PrepareHookError;
 var init_errors = __esm({
   "src/errors.ts"() {
     "use strict";
@@ -232,6 +237,12 @@ var init_errors = __esm({
         this.name = "CompanionError";
       }
     };
+    StandaloneError = class extends CompanionError {
+      constructor(message2) {
+        super(message2);
+        this.name = "StandaloneError";
+      }
+    };
     ApiError = class extends CompanionError {
       constructor(status2, message2, body) {
         super(message2);
@@ -603,31 +614,13 @@ function loadConfigTolerant() {
   const strict = companionConfigSchema.safeParse(parsed);
   if (strict.success) {
     const {
-      agents: agents2,
-      prepareHook: prepareHook2,
-      root: root2,
-      dashboardPort,
-      autoOpen,
-      logLevel,
-      logFormat,
-      harnesses: harnesses2,
-      opencode: opencode2
+      baseUrl: _baseUrl,
+      deviceToken: _deviceToken,
+      deviceId: _deviceId,
+      deviceLabel: _deviceLabel,
+      ...local2
     } = strict.data;
-    return {
-      local: {
-        ...agents2 !== void 0 ? { agents: agents2 } : {},
-        ...prepareHook2 !== void 0 ? { prepareHook: prepareHook2 } : {},
-        ...root2 !== void 0 ? { root: root2 } : {},
-        ...dashboardPort !== void 0 ? { dashboardPort } : {},
-        ...autoOpen !== void 0 ? { autoOpen } : {},
-        ...logLevel !== void 0 ? { logLevel } : {},
-        ...logFormat !== void 0 ? { logFormat } : {},
-        ...harnesses2 !== void 0 ? { harnesses: harnesses2 } : {},
-        ...opencode2 !== void 0 ? { opencode: opencode2 } : {}
-      },
-      note: null,
-      hadPriorConfig: true
-    };
+    return { local: local2, note: null, hadPriorConfig: true };
   }
   const obj = parsed && typeof parsed === "object" ? parsed : {};
   const local = {};
@@ -647,6 +640,11 @@ function loadConfigTolerant() {
   if (harnesses.success && harnesses.data !== void 0) local.harnesses = harnesses.data;
   const opencode = companionConfigSchema.shape.opencode.safeParse(obj.opencode);
   if (opencode.success && opencode.data !== void 0) local.opencode = opencode.data;
+  const update2 = companionConfigSchema.shape.update.safeParse(obj.update);
+  if (update2.success && update2.data !== void 0) local.update = update2.data;
+  if (typeof obj.serviceDeclined === "boolean") local.serviceDeclined = obj.serviceDeclined;
+  const runner = companionConfigSchema.shape.runner.safeParse(obj.runner);
+  if (runner.success && runner.data !== void 0) local.runner = runner.data;
   return {
     local,
     note: `the existing ${path} was from an older or incompatible companion; re-pairing rewrote it.`,
@@ -958,18 +956,32 @@ function resolveBundledBinary(runtime, env = defaultResolveEnv()) {
 function missingNoun(status2) {
   return status2 === "executable_missing" ? "executable" : "platform package";
 }
-function repairCommands(route = repairRoute(), spell = cabane) {
+function repairCommands(route = repairRoute(), spell = cabane, address = configuredAddress()) {
   if (route === "managed") return [spell("stop"), spell("update")];
-  if (route === "script") return [spell("stop"), INSTALL_SCRIPT_COMMAND];
+  if (route === "script")
+    return [
+      spell("stop"),
+      address ? installScriptCommand(address) : { words: installLineWords("script") }
+    ];
   return ["npm i -g @cabane/companion --include=optional"];
 }
-function repairAction(route = repairRoute(), spell = cabane) {
-  const [first, ...rest] = repairCommands(route, spell);
-  if (rest.length === 0) return `Reinstall with \`${first}\`.`;
-  return `Run \`${first}\`, then \`${rest.join("`, then `")}\`. ${STOP_WARNING}`;
+function configuredAddress() {
+  try {
+    return loadConfig()?.baseUrl ?? null;
+  } catch {
+    return null;
+  }
+}
+function quoteStep(step, quote) {
+  return typeof step === "string" ? quote(step) : step.words;
+}
+function repairAction(route = repairRoute(), spell = cabane, address = configuredAddress()) {
+  const [first, ...rest] = repairCommands(route, spell, address);
+  if (rest.length === 0) return `Reinstall with ${quoteStep(first, backticks)}.`;
+  return `Run ${quoteStep(first, backticks)}, then ${rest.map((step) => quoteStep(step, backticks)).join(", then ")}. ${STOP_WARNING}`;
 }
 function repairSteps(route = repairRoute()) {
-  return repairCommands(route).join(", then ");
+  return repairCommands(route).map((step) => quoteStep(step, (command) => command)).join(", then ");
 }
 function repairCost(route = repairRoute()) {
   return repairCommands(route).length > 1 ? STOP_WARNING : "";
@@ -981,11 +993,12 @@ function startupWarning(r) {
 function turnIncompleteCopy(runtime) {
   return `**This device's ${HARNESS_LABEL[runtime]} runtime is incomplete.** ${repairAction()} Restart it, then try again.`;
 }
-var CLAUDE_SDK, CODEX_SDK, CODEX_CLI, CODEX_PACKAGE_BY_TRIPLE, HARNESS_LABEL, HARNESS_INTENT_WORD, STOP_WARNING;
+var CLAUDE_SDK, CODEX_SDK, CODEX_CLI, CODEX_PACKAGE_BY_TRIPLE, HARNESS_LABEL, HARNESS_INTENT_WORD, backticks, STOP_WARNING;
 var init_bundled_binaries = __esm({
   "src/bundled-binaries.ts"() {
     "use strict";
     init_cabane_command();
+    init_config();
     init_install_kind();
     CLAUDE_SDK = "@anthropic-ai/claude-agent-sdk";
     CODEX_SDK = "@openai/codex-sdk";
@@ -1006,6 +1019,7 @@ var init_bundled_binaries = __esm({
       "claude-code": "connected",
       codex: "enabled"
     };
+    backticks = (command) => `\`${command}\``;
     STOP_WARNING = "Stopping ends any turn in progress.";
   }
 });
@@ -3205,9 +3219,11 @@ function envResolvedFrom(server, secretEnv) {
   if (!server.env && Object.keys(resolved).length === 0) return void 0;
   return { ...server.env, ...resolved };
 }
+var TURN_TOKEN_ENV;
 var init_mcp_secret_env = __esm({
   "packages/agent-runtime/src/mcp-secret-env.ts"() {
     "use strict";
+    TURN_TOKEN_ENV = "CABANE_TURN_TOKEN";
   }
 });
 
@@ -3357,7 +3373,7 @@ function buildClaudeCodeOptions(req, augment) {
       type: "http",
       url: req.cabane.mcpUrl,
       headers: {
-        Authorization: `Bearer ${req.cabane.bearer}`,
+        Authorization: `\${${TURN_TOKEN_ENV}}`,
         [ACTIVE_CONVERSATION_HEADER]: req.cabane.activeConversationId
       },
       // Claude Code 2.1.x defers every MCP tool behind tool-search by default;
@@ -3416,10 +3432,15 @@ function buildClaudeCodeOptions(req, augment) {
     //
     // `secretEnv` — the values the MCP headers above reference — joins here and only here: it is
     // this child's environment, not the host's.
+    //
+    // The turn token goes after everything a room secret, a hook or the inherited environment can
+    // supply: this spread order is the only thing that stops a variable of the same name from
+    // displacing the turn's own credential.
     env: {
       ...process.env,
       ...req.local.env,
       ...req.local.secretEnv,
+      [TURN_TOKEN_ENV]: `Bearer ${req.cabane.bearer}`,
       CLAUDE_CODE_DISABLE_BACKGROUND_TASKS: "1"
     },
     ...resume ? { resume } : {}
@@ -5249,12 +5270,16 @@ function codexSecretEnv(req) {
   const env = { ...req.local.secretEnv };
   for (const server of Object.values(req.local.mcpServers ?? {})) {
     if ("url" in server) continue;
-    for (const [variable, envName] of Object.entries(server.envFromEnv ?? {})) {
+    for (const [variable, envName] of forwardedEnvVars(server.envFromEnv)) {
       const value = req.local.secretEnv?.[envName];
       if (value !== void 0) env[variable] = value;
     }
   }
-  return Object.keys(env).length > 0 ? env : null;
+  env[TURN_TOKEN_ENV] = `Bearer ${req.cabane.bearer}`;
+  return env;
+}
+function forwardedEnvVars(envFromEnv) {
+  return Object.entries(envFromEnv ?? {}).filter(([variable]) => variable !== TURN_TOKEN_ENV);
 }
 function buildInput(req, segments, preamble, resumed) {
   const userText = req.content.filter((b) => b.type === "text").map((b) => b.text).join("\n\n");
@@ -5296,7 +5321,7 @@ function buildConfig(req) {
         default_tools_approval_mode: "approve"
       };
     } else if ("command" in server) {
-      const forwarded = Object.keys(server.envFromEnv ?? {}).sort();
+      const forwarded = forwardedEnvVars(server.envFromEnv).map(([variable]) => variable).sort();
       mcp_servers[name] = {
         command: server.command,
         ...server.args ? { args: server.args } : {},
@@ -5324,19 +5349,15 @@ function buildConfig(req) {
   }
   mcp_servers[CABANE_MCP_SERVER3] = {
     url: req.cabane.mcpUrl,
-    http_headers: {
-      Authorization: `Bearer ${req.cabane.bearer}`,
-      [ACTIVE_CONVERSATION_HEADER3]: req.cabane.activeConversationId
-    },
+    http_headers: { [ACTIVE_CONVERSATION_HEADER3]: req.cabane.activeConversationId },
+    env_http_headers: { Authorization: TURN_TOKEN_ENV },
     default_tools_approval_mode: "approve"
   };
   if (req.cabane.turnControlUrl) {
     mcp_servers[TURN_CONTROL_MCP_SERVER] = {
       url: req.cabane.turnControlUrl,
-      http_headers: {
-        Authorization: `Bearer ${req.cabane.bearer}`,
-        [ACTIVE_CONVERSATION_HEADER3]: req.cabane.activeConversationId
-      },
+      http_headers: { [ACTIVE_CONVERSATION_HEADER3]: req.cabane.activeConversationId },
+      env_http_headers: { Authorization: TURN_TOKEN_ENV },
       default_tools_approval_mode: "approve"
     };
   }
@@ -5361,6 +5382,7 @@ var CABANE_MCP_SERVER3, ACTIVE_CONVERSATION_HEADER3, ENV_ENVELOPE_KEYS, CORE_REP
 var init_run_spec2 = __esm({
   "packages/agent-runtime/src/codex/run-spec.ts"() {
     "use strict";
+    init_mcp_secret_env();
     init_descriptions();
     init_standing();
     init_policy3();
@@ -5476,7 +5498,7 @@ function createSdkCodexTransport(opts = {}) {
         // path (the CLI splits on `.` and ignores TOML quoting), so it must ride inside an inline-table
         // value, which the SDK's flattener can't produce. See `config-overrides.ts`.
         configOverrides: buildConfigOverrides(spec.config),
-        ...spec.secretEnv ? { env: codexProcessEnv(spec.secretEnv) } : {}
+        env: codexProcessEnv(spec.secretEnv)
       };
       const codex = new Codex(codexOptions);
       const threadOptions = buildSdkThreadOptions(spec);
@@ -9951,6 +9973,7 @@ import { hostname } from "os";
 
 // src/enrollment.ts
 init_errors();
+init_install_kind();
 var EnrollmentExpiredError = class extends CompanionError {
   constructor() {
     super("this pairing code expired before it was confirmed.");
@@ -10004,8 +10027,9 @@ async function postJson(baseUrl, path, body, signal) {
         "Too many pairing requests from this network. Wait a few minutes and run  cabane setup  again."
       );
     if (res.status === 404 && path.endsWith("/code"))
-      throw new CompanionError(
-        `No pairing endpoint at ${baseUrl}. Either that server is too old for this companion, or it isn't a Cabane API origin: the hosted app is https://app.cabane.ai (pass \`--server <url>\` for your own instance).`
+      throw new StandaloneError(
+        `No pairing endpoint at ${baseUrl}: it isn't a Cabane's address, or that Cabane is too old for this companion.
+Run ${installLineWords()}.`
       );
     const msg = parsed && typeof parsed === "object" && "error" in parsed ? String(parsed.error) : `${res.status}`;
     throw new ApiError(res.status, `${res.status} ${msg}`, parsed);
@@ -10190,6 +10214,7 @@ async function pairDevice(opts, deps = {}) {
         process.exitCode = 130;
         return null;
       }
+      if (!current) opts.onCode?.();
       current = code;
       const minutes = Math.max(1, Math.round(code.expiresIn / 60));
       const codeLines = ["", `  ${code.userCode}`, `  ${code.verificationUri}`, ""];
@@ -10296,10 +10321,11 @@ init_cabane_command();
 init_config();
 init_pairing();
 init_errors();
+init_install_kind();
 init_errors();
-var DEFAULT_BASE_URL = "https://app.cabane.ai";
 function resolvePairBaseUrl(server) {
-  const raw = (server ?? process.env.CABANE_BASE_URL ?? DEFAULT_BASE_URL).trim();
+  const raw = (server ?? process.env.CABANE_BASE_URL ?? "").trim();
+  if (!raw) throw new NoPairAddressError();
   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("setup --server https://your-cabane")}\`.`
@@ -10307,6 +10333,20 @@ function resolvePairBaseUrl(server) {
   }
   return raw;
 }
+var NoPairAddressError = class extends StandaloneError {
+  constructor(install = companionInstall()) {
+    const words = installLineWords(install);
+    super(
+      `Setup doesn't know which Cabane to pair this device with. Run the
+${words.slice("the ".length)}.`
+    );
+    this.name = "NoPairAddressError";
+  }
+};
+function rememberPairAddress(baseUrl) {
+  const { local } = loadConfigTolerant();
+  saveConfig({ ...local, baseUrl });
+}
 function writePairedConfig(paired) {
   const { local, note: note2 } = loadConfigTolerant();
   const config = {
@@ -10644,7 +10684,7 @@ function turnFailureCopy(reason, runtime) {
     const stopsFirst = commands.length > 1;
     if (!stopsFirst) commands.push("cabane stop");
     commands.push("cabane start");
-    const list = commands.map((command) => `\`${command}\``);
+    const list = commands.map((step) => quoteStep(step, (command) => `\`${command}\``));
     return `${harnessLabel(runtime ?? reason.slice("runtime_incomplete:".length))}'s installation on this device is incomplete. Run ${list.slice(0, -1).join(", ")} and ${list.at(-1)}. ${stopsFirst ? `${STOP_WARNING} ` : ""}Reply in Cabane to try again.`;
   }
   const unavailable = /^(codex|opencode)_unavailable:/.exec(reason ?? "")?.[1] ?? (reason?.startsWith("runtime_unavailable:") ? reason.slice("runtime_unavailable:".length).trim() : void 0);
@@ -14814,6 +14854,7 @@ function userName() {
     return process.env.USER ?? "";
   }
 }
+var SCRIPT_WRAPPER_COMMENT = /^# Written by \S+\/install\.sh\. /m;
 function rewriteScriptWrappers(dir2 = join27(cabaneDir(), "bin")) {
   for (const name of ["cabane", "cabane-companion"]) {
     const path = join27(dir2, name);
@@ -14823,7 +14864,7 @@ function rewriteScriptWrappers(dir2 = join27(cabaneDir(), "bin")) {
     } catch {
       continue;
     }
-    if (!text.includes("Written by https://cabane.ai/install.sh")) continue;
+    if (!SCRIPT_WRAPPER_COMMENT.test(text)) continue;
     if (!text.includes("/dist/cli.js")) continue;
     writeAtomic(path, text.replace("/dist/cli.js", "/dist/bin.js"));
     chmodSync5(path, 493);
@@ -15160,6 +15201,9 @@ async function runAttached(runtime) {
   });
 }
 
+// src/commands/setup.ts
+init_errors();
+
 // src/prompts.ts
 init_term();
 import * as clack from "@clack/prompts";
@@ -15180,7 +15224,8 @@ function terminalUi() {
     },
     spinner: () => railSpinner(),
     outro: (lines2) => clack.outro(lines2.join("\n   ")),
-    cancel: (message2) => clack.cancel(message2)
+    // Clack draws only the first line on the rail's end; the rest align under its text.
+    cancel: (message2) => clack.cancel(message2.split("\n").join("\n   "))
   };
 }
 var FRAMES = ["\u25D2", "\u25D0", "\u25D3", "\u25D1"];
@@ -15236,7 +15281,10 @@ function plainUi() {
     outro: (lines2) => {
       for (const line of lines2) write(`${INDENT}${line}`);
     },
-    cancel: (message2) => write(`${INDENT}${message2}`)
+    // A closing message can run to more than one line; each is indented like the first.
+    cancel: (message2) => {
+      for (const line of message2.split("\n")) write(`${INDENT}${line}`);
+    }
   };
 }
 
@@ -15248,9 +15296,13 @@ async function setup(opts = {}, deps = {}) {
   try {
     await setupScript(opts, deps);
   } catch (err) {
-    for (const line of pathLines(reloadLine())) write(line);
-    write(err instanceof Error ? err.message : String(err));
-    write(`Check the server connection, then run  ${cabane("setup")}  again.`);
+    if (err instanceof StandaloneError) {
+      write(err.message);
+    } else {
+      for (const line of pathLines(reloadLine())) write(line);
+      write(err instanceof Error ? err.message : String(err));
+      write(`Check the server connection, then run  ${cabane("setup")}  again.`);
+    }
     process.exitCode = 1;
   } finally {
     setConsoleLogging(true);
@@ -15278,8 +15330,21 @@ async function setupScript(opts, deps) {
   }
   let justPaired = false;
   if (!paired) {
-    const baseUrl = resolvePairBaseUrl(opts.server ?? cfg?.baseUrl);
-    const device = await (deps.pair ?? pairDevice)({ baseUrl, interactive, ui });
+    let baseUrl;
+    try {
+      baseUrl = resolvePairBaseUrl(opts.server ?? cfg?.baseUrl);
+    } catch (err) {
+      if (!(err instanceof NoPairAddressError)) throw err;
+      ui.cancel(err.message);
+      process.exitCode = 1;
+      return;
+    }
+    const device = await (deps.pair ?? pairDevice)({
+      baseUrl,
+      interactive,
+      ui,
+      onCode: () => rememberPairAddress(baseUrl)
+    });
     if (!device) return;
     writePairedConfig(device);
     justPaired = true;
@@ -16370,7 +16435,7 @@ init_cabane_command();
 rememberInvokedCommand();
 var program = new Command();
 program.name("cabane").description("Run your Cabane agents on this device, with Claude Code, Codex or OpenCode.").version(COMPANION_VERSION);
-program.command("setup").argument("[code]", "not taken: run  cabane setup  and enter the code it shows in Cabane").description("set up this device: find your agents, pair it with Cabane, and keep it running.").allowExcessArguments(false).option("--server <url>", "the Cabane instance to pair with (default https://app.cabane.ai)").addOption(
+program.command("setup").argument("[code]", "not taken: run  cabane setup  and enter the code it shows in Cabane").description("set up this device: find your agents, pair it with Cabane, and keep it running.").allowExcessArguments(false).option("--server <url>", "the address of the Cabane to pair with").addOption(
   new Option("--log-level <level>", "info (default), warn, or debug").choices([
     "info",
     "warn",

package/dist/pairing-config.js

@@ -8,6 +8,21 @@ import { realpathSync } from "fs";
 import { homedir } from "os";
 import { dirname, join, sep } from "path";
 import { fileURLToPath } from "url";
+function installLineWords(install = companionInstall()) {
+  const line = install === "script" ? "installer line" : "npm line";
+  return `the ${line} from Your settings \u2192 Devices \u2192 Add a device in your Cabane`;
+}
+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";
@@ -49,6 +64,12 @@ var CompanionError = class extends Error {
     this.name = "CompanionError";
   }
 };
+var StandaloneError = class extends CompanionError {
+  constructor(message) {
+    super(message);
+    this.name = "StandaloneError";
+  }
+};
 var ApiError = class extends CompanionError {
   constructor(status, message, body) {
     super(message);
@@ -341,31 +362,13 @@ function loadConfigTolerant() {
   const strict = companionConfigSchema.safeParse(parsed);
   if (strict.success) {
     const {
-      agents: agents2,
-      prepareHook: prepareHook2,
-      root: root2,
-      dashboardPort,
-      autoOpen,
-      logLevel,
-      logFormat,
-      harnesses: harnesses2,
-      opencode: opencode2
+      baseUrl: _baseUrl,
+      deviceToken: _deviceToken,
+      deviceId: _deviceId,
+      deviceLabel: _deviceLabel,
+      ...local2
     } = strict.data;
-    return {
-      local: {
-        ...agents2 !== void 0 ? { agents: agents2 } : {},
-        ...prepareHook2 !== void 0 ? { prepareHook: prepareHook2 } : {},
-        ...root2 !== void 0 ? { root: root2 } : {},
-        ...dashboardPort !== void 0 ? { dashboardPort } : {},
-        ...autoOpen !== void 0 ? { autoOpen } : {},
-        ...logLevel !== void 0 ? { logLevel } : {},
-        ...logFormat !== void 0 ? { logFormat } : {},
-        ...harnesses2 !== void 0 ? { harnesses: harnesses2 } : {},
-        ...opencode2 !== void 0 ? { opencode: opencode2 } : {}
-      },
-      note: null,
-      hadPriorConfig: true
-    };
+    return { local: local2, note: null, hadPriorConfig: true };
   }
   const obj = parsed && typeof parsed === "object" ? parsed : {};
   const local = {};
@@ -385,6 +388,11 @@ function loadConfigTolerant() {
   if (harnesses.success && harnesses.data !== void 0) local.harnesses = harnesses.data;
   const opencode = companionConfigSchema.shape.opencode.safeParse(obj.opencode);
   if (opencode.success && opencode.data !== void 0) local.opencode = opencode.data;
+  const update = companionConfigSchema.shape.update.safeParse(obj.update);
+  if (update.success && update.data !== void 0) local.update = update.data;
+  if (typeof obj.serviceDeclined === "boolean") local.serviceDeclined = obj.serviceDeclined;
+  const runner = companionConfigSchema.shape.runner.safeParse(obj.runner);
+  if (runner.success && runner.data !== void 0) local.runner = runner.data;
   return {
     local,
     note: `the existing ${path} was from an older or incompatible companion; re-pairing rewrote it.`,
@@ -469,8 +477,9 @@ async function postJson(baseUrl, path, body, signal) {
         "Too many pairing requests from this network. Wait a few minutes and run  cabane setup  again."
       );
     if (res.status === 404 && path.endsWith("/code"))
-      throw new CompanionError(
-        `No pairing endpoint at ${baseUrl}. Either that server is too old for this companion, or it isn't a Cabane API origin: the hosted app is https://app.cabane.ai (pass \`--server <url>\` for your own instance).`
+      throw new StandaloneError(
+        `No pairing endpoint at ${baseUrl}: it isn't a Cabane's address, or that Cabane is too old for this companion.
+Run ${installLineWords()}.`
       );
     const msg = parsed && typeof parsed === "object" && "error" in parsed ? String(parsed.error) : `${res.status}`;
     throw new ApiError(res.status, `${res.status} ${msg}`, parsed);
@@ -524,9 +533,9 @@ async function awaitEnrollment(baseUrl, code, opts = {}) {
 }
 
 // src/pairing-config.ts
-var DEFAULT_BASE_URL = "https://app.cabane.ai";
 function resolvePairBaseUrl(server) {
-  const raw = (server ?? process.env.CABANE_BASE_URL ?? DEFAULT_BASE_URL).trim();
+  const raw = (server ?? process.env.CABANE_BASE_URL ?? "").trim();
+  if (!raw) throw new NoPairAddressError();
   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("setup --server https://your-cabane")}\`.`
@@ -534,6 +543,20 @@ function resolvePairBaseUrl(server) {
   }
   return raw;
 }
+var NoPairAddressError = class extends StandaloneError {
+  constructor(install = companionInstall()) {
+    const words = installLineWords(install);
+    super(
+      `Setup doesn't know which Cabane to pair this device with. Run the
+${words.slice("the ".length)}.`
+    );
+    this.name = "NoPairAddressError";
+  }
+};
+function rememberPairAddress(baseUrl) {
+  const { local } = loadConfigTolerant();
+  saveConfig({ ...local, baseUrl });
+}
 function writePairedConfig(paired) {
   const { local, note } = loadConfigTolerant();
   const config = {
@@ -558,8 +581,10 @@ export {
   CompanionError,
   EnrollmentCancelledError,
   EnrollmentExpiredError,
+  NoPairAddressError,
   awaitEnrollment,
   isDevicePaired,
+  rememberPairAddress,
   requestEnrollmentCode,
   resolvePairBaseUrl,
   writePairedConfig

package/dist/postinstall.js

@@ -1,7 +1,7 @@
 // src/bundled-binaries.ts
 import { realpathSync as realpathSync3, statSync } from "fs";
 import { createRequire } from "module";
-import { dirname as dirname3, join as join4 } from "path";
+import { dirname as dirname4, join as join5 } from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 
 // src/cabane-command.ts
@@ -14,7 +14,13 @@ import { realpathSync } from "fs";
 import { homedir } from "os";
 import { dirname, join, sep } from "path";
 import { fileURLToPath } from "url";
-var INSTALL_SCRIPT_COMMAND = "curl -fsSL https://cabane.ai/install.sh | bash";
+function installScriptCommand(address) {
+  return `curl -fsSL ${address.replace(/\/+$/, "")}/install.sh | bash`;
+}
+function installLineWords(install = companionInstall()) {
+  const line = install === "script" ? "installer line" : "npm line";
+  return `the ${line} from Your settings \u2192 Devices \u2192 Add a device in your Cabane`;
+}
 function companionInstall(execPath = process.execPath, home = homedir()) {
   const real = (path) => {
     try {
@@ -57,6 +63,308 @@ function cabane(rest) {
   return `cabane ${rest}`;
 }
 
+// src/config.ts
+import {
+  chmodSync,
+  mkdirSync,
+  readFileSync as readFileSync2,
+  renameSync,
+  rmSync,
+  writeFileSync,
+  existsSync as existsSync3
+} from "fs";
+import { homedir as homedir5, userInfo } from "os";
+import { dirname as dirname3, isAbsolute, join as join4 } from "path";
+import { z as z2 } from "zod";
+
+// src/errors.ts
+var CompanionError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "CompanionError";
+  }
+};
+var ConfigError = class extends CompanionError {
+  constructor(message) {
+    super(message);
+    this.name = "ConfigError";
+  }
+};
+
+// 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()
+}).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 HARNESS_RUNTIMES = ["claude-code", "codex", "opencode"];
+var realHomeCache;
+function realAccountHome() {
+  if (realHomeCache === void 0) {
+    try {
+      realHomeCache = userInfo().homedir;
+    } catch {
+      realHomeCache = null;
+    }
+  }
+  return realHomeCache;
+}
+function cabaneDir() {
+  const dir = join4(process.env.CABANE_COMPANION_HOME || homedir5(), ".cabane");
+  if (process.env.VITEST) {
+    const real = realAccountHome();
+    if (real && dir === join4(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;
+}
+function configPath() {
+  return join4(cabaneDir(), "config.json");
+}
+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
+  // (the user and project settings load on every Claude Code turn).
+  claudeCode: z2.object({ autoMemory: z2.boolean().optional() }).strict().optional()
+}).strict();
+var agentsConfigSchema = z2.record(z2.string(), localAgentConfigSchema);
+function isRootPath(value) {
+  return isAbsolute(value) || value === "~" || value.startsWith("~/");
+}
+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`.
+  prepareHook: prepareHookSchema.optional(),
+  // The CLI ignores both dashboard settings. Desktop uses `dashboardPort`;
+  // `autoOpen` remains parseable for older config files but no longer controls
+  // startup. `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(),
+  // Where this device's `opencode serve` answers, when it isn't the default
+  // address (`DEFAULT_OPENCODE_SERVER_URL`). Detection probes this one; a serve
+  // that answers is connected. Auth is opencode's own; Cabane never sees
+  // provider keys.
+  opencode: z2.object({
+    serverUrl: z2.string().url()
+  }).strict().optional(),
+  // The one knob on agents: an allowlist. Agents are detected, never offered
+  // (`harness-detect.ts`): whatever is signed in here is connected. Someone with
+  // Codex on the device who doesn't want Cabane to see it lists the ones it may:
+  // `"harnesses": ["claude-code"]`. Absent means all three.
+  harnesses: z2.array(z2.enum(HARNESS_RUNTIMES)).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(),
+  // Where agents stand on this device. Every (agent, conversation) pair gets a directory under it,
+  // and an agent with no folder of its own and no prepare hook works there
+  // (`turn-execution.ts`, `prepareEnvironment`). Default `~/.cabane/work`: hidden, so pairing a
+  // laptop creates no new visible folder; set it to make the work visible.
+  root: z2.string().min(1).refine(isRootPath, { message: "must be an absolute path, or start with ~/" }).optional(),
+  // An argv prefix the operator puts in front of every turn's runner: the companion starts
+  // `<prefix…> <its own run-turn command…>` instead of the runner bare. What the prefix does
+  // is the operator's (a container or VM per turn, say); the companion knows nothing of it
+  // beyond handing the runner over, with the turn's inputs in its environment and the
+  // credential and secrets on its stdin (`runner/launch.ts`, `wrapped`). The README lists
+  // what a wrapper can rely on.
+  runner: z2.object({
+    command: z2.array(z2.string().min(1)).min(1),
+    // The external wrapper supplies only broker placeholders and removes
+    // credential mounts. Do not hand provider logins to that runner on stdin.
+    brokeredCredentials: z2.boolean().optional()
+  }).strict().optional()
+});
+var RETIRED_ROW_KEYS = ["sandbox"];
+var RETIRED_HOOK_KEYS = ["validateCached", "failureReporter"];
+function isObject(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function splitRetired(raw) {
+  const keys = [];
+  const without = (obj, names, path) => {
+    const out = {};
+    for (const [k, v] of Object.entries(obj)) {
+      if (names.includes(k)) keys.push(`${path}${k}`);
+      else out[k] = v;
+    }
+    return out;
+  };
+  const hook = (row, path) => isObject(row.prepareHook) ? { ...row, prepareHook: without(row.prepareHook, RETIRED_HOOK_KEYS, `${path}prepareHook.`) } : row;
+  const kept = hook(without(raw, ["runners"], ""), "");
+  if (isObject(kept.agents)) {
+    const agents = {};
+    for (const [key, row] of Object.entries(kept.agents)) {
+      const path = `agents.${key}.`;
+      agents[key] = isObject(row) ? hook(without(row, RETIRED_ROW_KEYS, path), path) : row;
+    }
+    kept.agents = agents;
+  }
+  return { keys, kept };
+}
+function withoutRetiredKeys(raw) {
+  return isObject(raw) ? splitRetired(raw).kept : raw;
+}
+var legacyOfferSchema = z2.object({
+  claudeCode: z2.object({ enabled: z2.boolean().optional() }).passthrough().optional(),
+  codex: z2.object({ enabled: z2.boolean().optional() }).passthrough().optional(),
+  harnessesChosen: z2.boolean().optional(),
+  opencodeDeclined: z2.boolean().optional()
+});
+function migrateHarnessAllowlist(raw) {
+  const legacy = legacyOfferSchema.safeParse(raw);
+  if (!legacy.success || !legacy.data.harnessesChosen) return null;
+  const declined = /* @__PURE__ */ new Set();
+  if (legacy.data.claudeCode?.enabled === false) declined.add("claude-code");
+  if (legacy.data.codex?.enabled === false) declined.add("codex");
+  if (legacy.data.opencodeDeclined === true) declined.add("opencode");
+  if (declined.size === 0) return null;
+  return HARNESS_RUNTIMES.filter((runtime) => !declined.has(runtime));
+}
+function carriesLegacyOffer(raw) {
+  if (!raw || typeof raw !== "object") return false;
+  const obj = raw;
+  return "harnessesChosen" in obj || "opencodeDeclined" in obj || typeof obj.claudeCode === "object" && obj.claudeCode !== null && "enabled" in obj.claudeCode || obj.codex !== void 0;
+}
+function loadConfig() {
+  const path = configPath();
+  if (!existsSync3(path)) return null;
+  let raw;
+  try {
+    raw = readFileSync2(path, "utf8");
+  } catch (err) {
+    throw new ConfigError(
+      `couldn't read ${path}: ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+  if (raw.trim().length === 0) return null;
+  let parsed;
+  try {
+    parsed = withoutRetiredKeys(JSON.parse(raw));
+  } catch (err) {
+    throw new ConfigError(
+      `${path} is not valid JSON: ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+  const result = companionConfigSchema.safeParse(parsed);
+  if (!result.success) {
+    const agentIssue = result.error.issues.find((i) => i.path[0] === "agents");
+    if (agentIssue) {
+      throw new ConfigError(
+        `${path}: invalid "agents" config at \`${agentIssue.path.join(".")}\` \u2014 ${agentIssue.message}. Fix the agents block in the config and retry.`
+      );
+    }
+    const rootIssue = result.error.issues.find((i) => i.path[0] === "root");
+    if (rootIssue) {
+      throw new ConfigError(
+        `${path}: invalid "root" \u2014 ${rootIssue.message}. Fix it in the config and retry.`
+      );
+    }
+    throw new ConfigError(
+      `${path} is from an incompatible or older version of the companion, or was hand-edited. Run \`${cabane("setup")}\` to pair again, or \`${cabane("logout --purge")}\` to reset.`
+    );
+  }
+  if (carriesLegacyOffer(parsed)) {
+    const allowlist = migrateHarnessAllowlist(parsed);
+    const migrated = {
+      ...result.data,
+      ...allowlist && !result.data.harnesses ? { harnesses: allowlist } : {}
+    };
+    saveConfig(migrated);
+    return migrated;
+  }
+  return result.data;
+}
+function saveConfig(cfg) {
+  const path = configPath();
+  mkdirSync(dirname3(path), { recursive: true });
+  try {
+    chmodSync(cabaneDir(), 448);
+  } catch {
+  }
+  const tmp = `${path}.${process.pid}.tmp`;
+  try {
+    writeFileSync(tmp, JSON.stringify(cfg, null, 2) + "\n", { mode: 384 });
+    try {
+      chmodSync(tmp, 384);
+    } catch {
+    }
+    renameSync(tmp, path);
+  } catch (err) {
+    try {
+      rmSync(tmp, { force: true });
+    } catch {
+    }
+    throw err;
+  }
+}
+
 // src/bundled-binaries.ts
 function nodeResolveSelf(specifier) {
   const here = fileURLToPath3(import.meta.url);
@@ -73,9 +381,9 @@ function nodeResolveSelf(specifier) {
   return walkNodeModules(specifier, here);
 }
 function walkNodeModules(pkg, fromPath) {
-  let dir = dirname3(fromPath);
+  let dir = dirname4(fromPath);
   for (; ; ) {
-    const manifest = join4(dir, "node_modules", pkg, "package.json");
+    const manifest = join5(dir, "node_modules", pkg, "package.json");
     if (nodeIsFile(manifest)) {
       try {
         return realpathSync3(manifest);
@@ -83,7 +391,7 @@ function walkNodeModules(pkg, fromPath) {
         return manifest;
       }
     }
-    const parent = dirname3(dir);
+    const parent = dirname4(dir);
     if (parent === dir) return null;
     dir = parent;
   }
@@ -145,7 +453,7 @@ function resolveClaude(env) {
     const manifest = env.resolve(`${pkg}/package.json`, sdkEntry);
     if (!manifest) continue;
     sawPackage ??= pkg;
-    const exe = join4(dirname3(manifest), env.platform === "win32" ? "claude.exe" : "claude");
+    const exe = join5(dirname4(manifest), env.platform === "win32" ? "claude.exe" : "claude");
     if (env.isFile(exe)) {
       return { ...base, packageName: pkg, status: "present", path: exe };
     }
@@ -196,13 +504,13 @@ function resolveCodex(env) {
   if (!cliManifest) return { ...base, status: "platform_package_missing", path: null };
   const platformManifest = env.resolve(`${pkg}/package.json`, cliManifest);
   if (!platformManifest) return { ...base, status: "platform_package_missing", path: null };
-  const packageRoot = join4(dirname3(platformManifest), "vendor", triple);
+  const packageRoot = join5(dirname4(platformManifest), "vendor", triple);
   const exeName = env.platform === "win32" ? "codex.exe" : "codex";
-  const current = join4(packageRoot, "bin", exeName);
-  if (env.isFile(current) && env.isFile(join4(packageRoot, "codex-package.json"))) {
+  const current = join5(packageRoot, "bin", exeName);
+  if (env.isFile(current) && env.isFile(join5(packageRoot, "codex-package.json"))) {
     return { ...base, status: "present", path: current };
   }
-  const legacy = join4(packageRoot, "codex", exeName);
+  const legacy = join5(packageRoot, "codex", exeName);
   if (env.isFile(legacy)) return { ...base, status: "present", path: legacy };
   return { ...base, status: "executable_missing", path: null };
 }
@@ -233,15 +541,30 @@ var HARNESS_LABEL = {
 function missingNoun(status) {
   return status === "executable_missing" ? "executable" : "platform package";
 }
-function repairCommands(route = repairRoute(), spell = cabane) {
+function repairCommands(route = repairRoute(), spell = cabane, address = configuredAddress()) {
   if (route === "managed") return [spell("stop"), spell("update")];
-  if (route === "script") return [spell("stop"), INSTALL_SCRIPT_COMMAND];
+  if (route === "script")
+    return [
+      spell("stop"),
+      address ? installScriptCommand(address) : { words: installLineWords("script") }
+    ];
   return ["npm i -g @cabane/companion --include=optional"];
 }
-function repairAction(route = repairRoute(), spell = cabane) {
-  const [first, ...rest] = repairCommands(route, spell);
-  if (rest.length === 0) return `Reinstall with \`${first}\`.`;
-  return `Run \`${first}\`, then \`${rest.join("`, then `")}\`. ${STOP_WARNING}`;
+function configuredAddress() {
+  try {
+    return loadConfig()?.baseUrl ?? null;
+  } catch {
+    return null;
+  }
+}
+function quoteStep(step, quote) {
+  return typeof step === "string" ? quote(step) : step.words;
+}
+var backticks = (command) => `\`${command}\``;
+function repairAction(route = repairRoute(), spell = cabane, address = configuredAddress()) {
+  const [first, ...rest] = repairCommands(route, spell, address);
+  if (rest.length === 0) return `Reinstall with ${quoteStep(first, backticks)}.`;
+  return `Run ${quoteStep(first, backticks)}, then ${rest.map((step) => quoteStep(step, backticks)).join(", then ")}. ${STOP_WARNING}`;
 }
 var STOP_WARNING = "Stopping ends any turn in progress.";
 function installWarning(r) {

package/dist/runtime.js

@@ -12,7 +12,13 @@ import { realpathSync } from "fs";
 import { homedir } from "os";
 import { dirname, join, sep } from "path";
 import { fileURLToPath } from "url";
-var INSTALL_SCRIPT_COMMAND = "curl -fsSL https://cabane.ai/install.sh | bash";
+function installScriptCommand(address) {
+  return `curl -fsSL ${address.replace(/\/+$/, "")}/install.sh | bash`;
+}
+function installLineWords(install = companionInstall()) {
+  const line = install === "script" ? "installer line" : "npm line";
+  return `the ${line} from Your settings \u2192 Devices \u2192 Add a device in your Cabane`;
+}
 function companionInstall(execPath = process.execPath, home = homedir()) {
   const real = (path) => {
     try {
@@ -983,19 +989,34 @@ var HARNESS_INTENT_WORD = {
 function missingNoun(status) {
   return status === "executable_missing" ? "executable" : "platform package";
 }
-function repairCommands(route = repairRoute(), spell = cabane) {
+function repairCommands(route = repairRoute(), spell = cabane, address = configuredAddress()) {
   if (route === "managed") return [spell("stop"), spell("update")];
-  if (route === "script") return [spell("stop"), INSTALL_SCRIPT_COMMAND];
+  if (route === "script")
+    return [
+      spell("stop"),
+      address ? installScriptCommand(address) : { words: installLineWords("script") }
+    ];
   return ["npm i -g @cabane/companion --include=optional"];
 }
-function repairAction(route = repairRoute(), spell = cabane) {
-  const [first, ...rest] = repairCommands(route, spell);
-  if (rest.length === 0) return `Reinstall with \`${first}\`.`;
-  return `Run \`${first}\`, then \`${rest.join("`, then `")}\`. ${STOP_WARNING}`;
+function configuredAddress() {
+  try {
+    return loadConfig()?.baseUrl ?? null;
+  } catch {
+    return null;
+  }
+}
+function quoteStep(step, quote) {
+  return typeof step === "string" ? quote(step) : step.words;
+}
+var backticks = (command) => `\`${command}\``;
+function repairAction(route = repairRoute(), spell = cabane, address = configuredAddress()) {
+  const [first, ...rest] = repairCommands(route, spell, address);
+  if (rest.length === 0) return `Reinstall with ${quoteStep(first, backticks)}.`;
+  return `Run ${quoteStep(first, backticks)}, then ${rest.map((step) => quoteStep(step, backticks)).join(", then ")}. ${STOP_WARNING}`;
 }
 var STOP_WARNING = "Stopping ends any turn in progress.";
 function repairSteps(route = repairRoute()) {
-  return repairCommands(route).join(", then ");
+  return repairCommands(route).map((step) => quoteStep(step, (command) => command)).join(", then ");
 }
 function repairCost(route = repairRoute()) {
   return repairCommands(route).length > 1 ? STOP_WARNING : "";
@@ -1610,7 +1631,7 @@ function turnFailureCopy(reason, runtime) {
     const stopsFirst = commands.length > 1;
     if (!stopsFirst) commands.push("cabane stop");
     commands.push("cabane start");
-    const list = commands.map((command) => `\`${command}\``);
+    const list = commands.map((step) => quoteStep(step, (command) => `\`${command}\``));
     return `${harnessLabel(runtime ?? reason.slice("runtime_incomplete:".length))}'s installation on this device is incomplete. Run ${list.slice(0, -1).join(", ")} and ${list.at(-1)}. ${stopsFirst ? `${STOP_WARNING} ` : ""}Reply in Cabane to try again.`;
   }
   const unavailable = /^(codex|opencode)_unavailable:/.exec(reason ?? "")?.[1] ?? (reason?.startsWith("runtime_unavailable:") ? reason.slice("runtime_unavailable:".length).trim() : void 0);
@@ -3134,6 +3155,7 @@ var CLAUDE_CODE_ADDENDUM = [
 ].join("\n");
 
 // packages/agent-runtime/src/mcp-secret-env.ts
+var TURN_TOKEN_ENV = "CABANE_TURN_TOKEN";
 function headersAsEnvReferences(server) {
   const refs = Object.entries(server.headersFromEnv ?? {}).map(
     ([header, envName]) => [header, `\${${envName}}`]
@@ -3298,7 +3320,7 @@ function buildClaudeCodeOptions(req, augment) {
       type: "http",
       url: req.cabane.mcpUrl,
       headers: {
-        Authorization: `Bearer ${req.cabane.bearer}`,
+        Authorization: `\${${TURN_TOKEN_ENV}}`,
         [ACTIVE_CONVERSATION_HEADER]: req.cabane.activeConversationId
       },
       // Claude Code 2.1.x defers every MCP tool behind tool-search by default;
@@ -3357,10 +3379,15 @@ function buildClaudeCodeOptions(req, augment) {
     //
     // `secretEnv` — the values the MCP headers above reference — joins here and only here: it is
     // this child's environment, not the host's.
+    //
+    // The turn token goes after everything a room secret, a hook or the inherited environment can
+    // supply: this spread order is the only thing that stops a variable of the same name from
+    // displacing the turn's own credential.
     env: {
       ...process.env,
       ...req.local.env,
       ...req.local.secretEnv,
+      [TURN_TOKEN_ENV]: `Bearer ${req.cabane.bearer}`,
       CLAUDE_CODE_DISABLE_BACKGROUND_TASKS: "1"
     },
     ...resume ? { resume } : {}
@@ -4991,12 +5018,16 @@ function codexSecretEnv(req) {
   const env = { ...req.local.secretEnv };
   for (const server of Object.values(req.local.mcpServers ?? {})) {
     if ("url" in server) continue;
-    for (const [variable, envName] of Object.entries(server.envFromEnv ?? {})) {
+    for (const [variable, envName] of forwardedEnvVars(server.envFromEnv)) {
       const value = req.local.secretEnv?.[envName];
       if (value !== void 0) env[variable] = value;
     }
   }
-  return Object.keys(env).length > 0 ? env : null;
+  env[TURN_TOKEN_ENV] = `Bearer ${req.cabane.bearer}`;
+  return env;
+}
+function forwardedEnvVars(envFromEnv) {
+  return Object.entries(envFromEnv ?? {}).filter(([variable]) => variable !== TURN_TOKEN_ENV);
 }
 var CORE_REPLACES = "Your standing instructions changed since an earlier copy in this conversation, or that copy may have been compacted away. This copy replaces every earlier one: where they differ, this one holds, and anything an earlier copy said that this one does not no longer applies.";
 var CONVERSATION_REPLACES = "This conversation's standing context \u2014 its charters, skill indexes and roster \u2014 changed since an earlier copy in this conversation, or that copy may have been compacted away. This copy replaces every earlier one, including charters and skills an earlier turn carried in its own text: where they differ, this one holds, and anything an earlier copy said that this one does not no longer applies.";
@@ -5040,7 +5071,7 @@ function buildConfig(req) {
         default_tools_approval_mode: "approve"
       };
     } else if ("command" in server) {
-      const forwarded = Object.keys(server.envFromEnv ?? {}).sort();
+      const forwarded = forwardedEnvVars(server.envFromEnv).map(([variable]) => variable).sort();
       mcp_servers[name] = {
         command: server.command,
         ...server.args ? { args: server.args } : {},
@@ -5068,19 +5099,15 @@ function buildConfig(req) {
   }
   mcp_servers[CABANE_MCP_SERVER3] = {
     url: req.cabane.mcpUrl,
-    http_headers: {
-      Authorization: `Bearer ${req.cabane.bearer}`,
-      [ACTIVE_CONVERSATION_HEADER3]: req.cabane.activeConversationId
-    },
+    http_headers: { [ACTIVE_CONVERSATION_HEADER3]: req.cabane.activeConversationId },
+    env_http_headers: { Authorization: TURN_TOKEN_ENV },
     default_tools_approval_mode: "approve"
   };
   if (req.cabane.turnControlUrl) {
     mcp_servers[TURN_CONTROL_MCP_SERVER] = {
       url: req.cabane.turnControlUrl,
-      http_headers: {
-        Authorization: `Bearer ${req.cabane.bearer}`,
-        [ACTIVE_CONVERSATION_HEADER3]: req.cabane.activeConversationId
-      },
+      http_headers: { [ACTIVE_CONVERSATION_HEADER3]: req.cabane.activeConversationId },
+      env_http_headers: { Authorization: TURN_TOKEN_ENV },
       default_tools_approval_mode: "approve"
     };
   }
@@ -5196,7 +5223,7 @@ function createSdkCodexTransport(opts = {}) {
         // path (the CLI splits on `.` and ignores TOML quoting), so it must ride inside an inline-table
         // value, which the SDK's flattener can't produce. See `config-overrides.ts`.
         configOverrides: buildConfigOverrides(spec.config),
-        ...spec.secretEnv ? { env: codexProcessEnv(spec.secretEnv) } : {}
+        env: codexProcessEnv(spec.secretEnv)
       };
       const codex = new Codex(codexOptions);
       const threadOptions = buildSdkThreadOptions(spec);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cabane/companion",
-  "version": "0.6.235",
+  "version": "0.6.237",
   "type": "module",
   "description": "The Cabane Companion (headless): connect an agent on your machine to your Cabane workspace as a responder — drive work against your own codebase, files, and MCP servers without putting any of it in Cabane.",
   "license": "UNLICENSED",