@cabane/companion 0.6.171 → 0.6.173

package/dist/pairing-config.js

@@ -432,114 +432,53 @@ function saveConfig(cfg) {
 }
 
 // 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) {
+async function claimSetupCode(baseUrl, input) {
   let res;
   try {
-    res = await fetch(`${trimBase(baseUrl)}${path}`, {
+    res = await fetch(`${baseUrl.replace(/\/$/, "")}/api/device-enrollment/claim`, {
       method: "POST",
-      headers: { "content-type": "application/json", accept: "application/json" },
-      body: JSON.stringify(body)
+      headers: {
+        "content-type": "application/json",
+        ...input.deviceToken ? { authorization: `Bearer ${input.deviceToken}` } : {}
+      },
+      body: JSON.stringify({
+        userCode: input.userCode,
+        label: input.label,
+        platform: process.platform,
+        arch: process.arch,
+        nodeMajor: Number.parseInt(process.versions.node.split(".")[0], 10)
+      })
     });
-  } catch (err) {
+  } catch {
     throw new CompanionError(
-      `couldn't reach cabane at ${baseUrl}: ${err instanceof Error ? err.message : String(err)}. Check the server URL (pass --server <url>) and your connection.`
+      `Couldn't reach Cabane at ${baseUrl}. Check the server URL and your connection.`
     );
   }
-  const raw = await res.text();
-  let parsed = void 0;
-  if (raw.length > 0) {
-    try {
-      parsed = JSON.parse(raw);
-    } catch {
-      parsed = raw;
-    }
-  }
-  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("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}`;
-    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()
-  });
-}
-function hostFacts() {
-  const nodeMajor = Number.parseInt(process.versions.node.split(".")[0] ?? "", 10);
+  if (res.status === 429)
+    throw new CompanionError(
+      "Too many attempts from this network. Wait a few minutes and paste the setup line again."
+    );
+  if (res.status === 404 && input.deviceToken)
+    throw new CompanionError(
+      "The setup code or saved device credential is unavailable. If this device was removed, run cabane logout, then take a fresh setup line from your workspace\u2019s Settings \u2192 Devices."
+    );
+  if (res.status === 404 || res.status === 410)
+    throw new CompanionError(
+      "That setup code is unavailable. Take a fresh setup line from your workspace\u2019s Settings \u2192 Devices."
+    );
+  if (!res.ok) throw new ApiError(res.status, `Setup failed (${res.status}).`);
+  const body = await res.json();
+  if (!body || typeof body !== "object" || !("baseUrl" in body) || typeof body.baseUrl !== "string" || !("deviceId" in body) || typeof body.deviceId !== "string")
+    throw new CompanionError("Cabane returned an incomplete setup response.");
+  const token = "deviceToken" in body && typeof body.deviceToken === "string" ? body.deviceToken : input.deviceToken;
+  if (!token) throw new CompanionError("Cabane returned no device credential.");
   return {
-    platform: process.platform,
-    arch: process.arch,
-    ...Number.isInteger(nodeMajor) ? { nodeMajor } : {}
+    baseUrl: body.baseUrl,
+    deviceToken: token,
+    deviceId: body.deviceId,
+    ..."deviceLabel" in body && typeof body.deviceLabel === "string" ? { deviceLabel: body.deviceLabel } : {}
   };
 }
-function pollOnce(baseUrl, deviceCode) {
-  return postJson(baseUrl, "/api/device-enrollment/poll", { deviceCode });
-}
-var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
-async function runDeviceFlow(baseUrl, print, opts = {}) {
-  if (opts.signal?.aborted) throw new EnrollmentCancelledError();
-  const code = await requestEnrollmentCode(baseUrl, {
-    ...opts.label ? { label: opts.label } : {}
-  });
-  if (opts.onCode) await opts.onCode(code);
-  print("");
-  print(`  Enter this code at ${code.verificationUri}`);
-  print("");
-  print(`      ${code.userCode}`);
-  print("");
-  print(`  or open: ${code.verificationUriComplete}`);
-  print("");
-  print("Waiting for you to confirm it in Cabane\u2026");
-  return awaitEnrollment(baseUrl, code, opts);
-}
-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);
-    if (res.status === "complete") {
-      if (!res.deviceToken || !res.baseUrl) {
-        throw new CompanionError("the server 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 } : {},
-        ...res.ownerName ? { ownerName: res.ownerName } : {}
-      };
-    }
-    if (res.status === "expired") throw new EnrollmentExpiredError();
-    if (res.status === "slow_down") intervalMs += 1e3;
-  }
-  throw new EnrollmentExpiredError();
-}
 
 // src/pairing-config.ts
 var DEFAULT_BASE_URL = "https://app.cabane.ai";
@@ -574,9 +513,8 @@ function isDevicePaired() {
 export {
   ApiError,
   CompanionError,
+  claimSetupCode,
   isDevicePaired,
-  requestEnrollmentCode,
   resolvePairBaseUrl,
-  runDeviceFlow,
   writePairedConfig
 };

package/dist/runtime.js

@@ -3487,9 +3487,9 @@ var TURN_CONTROL_TOOL_DESCRIPTIONS = {
 - Recorded when you call this; delivered when your turn ends, or after 3 minutes if it is still running. Ask as soon as you know. The answer reaches you on a later turn.
 - The person sends one response; unanswered questions end as Unanswered. A person can dismiss an ask; you aren't told and nothing wakes you. Check an ask's status before raising it again.
 - To replace a stale ask (yours or anyone's here), pass \`replaces: { askId, reason }\`: both land in one write and the person sees the reason. To withdraw without a replacement, use \`withdraw_ask\`.`,
-  cancel_wake: `Stand down your own wake \u2014 the inverse of \`wake_me\`. No arguments: it cancels the wake you have armed in this conversation, NOW, when you call it. Reach for it when the thing you armed a wake to check has already happened, or the work it was watching is over \u2014 an armed wake you no longer need fires into a turn with nothing to do, and a supervision loop with no off switch is one you can only end by leaving it running. Whether you have one armed is printed in your turn context ("Wake armed: \u2026"); a wake you armed that is no longer printed there has fired or been dismissed. Calling this with nothing armed is a clean no-op, no error. Each call acts as it arrives: \`cancel_wake\` then \`wake_me\` leaves the NEW wake armed; \`wake_me\` then \`cancel_wake\` leaves nothing armed. It reaches only your own wake in this conversation \u2014 never a peer's, and never a recurring schedule (those are \`schedules.*\`).`,
+  cancel_wake: `Stand down the wake you have armed in this conversation, now, when you call it. No arguments. Use it when what the wake was to check has already happened or the work it watched is over; an unneeded wake fires into a turn with nothing to do. Your turn context prints the armed wake ("Wake armed: \u2026"); one no longer printed has fired or been dismissed. Nothing armed is a clean no-op. Calls act in order: \`cancel_wake\` then \`wake_me\` leaves the new wake armed. It reaches only your own wake here, never a peer's and never a recurring schedule (\`schedules.*\`).`,
   skip_turn: `End your current turn WITHOUT posting a reply. Call this when you've been woken to read a message that genuinely doesn't need a response from you \u2014 a thanks/aside, a question already answered, chatter outside your lane, or something another participant clearly owns. Your turn ends silently: no message bubble is posted. The \`reason\` is a short free-text note for telemetry (e.g. "already answered by cabane", "thanks, nothing to add"). Prefer this over posting a low-value "ok!"/"got it" reply. Don't also write a reply when you skip \u2014 skipping IS the whole turn.`,
-  wake_me: `Wake yourself later \u2014 end this turn now and be re-dispatched at a time you pick, with a note you write to yourself. Use it for "wait until X": when the thing you need hasn't happened yet (a PR isn't merged, a human hasn't answered), arm a wake, end your turn, and you're woken later to CHECK \u2014 read the workspace, and either act or re-arm. Ground the delay before you arm it. Almost every wake is short \u2014 seconds to a couple of hours \u2014 waiting on a condition you can name: a session limit resetting, a PR merging. Reach past a few hours only when (a) a human asked for that timing, or (b) the wait is pinned to a real external event you can name \u2014 a report that only runs Mondays, a known reset time. A speculative far-future check-in you invented yourself is the one thing not to arm: if no one asked and you can't name both what clears the wait and why it takes that long, don't arm it \u2014 finish now, or raise an \`ask\`. Pass EXACTLY ONE of \`afterSeconds\` (a relative delay \u2014 \`300\` for five minutes) or \`at\` (an absolute ISO-8601 timestamp WITH a zone, e.g. \`2026-07-16T09:00:00-07:00\` \u2014 YOU compute it; the system never parses natural-language time). \`note\` is a message to your future self \u2014 it becomes the body of the wake message that re-dispatches you, so write the condition to re-check ("check whether CT441 merged yet"). The wake arms NOW, when you call this, and the delay counts from this call; a later \`wake_me\` in the same turn replaces it, and \`cancel_wake\` stands it down. A wake that comes due while your turn is still running waits and is delivered after your reply. This is the ONLY sanctioned way to schedule your own continuation; never reach for a host cron/scheduler. Guardrails: at least 60s out, at most 14 days \u2014 a wake that can't be armed returns an error here, in this call, so you can recompute; widen the interval as a loop ages (5m \u2192 15m \u2192 1h\u2026) rather than hammering; after many consecutive re-arms with no other activity you'll be steered to raise an \`ask\` to the human instead.`,
+  wake_me: `Wake yourself later: end this turn now and be re-dispatched at a time you pick, with a note to yourself. Use it to wait for a condition you can name (a PR merging, a session limit resetting, an answer landing): arm, end the turn, and you're woken to CHECK and either act or re-arm. Most wakes are short, seconds to a couple of hours. Reach past a few hours only when a person asked for that timing or the wait is pinned to a real external event (a report that runs Mondays); if no one asked and you can't name both what clears the wait and why it takes that long, don't arm it: finish now, or raise an \`ask\`. Pass EXACTLY ONE of \`afterSeconds\` (\`300\` for five minutes) or \`at\` (an ISO-8601 timestamp WITH a zone, e.g. \`2026-07-16T09:00:00-07:00\`, which YOU compute; nothing parses natural-language time). \`note\` becomes the body of the message that re-dispatches you: write the condition to re-check. The wake arms NOW, when you call this; a later \`wake_me\` in the same turn replaces it, \`cancel_wake\` stands it down, and one that comes due mid-turn is delivered after your reply. This is the ONLY way to schedule your own continuation; never a host cron or scheduler. Floor 60s, horizon 14 days, enforced here so you can recompute. Widen the interval as a loop ages (5m \u2192 15m \u2192 1h\u2026); after many re-arms with no other activity you'll be steered to an \`ask\` instead.`,
   withdraw_ask: `Withdraw an open ask \u2014 yours or anyone's in this conversation \u2014 because the question is moot, was wrong, or has been overtaken. \`reason\` is required and is shown to the person and, if it wasn't your ask, to the agent who asked it. If there is a current question to put in its place, don't call this \u2014 call \`ask\` with \`replaces\` so the two land as one and the person never sees neither or both. Never withdraw to hurry an answer; to act on a deadline, arm a \`wake_me\` and decide then.`
 };
 var TURN_CONTROL_FIELD_DESCRIPTIONS = {
@@ -14270,6 +14270,7 @@ var CompanionSupervisor = class {
   async sendHeartbeat() {
     if (!this.deviceApi) return;
     try {
+      if (!this.detection || advertisedRuntimes(this.detection).length === 0) await this.detect();
       const store = loadSecretStoreTolerant(
         (m) => this.log.warn({ err: m }, "Could not read the secrets file. Check ~/.cabane/secrets.json.")
       );

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cabane/companion",
-  "version": "0.6.171",
+  "version": "0.6.173",
   "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",