@skrr-ai/cli 0.1.89 → 0.1.90

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

@@ -0,0 +1,113 @@
+/**
+ * The Dedicated Runtime wake-progress wire contract (power-control task W5,
+ * `dedicated-runtime-power-and-demand-wake-2026-10-07.md` §5.3, §7.2, §9).
+ *
+ * Declared ONCE, here, for the same reason `computerWire.ts` is: the browser,
+ * the React Native app and the CLI import it, and none of them may spell the
+ * event, the capability or a code a second time. `dedicatedRuntimeWakeWire.test.ts`
+ * fails on a second spelling in the API.
+ *
+ * WHAT IT IS
+ * ---------------------------------------------------------------------------
+ * A person opens a terminal, an SSH channel, a service call or the Computer on a
+ * STOPPED Dedicated Runtime. That is wake progress, not an error: the relay asks
+ * `requestWake` (source `person`) to start the machine, then tells THAT request,
+ * in stages, how far the start has got, until the machine is assignable and the
+ * original request is served, or a bound runs out and it says why and what to do.
+ *
+ * THE CLIENT ANNOUNCES IT
+ * ---------------------------------------------------------------------------
+ * A client that has not announced `dedicated_wake_progress_v1` in the open
+ * request's `capabilities` array is NEVER sent `dedicated:wake:progress` and is
+ * never made to wait: it gets an immediate typed refusal instead. (A client
+ * socket has no registration step to announce on, so the announcement rides each
+ * request — stateless, nothing held in the relay.)
+ *
+ * THE VOCABULARY
+ * ---------------------------------------------------------------------------
+ * `phase` uses the cold-start measurement's phase names
+ * (`scripts/dedicated-runtime/measure-cold-start.js` `COLD_START_PHASES`), so
+ * what the person sees and what F4 measures are the same words. A spec holds the
+ * two lists equal.
+ *
+ * NOT A SPINNER WITHOUT A BOUND
+ * ---------------------------------------------------------------------------
+ * `boundMs` is carried on every event so a surface can show elapsed-of-bound.
+ * The bound sits ABOVE a slow-but-working start (design §9): running out says
+ * "this is taking longer than expected" and the machine is left starting; it is
+ * never an accusation that the machine is dead.
+ */
+/** API -> client, on the same socket as the request it belongs to. */
+export const DEDICATED_WAKE_EVENTS = {
+    progress: 'dedicated:wake:progress',
+};
+/** Announced in the open request's `capabilities` array. */
+export const DEDICATED_WAKE_CAPABILITIES = {
+    progress: 'dedicated_wake_progress_v1',
+};
+/** Same names, same order as `WAKE_PHASES` in api/server/services/DedicatedRuntime/wakePhases.js (pinned by a test). */
+export const DEDICATED_WAKE_PHASES = [
+    'start_requested',
+    'provider_start_accepted',
+    'instance_running',
+    'daemon_connected',
+    'first_heartbeat',
+    'assignable',
+];
+/**
+ * - `waking`    a start is in flight; `phase` says how far.
+ * - `ready`     assignable; the original request is about to be served.
+ * - `deferred`  the machine is stopping; nothing was started. Retry after `retryAfterSeconds`.
+ * - `refused`   the start was refused, with `code`, `reason`, `detail`, `fix`.
+ * - `timed_out` the bound ran out while it was still starting. Not a failure of the machine.
+ */
+export const DEDICATED_WAKE_STATES = [
+    'waking',
+    'ready',
+    'deferred',
+    'refused',
+    'timed_out',
+];
+/** The surfaces a wake can be asked from. */
+export const DEDICATED_WAKE_SURFACES = [
+    'terminal',
+    'ssh',
+    'services',
+    'templates',
+    'computer',
+    'http',
+];
+/**
+ * Typed refusals. Each is a different fact with a different next step; none of
+ * them is the generic "Dedicated Runtime dispatch was refused".
+ */
+export const DEDICATED_WAKE_CODES = {
+    /** Stopped, and this request did not (or could not) wake it. */
+    stopped: 'DEDICATED_RUNTIME_STOPPED',
+    /** A stop is finishing; retry when it has. */
+    stopping: 'DEDICATED_RUNTIME_STOPPING',
+    /** A start is in flight (ours or someone's). */
+    starting: 'DEDICATED_RUNTIME_STARTING',
+    /** The bound ran out while it was still starting. */
+    timeout: 'DEDICATED_RUNTIME_WAKE_TIMEOUT',
+    /** The start was refused: the plan no longer includes the machine. */
+    entitlement: 'DEDICATED_RUNTIME_WAKE_REFUSED_ENTITLEMENT',
+    /** The start was refused: the spend cap was reached. */
+    spendCap: 'DEDICATED_RUNTIME_WAKE_REFUSED_SPEND_CAP',
+    /** Any other refusal; `reason` names it. */
+    refused: 'DEDICATED_RUNTIME_WAKE_REFUSED',
+    /** The start was requested and the machine fell back to stopped or failed. */
+    failed: 'DEDICATED_RUNTIME_WAKE_FAILED',
+};
+/**
+ * How long a surface waits for a start before saying it is taking longer than
+ * expected. Above the slow-but-working case: a cold start on a fresh guest
+ * takes 25-30 s for the browser alone, and the AMI boot is longer. It is a
+ * bound on what we show, never a verdict on the machine.
+ */
+export const DEDICATED_WAKE_BOUND_MS = 180_000;
+/** How often the relay re-reads the lease while waiting. */
+export const DEDICATED_WAKE_POLL_MS = 2_000;
+export function clientAnnouncesWakeProgress(capabilities) {
+    return Array.isArray(capabilities) && capabilities.includes(DEDICATED_WAKE_CAPABILITIES.progress);
+}

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

@@ -30,7 +30,7 @@ export { buildProof as buildDeviceProof, generateDeviceKeyPair, jwkThumbprint, n
 export { DPOP_HEADER, DPOP_MAX_AGE_SECONDS, DPOP_PROOF_INVALID, DPOP_PROOF_REQUIRED, DPOP_PROOF_TYP, DPOP_PROOF_VERIFY_UNAVAILABLE, accessTokenHash, createDpopKey, isAth, isJwkThumbprint, normalizeDpopHtu, verifyDpopProof, type DpopKey, type DpopProofClaims, type DpopProofRequest, type DpopVerifyFailureReason, type DpopVerifyOptions, type DpopVerifyResult, } from './dpop.js';
 export { initCredEnvelope, resetCredEnvelope, shutdownCredEnvelope, isCredEnvelopeActive, hasCredEnvelopePathConflict, describeCredEnvelopeState, splitKeyConvergencePolicy, maybeEncryptForWrite, maybeDecryptOnRead, DEFAULT_UNREADABLE_CREDENTIAL_HINT, type DecryptOnReadOptions, __wrappedDekFilePathForTest, __setStateForTest as __setCredEnvelopeStateForTest, __getStateForTest as __getCredEnvelopeStateForTest, __resetShutdownGuardForTest, type ReadTransformResult, } from './credentialEnvelopeBridge.js';
 export { initDeviceIdentity, resetDeviceIdentity, signServerRequest, enrollWithServer, clearEnrollmentMarker, isDeviceIdentityActive, getDevicePublicKey, describeDeviceIdentityState, describeDeviceKeySplit, __publicKeyPathForTest, __privateKeyPathForTest, __enrollmentMarkerPathForTest, __enrollmentBackoffPathForTest, __setStateForTest as __setDeviceIdentityStateForTest, __getStateForTest as __getDeviceIdentityStateForTest, type EnrollmentResult, } from './deviceIdentityBridge.js';
-export { getMachineUuid, hostedRuntimeIdOverride, HOSTED_RUNTIME_MACHINE_SOURCES, __resetMachineUuidCacheForTest, } from './machineUuid.js';
+export { getMachineUuid, getHardwareMachineUuid, setMachineUuidProfile, getMachineUuidProfile, qualifyMachineUuid, MACHINE_IDENTITY_FILENAME, hostedRuntimeIdOverride, HOSTED_RUNTIME_MACHINE_SOURCES, __resetMachineUuidCacheForTest, } from './machineUuid.js';
 export { ensureMachineDaemonId, legacyDaemonUuids, __resetCachedDaemonIdForTest, } from './machineId.js';
 export { PAIR_AAD_PREFIX, PAIR_AAD_MAX_LEN, PAIR_BUNDLE_MAX_BASE64_LEN, PAIR_NONCE_LEN, PAIR_PUBKEY_LEN, PAIR_SECRET_LEN, PairBundleError, assemblePairBundleBase64, base64ToUint8Array as pairBase64ToUint8Array, base64UrlToUint8Array as pairBase64UrlToUint8Array, buildPairAad, buildPairUrl, generatePairKeyPair, openPairBundleBase64, parsePairBundle, parsePairPlaintext, parsePairUrl, uint8ArrayToBase64 as pairUint8ArrayToBase64, uint8ArrayToBase64Url as pairUint8ArrayToBase64Url, type AssembleBundleOptions as PairAssembleBundleOptions, type OpenBundleOptions as PairOpenBundleOptions, type PairBundle, type PairBundleErrorCode, type PairKeyPair, type PairPlaintextV1, type PairUrlFields, } from './daemonPair.js';
 export { HARNESS_TIERS, getHarnessTier, credentialPolicyForTier, tierPermitsConfiguredAutoMode, type HarnessTrustTier, type CredentialDeliveryPolicy, type CredentialMode, } from './harnessTrust.js';

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

@@ -125,7 +125,7 @@ __publicKeyPathForTest, __privateKeyPathForTest, __enrollmentMarkerPathForTest,
 // Hardware machine identity sent as `machineUuid` (IOPlatformUUID /
 // machine-id / MachineGuid). ONE implementation for daemon and CLI —
 // OSK-12063. Also exposed dependency-free as `@skrr-ai/auth-core/machine-uuid`.
-export { getMachineUuid, hostedRuntimeIdOverride, HOSTED_RUNTIME_MACHINE_SOURCES, __resetMachineUuidCacheForTest, } from './machineUuid.js';
+export { getMachineUuid, getHardwareMachineUuid, setMachineUuidProfile, getMachineUuidProfile, qualifyMachineUuid, MACHINE_IDENTITY_FILENAME, hostedRuntimeIdOverride, HOSTED_RUNTIME_MACHINE_SOURCES, __resetMachineUuidCacheForTest, } from './machineUuid.js';
 // Stable per-machine UUIDv7 identity persisted at <configDir>/daemon.id.
 // NOT a `machineUuid` — see machineUuid.ts.
 export { ensureMachineDaemonId, legacyDaemonUuids, __resetCachedDaemonIdForTest, } from './machineId.js';

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

@@ -18,19 +18,43 @@ export declare const HOSTED_RUNTIME_MACHINE_SOURCES: ReadonlySet<string>;
  */
 export declare function hostedRuntimeIdOverride(name: string, env?: NodeJS.ProcessEnv): string | null;
 /**
- * Return a stable, machine-scoped UUID. Cached for the process lifetime.
+ * The HARDWARE identity of this machine (IOPlatformUUID / machine-id /
+ * MachineGuid, or a control-plane-issued value on a hosted runtime). Cached for
+ * the process lifetime. Same machine -> same value across reboots.
  *
- * 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.
+ * Almost nothing should call this: `getMachineUuid()` is what goes on the wire,
+ * and it equals this for the default profile.
  *
  * 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 getHardwareMachineUuid(): string;
+/** The profile's persisted machine-identity choice, beside its other state. */
+export declare const MACHINE_IDENTITY_FILENAME = "machine-identity.json";
+/** The server caps `machineUuid` at 64 characters; 36 + 15 fits, and so does a 41-character fallback. */
+export declare function qualifyMachineUuid(hardware: string, profile: string): string;
+/**
+ * Tell this module which profile the process runs as. Called wherever a binary
+ * resolves its profile (`setActiveProfile` in the daemon and in the CLI), so the
+ * identity cannot depend on call order. `null`, '' and the default profile all
+ * mean "the hardware identity".
+ */
+export declare function setMachineUuidProfile(profile: string | null | undefined): void;
+export declare function getMachineUuidProfile(): string | null;
+/**
+ * Return the `machineUuid` this process sends to the server.
+ *
+ * Callers should treat this as opaque: the format differs per platform
+ * (macOS IOPlatformUUID, Linux systemd machine-id, Windows MachineGuid), and a
+ * non-default profile that started new carries a `:p-<hash>` suffix. The
+ * guarantee is only: same machine + same profile -> same value across reboots,
+ * and the same value from every binary of that profile that calls this function.
+ *
+ * Equals the hardware identity for the default profile, for a hosted runtime
+ * (the control-plane-issued `OVERSKY_MACHINE_UUID` wins) and for a non-default
+ * profile that already held credentials; see the block above.
+ */
 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

@@ -25,7 +25,9 @@
 import crypto from 'node:crypto';
 import fs from 'node:fs';
 import os from 'node:os';
+import path from 'node:path';
 import { execFileSync } from 'node:child_process';
+import { resolveConfigRoot } from './configRoot.js';
 /**
  * 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
@@ -97,20 +99,18 @@ function readMachineUuidWindows() {
     }
 }
 /**
- * Return a stable, machine-scoped UUID. Cached for the process lifetime.
+ * The HARDWARE identity of this machine (IOPlatformUUID / machine-id /
+ * MachineGuid, or a control-plane-issued value on a hosted runtime). Cached for
+ * the process lifetime. Same machine -> same value across reboots.
  *
- * 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.
+ * Almost nothing should call this: `getMachineUuid()` is what goes on the wire,
+ * and it equals this for the default profile.
  *
  * 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() {
+export function getHardwareMachineUuid() {
     const hostedMachineUuid = hostedRuntimeIdOverride('OVERSKY_MACHINE_UUID');
     if (hostedMachineUuid)
         return hostedMachineUuid;
@@ -141,7 +141,143 @@ export function getMachineUuid() {
     cachedMachineUuid = fallback;
     return fallback;
 }
+// ---------------------------------------------------------------------------
+// Profile-qualified machine identity (OSK-13845)
+//
+// The server keys a Daemon row on (user, machineUuid), pins ONE device key to
+// that row, and groups Harness rows into one "machine" by it. A profile is the
+// documented way to run a second, isolated daemon on the same computer, and
+// while the machineUuid was hardware only a second profile landed on the FIRST
+// profile's row: it replaced the machine page's Daemon and working directory,
+// re-registered every harness under itself, and its interactive login re-pinned
+// the row's device key (OSK-12063), so the default profile's next refresh was
+// refused DEVICE_KEY_MISMATCH and every `skrr` call failed until a re-login.
+//
+// So a profile that STARTS NEW on a machine is qualified:
+// `<hardware>:p-<12 hex of sha256(profile)>`. Two rules keep everything that
+// exists where it is:
+//
+//   - the default profile is NEVER qualified: its identity is the hardware value
+//     it has always had, so no existing machine row changes;
+//   - a non-default profile that already holds credentials (an
+//     `auth-binding.json` or a persisted daemon identity) keeps the hardware
+//     value. Its refresh tokens are bound to that row and the server refuses a
+//     refresh whose machineUuid differs from the stored one (H7), so qualifying
+//     it would sign it out. It stays a second daemon on the shared row.
+//
+// The choice is made ONCE, from that evidence, and written to the profile's
+// `machine-identity.json`; afterwards it is read, never re-derived. Deriving it
+// every time would flip a profile from qualified to shared the moment its own
+// first login wrote `auth-binding.json`.
+// ---------------------------------------------------------------------------
+/** The profile's persisted machine-identity choice, beside its other state. */
+export const MACHINE_IDENTITY_FILENAME = 'machine-identity.json';
+/** Files that prove a profile already holds credentials bound to the shared row. */
+const PRE_EXISTING_PROFILE_EVIDENCE = ['auth-binding.json', 'daemon-identity.json'];
+const DEFAULT_PROFILE_NAME = 'default';
+/** The server caps `machineUuid` at 64 characters; 36 + 15 fits, and so does a 41-character fallback. */
+export function qualifyMachineUuid(hardware, profile) {
+    const digest = crypto
+        .createHash('sha256')
+        .update(`profile:${profile}`)
+        .digest('hex')
+        .slice(0, 12);
+    return `${hardware}:p-${digest}`;
+}
+let activeMachineProfile = null;
+const profileChoiceCache = new Map();
+/**
+ * Tell this module which profile the process runs as. Called wherever a binary
+ * resolves its profile (`setActiveProfile` in the daemon and in the CLI), so the
+ * identity cannot depend on call order. `null`, '' and the default profile all
+ * mean "the hardware identity".
+ */
+export function setMachineUuidProfile(profile) {
+    activeMachineProfile = typeof profile === 'string' && profile.trim() ? profile.trim() : null;
+}
+export function getMachineUuidProfile() {
+    return activeMachineProfile;
+}
+function readPersistedChoice(file, hardware, profile) {
+    try {
+        const parsed = JSON.parse(fs.readFileSync(file, 'utf-8'));
+        // A file from another machine (a restored backup, a synced home) is absent.
+        if (parsed?.version !== 1 || parsed.hardware !== hardware)
+            return null;
+        // Only the two values this module can produce are accepted: a hand-edited or
+        // foreign string must never become an identity.
+        if (parsed.machineUuid === hardware)
+            return hardware;
+        const qualified = qualifyMachineUuid(hardware, profile);
+        return parsed.machineUuid === qualified ? qualified : null;
+    }
+    catch {
+        return null;
+    }
+}
+function persistChoice(dir, file, hardware, machineUuid, reason) {
+    try {
+        fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+        const tmp = `${file}.${process.pid}.${Date.now()}.tmp`;
+        const body = { version: 1, hardware, machineUuid, reason, decidedAt: new Date().toISOString() };
+        fs.writeFileSync(tmp, `${JSON.stringify(body)}\n`, { mode: 0o600 });
+        fs.renameSync(tmp, file);
+    }
+    catch {
+        // Not persisted: the in-process cache keeps this process consistent, and the
+        // next process decides again from the same evidence.
+    }
+}
+/** The identity a NON-default profile registers under. Never throws. */
+function resolveProfileMachineUuid(profile, hardware) {
+    const cacheKey = `${hardware}\u0000${profile}`;
+    const cached = profileChoiceCache.get(cacheKey);
+    if (cached)
+        return cached;
+    const dir = path.join(resolveConfigRoot(), 'profiles', profile);
+    const file = path.join(dir, MACHINE_IDENTITY_FILENAME);
+    let chosen = readPersistedChoice(file, hardware, profile);
+    if (!chosen) {
+        const preExisting = PRE_EXISTING_PROFILE_EVIDENCE.some((name) => {
+            try {
+                return fs.existsSync(path.join(dir, name));
+            }
+            catch {
+                return false;
+            }
+        });
+        chosen = preExisting ? hardware : qualifyMachineUuid(hardware, profile);
+        persistChoice(dir, file, hardware, chosen, preExisting ? 'pre_existing_profile' : 'new_profile');
+    }
+    profileChoiceCache.set(cacheKey, chosen);
+    return chosen;
+}
+/**
+ * Return the `machineUuid` this process sends to the server.
+ *
+ * Callers should treat this as opaque: the format differs per platform
+ * (macOS IOPlatformUUID, Linux systemd machine-id, Windows MachineGuid), and a
+ * non-default profile that started new carries a `:p-<hash>` suffix. The
+ * guarantee is only: same machine + same profile -> same value across reboots,
+ * and the same value from every binary of that profile that calls this function.
+ *
+ * Equals the hardware identity for the default profile, for a hosted runtime
+ * (the control-plane-issued `OVERSKY_MACHINE_UUID` wins) and for a non-default
+ * profile that already held credentials; see the block above.
+ */
+export function getMachineUuid() {
+    const hardware = getHardwareMachineUuid();
+    // A hosted runtime's identity is ISSUED and fenced by the control plane.
+    if (hostedRuntimeIdOverride('OVERSKY_MACHINE_UUID'))
+        return hardware;
+    const profile = activeMachineProfile;
+    if (!profile || profile === DEFAULT_PROFILE_NAME)
+        return hardware;
+    return resolveProfileMachineUuid(profile, hardware);
+}
 /** @internal test seam — forget the cached value so the next call re-probes. */
 export function __resetMachineUuidCacheForTest() {
     cachedMachineUuid = null;
+    activeMachineProfile = null;
+    profileChoiceCache.clear();
 }

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

@@ -1,6 +1,6 @@
 {
   "name": "@skrr-ai/auth-core",
-  "version": "0.4.15",
+  "version": "0.4.16",
   "main": "dist/cjs/index.js",
   "types": "dist/esm/index.d.ts",
   "exports": {
@@ -84,6 +84,16 @@
         "default": "./dist/cjs/cliHandoffWire.js"
       }
     },
+    "./dedicated-runtime-busy-wire": {
+      "import": {
+        "types": "./dist/esm/dedicatedRuntimeBusyWire.d.ts",
+        "default": "./dist/esm/dedicatedRuntimeBusyWire.js"
+      },
+      "require": {
+        "types": "./dist/cjs/dedicatedRuntimeBusyWire.d.ts",
+        "default": "./dist/cjs/dedicatedRuntimeBusyWire.js"
+      }
+    },
     "./computer-wire": {
       "import": {
         "types": "./dist/esm/computerWire.d.ts",
@@ -113,6 +123,16 @@
         "types": "./dist/cjs/machineUuid.d.ts",
         "default": "./dist/cjs/machineUuid.js"
       }
+    },
+    "./dedicated-runtime-wake-wire": {
+      "import": {
+        "types": "./dist/esm/dedicatedRuntimeWakeWire.d.ts",
+        "default": "./dist/esm/dedicatedRuntimeWakeWire.js"
+      },
+      "require": {
+        "types": "./dist/cjs/dedicatedRuntimeWakeWire.d.ts",
+        "default": "./dist/cjs/dedicatedRuntimeWakeWire.js"
+      }
     }
   },
   "dependencies": {