@skrr-ai/cli 0.1.50 → 0.1.51

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/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

@@ -953,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/spawnEnv.d.ts

@@ -84,3 +84,25 @@ export declare const SENSITIVE_ENV_PREFIX_EXCEPTIONS: ReadonlySet<string>;
  * etc.) so legitimate tools keep working.
  */
 export declare function sanitizeSpawnEnv(env: NodeJS.ProcessEnv): NodeJS.ProcessEnv;
+/**
+ * OSK-12134 — loopback names a spawned child must reach directly, never through
+ * a proxy. A harness talks to this machine constantly: the daemon's local
+ * bridges (browser, delegated CLI, message intents), the inference broker, and
+ * the engine's own loopback services (skrr Code's `session/new` reaches a local
+ * directory service and failed with "service failure" behind a shell proxy).
+ */
+export declare const LOOPBACK_NO_PROXY_HOSTS: readonly string[];
+/** True when `env` names a proxy some client in the child might honour. */
+export declare function envHasProxy(env: Readonly<Record<string, string | undefined>>): boolean;
+/**
+ * Return `env` with the loopback hosts appended to BOTH `NO_PROXY` and
+ * `no_proxy`, when (and only when) it names a proxy. Tools disagree on which
+ * spelling they read and whether they fall back to the other, so an unset
+ * spelling is seeded from the other one before the hosts are appended —
+ * seeding only the hosts would silently drop every existing exemption for a
+ * tool that prefers the unset spelling. Existing entries keep their order.
+ *
+ * Exported for a parent that layers a proxy onto the child's env AFTER
+ * {@link sanitizeSpawnEnv}: call it again on the final map.
+ */
+export declare function withLoopbackNoProxy<T extends Record<string, string | undefined>>(env: T): T;

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

@@ -183,5 +183,62 @@ export function sanitizeSpawnEnv(env) {
             continue;
         out[key] = value;
     }
-    return out;
+    return withLoopbackNoProxy(out);
+}
+/**
+ * OSK-12134 — loopback names a spawned child must reach directly, never through
+ * a proxy. A harness talks to this machine constantly: the daemon's local
+ * bridges (browser, delegated CLI, message intents), the inference broker, and
+ * the engine's own loopback services (skrr Code's `session/new` reaches a local
+ * directory service and failed with "service failure" behind a shell proxy).
+ */
+export const LOOPBACK_NO_PROXY_HOSTS = ['127.0.0.1', 'localhost', '::1'];
+const PROXY_ENV_VARS = [
+    'HTTP_PROXY',
+    'http_proxy',
+    'HTTPS_PROXY',
+    'https_proxy',
+    'ALL_PROXY',
+    'all_proxy',
+];
+/** True when `env` names a proxy some client in the child might honour. */
+export function envHasProxy(env) {
+    return PROXY_ENV_VARS.some((name) => typeof env[name] === 'string' && env[name].trim() !== '');
+}
+function appendNoProxyHosts(list, hosts) {
+    const entries = list
+        .split(',')
+        .map((entry) => entry.trim().toLowerCase())
+        .filter(Boolean);
+    // `*` already exempts everything, and some clients honour it only as the
+    // entire value, so appending to it would break them.
+    if (entries.includes('*'))
+        return list;
+    const missing = hosts.filter((host) => !entries.includes(host));
+    if (missing.length === 0)
+        return list;
+    const kept = list.replace(/[\s,]+$/, '');
+    return kept ? `${kept},${missing.join(',')}` : missing.join(',');
+}
+/**
+ * Return `env` with the loopback hosts appended to BOTH `NO_PROXY` and
+ * `no_proxy`, when (and only when) it names a proxy. Tools disagree on which
+ * spelling they read and whether they fall back to the other, so an unset
+ * spelling is seeded from the other one before the hosts are appended —
+ * seeding only the hosts would silently drop every existing exemption for a
+ * tool that prefers the unset spelling. Existing entries keep their order.
+ *
+ * Exported for a parent that layers a proxy onto the child's env AFTER
+ * {@link sanitizeSpawnEnv}: call it again on the final map.
+ */
+export function withLoopbackNoProxy(env) {
+    if (!envHasProxy(env))
+        return env;
+    const upper = env.NO_PROXY?.trim() ? env.NO_PROXY : undefined;
+    const lower = env.no_proxy?.trim() ? env.no_proxy : undefined;
+    return {
+        ...env,
+        NO_PROXY: appendNoProxyHosts(upper ?? lower ?? '', LOOPBACK_NO_PROXY_HOSTS),
+        no_proxy: appendNoProxyHosts(lower ?? upper ?? '', LOOPBACK_NO_PROXY_HOSTS),
+    };
 }

package/dist/node_modules/@skrr-ai/auth-core/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@skrr-ai/auth-core",
-  "version": "0.4.4",
+  "version": "0.4.5",
   "main": "dist/cjs/index.js",
   "types": "dist/esm/index.d.ts",
   "exports": {
@@ -83,6 +83,26 @@
         "types": "./dist/cjs/cliHandoffWire.d.ts",
         "default": "./dist/cjs/cliHandoffWire.js"
       }
+    },
+    "./loopback-http": {
+      "import": {
+        "types": "./dist/esm/loopbackHttp.d.ts",
+        "default": "./dist/esm/loopbackHttp.js"
+      },
+      "require": {
+        "types": "./dist/cjs/loopbackHttp.d.ts",
+        "default": "./dist/cjs/loopbackHttp.js"
+      }
+    },
+    "./machine-uuid": {
+      "import": {
+        "types": "./dist/esm/machineUuid.d.ts",
+        "default": "./dist/esm/machineUuid.js"
+      },
+      "require": {
+        "types": "./dist/cjs/machineUuid.d.ts",
+        "default": "./dist/cjs/machineUuid.js"
+      }
     }
   },
   "dependencies": {