@cabane/companion 0.6.19 → 0.6.21

package/dist/pairing-config.js

@@ -161,6 +161,26 @@ var companionConfigSchema = z2.object({
   opencode: z2.object({
     serverUrl: z2.string().url()
   }).strict().optional(),
+  // CT1082: the Claude Code runtime, when the user connected it on this machine.
+  // The change this task exists for: Claude Code used to be the one harness a
+  // device exposed with no configuration — a `claude --version` exit-0 was taken as
+  // consent — and it is now the third config-driven harness, opted into exactly
+  // like codex. `claude` on PATH is still required (you can't run what isn't
+  // installed), but presence alone no longer exposes anything: the manifest
+  // advertises claude-code only when this block says so AND the binary is there.
+  //
+  // The block's PRESENCE is also the migration marker (see `migrateConnectedHarnesses`).
+  // Absent means the config predates this task — a device whose user was never
+  // asked — and the migration grandfathers it on first start. So every config
+  // written from here on carries the block explicitly, including a freshly-paired
+  // one, which starts at `enabled: false`: a new device is connected to nothing
+  // until its user says otherwise.
+  //
+  // Not to be confused with the per-agent `agents.<key>.claudeCode.autoMemory`
+  // above — that's one agent's memory switch, this is the device's connected set.
+  claudeCode: z2.object({
+    enabled: z2.boolean().optional()
+  }).strict().optional(),
   // CT481: the codex runtime, when the operator runs Codex on this machine. Unlike
   // opencode (a long-lived `opencode serve` addressed by URL), Codex is a local CLI
   // the `@openai/codex-sdk` spawns per turn — so the config is just an opt-in flag,
@@ -211,31 +231,38 @@ function loadConfig() {
 function loadConfigTolerant() {
   const path = configPath();
   const empty = {};
-  if (!existsSync(path)) return { local: empty, note: null };
+  const fresh = { local: empty, note: null, hadPriorConfig: false };
+  if (!existsSync(path)) return fresh;
   let raw;
   try {
     raw = readFileSync(path, "utf8");
   } catch {
-    return { local: empty, note: null };
+    return fresh;
   }
-  if (raw.trim().length === 0) return { local: empty, note: null };
+  if (raw.trim().length === 0) return fresh;
   let parsed;
   try {
     parsed = JSON.parse(raw);
   } catch {
-    return { local: empty, note: `${path} was unreadable (invalid JSON) and has been reset.` };
+    return {
+      local: empty,
+      note: `${path} was unreadable (invalid JSON) and has been reset.`,
+      hadPriorConfig: true
+    };
   }
   const strict = companionConfigSchema.safeParse(parsed);
   if (strict.success) {
-    const { agents: agents2, dashboardPort, autoOpen, logLevel } = strict.data;
+    const { agents: agents2, dashboardPort, autoOpen, logLevel, claudeCode: claudeCode2 } = strict.data;
     return {
       local: {
         ...agents2 !== void 0 ? { agents: agents2 } : {},
         ...dashboardPort !== void 0 ? { dashboardPort } : {},
         ...autoOpen !== void 0 ? { autoOpen } : {},
-        ...logLevel !== void 0 ? { logLevel } : {}
+        ...logLevel !== void 0 ? { logLevel } : {},
+        ...claudeCode2 !== void 0 ? { claudeCode: claudeCode2 } : {}
       },
-      note: null
+      note: null,
+      hadPriorConfig: true
     };
   }
   const obj = parsed && typeof parsed === "object" ? parsed : {};
@@ -247,9 +274,12 @@ function loadConfigTolerant() {
   if (obj.logLevel === "warn" || obj.logLevel === "info" || obj.logLevel === "debug") {
     local.logLevel = obj.logLevel;
   }
+  const claudeCode = companionConfigSchema.shape.claudeCode.safeParse(obj.claudeCode);
+  if (claudeCode.success && claudeCode.data !== void 0) local.claudeCode = claudeCode.data;
   return {
     local,
-    note: `the existing ${path} was from an older or incompatible companion; re-pairing rewrote it.`
+    note: `the existing ${path} was from an older or incompatible companion; re-pairing rewrote it.`,
+    hadPriorConfig: true
   };
 }
 function saveConfig(cfg) {
@@ -375,8 +405,16 @@ function resolvePairBaseUrl(server) {
   return raw;
 }
 function writePairedConfig(paired) {
-  const { local, note } = loadConfigTolerant();
+  const { local, note, hadPriorConfig } = loadConfigTolerant();
   const config = {
+    // CT1082: a device pairs connected to NOTHING — `claudeCode: { enabled: false }`
+    // written explicitly, not left absent, because absence is exactly what marks a
+    // pre-CT1082 config for the grandfathering migration. Omit it and a brand-new
+    // device gets auto-connected on its first start by the behaviour this task
+    // removes; stamp it on a RE-pair and an upgrading user's working device gets
+    // disconnected instead. So it's written only when there was no config here
+    // before. `local` spreads after, so a re-pair keeps the answer already given.
+    ...hadPriorConfig ? {} : { claudeCode: { enabled: false } },
     ...local,
     baseUrl: paired.baseUrl,
     deviceToken: paired.deviceToken,