@skrr-ai/cli 0.1.49 → 0.1.51

package/dist/node_modules/@skrr-ai/auth-core/dist/esm/loopbackHttp.js

@@ -0,0 +1,257 @@
+/**
+ * OSK-12134 — the ONE HTTP client for talking to a process on this machine.
+ *
+ * ── Why this is not `fetch` ────────────────────────────────────────────────
+ *
+ * The compiled daemon runs on Bun, and Bun's `fetch` routes EVERY URL through
+ * `HTTP_PROXY` / `HTTPS_PROXY` unless `NO_PROXY` names it — a `127.0.0.1`
+ * target included. Node's `fetch` does the same once `NODE_USE_ENV_PROXY=1` is
+ * set (Node 22.21+/24). On a laptop with a local proxy exported in the shell
+ * (Clash, Surge, a corporate agent, …) every loopback call the daemon, a
+ * wrapper, or the CLI made with `fetch` was delivered to that proxy instead —
+ * WITH its credential: the daemon's local secret, the CLI-handoff descriptor
+ * secret, the wrapper fan-out bearer, the browser bridge token, the extension
+ * relay token. OSK-12087 found this on the `/health` probe and moved that one
+ * caller to `node:http`; this module is that fix made the only way to do it.
+ *
+ * `node:http` never consults proxy environment variables, on Node or on Bun, so
+ * a request made through it cannot be routed off the machine by environment.
+ *
+ * ── What it refuses ────────────────────────────────────────────────────────
+ *
+ * Only `http:` URLs whose host is a loopback name or address are accepted
+ * (`127.0.0.0/8`, `::1`, `localhost`). Anything else throws BEFORE a socket is
+ * opened: a caller that builds its URL from a descriptor or an environment
+ * variable must not be turned into an SSRF primitive by a hostile value, and a
+ * credential that is only meant for this machine must not be sent anywhere
+ * else. `localhost` is resolved through a lookup that rejects any non-loopback
+ * answer, so a rewritten hosts file cannot redirect it either.
+ *
+ * ── Shape ──────────────────────────────────────────────────────────────────
+ *
+ * `loopbackFetch` is a drop-in for the subset of `fetch` these callers use —
+ * method, headers, a string/bytes body, an `AbortSignal` — and returns a real
+ * `Response`, so existing callers (and their `fetchImpl` test seams) change one
+ * identifier. Transport failures reject with `TypeError('fetch failed')` whose
+ * `cause` carries the socket error (`ECONNREFUSED`, …), and aborts reject with
+ * the signal's reason, exactly as `fetch` does, so existing error handling keeps
+ * working. The response body is buffered (bounded by `maxBodyBytes`); nothing
+ * on loopback streams through this client.
+ */
+import dns from 'node:dns';
+import http from 'node:http';
+import net from 'node:net';
+/** Loopback host names this client will connect to, besides 127/8 and ::1 literals. */
+const LOOPBACK_NAMES = new Set(['localhost']);
+/** Upper bound on a buffered response body. Loopback control-plane bodies are small. */
+export const LOOPBACK_DEFAULT_MAX_BODY_BYTES = 16 * 1024 * 1024;
+/** Statuses a `Response` must be constructed with a null body for. */
+const NULL_BODY_STATUSES = new Set([101, 103, 204, 205, 304]);
+/** Thrown (synchronously surfaced as a rejection) for a URL that is not loopback HTTP. */
+export class LoopbackTargetRefusedError extends Error {
+    code = 'LOOPBACK_TARGET_REFUSED';
+    constructor(message) {
+        super(message);
+        this.name = 'LoopbackTargetRefusedError';
+    }
+}
+function stripBrackets(hostname) {
+    return hostname.startsWith('[') && hostname.endsWith(']') ? hostname.slice(1, -1) : hostname;
+}
+/** True for an IP literal in 127.0.0.0/8, `::1`, or an IPv4-mapped 127/8 address. */
+export function isLoopbackAddress(address) {
+    const value = stripBrackets(address.trim().toLowerCase());
+    if (net.isIPv4(value))
+        return value.split('.')[0] === '127';
+    if (net.isIPv6(value)) {
+        if (value === '::1' || value === '0:0:0:0:0:0:0:1')
+            return true;
+        // IPv4-mapped (::ffff:127.0.0.1, which WHATWG URL normalizes to ::ffff:7f00:1).
+        if (value.startsWith('::ffff:')) {
+            const rest = value.slice('::ffff:'.length);
+            if (net.isIPv4(rest))
+                return isLoopbackAddress(rest);
+            const high = /^([0-9a-f]{1,4}):[0-9a-f]{1,4}$/.exec(rest);
+            return high ? parseInt(high[1], 16) >> 8 === 127 : false;
+        }
+        return false;
+    }
+    return false;
+}
+/** True for a host name or address this client accepts as "this machine". */
+export function isLoopbackHostname(hostname) {
+    const value = stripBrackets(hostname.trim().toLowerCase());
+    return LOOPBACK_NAMES.has(value) || isLoopbackAddress(value);
+}
+/**
+ * Parse and validate a loopback HTTP URL. Throws {@link LoopbackTargetRefusedError}
+ * for anything that is not `http:` to a loopback host.
+ */
+export function assertLoopbackHttpUrl(input) {
+    let url;
+    try {
+        url = new URL(String(input));
+    }
+    catch {
+        throw new LoopbackTargetRefusedError('Loopback request refused: not a valid URL.');
+    }
+    if (url.protocol !== 'http:') {
+        throw new LoopbackTargetRefusedError(`Loopback request refused: only http: is allowed on loopback (got ${url.protocol}).`);
+    }
+    if (!isLoopbackHostname(url.hostname)) {
+        throw new LoopbackTargetRefusedError(`Loopback request refused: ${url.hostname} is not a loopback host.`);
+    }
+    if (url.username || url.password) {
+        throw new LoopbackTargetRefusedError('Loopback request refused: URL must not carry userinfo.');
+    }
+    return url;
+}
+/** A `dns.lookup` that only ever answers with a loopback address. */
+const loopbackOnlyLookup = (hostname, options, callback) => {
+    dns.lookup(hostname, { ...options, all: true }, (err, addresses) => {
+        if (err) {
+            callback(err, '', 0);
+            return;
+        }
+        const list = (Array.isArray(addresses) ? addresses : []);
+        const loopback = list.filter((entry) => isLoopbackAddress(entry.address));
+        if (loopback.length === 0) {
+            const refused = Object.assign(new Error(`${hostname} did not resolve to a loopback address`), { code: 'LOOPBACK_TARGET_REFUSED' });
+            callback(refused, '', 0);
+            return;
+        }
+        if (options?.all) {
+            callback(null, loopback);
+            return;
+        }
+        callback(null, loopback[0].address, loopback[0].family);
+    });
+};
+function abortReason(signal) {
+    return signal.reason !== undefined
+        ? signal.reason
+        : new DOMException('This operation was aborted', 'AbortError');
+}
+function fetchFailed(cause) {
+    return new TypeError('fetch failed', { cause });
+}
+function toBodyBuffer(body) {
+    if (body === undefined || body === null)
+        return null;
+    if (typeof body === 'string')
+        return Buffer.from(body, 'utf8');
+    if (body instanceof ArrayBuffer)
+        return Buffer.from(body);
+    if (ArrayBuffer.isView(body))
+        return Buffer.from(body.buffer, body.byteOffset, body.byteLength);
+    throw new TypeError('loopbackFetch supports only string or byte bodies');
+}
+/**
+ * `fetch` for a loopback URL, over `node:http`, never through a proxy.
+ * Refuses (rejects with {@link LoopbackTargetRefusedError}) any other target.
+ */
+export const loopbackFetch = (input, init = {}) => {
+    let url;
+    let payload;
+    try {
+        url = assertLoopbackHttpUrl(input);
+        payload = toBodyBuffer(init.body);
+    }
+    catch (err) {
+        return Promise.reject(err);
+    }
+    const signal = init.signal ?? undefined;
+    if (signal?.aborted)
+        return Promise.reject(abortReason(signal));
+    const maxBodyBytes = init.maxBodyBytes ?? LOOPBACK_DEFAULT_MAX_BODY_BYTES;
+    const method = (init.method ?? 'GET').toUpperCase();
+    const headers = {};
+    new Headers(init.headers ?? undefined).forEach((value, name) => {
+        headers[name] = value;
+    });
+    if (payload && headers['content-length'] === undefined) {
+        headers['content-length'] = String(payload.length);
+    }
+    return new Promise((resolve, reject) => {
+        let settled = false;
+        let req;
+        const onAbort = () => {
+            if (settled)
+                return;
+            settled = true;
+            req?.destroy();
+            reject(abortReason(signal));
+        };
+        const finish = (fn) => {
+            if (settled)
+                return;
+            settled = true;
+            signal?.removeEventListener('abort', onAbort);
+            fn();
+        };
+        signal?.addEventListener('abort', onAbort, { once: true });
+        try {
+            req = http.request({
+                protocol: 'http:',
+                host: stripBrackets(url.hostname),
+                port: url.port ? Number(url.port) : 80,
+                path: `${url.pathname}${url.search}`,
+                method,
+                headers,
+                // No pooled agent: a short-lived command must be able to exit as soon
+                // as it has its answer, and no socket outlives its request.
+                agent: false,
+                lookup: loopbackOnlyLookup,
+            }, (res) => {
+                const chunks = [];
+                let size = 0;
+                res.on('data', (chunk) => {
+                    size += chunk.length;
+                    if (size > maxBodyBytes) {
+                        res.destroy();
+                        finish(() => reject(fetchFailed(new Error(`response larger than ${maxBodyBytes} bytes`))));
+                        return;
+                    }
+                    chunks.push(chunk);
+                });
+                res.on('error', (err) => finish(() => reject(fetchFailed(err))));
+                res.on('aborted', () => finish(() => reject(fetchFailed(new Error('response aborted')))));
+                res.on('end', () => {
+                    finish(() => {
+                        const status = res.statusCode ?? 0;
+                        const responseHeaders = new Headers();
+                        for (const [name, value] of Object.entries(res.headers)) {
+                            if (value === undefined)
+                                continue;
+                            if (Array.isArray(value)) {
+                                for (const v of value)
+                                    responseHeaders.append(name, v);
+                            }
+                            else {
+                                responseHeaders.set(name, String(value));
+                            }
+                        }
+                        const body = NULL_BODY_STATUSES.has(status) ? null : Buffer.concat(chunks);
+                        try {
+                            resolve(new Response(body, {
+                                status,
+                                statusText: res.statusMessage ?? '',
+                                headers: responseHeaders,
+                            }));
+                        }
+                        catch (err) {
+                            reject(fetchFailed(err));
+                        }
+                    });
+                });
+            });
+            req.on('error', (err) => finish(() => reject(fetchFailed(err))));
+            if (payload)
+                req.write(payload);
+            req.end();
+        }
+        catch (err) {
+            finish(() => reject(fetchFailed(err)));
+        }
+    });
+};

package/dist/node_modules/@skrr-ai/auth-core/dist/esm/machineId.d.ts

@@ -10,8 +10,8 @@
  * with a real UUIDv7 downstream.
  *
  * The caller may pass `machineUuidFallback` to override the default
- * hostname+platform fingerprint with a richer detector (e.g. the
- * daemon's `getMachineUuid()` from `registry.ts`).
+ * hostname+platform fingerprint with a richer detector (e.g.
+ * `getMachineUuid()` from `machineUuid.ts`).
  */
 export declare function ensureMachineDaemonId(machineUuidFallback?: () => string): string;
 /**

package/dist/node_modules/@skrr-ai/auth-core/dist/esm/machineId.js

@@ -15,11 +15,13 @@
  *     directory survives), and a user whose machineUuid changes can
  *     still be re-anchored via the legacy-id list.
  *
- * Auth-core does NOT know about platform-level OS UUIDs (those still
- * live in `daemon/src/registry.ts::getMachineUuid()`). The fallback is
- * supplied by the consumer via the `machineUuidFallback` parameter so
- * a daemon can pass its richer detector while a CLI uses a hostname
- * fingerprint.
+ * This id is NOT the `machineUuid` the server keys Daemon rows on. That
+ * is the hardware id from `getMachineUuid()` (`machineUuid.ts`), and the
+ * two must never be substituted for each other on the wire: OSK-12063
+ * was the CLI sending this id as `machineUuid` on device-key enrollment,
+ * which matched no Daemon row and 404'd forever. The fallback used when
+ * this file cannot be persisted is supplied by the consumer via the
+ * `machineUuidFallback` parameter (the daemon passes `getMachineUuid`).
  */
 import crypto from 'node:crypto';
 import fs from 'node:fs';
@@ -100,9 +102,8 @@ function writeDaemonIdFile(target, id) {
  * SHA-256 of `os.hostname()` + `os.platform()` — better than just
  * hostname (includes platform) but worse than a true hardware UUID.
  *
- * The daemon overrides this with its richer detector
- * (`registry.ts::getMachineUuid()`) when available. The CLI today has
- * no native deps for OS UUIDs and so accepts this default.
+ * The daemon overrides this with the hardware detector
+ * (`getMachineUuid()`, `machineUuid.ts`).
  */
 function defaultMachineUuidFallback() {
     const host = os.hostname() || 'unknown-host';
@@ -121,8 +122,8 @@ function defaultMachineUuidFallback() {
  * with a real UUIDv7 downstream.
  *
  * The caller may pass `machineUuidFallback` to override the default
- * hostname+platform fingerprint with a richer detector (e.g. the
- * daemon's `getMachineUuid()` from `registry.ts`).
+ * hostname+platform fingerprint with a richer detector (e.g.
+ * `getMachineUuid()` from `machineUuid.ts`).
  */
 export function ensureMachineDaemonId(machineUuidFallback) {
     if (cachedStableDaemonId !== null)

package/dist/node_modules/@skrr-ai/auth-core/dist/esm/machineUuid.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Daemon sources whose identity is ISSUED by the control plane rather than
+ * derived from the host: the provisioner mints the daemon id and machine uuid
+ * before the daemon exists, and every binary on the runtime must use exactly
+ * those values.
+ *
+ * `dedicated-runtime` is here because the server's generation fence parses the
+ * lease generation out of the machine uuid (`dedicated-runtime:<lease>:<gen>`).
+ * A guest that fell back to `/etc/machine-id` would register under a uuid the
+ * fence cannot read, and every dispatch to it would be refused.
+ */
+export declare const HOSTED_RUNTIME_MACHINE_SOURCES: ReadonlySet<string>;
+/**
+ * The control-plane-issued value of `name` (e.g. `OVERSKY_MACHINE_UUID`), or
+ * null when this process is not on a hosted runtime or the value is absent /
+ * malformed. Only honoured under a hosted `OVERSKY_DAEMON_SOURCE`, so a stray
+ * variable on a laptop cannot rename the machine.
+ */
+export declare function hostedRuntimeIdOverride(name: string, env?: NodeJS.ProcessEnv): string | null;
+/**
+ * Return a stable, machine-scoped UUID. Cached for the process lifetime.
+ *
+ * Callers should treat this as opaque: the format differs per platform
+ * (macOS IOPlatformUUID, Linux systemd machine-id, Windows MachineGuid).
+ * The guarantee is only: same machine -> same value across reboots, and the
+ * same value from every binary that calls this function.
+ *
+ * On a hosted runtime the control-plane-issued `OVERSKY_MACHINE_UUID` wins.
+ *
+ * Falls back to a deterministic hostname+username hash if the platform
+ * probe fails. This preserves server-side record continuity even on
+ * locked-down machines that refuse ioreg / registry access.
+ */
+export declare function getMachineUuid(): string;
+/** @internal test seam — forget the cached value so the next call re-probes. */
+export declare function __resetMachineUuidCacheForTest(): void;

package/dist/node_modules/@skrr-ai/auth-core/dist/esm/machineUuid.js

@@ -0,0 +1,147 @@
+/**
+ * machineUuid.ts — the ONE hardware machine identity sent to the server as
+ * `machineUuid`, shared by the daemon and the CLI.
+ *
+ * Server Daemon rows are keyed on this value (daemon register, device-key
+ * enrollment, token mint, pairing), so every binary on one machine must
+ * compute it identically. Until OSK-12063 the CLI sent its own UUIDv7 from
+ * `~/.skrr/daemon.id` (`ensureMachineDaemonId()`, a DIFFERENT identity) as
+ * `machineUuid` on device-key enrollment while the daemon sent the hardware
+ * UUID computed here, so every CLI enrollment matched no Daemon row, got
+ * 404 DAEMON_NOT_FOUND and backed off forever. Two implementations of one
+ * identity can only agree by being edited together; this file is the one
+ * implementation, and `daemon/src/registry-lite.ts` re-exports it.
+ *
+ * Deliberately dependency-free (node builtins only) and exposed as the
+ * `@skrr-ai/auth-core/machine-uuid` subpath: the packaged desktop imports the
+ * daemon's `registry-lite.js` directly, and loading the full auth-core index
+ * there would drag in the credential stack for a one-function need.
+ *
+ * Not to be confused with `ensureMachineDaemonId()` (`machineId.ts`), the
+ * minted per-home-dir UUIDv7 that anchors the daemon's `stableDaemonId`. That
+ * one survives an OS reinstall; this one survives a home-dir wipe. They are
+ * different facts and neither may stand in for the other on the wire.
+ */
+import crypto from 'node:crypto';
+import fs from 'node:fs';
+import os from 'node:os';
+import { execFileSync } from 'node:child_process';
+/**
+ * Daemon sources whose identity is ISSUED by the control plane rather than
+ * derived from the host: the provisioner mints the daemon id and machine uuid
+ * before the daemon exists, and every binary on the runtime must use exactly
+ * those values.
+ *
+ * `dedicated-runtime` is here because the server's generation fence parses the
+ * lease generation out of the machine uuid (`dedicated-runtime:<lease>:<gen>`).
+ * A guest that fell back to `/etc/machine-id` would register under a uuid the
+ * fence cannot read, and every dispatch to it would be refused.
+ */
+export const HOSTED_RUNTIME_MACHINE_SOURCES = new Set([
+    'hosted-machine',
+    'cloud-coding',
+    'dedicated-runtime',
+]);
+const HOSTED_RUNTIME_ID_RE = /^[A-Za-z0-9_.:-]{1,160}$/;
+/**
+ * The control-plane-issued value of `name` (e.g. `OVERSKY_MACHINE_UUID`), or
+ * null when this process is not on a hosted runtime or the value is absent /
+ * malformed. Only honoured under a hosted `OVERSKY_DAEMON_SOURCE`, so a stray
+ * variable on a laptop cannot rename the machine.
+ */
+export function hostedRuntimeIdOverride(name, env = process.env) {
+    if (!HOSTED_RUNTIME_MACHINE_SOURCES.has(env.OVERSKY_DAEMON_SOURCE ?? '')) {
+        return null;
+    }
+    const value = env[name]?.trim();
+    if (!value || !HOSTED_RUNTIME_ID_RE.test(value))
+        return null;
+    return value;
+}
+let cachedMachineUuid = null;
+function readMachineUuidDarwin() {
+    try {
+        const out = execFileSync('ioreg', ['-rd1', '-c', 'IOPlatformExpertDevice'], {
+            encoding: 'utf-8',
+            timeout: 2_000,
+            stdio: ['ignore', 'pipe', 'ignore'],
+        });
+        const match = out.match(/IOPlatformUUID"?\s*=\s*"?([0-9A-F-]{36})/i);
+        return match ? match[1].toLowerCase() : null;
+    }
+    catch {
+        return null;
+    }
+}
+function readMachineUuidLinux() {
+    for (const p of ['/etc/machine-id', '/var/lib/dbus/machine-id']) {
+        try {
+            const raw = fs.readFileSync(p, 'utf-8').trim();
+            if (raw)
+                return raw.toLowerCase();
+        }
+        catch {
+            // Try the next candidate.
+        }
+    }
+    return null;
+}
+function readMachineUuidWindows() {
+    try {
+        const out = execFileSync('reg', ['query', 'HKLM\\SOFTWARE\\Microsoft\\Cryptography', '/v', 'MachineGuid'], { encoding: 'utf-8', timeout: 2_000, stdio: ['ignore', 'pipe', 'ignore'] });
+        const match = out.match(/MachineGuid\s+REG_SZ\s+([0-9A-Fa-f-]{36})/);
+        return match ? match[1].toLowerCase() : null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Return a stable, machine-scoped UUID. Cached for the process lifetime.
+ *
+ * Callers should treat this as opaque: the format differs per platform
+ * (macOS IOPlatformUUID, Linux systemd machine-id, Windows MachineGuid).
+ * The guarantee is only: same machine -> same value across reboots, and the
+ * same value from every binary that calls this function.
+ *
+ * On a hosted runtime the control-plane-issued `OVERSKY_MACHINE_UUID` wins.
+ *
+ * Falls back to a deterministic hostname+username hash if the platform
+ * probe fails. This preserves server-side record continuity even on
+ * locked-down machines that refuse ioreg / registry access.
+ */
+export function getMachineUuid() {
+    const hostedMachineUuid = hostedRuntimeIdOverride('OVERSKY_MACHINE_UUID');
+    if (hostedMachineUuid)
+        return hostedMachineUuid;
+    if (cachedMachineUuid !== null)
+        return cachedMachineUuid;
+    let detected = null;
+    switch (process.platform) {
+        case 'darwin':
+            detected = readMachineUuidDarwin();
+            break;
+        case 'linux':
+            detected = readMachineUuidLinux();
+            break;
+        case 'win32':
+            detected = readMachineUuidWindows();
+            break;
+    }
+    if (detected) {
+        cachedMachineUuid = detected;
+        return detected;
+    }
+    const fallback = 'fallback-' +
+        crypto
+            .createHash('sha256')
+            .update(`${os.hostname()}:${os.userInfo().username}`)
+            .digest('hex')
+            .slice(0, 32);
+    cachedMachineUuid = fallback;
+    return fallback;
+}
+/** @internal test seam — forget the cached value so the next call re-probes. */
+export function __resetMachineUuidCacheForTest() {
+    cachedMachineUuid = null;
+}

package/dist/node_modules/@skrr-ai/auth-core/dist/esm/messages.d.ts

@@ -1,4 +1,4 @@
-export type AuthFailureReason = 'REFRESH_INVALID' | 'REFRESH_REUSED' | 'REFRESH_EXPIRED' | 'SESSION_REVOKED' | 'TOKEN_EXPIRED' | 'TOKEN_INVALID' | 'UNKNOWN_401' | 'UNKNOWN';
+export type AuthFailureReason = 'REFRESH_INVALID' | 'REFRESH_REUSED' | 'REFRESH_EXPIRED' | 'SESSION_REVOKED' | 'DEVICE_KEY_MISMATCH' | 'TOKEN_EXPIRED' | 'TOKEN_INVALID' | 'UNKNOWN_401' | 'UNKNOWN';
 /**
  * The command that recovers this process from a re-auth latch.
  *
@@ -11,8 +11,13 @@ export type AuthFailureReason = 'REFRESH_INVALID' | 'REFRESH_REUSED' | 'REFRESH_
  * something the other did not describe (OSK-10224).
  *
  * The binary is whatever the consumer registered with
- * `configureAuthCore({ binaryName })` — the binary the user actually typed —
- * and `--device` is added only when there is no TTY to open a browser from.
+ * `configureAuthCore({ binaryName })` — the binary the user actually typed.
+ *
+ * No flag. This used to append `--device` whenever stdout was not a TTY, which
+ * is always true for a daemon under launchd/systemd — and neither `skrrd login`
+ * nor `skrr login` has a `--device` option, so the one command the latch line
+ * named failed with `unknown option '--device'` (OSK-12056). Both logins already
+ * fall back to a paste-a-code arm when no browser can be opened.
  */
 export declare function reauthCommand(): string;
 export declare function formatReauthMessage(reason: AuthFailureReason | string): string;

package/dist/node_modules/@skrr-ai/auth-core/dist/esm/messages.js

@@ -12,6 +12,7 @@ const REASON_HUMAN = {
     REFRESH_REUSED: 'Your session was ended for security reasons (token replay detected).',
     REFRESH_EXPIRED: 'Your session has expired.',
     SESSION_REVOKED: 'Your session was ended (you signed out elsewhere or your password changed).',
+    DEVICE_KEY_MISMATCH: "This computer's device key no longer matches the one skrr registered for it, so its session cannot be renewed.",
     TOKEN_EXPIRED: 'Your access token has expired.',
     TOKEN_INVALID: 'Your saved credentials are no longer valid.',
     UNKNOWN_401: 'skrr needs you to sign in again.',
@@ -29,12 +30,16 @@ const REASON_HUMAN = {
  * something the other did not describe (OSK-10224).
  *
  * The binary is whatever the consumer registered with
- * `configureAuthCore({ binaryName })` — the binary the user actually typed —
- * and `--device` is added only when there is no TTY to open a browser from.
+ * `configureAuthCore({ binaryName })` — the binary the user actually typed.
+ *
+ * No flag. This used to append `--device` whenever stdout was not a TTY, which
+ * is always true for a daemon under launchd/systemd — and neither `skrrd login`
+ * nor `skrr login` has a `--device` option, so the one command the latch line
+ * named failed with `unknown option '--device'` (OSK-12056). Both logins already
+ * fall back to a paste-a-code arm when no browser can be opened.
  */
 export function reauthCommand() {
-    const bin = getAuthBinaryName();
-    return process.stdout.isTTY ? `${bin} login` : `${bin} login --device`;
+    return `${getAuthBinaryName()} login`;
 }
 export function formatReauthMessage(reason) {
     const norm = REASON_HUMAN[reason] || REASON_HUMAN.UNKNOWN;

package/dist/node_modules/@skrr-ai/auth-core/dist/esm/refresh.d.ts

@@ -274,6 +274,14 @@ export declare function persistReauthState(state: ReauthState): void;
 export declare function needsReauthState(): {
     needed: boolean;
     reason?: string;
+    /**
+     * The server's own words for the refusal (`Refresh token bound to a different
+     * daemon`). The code alone collapses several distinct causes into one
+     * (`REFRESH_INVALID` is also "not recognized" and "issued without a
+     * daemonId"), and a surface that names only the code cannot tell the reader
+     * which one they hit (OSK-12116).
+     */
+    message?: string;
     since?: number;
 };
 export declare function clearReauthState(): void;

package/dist/node_modules/@skrr-ai/auth-core/dist/esm/refresh.js

@@ -25,6 +25,7 @@ import fs from 'node:fs';
 import path from 'node:path';
 import lockfile from 'proper-lockfile';
 import { getAuthLogger, getAuthConfigDir, emitAuthTelemetry, notifyResponseObserver, } from './runtime.js';
+import { permanentReasonForRefreshCode } from './refreshClassification.js';
 import { PermanentAuthFailure, TransientAuthFailure, } from './types.js';
 /**
  * P1-6: Reduced from 30 s to 5 s.
@@ -804,14 +805,12 @@ async function doRefresh(serverUrl, currentRefreshToken, daemonId, options = {})
         catch {
             /* ignore */
         }
-        const code = parsedBody.code;
-        const permanent = [
-            'REFRESH_INVALID',
-            'REFRESH_REUSED',
-            'REFRESH_EXPIRED',
-            'SESSION_REVOKED',
-        ];
-        if (code && permanent.includes(code)) {
+        // The server's code, mapped through the one table the stateless classifier
+        // reads too — so a permanent refusal that is not spelled as a reason name
+        // (DEVICE_PROOF_THUMBPRINT_MISMATCH) latches instead of riding the
+        // unknown-401 budget forever (OSK-12056).
+        const code = permanentReasonForRefreshCode(parsedBody.code);
+        if (code) {
             // A KNOWN credential-death code is genuinely permanent — latch
             // immediately, exactly as before. It is NOT routed through the
             // unknown-401 budget.
@@ -841,7 +840,7 @@ async function doRefresh(serverUrl, currentRefreshToken, daemonId, options = {})
         }
         // Unknown-shape 401 — unknown code, missing code, or unparseable body.
         // By construction this is NOT a daemon's actual refresh-family burn
-        // (those arrive as one of the four KNOWN codes above); it most likely
+        // (those arrive as one of the KNOWN codes above); it most likely
         // came from infra OverSky does not fully control — a proxy/middleware
         // regression, a clock-skew replay rejection (DEVICE_PROOF_REPLAYED),
         // or a half-rolled-out server route.
@@ -954,7 +953,14 @@ export function needsReauthState() {
             return { needed: false };
         const raw = fs.readFileSync(flagPath, 'utf-8');
         const state = JSON.parse(raw);
-        return { needed: true, reason: state.code, since: state.at };
+        return {
+            needed: true,
+            reason: state.code,
+            ...(typeof state.message === 'string' && state.message.length > 0
+                ? { message: state.message }
+                : {}),
+            since: state.at,
+        };
     }
     catch {
         return { needed: false };

package/dist/node_modules/@skrr-ai/auth-core/dist/esm/refreshClassification.d.ts

@@ -36,6 +36,12 @@ export interface ClassifiedRefreshFailure {
     failure: PermanentAuthFailure | TransientAuthFailure;
 }
 export type ClassifiedRefreshResult = ClassifiedRefreshSuccess | ClassifiedRefreshFailure;
+/**
+ * The permanent reason a 401 refresh refusal's `code` names, or `null` when the
+ * code is missing or unrecognised (an unknown-shape 401). The ONE mapping both
+ * this classifier and the daemon's `refresh.ts` read.
+ */
+export declare function permanentReasonForRefreshCode(code: string | undefined | null): PermanentAuthReason | null;
 /**
  * Classify an HTTP response from /api/auth/refresh (or /api/daemons/token/refresh)
  * into a discriminated union of success or failure.