@skrr-ai/cli 0.1.119 → 0.1.121

package/dist/node_modules/@skrr-ai/auth-core/dist/cjs/independentMachineReservation.d.ts

@@ -0,0 +1,27 @@
+/** The desktop reserves a new profile for every background authorization. */
+export declare const INDEPENDENT_MACHINE_PROFILE_RE: RegExp;
+export declare const INDEPENDENT_MACHINE_RESERVATION_FILE = "independent-machine-attempt.json";
+export interface IndependentMachineReservation {
+    version: 2;
+    profile: string;
+    ownerId: string;
+    origin: string;
+    secretHash: string;
+    encryptedSecret: string;
+    createdAt: string;
+}
+/** Reserve a previously absent profile and persist the encrypted attempt secret.
+ * `encrypt` must use the platform secure store and throw if it is unavailable. */
+export declare function reserveIndependentMachineProfile(options: {
+    root: string;
+    ownerId: string;
+    origin: string;
+    encrypt: (secret: string) => Buffer;
+}): {
+    reservation: IndependentMachineReservation;
+    secret: string;
+};
+/** A saved reservation is a selection hint, never proof of machine ownership. */
+export declare function readIndependentMachineReservation(root: string, profile: string): IndependentMachineReservation | null;
+/** Confirm a one-shot signer is acting on the desktop's reserved attempt. */
+export declare function verifyIndependentMachineReservation(root: string, profile: string, secret: unknown): boolean;

package/dist/node_modules/@skrr-ai/auth-core/dist/cjs/independentMachineReservation.js

@@ -0,0 +1,161 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var independentMachineReservation_exports = {};
+__export(independentMachineReservation_exports, {
+  INDEPENDENT_MACHINE_PROFILE_RE: () => INDEPENDENT_MACHINE_PROFILE_RE,
+  INDEPENDENT_MACHINE_RESERVATION_FILE: () => INDEPENDENT_MACHINE_RESERVATION_FILE,
+  readIndependentMachineReservation: () => readIndependentMachineReservation,
+  reserveIndependentMachineProfile: () => reserveIndependentMachineProfile,
+  verifyIndependentMachineReservation: () => verifyIndependentMachineReservation
+});
+module.exports = __toCommonJS(independentMachineReservation_exports);
+var import_node_crypto = __toESM(require("node:crypto"), 1);
+var import_node_fs = __toESM(require("node:fs"), 1);
+var import_node_path = __toESM(require("node:path"), 1);
+const INDEPENDENT_MACHINE_PROFILE_RE = /^desktop-bg-[a-f0-9]{32}$/;
+const INDEPENDENT_MACHINE_RESERVATION_FILE = "independent-machine-attempt.json";
+function canonicalOrigin(input) {
+  try {
+    const url = new URL(input);
+    const local = ["localhost", "127.0.0.1", "[::1]"].includes(url.hostname);
+    return !url.username && !url.password && url.origin === input && (url.protocol === "https:" || url.protocol === "http:" && local);
+  } catch {
+    return false;
+  }
+}
+function validSecret(secret) {
+  return typeof secret === "string" && /^[A-Za-z0-9_-]{43}$/.test(secret) && Buffer.from(secret, "base64url").length === 32 && Buffer.from(secret, "base64url").toString("base64url") === secret;
+}
+function hashSecret(profile, ownerId, origin, secret) {
+  return import_node_crypto.default.createHash("sha256").update("independent-machine-reservation:v2\0").update(profile).update("\0").update(ownerId).update("\0").update(origin).update("\0").update(secret).digest();
+}
+function reservationPath(root, profile) {
+  if (!import_node_path.default.isAbsolute(root) || !INDEPENDENT_MACHINE_PROFILE_RE.test(profile)) {
+    throw new Error("Invalid independent machine profile");
+  }
+  return import_node_path.default.join(root, "profiles", profile, INDEPENDENT_MACHINE_RESERVATION_FILE);
+}
+function reserveIndependentMachineProfile(options) {
+  if (!import_node_path.default.isAbsolute(options.root) || !/^[a-fA-F0-9]{24}$/.test(options.ownerId) || !canonicalOrigin(options.origin))
+    throw new Error("Invalid background authorization context");
+  const secret = import_node_crypto.default.randomBytes(32).toString("base64url");
+  const encrypted = options.encrypt(secret);
+  if (!Buffer.isBuffer(encrypted) || encrypted.length === 0 || encrypted.length > 4096) {
+    throw new Error("Background authorization secure storage is unavailable");
+  }
+  const profiles = import_node_path.default.join(options.root, "profiles");
+  const rootExisted = import_node_fs.default.existsSync(options.root);
+  const profilesExisted = import_node_fs.default.existsSync(profiles);
+  import_node_fs.default.mkdirSync(profiles, { recursive: true, mode: 448 });
+  for (let i = 0; i < 5; i += 1) {
+    const profile = `desktop-bg-${import_node_crypto.default.randomBytes(16).toString("hex")}`;
+    const dir = import_node_path.default.join(profiles, profile);
+    try {
+      import_node_fs.default.mkdirSync(dir, { mode: 448 });
+    } catch (error) {
+      if (error.code === "EEXIST")
+        continue;
+      throw error;
+    }
+    const reservation = {
+      version: 2,
+      profile,
+      ownerId: options.ownerId.toLowerCase(),
+      origin: options.origin,
+      secretHash: hashSecret(profile, options.ownerId.toLowerCase(), options.origin, secret).toString("hex"),
+      encryptedSecret: encrypted.toString("base64"),
+      createdAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    const file = reservationPath(options.root, profile);
+    const fd = import_node_fs.default.openSync(file, import_node_fs.default.constants.O_WRONLY | import_node_fs.default.constants.O_CREAT | import_node_fs.default.constants.O_EXCL | (import_node_fs.default.constants.O_NOFOLLOW ?? 0), 384);
+    try {
+      import_node_fs.default.writeFileSync(fd, `${JSON.stringify(reservation)}
+`, "utf8");
+      import_node_fs.default.fsyncSync(fd);
+    } finally {
+      import_node_fs.default.closeSync(fd);
+    }
+    const directories = [
+      dir,
+      profiles,
+      ...!profilesExisted ? [options.root] : [],
+      ...!rootExisted ? [import_node_path.default.dirname(options.root)] : []
+    ];
+    for (const directory of directories) {
+      const directoryFd = import_node_fs.default.openSync(directory, "r");
+      try {
+        import_node_fs.default.fsyncSync(directoryFd);
+      } finally {
+        import_node_fs.default.closeSync(directoryFd);
+      }
+    }
+    return { reservation, secret };
+  }
+  throw new Error("Could not reserve a new background machine profile");
+}
+function readIndependentMachineReservation(root, profile) {
+  try {
+    const file = reservationPath(root, profile);
+    const directory = import_node_fs.default.lstatSync(import_node_path.default.dirname(file));
+    if (!directory.isDirectory() || directory.isSymbolicLink())
+      return null;
+    const fd = import_node_fs.default.openSync(file, import_node_fs.default.constants.O_RDONLY | (import_node_fs.default.constants.O_NOFOLLOW ?? 0));
+    let raw;
+    try {
+      const stat = import_node_fs.default.fstatSync(fd);
+      if (!stat.isFile() || stat.nlink !== 1 || stat.size > 8192 || (stat.mode & 63) !== 0)
+        return null;
+      raw = import_node_fs.default.readFileSync(fd, "utf8");
+    } finally {
+      import_node_fs.default.closeSync(fd);
+    }
+    const value = JSON.parse(raw);
+    if (value.version !== 2 || value.profile !== profile || typeof value.ownerId !== "string" || !/^[a-f0-9]{24}$/.test(value.ownerId) || typeof value.origin !== "string" || !canonicalOrigin(value.origin) || typeof value.secretHash !== "string" || !/^[a-f0-9]{64}$/.test(value.secretHash) || typeof value.encryptedSecret !== "string" || !/^[A-Za-z0-9+/]+={0,2}$/.test(value.encryptedSecret) || typeof value.createdAt !== "string" || !Number.isFinite(Date.parse(value.createdAt)))
+      return null;
+    return value;
+  } catch {
+    return null;
+  }
+}
+function verifyIndependentMachineReservation(root, profile, secret) {
+  if (!validSecret(secret))
+    return false;
+  const saved = readIndependentMachineReservation(root, profile);
+  if (!saved)
+    return false;
+  return import_node_crypto.default.timingSafeEqual(Buffer.from(saved.secretHash, "hex"), hashSecret(profile, saved.ownerId, saved.origin, secret));
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  INDEPENDENT_MACHINE_PROFILE_RE,
+  INDEPENDENT_MACHINE_RESERVATION_FILE,
+  readIndependentMachineReservation,
+  reserveIndependentMachineProfile,
+  verifyIndependentMachineReservation
+});

package/dist/node_modules/@skrr-ai/auth-core/dist/cjs/independentMachineScopes.d.ts

@@ -0,0 +1,26 @@
+/**
+ * The capabilities explained to a person before a separate background
+ * machine is authorized. This version is an immutable wire contract: adding
+ * access needs a new contract and a new authorization, not an edit to v1.
+ */
+export declare const INDEPENDENT_MACHINE_SCOPE_CONTRACT_V1: "desktop-background-v1";
+export declare const INDEPENDENT_MACHINE_PERMISSIONS_V1: readonly [Readonly<{
+    scope: "daemon:tools:bash";
+    description: "Run terminal commands and local agents";
+}>, Readonly<{
+    scope: "daemon:tools:fs:read";
+    description: "Read files in allowed folders";
+}>, Readonly<{
+    scope: "daemon:tools:fs:write";
+    description: "Create and edit files in allowed folders";
+}>, Readonly<{
+    scope: "daemon:browser:cdp";
+    description: "Control connected browser tabs";
+}>, Readonly<{
+    scope: "daemon:session:replay";
+    description: "Replay results recorded while offline";
+}>, Readonly<{
+    scope: "daemon:offline-queue";
+    description: "Send queued results after reconnecting";
+}>];
+export declare const INDEPENDENT_MACHINE_SCOPES_V1: readonly string[];

package/dist/node_modules/@skrr-ai/auth-core/dist/cjs/independentMachineScopes.js

@@ -0,0 +1,41 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var independentMachineScopes_exports = {};
+__export(independentMachineScopes_exports, {
+  INDEPENDENT_MACHINE_PERMISSIONS_V1: () => INDEPENDENT_MACHINE_PERMISSIONS_V1,
+  INDEPENDENT_MACHINE_SCOPES_V1: () => INDEPENDENT_MACHINE_SCOPES_V1,
+  INDEPENDENT_MACHINE_SCOPE_CONTRACT_V1: () => INDEPENDENT_MACHINE_SCOPE_CONTRACT_V1
+});
+module.exports = __toCommonJS(independentMachineScopes_exports);
+const INDEPENDENT_MACHINE_SCOPE_CONTRACT_V1 = "desktop-background-v1";
+const INDEPENDENT_MACHINE_PERMISSIONS_V1 = Object.freeze([
+  Object.freeze({ scope: "daemon:tools:bash", description: "Run terminal commands and local agents" }),
+  Object.freeze({ scope: "daemon:tools:fs:read", description: "Read files in allowed folders" }),
+  Object.freeze({ scope: "daemon:tools:fs:write", description: "Create and edit files in allowed folders" }),
+  Object.freeze({ scope: "daemon:browser:cdp", description: "Control connected browser tabs" }),
+  Object.freeze({ scope: "daemon:session:replay", description: "Replay results recorded while offline" }),
+  Object.freeze({ scope: "daemon:offline-queue", description: "Send queued results after reconnecting" })
+]);
+const INDEPENDENT_MACHINE_SCOPES_V1 = Object.freeze(INDEPENDENT_MACHINE_PERMISSIONS_V1.map((permission) => permission.scope));
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  INDEPENDENT_MACHINE_PERMISSIONS_V1,
+  INDEPENDENT_MACHINE_SCOPES_V1,
+  INDEPENDENT_MACHINE_SCOPE_CONTRACT_V1
+});

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

@@ -28,7 +28,7 @@ export { buildCredentialAad, decrypt as credEnvelopeDecrypt, deserialize as cred
 export { __setKekStrategyForTest, getKekStrategy, InMemoryKek, UnavailableKek, KekUnavailableError, LinuxKek, MacosKek, registerZeroizeHook, WindowsKek, zeroizeKekCaches, type KekStrategy, } from './kek/index.js';
 export { buildProof as buildDeviceProof, generateDeviceKeyPair, jwkThumbprint, normalizeHtu, publicJwkFromX, tokenHash, verifyProof as verifyDeviceProof, type DeviceKeyPair, type DeviceProofClaims, type DeviceProofHeader, type Ed25519PrivateJwk, type Ed25519PublicJwk, type VerifyFailureReason as DeviceProofVerifyFailureReason, type VerifyFailure as DeviceProofVerifyFailure, type VerifyOptions as DeviceProofVerifyOptions, type VerifySuccess as DeviceProofVerifySuccess, } from './deviceKey.js';
 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 { initCredEnvelope, initExistingCredEnvelope, initNewIndependentCredEnvelope, 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, getMachineUuidForProfile, describeMachineIdentity, type MachineIdentityDescription, type MachineIdentityReason, getHardwareMachineUuid, setMachineUuidProfile, getMachineUuidProfile, qualifyMachineUuid, MACHINE_IDENTITY_FILENAME, hostedRuntimeIdOverride, HOSTED_RUNTIME_MACHINE_SOURCES, __resetMachineUuidCacheForTest, } from './machineUuid.js';
 export { ensureMachineDaemonId, legacyDaemonUuids, __resetCachedDaemonIdForTest, } from './machineId.js';
@@ -50,3 +50,4 @@ export * from './harnessPermissionControls.js';
 export { compareReleaseVersions } from './releaseVersions.js';
 export * from './computerUse.js';
 export * from './desktopWire.js';
+export { INDEPENDENT_MACHINE_PROFILE_RE, INDEPENDENT_MACHINE_RESERVATION_FILE, readIndependentMachineReservation, reserveIndependentMachineProfile, verifyIndependentMachineReservation, type IndependentMachineReservation, } from './independentMachineReservation.js';

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

@@ -47,6 +47,8 @@ __export(index_exports, {
   HARNESSES_LOADING_CLAUDE_SKILLS_LAYOUT: () => import_harnessSkillLayout.HARNESSES_LOADING_CLAUDE_SKILLS_LAYOUT,
   HARNESS_TIERS: () => import_harnessTrust.HARNESS_TIERS,
   HOSTED_RUNTIME_MACHINE_SOURCES: () => import_machineUuid.HOSTED_RUNTIME_MACHINE_SOURCES,
+  INDEPENDENT_MACHINE_PROFILE_RE: () => import_independentMachineReservation.INDEPENDENT_MACHINE_PROFILE_RE,
+  INDEPENDENT_MACHINE_RESERVATION_FILE: () => import_independentMachineReservation.INDEPENDENT_MACHINE_RESERVATION_FILE,
   InMemoryKek: () => import_kek.InMemoryKek,
   KekUnavailableError: () => import_kek.KekUnavailableError,
   LEGACY_CONFIG_DIR_NAMES: () => import_localIdentity.LEGACY_CONFIG_DIR_NAMES,
@@ -189,6 +191,8 @@ __export(index_exports, {
   hostedRuntimeIdOverride: () => import_machineUuid.hostedRuntimeIdOverride,
   initCredEnvelope: () => import_credentialEnvelopeBridge.initCredEnvelope,
   initDeviceIdentity: () => import_deviceIdentityBridge.initDeviceIdentity,
+  initExistingCredEnvelope: () => import_credentialEnvelopeBridge.initExistingCredEnvelope,
+  initNewIndependentCredEnvelope: () => import_credentialEnvelopeBridge.initNewIndependentCredEnvelope,
   installLockExitHandlers: () => import_refresh.installLockExitHandlers,
   invalidateAuthHelperCache: () => import_credentialResolver.invalidateAuthHelperCache,
   invalidateHeadersHelperCache: () => import_headers_helper.invalidateHeadersHelperCache,
@@ -238,9 +242,11 @@ __export(index_exports, {
   publicJwkFromX: () => import_deviceKey.publicJwkFromX,
   qualifyMachineUuid: () => import_machineUuid.qualifyMachineUuid,
   readAuthFromFd: () => import_fdToken.readAuthFromFd,
+  readIndependentMachineReservation: () => import_independentMachineReservation.readIndependentMachineReservation,
   reauthCommand: () => import_messages.reauthCommand,
   refreshDaemonToken: () => import_refresh.refreshDaemonToken,
   registerZeroizeHook: () => import_kek.registerZeroizeHook,
+  reserveIndependentMachineProfile: () => import_independentMachineReservation.reserveIndependentMachineProfile,
   resetCredEnvelope: () => import_credentialEnvelopeBridge.resetCredEnvelope,
   resetDeviceIdentity: () => import_deviceIdentityBridge.resetDeviceIdentity,
   resolveChannelManifestUrl: () => import_firstPartyHarnessChannels.resolveChannelManifestUrl,
@@ -263,6 +269,7 @@ __export(index_exports, {
   verifyChallenge: () => import_pkce.verifyChallenge,
   verifyDeviceProof: () => import_deviceKey.verifyProof,
   verifyDpopProof: () => import_dpop.verifyDpopProof,
+  verifyIndependentMachineReservation: () => import_independentMachineReservation.verifyIndependentMachineReservation,
   verifyManifest: () => import_releaseManifest.verifyManifest,
   withAuthLock: () => import_refresh.withAuthLock,
   withLoopbackNoProxy: () => import_spawnEnv.withLoopbackNoProxy,
@@ -313,6 +320,7 @@ __reExport(index_exports, require("./harnessPermissionControls.js"), module.expo
 var import_releaseVersions = require("./releaseVersions.js");
 __reExport(index_exports, require("./computerUse.js"), module.exports);
 __reExport(index_exports, require("./desktopWire.js"), module.exports);
+var import_independentMachineReservation = require("./independentMachineReservation.js");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ALL_DAEMON_SCOPES,
@@ -343,6 +351,8 @@ __reExport(index_exports, require("./desktopWire.js"), module.exports);
   HARNESSES_LOADING_CLAUDE_SKILLS_LAYOUT,
   HARNESS_TIERS,
   HOSTED_RUNTIME_MACHINE_SOURCES,
+  INDEPENDENT_MACHINE_PROFILE_RE,
+  INDEPENDENT_MACHINE_RESERVATION_FILE,
   InMemoryKek,
   KekUnavailableError,
   LEGACY_CONFIG_DIR_NAMES,
@@ -485,6 +495,8 @@ __reExport(index_exports, require("./desktopWire.js"), module.exports);
   hostedRuntimeIdOverride,
   initCredEnvelope,
   initDeviceIdentity,
+  initExistingCredEnvelope,
+  initNewIndependentCredEnvelope,
   installLockExitHandlers,
   invalidateAuthHelperCache,
   invalidateHeadersHelperCache,
@@ -534,9 +546,11 @@ __reExport(index_exports, require("./desktopWire.js"), module.exports);
   publicJwkFromX,
   qualifyMachineUuid,
   readAuthFromFd,
+  readIndependentMachineReservation,
   reauthCommand,
   refreshDaemonToken,
   registerZeroizeHook,
+  reserveIndependentMachineProfile,
   resetCredEnvelope,
   resetDeviceIdentity,
   resolveChannelManifestUrl,
@@ -559,6 +573,7 @@ __reExport(index_exports, require("./desktopWire.js"), module.exports);
   verifyChallenge,
   verifyDeviceProof,
   verifyDpopProof,
+  verifyIndependentMachineReservation,
   verifyManifest,
   withAuthLock,
   withLoopbackNoProxy,

package/dist/node_modules/@skrr-ai/auth-core/dist/cjs/kek/macos.js

@@ -178,7 +178,6 @@ async function writeKekToKeychain(kek, service, account) {
       account,
       "-w",
       b64,
-      "-U",
       keychainPath
     ]);
   } catch (err) {
@@ -219,9 +218,26 @@ async function resolveOrCreateKek(service, account) {
     return existing;
   }
   const fresh = import_node_crypto.default.randomBytes(import_credentialEnvelope.KEY_LEN);
-  await writeKekToKeychain(fresh, service, account);
-  _kekCacheBySvc.set(cacheKey, fresh);
-  return fresh;
+  try {
+    try {
+      await writeKekToKeychain(fresh, service, account);
+    } catch (error) {
+      const winner = await readKekFromKeychain(service, account).catch(() => null);
+      if (!winner)
+        throw error;
+      _kekCacheBySvc.set(cacheKey, winner);
+      return winner;
+    }
+    const persisted = await readKekFromKeychain(service, account);
+    if (!persisted || !persisted.equals(fresh)) {
+      persisted?.fill(0);
+      throw new import_types.KekUnavailableError(KIND_SHELLOUT, "created master KEK could not be verified");
+    }
+    _kekCacheBySvc.set(cacheKey, persisted);
+    return persisted;
+  } finally {
+    fresh.fill(0);
+  }
 }
 async function resolveExistingKek(service, account) {
   const cacheKey = `${service}::${account}`;

package/dist/node_modules/@skrr-ai/auth-core/dist/cjs/maintenanceReportWire.d.ts

@@ -0,0 +1,178 @@
+/**
+ * The maintenance report wire contract (Machine Maintenance, OSK-19107, task M24;
+ * `docs/architecture/machine-maintenance/implementation-plan-2026-10-24.md` §3.5,
+ * `phase0/m04-quiescence-evidence.md` §2.5 and §2.6).
+ *
+ * Declared ONCE, here. The daemon is published and cannot import the API, so the
+ * capability name, the payload shape and its bounds live in this package, which
+ * every end can import (`@skrr-ai/auth-core/maintenance-report-wire`).
+ * `maintenanceReportWire.test.ts` fails on a second spelling of the capability
+ * anywhere else in the repo. The shape follows `dedicatedRuntimeBusyWire.ts`, the
+ * precedent for a positively announced, fail-closed report, and differs from it
+ * only where the owner's pause needs more.
+ *
+ * WHAT THE REPORT SAYS
+ * ---------------------------------------------------------------------------
+ * "What does this daemon process hold right now that an update would take from
+ * the owner, and has anything been admitted since the last time you asked?" It is
+ * a LOCAL read summarised into counts, the handoff's own restart blockers, and
+ * the daemon's own update handoff phase.
+ *
+ * It is EVIDENCE, never authority. The fence does not depend on it: a daemon that
+ * lies, or one that sends nothing, cannot make a held machine accept work. Only
+ * this report can grant `ready` (a server-side source can only veto it), and a
+ * daemon that never announces the capability can only reach `ready` by the
+ * owner's attestation.
+ *
+ * FAIL CLOSED, in three places
+ * ---------------------------------------------------------------------------
+ *  1. A count is `0` only when the daemon positively counted. A source that could
+ *     not be read is `complete: 'unknown'`; a daemon that is leaving is
+ *     `complete: false`. A reader MUST treat both as busy, whatever the counts
+ *     say (`maintenanceReportIsQuiet` is the one place that says so).
+ *  2. A report that is malformed in ANY field is `null` from
+ *     `parseMaintenanceReport`, and the caller treats the machine as not quiet.
+ *     A count that is missing, negative, fractional or not a safe integer is not
+ *     "zero": it is a different, broken report. A version this parser does not
+ *     know is `null` too: a newer shape needs its own announced capability.
+ *  3. Bounds. The blocker list and every string are clamped, so one report can
+ *     never be large enough to matter, and a field that is NOT in the contract is
+ *     never copied into what the parser returns (the result is built from a
+ *     fresh object, so `__proto__` and its kin cannot ride along).
+ *
+ * `admittedTotal`
+ * ---------------------------------------------------------------------------
+ * A MONOTONIC counter of admissions since this process started. The server proves
+ * "nothing was admitted between two reports" by comparing two values, without
+ * trusting the daemon's clock. It counts at every place the daemon admits work
+ * and OVER-counts on purpose (one admission may be noted at the gate and again
+ * where the work registers): a second increment can only make the proof harder,
+ * never easier. A path that the daemon cannot count must say so in
+ * `daemon/src/maintenance-report.ts`, not hide in a zero.
+ */
+export declare const MAINTENANCE_REPORT_CAPABILITY = "maintenance_report_v1";
+/** The heartbeat (and register) key the report rides under. Sent only by a daemon that announced the capability. */
+export declare const MAINTENANCE_REPORT_HEARTBEAT_KEY = "maintenanceReport";
+export declare const MAINTENANCE_REPORT_VERSION = 1;
+/**
+ * The daemon's own update handoff phases (`daemon/src/update/handoff.ts`), and the
+ * members of `DaemonMaintenanceHandoff.phase` in `@skrr-ai/data-provider`. A phase
+ * outside this list is a newer protocol and makes the whole report `null`.
+ */
+export declare const MAINTENANCE_REPORT_HANDOFF_PHASES: readonly ["ready", "deferred", "reconnecting", "verified", "failed", "rolled-back"];
+export type MaintenanceReportHandoffPhase = (typeof MAINTENANCE_REPORT_HANDOFF_PHASES)[number];
+export declare const MAINTENANCE_REPORT_LIMITS: {
+    /** The handoff's blockers carried for the "waiting on" text; the counts, not this list, decide busy. */
+    readonly maxBlockers: 32;
+    readonly maxKindLength: 32;
+    readonly maxIdLength: 128;
+    readonly maxReasonLength: 240;
+    readonly maxHandoffIdLength: 64;
+    readonly maxHandoffReasonLength: 64;
+    readonly maxProcessStartIdLength: 64;
+    /** Hard ceiling on the serialized report. The clamps above keep a valid one well under it. */
+    readonly maxSerializedBytes: 20000;
+};
+/** What `complete` can be. Anything but `true` means the counts prove nothing. */
+export type MaintenanceReportComplete = boolean | 'unknown';
+/** The handoff's own `RestartBlocker` shape (`daemon/src/update/handoff.ts`). Reason text is the handoff's, never re-spelled. */
+export interface MaintenanceReportBlocker {
+    kind: string;
+    id?: string;
+    reason: string;
+}
+export interface MaintenanceReportInflight {
+    /** Provider sessions and their wrapper processes: in-process turns, preparing dispatches, live wrappers. */
+    sessions: number;
+    /** Tool calls running, plus background commands still running. */
+    tools: number;
+    /** Terminals the daemon holds, preservable or not. A person's open shell is work an update would interrupt. */
+    terminals: number;
+    /** Provider turns that still depend on credentials, permissions, a browser or a model connection the service owns. */
+    providerDependencies: number;
+    /** Write-ahead entries whose durability the daemon has not confirmed. */
+    walUnconfirmed: number;
+}
+export interface MaintenanceReportHandoff {
+    phase: MaintenanceReportHandoffPhase;
+    handoffId: string;
+    reason?: string;
+    /** ISO time the daemon's lease on this phase ends. */
+    expiresAt?: string;
+}
+export interface MaintenanceReport {
+    version: typeof MAINTENANCE_REPORT_VERSION;
+    /** The daemon process that read this. The server drops a report that is not its registered process's. */
+    processStartId: string;
+    /** ISO time of the daemon's own read. Informational: freshness is the server's receipt time. */
+    readAt: string;
+    /** `true`: every source was read. `'unknown'`: one could not be. `false`: the process is leaving. */
+    complete: MaintenanceReportComplete;
+    /** Monotonic count of admissions since this process started. */
+    admittedTotal: number;
+    inflight: MaintenanceReportInflight;
+    blockers: MaintenanceReportBlocker[];
+    /** True when the daemon had more blockers than it sent. */
+    blockersTruncated: boolean;
+    /** The daemon's own update handoff, only while it is live or unresolved; otherwise `null`. */
+    handoff: MaintenanceReportHandoff | null;
+}
+/**
+ * The reader's view of a daemon's heartbeat section. Anything malformed, from a
+ * daemon that did not announce the capability, an unknown version, or oversized
+ * is `null`, and the caller must then treat the machine as NOT quiet. Never
+ * trusts a field it did not validate and never copies one it does not know.
+ */
+export declare function parseMaintenanceReport(raw: unknown): MaintenanceReport | null;
+/**
+ * A report as it was stored (JSON text on the presence row). Anything that does
+ * not parse, or does not validate, is `null`: a stored value is an input like any
+ * other and is read with the same suspicion.
+ */
+export declare function parseStoredMaintenanceReport(stored: unknown): MaintenanceReport | null;
+/**
+ * The one definition of a POSITIVE ZERO: the daemon read every source and found
+ * nothing. `complete: 'unknown'` and `complete: false` are never zero whatever
+ * the counts say, because the counts were not (all) read.
+ *
+ * A blocker that is not work (a missing restart owner, say) does not make a
+ * report non-quiet; readiness is "nothing is running", not "the daemon can
+ * restart itself".
+ */
+export declare function maintenanceReportIsQuiet(report: MaintenanceReport | null): boolean;
+export interface BuildMaintenanceReportInput {
+    processStartId: string;
+    /** Epoch ms of the daemon's own read. */
+    readAtMs: number;
+    complete: MaintenanceReportComplete;
+    admittedTotal: number;
+    inflight: MaintenanceReportInflight;
+    blockers: ReadonlyArray<{
+        kind: string;
+        id?: string;
+        reason: string;
+    }>;
+    /** `expiresAtMs` is epoch ms; the wire carries ISO. */
+    handoff: {
+        phase: MaintenanceReportHandoffPhase;
+        handoffId: string;
+        reason?: string;
+        expiresAtMs?: number;
+    } | null;
+}
+/**
+ * A report that says nothing was counted. The shape the daemon sends when it
+ * could not read an inventory source at all, and the shape `buildMaintenanceReport`
+ * falls back to when it was handed something the contract cannot carry.
+ */
+export declare function unknownMaintenanceReport(processStartId: string, readAtMs: number, admittedTotal?: number): MaintenanceReport;
+/**
+ * Build the wire report from what the daemon read. Input the contract cannot
+ * carry (a negative count, a blocker with no kind, a time that is not a time)
+ * becomes an `unknown` report rather than a throw or a report that parses to
+ * something else, so the result parses whenever `processStartId` is a real id (the
+ * daemon's always is). A builder that threw would turn a bad read into silence,
+ * and silence is the absence of a report, which the server reads the same way,
+ * but later.
+ */
+export declare function buildMaintenanceReport(input: BuildMaintenanceReportInput): MaintenanceReport;