@khalido/home 0.2.0 → 0.2.1

package/dist/connectors/printers/raster.js

@@ -0,0 +1,175 @@
+// PWG Raster (PWG 5102.4), 8-bit grey only: what an AirPrint printer that lists `image/pwg-raster` takes when it lists no
+// PDF. A file is "RaS2", then per page a 1796-byte big-endian header and the page's pixels, compressed line by line:
+// a line-repeat byte (the line appears n + 1 times), then runs: 0 to 127 is one pixel repeated n + 1 times, 129 to 255 is
+// 257 − n pixels as they are. Checked against a page macOS's own filters made for a Brother (test/fixtures/printers).
+const HEADER = 1796;
+const SGRAY = 18; // cupsColorSpace for sgray (PWG 5102.4 table 9)
+const WHITE = 0xffffff; // AlternatePrimary: the white point, as PWG 5102.4 recommends
+/** A PWG media name's size in inches: `iso_a4_210x297mm` is 8.27 × 11.69. */
+function mediaInches(name) {
+    const m = /_(\d+(?:\.\d+)?)x(\d+(?:\.\d+)?)(mm|in)$/.exec(name);
+    if (!m)
+        throw new RangeError(`not a PWG media size: ${name}`);
+    const per = m[3] === "mm" ? 1 / 25.4 : 1;
+    return { width: Number(m[1]) * per, height: Number(m[2]) * per };
+}
+/** The pixels a page of this media is at its resolution, rounded down as macOS's filters do: A4 at 600 dpi is 4960 × 7015. */
+export function mediaPixels(media) {
+    const i = mediaInches(media.name);
+    return {
+        width: Math.floor(i.width * media.dpi),
+        height: Math.floor(i.height * media.dpi),
+    };
+}
+function header(page, media, total) {
+    const h = new Uint8Array(HEADER);
+    const v = new DataView(h.buffer);
+    const u32 = (offset, n) => v.setUint32(offset, n);
+    const str = (offset, s) => h.set(new TextEncoder().encode(s).subarray(0, 63), offset);
+    const pt = mediaPixels({ name: media.name, dpi: 72 }); // PageSize is in points
+    str(0, "PwgRaster"); // MediaClass
+    u32(276, media.dpi); // HWResolution
+    u32(280, media.dpi);
+    u32(340, 1); // NumCopies: copies are the job's, not the page's
+    u32(352, pt.width); // PageSize, points
+    u32(356, pt.height);
+    u32(372, page.width); // Width, Height in pixels
+    u32(376, page.height);
+    u32(384, 8); // BitsPerColor
+    u32(388, 8); // BitsPerPixel
+    u32(392, page.width); // BytesPerLine
+    u32(400, SGRAY); // ColorSpace; ColorOrder (396) 0 is chunky
+    u32(420, 1); // NumColors
+    u32(452, total); // TotalPageCount
+    u32(456, 1); // CrossFeedTransform
+    u32(460, 1); // FeedTransform
+    u32(480, WHITE); // AlternatePrimary
+    str(1732, media.name); // PageSizeName
+    return h;
+}
+/** One line's runs, appended to `out`. */
+function packLine(line, out) {
+    let i = 0;
+    while (i < line.length) {
+        let run = 1;
+        while (run < 128 && i + run < line.length && line[i + run] === line[i])
+            run++;
+        if (run > 1 || i + 1 === line.length) {
+            out.push(run - 1, line[i]);
+            i += run;
+            continue;
+        }
+        // Literal: up to 128 pixels, stopping before two equal pixels that would pack better as a repeat.
+        let n = 1;
+        while (n < 128 &&
+            i + n < line.length &&
+            !(i + n + 1 < line.length && line[i + n] === line[i + n + 1]))
+            n++;
+        if (n === 1) {
+            out.push(0, line[i]); // a lone pixel is a repeat of one: 257 − 256 can't be written
+            i += 1;
+            continue;
+        }
+        out.push(257 - n);
+        for (let k = 0; k < n; k++)
+            out.push(line[i + k]);
+        i += n;
+    }
+}
+/**
+ * Pages as one PWG Raster document, `image/pwg-raster`. Every page must be `width × height` bytes. Pages may come one at
+ * a time (a generator), so only the packed document and the current page are held; then `total` is the page count.
+ */
+export function pwgRaster(pages, media, total = Array.isArray(pages) ? pages.length : 0) {
+    const chunks = [new TextEncoder().encode("RaS2")];
+    for (const page of pages) {
+        if (page.pixels.length !== page.width * page.height)
+            throw new RangeError(`a ${page.width} × ${page.height} page needs ${page.width * page.height} bytes, got ${page.pixels.length}`);
+        chunks.push(header(page, media, total));
+        let y = 0;
+        while (y < page.height) {
+            const line = page.pixels.subarray(y * page.width, (y + 1) * page.width);
+            let repeat = 0;
+            while (repeat < 255 &&
+                y + repeat + 1 < page.height &&
+                equal(line, page.pixels.subarray((y + repeat + 1) * page.width, (y + repeat + 2) * page.width)))
+                repeat++;
+            const out = [repeat]; // one line at a time: a page as a number[] would be hundreds of MB
+            packLine(line, out);
+            chunks.push(Uint8Array.from(out));
+            y += repeat + 1;
+        }
+    }
+    const size = chunks.reduce((n, c) => n + c.length, 0);
+    const file = new Uint8Array(size);
+    let at = 0;
+    for (const c of chunks)
+        (file.set(c, at), (at += c.length));
+    return file;
+}
+function equal(a, b) {
+    if (a.length !== b.length)
+        return false;
+    for (let i = 0; i < a.length; i++)
+        if (a[i] !== b[i])
+            return false;
+    return true;
+}
+/** A PWG Raster document back as pages and their headers' key fields; for tests and for checking a file before it prints. */
+export function readPwgRaster(file) {
+    const text = new TextDecoder();
+    if (text.decode(file.subarray(0, 4)) !== "RaS2")
+        throw new Error("pwg raster: no RaS2 sync word");
+    const pages = [];
+    let at = 4;
+    while (at < file.length) {
+        const v = new DataView(file.buffer, file.byteOffset + at, HEADER);
+        const width = v.getUint32(372);
+        const height = v.getUint32(376);
+        const bitsPerPixel = v.getUint32(388);
+        const bytes = bitsPerPixel / 8;
+        const name = file.subarray(at + 1732, at + 1796);
+        const pageSizeName = text.decode(name.subarray(0, name.indexOf(0)));
+        const page = {
+            width,
+            height,
+            dpi: v.getUint32(276),
+            pageSizeName,
+            colorSpace: v.getUint32(400),
+            bitsPerPixel,
+            pixels: new Uint8Array(width * height * bytes),
+        };
+        at += HEADER;
+        const lineBytes = width * bytes;
+        let y = 0;
+        while (y < height) {
+            const repeat = file[at++] + 1;
+            const line = new Uint8Array(lineBytes);
+            let x = 0;
+            while (x < lineBytes) {
+                const c = file[at++];
+                if (c === 128) {
+                    line.fill(255, x); // the rest of the line is white
+                    break;
+                }
+                if (c < 128) {
+                    const px = file.subarray(at, at + bytes);
+                    for (let k = 0; k <= c; k++)
+                        line.set(px, x + k * bytes);
+                    at += bytes;
+                    x += (c + 1) * bytes;
+                }
+                else {
+                    const n = (257 - c) * bytes;
+                    line.set(file.subarray(at, at + n), x);
+                    at += n;
+                    x += n;
+                }
+            }
+            for (let k = 0; k < repeat && y < height; k++, y++)
+                page.pixels.set(line, y * lineBytes);
+        }
+        pages.push(page);
+    }
+    return pages;
+}

package/dist/connectors/printers/state.d.ts

@@ -18,6 +18,8 @@ export type Printer = {
     name: string;
     model?: string;
     host?: string;
+    port?: number;
+    rp?: string;
     room?: string;
     state?: PrinterStatus;
     stateCode?: number;

package/dist/connectors/spotify/changes.d.ts

@@ -41,6 +41,6 @@ export declare function spotifyChanges(before: Part<SpotifyState> | undefined, a
 /**
  * The speaker in a few words: `Kitchen speaker: playing "Song" by Band · 35%`, `…: waiting for someone to pick it`, or,
  * for music on another Spotify device, `…: silent · "Song" by Band is playing on another Spotify device` (no volume: it isn't this speaker's playing level).
- * `on` names where, when the caller knows (`spotifyElsewhere`): `… is playing on Front room speaker`.
+ * `on` names where, when the caller knows (`spotifyElsewhere`): `… is playing on Den speaker`.
  */
 export declare function spotifyText(s: SpotifyState, on?: string[]): string;

package/dist/connectors/spotify/changes.js

@@ -87,7 +87,7 @@ export function spotifyChanges(before, after) {
 /**
  * The speaker in a few words: `Kitchen speaker: playing "Song" by Band · 35%`, `…: waiting for someone to pick it`, or,
  * for music on another Spotify device, `…: silent · "Song" by Band is playing on another Spotify device` (no volume: it isn't this speaker's playing level).
- * `on` names where, when the caller knows (`spotifyElsewhere`): `… is playing on Front room speaker`.
+ * `on` names where, when the caller knows (`spotifyElsewhere`): `… is playing on Den speaker`.
  */
 export function spotifyText(s, on = []) {
     const who = s.deviceName ?? "Soloist";

package/dist/connectors/spotify/index.js

@@ -228,6 +228,17 @@ export function spotify(config = {}) {
      * one raised before it is reported can't be told from the start's own jump, so it is lowered too.
      */
     const applyCap = () => {
+        // Lowered, then above the cap again in the same window: Soloist putting its own level back (seen live) or a person.
+        // The note says where it is now, not only that it was lowered.
+        if (capped && capNote && cap !== undefined && state.volume !== undefined) {
+            const base = capNote.replace(/; it is back at \d+$/, "");
+            const note = state.volume > cap + VOLUME_SLACK
+                ? `${base}; it is back at ${state.volume}`
+                : base;
+            if (note !== capNote)
+                ((capNote = note), publish());
+            return;
+        }
         if (cap === undefined ||
             capped ||
             capping ||
@@ -247,7 +258,7 @@ export function spotify(config = {}) {
                 capped = true;
                 if (state.status === "idle")
                     return;
-                capNote = `started at volume ${from}, above maxVolume ${cap}; lowered it (Soloist issue #23)`;
+                capNote = `started at volume ${from}, above maxVolume ${cap}; lowered it to ${cap} (Soloist issue #23)`;
                 note = undefined;
                 return publish();
             }

package/dist/connectors/up/client.d.ts

@@ -1,6 +1,6 @@
 import { z } from "zod";
 import { ConnectorError } from "../../connector.ts";
-/** A failed Up call. `status` 401 means the token is wrong or revoked; 429 the rate limit (unpublished: read `X-RateLimit-Remaining`). */
+/** A failed Up call. `status` 401 or 403 (`isRejectedKey`) means the token is wrong or revoked; 429 the rate limit (unpublished: read `X-RateLimit-Remaining`). */
 export declare class UpError extends ConnectorError {
 }
 declare const TransactionResource: z.ZodObject<{

package/dist/connectors/up/client.js

@@ -3,7 +3,7 @@ import { ConnectorError, fetchTimeout, getJson } from "../../connector.js";
 // Up Bank's API v1 (https://developer.up.com.au/, spec github.com/up-banking/api, v1/openapi.json). Field names checked
 // against one live read, 2026-10-16. Every field optional so a change degrades a reading rather than throwing.
 const BASE = "https://api.up.com.au/api/v1";
-/** A failed Up call. `status` 401 means the token is wrong or revoked; 429 the rate limit (unpublished: read `X-RateLimit-Remaining`). */
+/** A failed Up call. `status` 401 or 403 (`isRejectedKey`) means the token is wrong or revoked; 429 the rate limit (unpublished: read `X-RateLimit-Remaining`). */
 export class UpError extends ConnectorError {
 }
 const Money = z.looseObject({

package/dist/connectors/up/index.js

@@ -1,6 +1,6 @@
 import { z } from "zod";
 import { asOf, realClock } from "../../clock.js";
-import { errorText } from "../../connector.js";
+import { errorText, isRejectedKey } from "../../connector.js";
 import { envName } from "../../home.js";
 import { poller } from "../../poll.js";
 import { upClient, UpError, } from "./client.js";
@@ -139,7 +139,7 @@ export function up(config) {
                 catch (error) {
                     if (signal.aborted)
                         return; // stopped mid-read: not a failure
-                    if (error instanceof UpError && error.status === 401)
+                    if (isRejectedKey(error))
                         return update({
                             status: "unavailable",
                             reason: "auth",

package/dist/connectors/weather/google.js

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import { ConnectorError, fetchTimeout } from "../../connector.js";
+import { ConnectorError, fetchTimeout, isRejectedKey, } from "../../connector.js";
 import { RAIN_INTENSITIES } from "./rain.js";
 import { sunDisagrees } from "./sun.js";
 import { HOURLY_MINUTES, iso, nextPoll, num, RAIN_HORIZON_MINUTES, USER_AGENT, } from "./source.js";
@@ -360,7 +360,7 @@ export function google(options) {
                     ? error
                     : {};
                 const said = `HTTP ${status}${why ? ` ${why}` : ""}`;
-                if (status === 401 || status === 403 || why?.startsWith("API_KEY_"))
+                if (isRejectedKey(error) || why?.startsWith("API_KEY_"))
                     return {
                         stop: `google: the key was rejected (${said})`,
                         stopReason: "auth",

package/docs/cli.md

@@ -18,6 +18,8 @@ home discover [--json] [--passes n]  # which smart-home devices answer here (mDN
 home cache [clear]            # the addresses kept between runs, or delete them so the next run discovers afresh
 home config check [path]      # validate a home config: what it would set up, secrets as set or unset by name, every problem
 home discover --write [path]  # with a config (the path, else --config or HOME_CONFIG): match what answers by identity, add new devices, update moved hosts and renamed Cast names in place
+home printers print <file.pdf> [printer]   # PDF as is, or rendered to PWG Raster with pdftoppm when the printer takes no PDF; --dry-run
+home printers identify | cancel <job>       # the printer shows itself; stop a job
 home probe                    # read-only, no keys: Hue's public config, Daikin by UDP broadcast, the IQ Gateway's /info, each weather source, each Cast device's and printer's status
 home locate "<street address>" [--write [path]]  # latitude and longitude from OpenStreetMap's Nominatim; --write sets them in the config's location (and timezone, when absent, to this machine's)
 home cast announce --to <name> [--to <name>…] (--say "<text>" | --file <path>) [--volume 0-100]  # exit 1 if any didn't play; play a clip, then put back what was playing and the volume

package/docs/decisions.md

@@ -165,3 +165,10 @@ KO's decisions on this package, newest block last. They override every other doc
 - **Spotify playing on another device reads as `elsewhere`, not `playing`** (KO, 2026-11-11; chota raised it three times). Soloist reports the account's playback, not the box's, so `playing` while inactive is a silent speaker. `speakerState`, `spotifyText` and `spotifyChanges` all go through one test, `playingElsewhere`. Paused while inactive is left as Soloist says: nothing live shows whose pause it is. Soloist never names the other device, so where is a join with Cast by track name (`spotifyElsewhere`), passed to `spotifyText(state, on)` by `homeDevices`, which sees both parts; the speaker's own part can't know it, so `home status` says "another Spotify device".
 - **`home.add` replaces by name and starts the part over** (KO, 2026-11-11; chota pairs Hue from a chat). The old run ends before the new one starts, so a device never has two streams; the new part is a bare `connecting`, since the old state belonged to another key or address. No type widening: a `loadHome` home is already typed for every connector, so `add` takes the home's own integration type. `remove` fires no `onChange`: a change needs an `after`.
 - **Dry run is an option on each write, not a separate client** (KO, 2026-11-12; chota asked, since KO's rule is no device write without his OK at the time). It runs the read and every check a real write runs, so a wrong name or an unreachable light fails the same way, and returns the request instead of sending it, in the same `{ state, confirmed }` shape with `wouldSend` added. Hue and Daikin first, chota's lights and aircon tools; Cast and Spotify when a tool needs them.
+
+## Printing (2026-11-12)
+
+- **The library sends bytes; the CLI makes them.** `printJob` takes a document already in a format the printer lists. Many AirPrint printers (KO's Brother) take no PDF, only PWG Raster or Apple's URF, so a PDF has to be rendered. Rendering a PDF needs a PDF engine, which is not runtime-neutral; it lives in `src/cli/printers.ts` as poppler's `pdftoppm`, the one new tool. `pwgRaster` packs the pixels and stays in the library, so a consumer with its own renderer can print.
+- **PWG Raster, not URF.** PWG 5102.4 is a published standard; URF is Apple's and undocumented. 8-bit grey only, until a colour printer is here.
+- **Validate-Job before every Print-Job**, so a wrong attribute fails before paper moves; **`one-sided` sent explicitly**; **a timed-out Print-Job is never resent**, since the printer may have taken it.
+- **No write lane yet.** The writes are one-shot calls on an address, not methods on the integration: nothing calls them in a loop. When a consumer prints from a long-running process, put them on the integration with a lane, slot per job so two prints never merge.

package/docs/ideas.md

@@ -61,6 +61,8 @@ Two ideas from KO, 2026-10-14, not yet decided:
 
 ## Spotify search and library (KO, 2026-11-08)
 
+A signed-in account's playlists and library are now [khalido/home.ts#2](https://github.com/khalido/home.ts/issues/2).
+
 Soloist plays URIs; it can't search or read a library. Starting music by name ("play some Seal", "my Soft 90s playlist") needs Spotify's cloud Web API beside it: search returns a URI, and the spotify connector's `play(uri)` plays it. **KO's call, 2026-11-08: search lives in chota-bot, not here.** This library turns a box into a speaker; the bot owns its music search tool. chota-bot checked live that catalogue search works with client credentials, no user sign-in, on a development-mode app, and that Soloist played the URI it found. The notes below stay as the research.
 
 - **Search without a user** (catalogue only): the Client Credentials flow reaches "only endpoints that do not access user information" ([client credentials](https://developer.spotify.com/documentation/web-api/tutorials/client-credentials-flow)). The search reference names no flow, but the scopes page lists search under `user-read-private`, so whether an app-only token can search is unsettled: one test call answers it. Search needs a `market`. Since February 2026 a development-mode app gets at most 10 results per search ([migration guide](https://developer.spotify.com/documentation/web-api/tutorials/february-2026-migration-guide)).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@khalido/home",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "description": "home.ts: small, typed home automation for TypeScript: Hue, Daikin, Enphase, Google Cast, AirPrint printers and a Spotify Soloist speaker on the local network; Amber prices, Up Bank spending and the weather from the cloud.",
   "license": "MIT",
   "author": "Khalid Omar",

package/skills/draw-home/README.md

@@ -1,5 +1,7 @@
 # draw-home: references
 
+Where the skill is going, from a floor plan PDF to a live view: [khalido/home.ts#3](https://github.com/khalido/home.ts/issues/3).
+
 Good drawing references to read before drawing a home, newest idea first. All are skills or kits for coding agents; read for craft, keep this skill's contract (`SKILL.md` section 3) where they disagree.
 
 | Reference                                                                                                                                                     | What it is                                                                                                                                                                                                                                                                                                                                         | Use it for                                                                                                                                                                          | Licence                                                          |

package/skills/use-home/SKILL.md

@@ -10,7 +10,7 @@ description: Use the `home` command and the @khalido/home library to see and run
 ## Rules
 
 - **Reads are free.** `home`, `home <connector>` with no verb, `home devices`, `home discover`, `home probe`, `home up spend` and every `--json` read touch nothing.
-- **Writes only on request.** Lights, AC, speakers, Up categories and tags, webhooks: run one only when the person asked for that change, then read back and report the state it left. Never write to "test" something: `--dry-run` on a Hue or Daikin write (`home room …`, `home scene …`, `home lights off`, `home daikin …`) checks it and prints what it would send, sending nothing; other commands refuse the flag.
+- **Writes only on request.** Lights, AC, speakers, printing, Up categories and tags, webhooks: run one only when the person asked for that change, then read back and report the state it left. Never write to "test" something: `--dry-run` on a Hue or Daikin write (`home room …`, `home scene …`, `home lights off`, `home daikin …`, `home printers print …`) checks it and prints what it would send, sending nothing (a print's dry run also asks the printer to validate the job, which prints nothing); other commands refuse the flag.
 - **Never print a key, token or password**, not even part of one. Say "set" or "unset". Env names are fine; values are not.
 - **Nothing private into a public repo**: no IPs, MACs, serials, device or room names, Up transactions or balances. A real `home.jsonc`, `home.svg` and floor plan live in a private folder.
 - **Show values as read.** A missing field is unknown, not zero. An `anomaly` is something odd the device said: report it, never smooth it.

package/src/cli/enphase.ts

@@ -7,8 +7,16 @@ import {
   tokenExpiry,
 } from "../connectors/enphase/index.ts";
 import { daysLeft } from "../connectors/enphase/client.ts";
-import { writePrivate } from "../finders.ts";
-import { env, fail, homeTimeZone, TOKEN_FILE, type Verbs } from "./context.ts";
+import { addressBook } from "../discover.ts";
+import { FINDERS, writePrivate } from "../finders.ts";
+import {
+  addresses,
+  env,
+  fail,
+  homeTimeZone,
+  TOKEN_FILE,
+  type Verbs,
+} from "./context.ts";
 
 /** The cached Enphase token, or undefined if `home enphase login` has not run. A corrupt file throws, naming it. */
 export function enphaseToken(): { token: string; expiresAt: Date } | undefined {
@@ -31,12 +39,30 @@ export function enphaseToken(): { token: string; expiresAt: Date } | undefined {
   }
 }
 
-/** Enphase as an integration from IQ_GATEWAY_HOST and the token file, for `home status`. */
-export function enphaseFromEnv() {
+/**
+ * Enphase as an integration for `home status`: IQ_GATEWAY_HOST, else the address cache, else the first gateway mDNS finds.
+ * With the gateway's serial from the cache, a read that fails is followed by discovery at once, so an IQ_GATEWAY_HOST left
+ * behind by a DHCP move still reads, and its detail says where the gateway went.
+ */
+export async function enphaseFromEnv() {
   const t =
     enphaseToken() ?? fail("no Enphase token", "auth", "home enphase login");
+  const book = addressBook(addresses.cache);
+  const serial = Object.keys(book.entries())
+    .find((k) => k.startsWith("enphase:"))
+    ?.slice("enphase:".length);
+  const cached = serial ? book.fresh("enphase", serial) : undefined;
+  const host =
+    env.IQ_GATEWAY_HOST ??
+    cached?.host ??
+    (await FINDERS.enphase())[0]?.host ??
+    fail("no gateway found by mDNS; set IQ_GATEWAY_HOST", "network");
   return enphase({
-    host: env.IQ_GATEWAY_HOST!,
+    host,
+    serial,
+    find: FINDERS.enphase,
+    seen: (h) => book.seen("enphase", serial, { host: h }),
+    hostCached: true, // an env address is as likely stale as a cached one: look again after one failure
     token: t.token,
     fetch: bunGatewayFetch(),
     timeZone: homeTimeZone(),

package/src/cli/main.ts

@@ -1,7 +1,7 @@
 #!/usr/bin/env bun
 // `home`: the terminal layer. Commands come from cac; one `home <connector>` per manifest, its verbs from src/cli/<connector>.ts.
 import { cac } from "cac";
-import { ConnectorError, errorText } from "../connector.ts";
+import { errorText, isRejectedKey } from "../connector.ts";
 import { MANIFESTS } from "../manifests.ts";
 import { cacheCommand } from "./cache.ts";
 import { CAST_OPTIONS, CAST_USAGE, castVerbs } from "./cast.ts";
@@ -19,6 +19,7 @@ import { discover } from "./discover.ts";
 import { enphaseVerbs } from "./enphase.ts";
 import { CHANGE_USAGE, hueVerbs } from "./hue.ts";
 import { locate } from "./locate.ts";
+import { PRINTERS_USAGE, printersVerbs } from "./printers.ts";
 import { probe } from "./probe.ts";
 import { SPOTIFY_USAGE, spotifyVerbs } from "./spotify.ts";
 import { devices, status } from "./status.ts";
@@ -59,6 +60,11 @@ const VERBS: Record<
   cast: { verbs: castVerbs, usage: CAST_USAGE, options: CAST_OPTIONS },
   up: { verbs: upVerbs, usage: UP_USAGE, options: UP_OPTIONS },
   spotify: { verbs: spotifyVerbs, usage: SPOTIFY_USAGE },
+  printers: {
+    verbs: printersVerbs,
+    usage: PRINTERS_USAGE,
+    options: [DRY_RUN],
+  },
 };
 
 const cli = cac("home");
@@ -157,8 +163,7 @@ function describe(e: unknown): {
   if (e instanceof CliError) return { error, code: e.code, fix: e.fix };
   if (e instanceof Error && e.name === "CACError")
     return { error, code: "usage" }; // cac: a missing argument or an unknown option
-  if (e instanceof ConnectorError && (e.status === 401 || e.status === 403))
-    return { error, code: "auth" };
+  if (isRejectedKey(e)) return { error, code: "auth" };
   // A timeout, or a socket error Bun and Node tag with a code (ECONNREFUSED, ENOTFOUND). A bare TypeError is more likely a bug.
   const socket =
     typeof (e as { code?: unknown })?.code === "string" &&