@cabane/companion 0.6.237 → 0.6.238

package/dist/pairing-config.js

@@ -1,591 +0,0 @@
-// src/cabane-command.ts
-import { accessSync, constants, realpathSync as realpathSync2 } from "fs";
-import { homedir as homedir4 } from "os";
-import { basename as basename2, delimiter, dirname as dirname2, join as join3, sep as sep2 } from "path";
-
-// src/install-kind.ts
-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";
-import { fileURLToPath as fileURLToPath2 } from "url";
-
-// src/install-record.ts
-import { existsSync as existsSync2, readFileSync } from "fs";
-import { homedir as homedir2 } from "os";
-import { basename, join as join2 } from "path";
-
-// src/term.ts
-import { homedir as homedir3 } from "os";
-import pc from "picocolors";
-
-// src/cabane-command.ts
-var VERSIONS_SEGMENT = `${sep2}.cabane${sep2}versions${sep2}`;
-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 StandaloneError = class extends CompanionError {
-  constructor(message) {
-    super(message);
-    this.name = "StandaloneError";
-  }
-};
-var ApiError = class extends CompanionError {
-  constructor(status, message, body) {
-    super(message);
-    this.status = status;
-    this.body = body;
-    this.name = "ApiError";
-  }
-  status;
-  body;
-};
-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 loadConfigTolerant() {
-  const path = configPath();
-  const empty = {};
-  const fresh = { local: empty, note: null, hadPriorConfig: false };
-  if (!existsSync3(path)) return fresh;
-  let raw;
-  try {
-    raw = readFileSync2(path, "utf8");
-  } catch {
-    return fresh;
-  }
-  if (raw.trim().length === 0) return fresh;
-  let parsed;
-  try {
-    parsed = withoutRetiredKeys(JSON.parse(raw));
-  } catch {
-    return {
-      local: empty,
-      note: `${path} was unreadable (invalid JSON) and has been reset.`,
-      hadPriorConfig: true
-    };
-  }
-  const strict = companionConfigSchema.safeParse(parsed);
-  if (strict.success) {
-    const {
-      baseUrl: _baseUrl,
-      deviceToken: _deviceToken,
-      deviceId: _deviceId,
-      deviceLabel: _deviceLabel,
-      ...local2
-    } = strict.data;
-    return { local: local2, note: null, hadPriorConfig: true };
-  }
-  const obj = parsed && typeof parsed === "object" ? parsed : {};
-  const local = {};
-  const agents = agentsConfigSchema.safeParse(obj.agents);
-  if (agents.success) local.agents = agents.data;
-  const prepareHook = prepareHookSchema.safeParse(obj.prepareHook);
-  if (prepareHook.success) local.prepareHook = prepareHook.data;
-  const root = companionConfigSchema.shape.root.safeParse(obj.root);
-  if (root.success && root.data !== void 0) local.root = root.data;
-  if (typeof obj.dashboardPort === "number") local.dashboardPort = obj.dashboardPort;
-  if (typeof obj.autoOpen === "boolean") local.autoOpen = obj.autoOpen;
-  if (obj.logFormat === "human" || obj.logFormat === "json") local.logFormat = obj.logFormat;
-  if (obj.logLevel === "warn" || obj.logLevel === "info" || obj.logLevel === "debug") {
-    local.logLevel = obj.logLevel;
-  }
-  const harnesses = companionConfigSchema.shape.harnesses.safeParse(obj.harnesses);
-  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.`,
-    hadPriorConfig: true
-  };
-}
-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/enrollment.ts
-var EnrollmentExpiredError = class extends CompanionError {
-  constructor() {
-    super("this pairing code expired before it was confirmed.");
-    this.name = "EnrollmentExpiredError";
-  }
-};
-var EnrollmentCancelledError = class extends CompanionError {
-  constructor() {
-    super("pairing was cancelled.");
-    this.name = "EnrollmentCancelledError";
-  }
-};
-function trimBase(baseUrl) {
-  return baseUrl.endsWith("/") ? baseUrl.slice(0, -1) : baseUrl;
-}
-async function postJson(baseUrl, path, body, signal) {
-  let res;
-  try {
-    res = await fetch(`${trimBase(baseUrl)}${path}`, {
-      method: "POST",
-      headers: { "content-type": "application/json", accept: "application/json" },
-      body: JSON.stringify(body),
-      ...signal ? { signal } : {}
-    });
-  } catch {
-    if (signal?.aborted) throw new EnrollmentCancelledError();
-    throw new CompanionError(
-      `Couldn't reach Cabane at ${baseUrl}. Check the server URL and your connection.`
-    );
-  }
-  let raw;
-  try {
-    raw = await res.text();
-  } catch {
-    if (signal?.aborted) throw new EnrollmentCancelledError();
-    throw new CompanionError(
-      `Couldn't reach Cabane at ${baseUrl}. Check the server URL and your connection.`
-    );
-  }
-  let parsed = void 0;
-  if (raw.length > 0) {
-    try {
-      parsed = JSON.parse(raw);
-    } catch {
-      parsed = raw;
-    }
-  }
-  if (res.status >= 400) {
-    if (res.status === 429)
-      throw new CompanionError(
-        "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 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);
-  }
-  return parsed;
-}
-function requestEnrollmentCode(baseUrl, opts = {}) {
-  return postJson(
-    baseUrl,
-    "/api/device-enrollment/code",
-    { ...opts.label ? { label: opts.label } : {}, ...hostFacts() },
-    opts.signal
-  );
-}
-function hostFacts() {
-  const nodeMajor = Number.parseInt(process.versions.node.split(".")[0] ?? "", 10);
-  return {
-    platform: process.platform,
-    arch: process.arch,
-    ...Number.isInteger(nodeMajor) ? { nodeMajor } : {}
-  };
-}
-function pollOnce(baseUrl, deviceCode, signal) {
-  return postJson(baseUrl, "/api/device-enrollment/poll", { deviceCode }, signal);
-}
-var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
-async function awaitEnrollment(baseUrl, code, opts = {}) {
-  const now = opts.now ?? (() => Date.now());
-  const wait = opts.sleepMs ?? sleep;
-  const deadline = now() + code.expiresIn * 1e3;
-  let intervalMs = Math.max(1, code.interval) * 1e3;
-  while (now() < deadline) {
-    await wait(intervalMs);
-    if (opts.signal?.aborted) throw new EnrollmentCancelledError();
-    const res = await pollOnce(baseUrl, code.deviceCode, opts.signal);
-    if (opts.signal?.aborted) throw new EnrollmentCancelledError();
-    if (res.status === "complete") {
-      if (!res.deviceToken || !res.baseUrl)
-        throw new CompanionError("Cabane reported the pairing complete but returned no token.");
-      return {
-        baseUrl: res.baseUrl,
-        deviceToken: res.deviceToken,
-        ...res.deviceId ? { deviceId: res.deviceId } : {},
-        ...res.deviceLabel ? { deviceLabel: res.deviceLabel } : {}
-      };
-    }
-    if (res.status === "expired") throw new EnrollmentExpiredError();
-    if (res.status === "slow_down") intervalMs += 1e3;
-  }
-  throw new EnrollmentExpiredError();
-}
-
-// src/pairing-config.ts
-function resolvePairBaseUrl(server) {
-  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")}\`.`
-    );
-  }
-  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 = {
-    ...local,
-    baseUrl: paired.baseUrl,
-    deviceToken: paired.deviceToken,
-    ...paired.deviceId ? { deviceId: paired.deviceId } : {},
-    ...paired.deviceLabel ? { deviceLabel: paired.deviceLabel } : {}
-  };
-  saveConfig(config);
-  return { config, note };
-}
-function isDevicePaired() {
-  try {
-    return !!loadConfig()?.deviceToken;
-  } catch {
-    return false;
-  }
-}
-export {
-  ApiError,
-  CompanionError,
-  EnrollmentCancelledError,
-  EnrollmentExpiredError,
-  NoPairAddressError,
-  awaitEnrollment,
-  isDevicePaired,
-  rememberPairAddress,
-  requestEnrollmentCode,
-  resolvePairBaseUrl,
-  writePairedConfig
-};