@birdybeep/cli 0.6.0 → 0.7.0

package/dist/index.cjs

@@ -67,6 +67,21 @@ async function gatherIntegrations(adapters) {
 async function isPaired(tokenOptions = {}) {
   return await (0, import_agent_core.getToken)(tokenOptions) !== null;
 }
+async function pairingReport(tokenOptions = {}) {
+  const lookup = await (0, import_agent_core.readToken)(tokenOptions);
+  if (lookup.state === "present") return { state: "paired" };
+  if (lookup.state === "absent") return { state: "unpaired" };
+  return { state: "unknown", reason: lookup.reason, store: lookup.store };
+}
+function describeTokenStoreUnavailable(report) {
+  return `Could not read the token store (${report.reason ?? "unknown error"}), so whether this machine is paired is unknown. Events fired now are QUEUED, not lost, and send once it is readable.`;
+}
+function tokenStoreRemedy(report) {
+  if (report.store === "file") {
+    return "Repair the token file \u2014 check that its directory and the file itself are readable and writable by you (`chmod 700` the directory, `chmod 600` the file), then run `birdybeep doctor` again to drain the queue.";
+  }
+  return "Unlock your login keychain (log in to the desktop session, or unlock the screen), then run `birdybeep doctor` again to drain the queue. If it stays unreadable, run `birdybeep pair`.";
+}
 function localQueueDepth() {
   return new import_agent_core.LocalEventQueue().size();
 }
@@ -676,16 +691,36 @@ function createDoctorCommand(deps = {}) {
     usage: "birdybeep doctor [--json]",
     run: async (ctx) => {
       const checks = [];
-      const apiUrl = resolveApiUrl();
-      const paired = await isPaired(deps.tokenOptions ?? {});
+      const apiUrl = deps.baseUrl ?? resolveApiUrl();
+      const pairing = await pairingReport(deps.tokenOptions ?? {});
       checks.push(
-        paired ? { name: "Machine token", ok: true } : {
+        pairing.state === "paired" ? { name: "Machine token", ok: true } : pairing.state === "unpaired" ? {
           name: "Machine token",
           ok: false,
           detail: "No machine token found.",
           remedy: "Run `birdybeep pair` to pair this machine."
+        } : {
+          name: "Machine token",
+          ok: false,
+          detail: describeTokenStoreUnavailable(pairing),
+          remedy: tokenStoreRemedy(pairing)
         }
       );
+      const reach = (0, import_agent_core4.describeReachability)(
+        await (0, import_agent_core4.fetchPushReachability)({
+          baseUrl: apiUrl,
+          ...deps.tokenOptions ? { tokenOptions: deps.tokenOptions } : {},
+          ...deps.fetchImpl ? { fetchImpl: deps.fetchImpl } : {}
+        })
+      );
+      if (reach !== null) {
+        checks.push({
+          name: "Push reachability",
+          ok: reach.ok,
+          detail: reach.detail,
+          ...reach.remedy !== void 0 ? { remedy: reach.remedy } : {}
+        });
+      }
       const unpaired = unpairedActivity();
       if (unpaired !== null) {
         checks.push({
@@ -757,6 +792,8 @@ function createDoctorCommand(deps = {}) {
         ctx.io.result({
           ok,
           checks,
+          pairing,
+          // gcgp.23: paired | unpaired | unknown — never a bare boolean
           surfaces: surfaceGroups,
           queue: { depthBefore, delivered: drain.delivered, depthAfter, overflowDropped },
           ...unpaired !== null ? { unpairedActivity: unpaired } : {},
@@ -1003,13 +1040,20 @@ function createHookCommand(deps = {}) {
         outcome: result.outcome,
         eventType: result.eventType,
         ...result.send?.decision ? { decision: result.send.decision } : {},
-        ...result.send?.status !== void 0 ? { status: result.send.status } : {}
+        ...result.send?.status !== void 0 ? { status: result.send.status } : {},
+        ...result.send?.tokenStoreUnavailable !== void 0 ? { tokenStore: "unavailable" } : {}
       });
       if (result.outcome === "unpaired") {
         ctx.io.errline(
           "birdybeep: this machine is not paired \u2014 the event was not sent and was not queued. Run `birdybeep pair` (or `birdybeep doctor` to see how many events this has cost)."
         );
       }
+      const unavailable = result.send?.tokenStoreUnavailable;
+      if (unavailable !== void 0) {
+        ctx.io.errline(
+          `birdybeep: could not read the machine token (${unavailable.reason}) \u2014 the event was QUEUED, not sent. It will deliver once the token store is readable (unlock your keychain); \`birdybeep doctor\` drains the queue.`
+        );
+      }
       return EXIT.OK;
     }
   };
@@ -1142,7 +1186,7 @@ async function pairTokenPoll(apiUrl, deviceCode, fetchImpl, machineFingerprint,
 }
 
 // src/version.ts
-var CLI_VERSION = "0.6.0".length > 0 ? "0.6.0" : "0.0.0";
+var CLI_VERSION = "0.7.0".length > 0 ? "0.7.0" : "0.0.0";
 
 // src/commands/setup.ts
 var import_claude_code5 = require("@birdybeep/claude-code");
@@ -1184,16 +1228,33 @@ function createTestCommand(deps = {}) {
     usage: "birdybeep test [--json]",
     run: async (ctx) => {
       const event = buildTestEvent();
-      const result = await makeSender(resolveApiUrl()).send(event);
+      const baseUrl = deps.baseUrl ?? resolveApiUrl();
+      const result = await makeSender(baseUrl).send(event);
       if (ctx.flags.json) {
         ctx.io.result({
           outcome: result.outcome,
           ...result.status ? { status: result.status } : {},
-          ...result.decision ? { decision: result.decision } : {}
+          ...result.decision ? { decision: result.decision } : {},
+          ...result.tokenStoreUnavailable !== void 0 ? { tokenStore: "unavailable", tokenStoreReason: result.tokenStoreUnavailable.reason } : {}
         });
       } else if (result.outcome === "delivered") {
         if (result.decision === "notified" || result.decision === void 0) {
-          ctx.io.line("\u2713 Test event delivered \u2014 check your phone for a test Beep.");
+          const reach = await (0, import_agent_core8.fetchPushReachability)({
+            baseUrl,
+            ...deps.tokenOptions ? { tokenOptions: deps.tokenOptions } : {},
+            ...deps.fetchImpl ? { fetchImpl: deps.fetchImpl } : {}
+          });
+          if (reach.state === "ok" && reach.data.active_device_count === 0) {
+            ctx.io.line(
+              "\u26A0 The backend accepted the test event, but NO device on this account can receive it \u2014 nothing will arrive. Open the BirdyBeep app on your phone to register it (if it says the device limit is full, free a slot in Settings \u203A devices)."
+            );
+          } else if (reach.state === "ok") {
+            ctx.io.line(
+              `\u2713 Test event accepted and queued for ${String(reach.data.active_device_count)} registered device(s) \u2014 check your phone for a test Beep.`
+            );
+          } else {
+            ctx.io.line("\u2713 Test event accepted by the backend \u2014 check your phone for a test Beep.");
+          }
         } else if (result.decision === "suppressed") {
           ctx.io.line(
             "\u26A0 The backend accepted the test event but suppressed the push \u2014 this machine or integration is probably muted. Check mutes in the app, or run `birdybeep doctor`."
@@ -1211,6 +1272,10 @@ function createTestCommand(deps = {}) {
         ctx.io.line(
           "\u2717 NOT PAIRED \u2014 this machine has no BirdyBeep machine token, so nothing was sent (and nothing was queued). Run `birdybeep pair`."
         );
+      } else if (result.tokenStoreUnavailable !== void 0) {
+        ctx.io.line(
+          `\u2022 Could not read the machine token (${result.tokenStoreUnavailable.reason}) \u2014 the test event was queued and delivers once the token store is readable. If your keychain is locked, unlock it and run \`birdybeep test\` again.`
+        );
       } else if (result.outcome === "queued") {
         ctx.io.line("\u2022 Offline \u2014 test event queued; it will deliver when you reconnect.");
       } else {
@@ -1913,7 +1978,8 @@ function createStatusCommand(deps = {}) {
     usage: "birdybeep status [--json]",
     run: async (ctx) => {
       const machine = machineIdentity();
-      const paired = await isPaired(deps.tokenOptions ?? {});
+      const pairing = await pairingReport(deps.tokenOptions ?? {});
+      const paired = pairing.state === "paired";
       const integrations = await gatherIntegrations(adapters);
       const surfaces = await gatherSurfaces(adapters, deps.surfaceOptions ?? {});
       const depthBefore = localQueueDepth();
@@ -1925,6 +1991,8 @@ function createStatusCommand(deps = {}) {
       const report = {
         machine,
         paired,
+        pairing,
+        // gcgp.23: paired | unpaired | unknown — `paired: false` cannot say which
         integrations,
         surfaces,
         queue: { depthBefore, delivered: drain.delivered, depthAfter, overflowDropped },
@@ -1935,7 +2003,9 @@ function createStatusCommand(deps = {}) {
         ctx.io.result(report);
       } else {
         ctx.io.line(`Machine: ${machine.label} (${machine.os})`);
-        ctx.io.line(paired ? "Paired:  yes" : "Paired:  no \u2014 run `birdybeep pair`");
+        ctx.io.line(
+          pairing.state === "paired" ? "Paired:  yes" : pairing.state === "unpaired" ? "Paired:  no \u2014 run `birdybeep pair`" : `Paired:  unknown \u2014 ${describeTokenStoreUnavailable(pairing)}`
+        );
         ctx.io.line("Integrations:");
         for (const i of integrations) {
           ctx.io.line(`  ${i.displayName}: ${i.status}`);