@skrr-ai/cli 0.1.120 → 0.1.121

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

@@ -37,6 +37,8 @@ __export(credentialEnvelopeBridge_exports, {
   describeCredEnvelopeState: () => describeCredEnvelopeState,
   hasCredEnvelopePathConflict: () => hasCredEnvelopePathConflict,
   initCredEnvelope: () => initCredEnvelope,
+  initExistingCredEnvelope: () => initExistingCredEnvelope,
+  initNewIndependentCredEnvelope: () => initNewIndependentCredEnvelope,
   isCredEnvelopeActive: () => isCredEnvelopeActive,
   maybeDecryptOnRead: () => maybeDecryptOnRead,
   maybeEncryptForWrite: () => maybeEncryptForWrite,
@@ -256,7 +258,150 @@ function retiredDekFiles(profile) {
     return [];
   }
 }
+async function initExistingCredEnvelope(profile) {
+  if (_state.kind === "active" && _state.profile === profile)
+    return;
+  if (_state.kind !== "uninit" || typeof profile !== "string" || !profile) {
+    throw new Error("Existing credential envelope is unavailable");
+  }
+  let fd;
+  let candidate;
+  try {
+    const target = wrappedDekFilePath(profile);
+    fd = import_node_fs.default.openSync(target, import_node_fs.default.constants.O_RDONLY | (import_node_fs.default.constants.O_NOFOLLOW ?? 0));
+    const before = import_node_fs.default.fstatSync(fd);
+    const safe = (stat) => stat.isFile() && stat.nlink === 1 && stat.size > 0 && stat.size <= 65536 && (stat.mode & 63) === 0 && (typeof process.getuid !== "function" || stat.uid === process.getuid());
+    if (!safe(before))
+      throw new Error("unsafe envelope");
+    const readBounded = () => {
+      const bytes = Buffer.alloc(before.size);
+      let offset = 0;
+      while (offset < bytes.length) {
+        const count = import_node_fs.default.readSync(fd, bytes, offset, bytes.length - offset, offset);
+        if (count <= 0)
+          throw new Error("changed envelope");
+        offset += count;
+      }
+      return bytes;
+    };
+    const wrapped = readBounded();
+    const kek = (0, import_kek.getKekStrategy)();
+    if (!kek.unwrapExisting || !await kek.available())
+      throw new Error("read-only KEK unavailable");
+    candidate = await kek.unwrapExisting(wrapped, (0, import_credentialEnvelope.buildCredentialAad)(profile));
+    if (!Buffer.isBuffer(candidate) || candidate.length !== 32)
+      throw new Error("invalid envelope");
+    if (!readBounded().equals(wrapped))
+      throw new Error("changed envelope");
+    const after = import_node_fs.default.fstatSync(fd);
+    const current = import_node_fs.default.lstatSync(target);
+    if (!safe(after) || !safe(current) || before.dev !== after.dev || before.ino !== after.ino || before.dev !== current.dev || before.ino !== current.ino || before.size !== after.size || before.size !== current.size || before.mtimeMs !== after.mtimeMs || before.ctimeMs !== after.ctimeMs || before.mtimeMs !== current.mtimeMs || before.ctimeMs !== current.ctimeMs || wrappedDekFilePath(profile) !== target || _state.kind !== "uninit") {
+      throw new Error("changed envelope");
+    }
+    for (const old of _retiredDeks)
+      old.fill(0);
+    _retiredDeks = [];
+    _state = {
+      kind: "active",
+      dek: candidate,
+      kekId: kek.id,
+      kekKind: typeof kek.kind === "string" || kek.kind === null ? kek.kind ?? null : null,
+      profile
+    };
+    candidate = void 0;
+  } catch {
+    if (Buffer.isBuffer(candidate))
+      candidate.fill(0);
+    throw new Error("Existing credential envelope is unavailable");
+  } finally {
+    if (fd !== void 0)
+      import_node_fs.default.closeSync(fd);
+  }
+}
+async function initNewIndependentCredEnvelope(profile) {
+  if (!/^desktop-bg-[a-f0-9]{32}$/.test(profile))
+    throw new Error("Background credential enrollment is unavailable");
+  if (_state.kind === "active" && _state.profile === profile)
+    return;
+  if (_state.kind !== "uninit")
+    throw new Error("Background credential enrollment is unavailable");
+  const resolved = (0, import_profileStateDir.resolveProfileStateFile)(profile, ACCOUNT_CRED_DEK_WRAPPED);
+  const paths = [resolved.canonicalPath, ...resolved.legacyPath ? [resolved.legacyPath] : []];
+  const present = (file) => {
+    try {
+      import_node_fs.default.lstatSync(file);
+      return true;
+    } catch (err) {
+      if (err.code === "ENOENT")
+        return false;
+      throw err;
+    }
+  };
+  if (paths.some(present))
+    return initExistingCredEnvelope(profile);
+  const dir = resolved.canonicalDir;
+  const stat = import_node_fs.default.lstatSync(dir);
+  if (!stat.isDirectory() || stat.isSymbolicLink() || (stat.mode & 63) !== 0 || typeof process.getuid === "function" && stat.uid !== process.getuid()) {
+    throw new Error("Background credential enrollment is unavailable");
+  }
+  const artifacts = ["device-private-key", "device-public-key.jwk", "auth-binding.json", "auth.json"];
+  const artifactDirs = [dir, ...resolved.legacyDir ? [resolved.legacyDir] : []];
+  const assertEmpty = () => {
+    if (paths.some(present) || artifactDirs.some((root) => artifacts.some((name) => present(import_node_path.default.join(root, name)))) || wrappedDekFilePath(profile) !== resolved.canonicalPath) {
+      throw new Error("Background credential enrollment needs recovery");
+    }
+  };
+  assertEmpty();
+  const kek = (0, import_kek.getKekStrategy)();
+  if (!kek.unwrapExisting || !await kek.available())
+    throw new Error("Background credential enrollment is unavailable");
+  assertEmpty();
+  const dek = (0, import_credentialEnvelope.generateDek)();
+  let temp;
+  try {
+    const wrapped = await kek.wrap(dek, (0, import_credentialEnvelope.buildCredentialAad)(profile));
+    if (paths.some(present))
+      return await initExistingCredEnvelope(profile);
+    assertEmpty();
+    const temporaryPath = import_node_path.default.join(dir, `.cred-dek-enrollment.${(0, import_node_crypto.randomBytes)(12).toString("hex")}.tmp`);
+    const fd = import_node_fs.default.openSync(temporaryPath, 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);
+    temp = temporaryPath;
+    try {
+      import_node_fs.default.writeFileSync(fd, wrapped);
+      import_node_fs.default.fsyncSync(fd);
+    } finally {
+      import_node_fs.default.closeSync(fd);
+    }
+    assertEmpty();
+    try {
+      import_node_fs.default.linkSync(temp, resolved.canonicalPath);
+    } catch (err) {
+      if (err.code !== "EEXIST")
+        throw err;
+    }
+    const dirFd = import_node_fs.default.openSync(dir, "r");
+    try {
+      import_node_fs.default.fsyncSync(dirFd);
+    } finally {
+      import_node_fs.default.closeSync(dirFd);
+    }
+  } finally {
+    dek.fill(0);
+    if (temp) {
+      import_node_fs.default.unlinkSync(temp);
+      const dirFd = import_node_fs.default.openSync(dir, "r");
+      try {
+        import_node_fs.default.fsyncSync(dirFd);
+      } finally {
+        import_node_fs.default.closeSync(dirFd);
+      }
+    }
+  }
+  await initExistingCredEnvelope(profile);
+}
 async function initCredEnvelope(profile) {
+  if (/^desktop-bg-[a-f0-9]{32}$/i.test(profile))
+    return initExistingCredEnvelope(profile);
   if (_state.kind !== "uninit")
     return;
   if (typeof profile !== "string" || profile.length === 0) {
@@ -629,6 +774,8 @@ function __wrappedDekFilePathForTest(profile) {
   describeCredEnvelopeState,
   hasCredEnvelopePathConflict,
   initCredEnvelope,
+  initExistingCredEnvelope,
+  initNewIndependentCredEnvelope,
   isCredEnvelopeActive,
   maybeDecryptOnRead,
   maybeEncryptForWrite,

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

@@ -0,0 +1,20 @@
+export interface DaemonConsentPayload {
+    consentVersion: number;
+    consentSource: string;
+    isLegacy: boolean;
+    isReConsent: boolean;
+    scopes: string[];
+    scopeDescriptions: Record<string, string>;
+}
+/** A single canonical, bounded representation on both sides of the log. */
+export declare function normalizeDaemonConsent(input: unknown): DaemonConsentPayload | null;
+export interface DaemonConsentIdentity {
+    pid: number;
+    daemonId: string;
+    userId: string;
+    origin: string;
+}
+/** The bootstrap secret is never logged. This MAC binds the exact consent,
+ * live process, daemon and cloud owner; an old log entry is not authority. */
+export declare function daemonConsentProof(secret: string, identity: DaemonConsentIdentity, payload: DaemonConsentPayload): string;
+export declare function verifyDaemonConsentProof(secret: string, identity: DaemonConsentIdentity, payload: DaemonConsentPayload, proof: string): boolean;

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

@@ -0,0 +1,72 @@
+"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 daemonConsentProof_exports = {};
+__export(daemonConsentProof_exports, {
+  daemonConsentProof: () => daemonConsentProof,
+  normalizeDaemonConsent: () => normalizeDaemonConsent,
+  verifyDaemonConsentProof: () => verifyDaemonConsentProof
+});
+module.exports = __toCommonJS(daemonConsentProof_exports);
+var import_node_crypto = require("node:crypto");
+function normalizeDaemonConsent(input) {
+  if (!input || typeof input !== "object" || Array.isArray(input))
+    return null;
+  const value = input;
+  if (!Number.isSafeInteger(value.consentVersion) || value.consentVersion < 0 || typeof value.consentSource !== "string" || value.consentSource.length > 64 || typeof value.isLegacy !== "boolean" || typeof value.isReConsent !== "boolean" || !Array.isArray(value.scopes) || value.scopes.length > 128 || !value.scopes.every((scope) => typeof scope === "string" && scope.length <= 256) || !value.scopeDescriptions || typeof value.scopeDescriptions !== "object" || Array.isArray(value.scopeDescriptions))
+    return null;
+  const entries = Object.entries(value.scopeDescriptions).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0);
+  if (entries.length > 128 || entries.some(([key, text]) => key.length > 256 || typeof text !== "string" || text.length > 1024))
+    return null;
+  return {
+    consentVersion: value.consentVersion,
+    consentSource: value.consentSource,
+    isLegacy: value.isLegacy,
+    isReConsent: value.isReConsent,
+    scopes: value.scopes,
+    scopeDescriptions: Object.fromEntries(entries)
+  };
+}
+function daemonConsentProof(secret, identity, payload) {
+  const key = Buffer.from(secret, "base64");
+  if (key.length !== 32 || !Number.isSafeInteger(identity.pid) || identity.pid <= 0 || !identity.daemonId || !identity.userId)
+    throw new Error("Invalid daemon consent identity");
+  const origin = new URL(identity.origin).origin;
+  return (0, import_node_crypto.createHmac)("sha256", key).update("skrr-daemon-consent:v1\0").update(JSON.stringify([
+    identity.pid,
+    identity.daemonId,
+    identity.userId.toLowerCase(),
+    origin,
+    payload
+  ])).digest("hex");
+}
+function verifyDaemonConsentProof(secret, identity, payload, proof) {
+  if (!/^[a-f0-9]{64}$/.test(proof))
+    return false;
+  try {
+    return (0, import_node_crypto.timingSafeEqual)(Buffer.from(proof, "hex"), Buffer.from(daemonConsentProof(secret, identity, payload), "hex"));
+  } catch {
+    return false;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  daemonConsentProof,
+  normalizeDaemonConsent,
+  verifyDaemonConsentProof
+});

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

@@ -0,0 +1,21 @@
+export declare const DESKTOP_DAEMON_PROOF_NAMESPACE = "/desktop-proof-v1";
+export declare const DESKTOP_DAEMON_RENEWAL_NAMESPACE = "/desktop-renewal-v1";
+export interface DesktopDaemonOwner {
+    userId: string;
+    serverUrl: string;
+}
+export interface DesktopDaemonChallenge {
+    owner: DesktopDaemonOwner;
+    port: number;
+    clientNonce: string;
+    serverNonce: string;
+}
+/** The same canonical owner is used by the daemon's owner boundary and MAC. */
+export declare function normalizeDesktopDaemonOwner(input: unknown): DesktopDaemonOwner | null;
+/** Role separation prevents reflecting the daemon's proof as client proof. */
+export declare function desktopDaemonProof(secret: string, role: 'daemon' | 'desktop', challenge: DesktopDaemonChallenge): string;
+/** Renewal uses a distinct domain so a proof for this narrow channel cannot
+ * be reflected or replayed as a normal desktop attachment. */
+export declare function desktopRenewalProof(secret: string, role: 'daemon' | 'desktop', challenge: DesktopDaemonChallenge): string;
+export declare function verifyDesktopDaemonProof(secret: string, role: 'daemon' | 'desktop', challenge: DesktopDaemonChallenge, proof: unknown): boolean;
+export declare function verifyDesktopRenewalProof(secret: string, role: 'daemon' | 'desktop', challenge: DesktopDaemonChallenge, proof: unknown): boolean;

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

@@ -0,0 +1,96 @@
+"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 desktopDaemonProof_exports = {};
+__export(desktopDaemonProof_exports, {
+  DESKTOP_DAEMON_PROOF_NAMESPACE: () => DESKTOP_DAEMON_PROOF_NAMESPACE,
+  DESKTOP_DAEMON_RENEWAL_NAMESPACE: () => DESKTOP_DAEMON_RENEWAL_NAMESPACE,
+  desktopDaemonProof: () => desktopDaemonProof,
+  desktopRenewalProof: () => desktopRenewalProof,
+  normalizeDesktopDaemonOwner: () => normalizeDesktopDaemonOwner,
+  verifyDesktopDaemonProof: () => verifyDesktopDaemonProof,
+  verifyDesktopRenewalProof: () => verifyDesktopRenewalProof
+});
+module.exports = __toCommonJS(desktopDaemonProof_exports);
+var import_node_crypto = require("node:crypto");
+const DESKTOP_DAEMON_PROOF_NAMESPACE = "/desktop-proof-v1";
+const DESKTOP_DAEMON_RENEWAL_NAMESPACE = "/desktop-renewal-v1";
+function normalizeDesktopDaemonOwner(input) {
+  if (!input || typeof input !== "object" || Array.isArray(input))
+    return null;
+  const value = input;
+  if (typeof value.userId !== "string" || !value.userId || value.userId.length > 128 || typeof value.serverUrl !== "string" || value.serverUrl.length > 2048)
+    return null;
+  try {
+    const url = new URL(value.serverUrl);
+    if (url.protocol !== "https:" && url.protocol !== "http:")
+      return null;
+    return { userId: value.userId, serverUrl: url.origin };
+  } catch {
+    return null;
+  }
+}
+function desktopDaemonProof(secret, role, challenge) {
+  return proofForPurpose(secret, role, challenge, "skrr-desktop-daemon-proof:v1\0");
+}
+function desktopRenewalProof(secret, role, challenge) {
+  return proofForPurpose(secret, role, challenge, "skrr-desktop-renewal-proof:v1\0");
+}
+function proofForPurpose(secret, role, challenge, domain) {
+  const key = Buffer.from(secret, "base64");
+  const owner = normalizeDesktopDaemonOwner(challenge.owner);
+  if (key.length !== 32 || key.toString("base64") !== secret || !owner || !Number.isInteger(challenge.port) || challenge.port < 1 || challenge.port > 65535 || !/^[a-f0-9]{64}$/.test(challenge.clientNonce) || !/^[a-f0-9]{64}$/.test(challenge.serverNonce)) {
+    throw new Error("Invalid desktop daemon challenge");
+  }
+  return (0, import_node_crypto.createHmac)("sha256", key).update(domain).update(JSON.stringify([
+    role,
+    challenge.port,
+    owner.userId,
+    owner.serverUrl,
+    challenge.clientNonce,
+    challenge.serverNonce
+  ])).digest("hex");
+}
+function verifyDesktopDaemonProof(secret, role, challenge, proof) {
+  if (typeof proof !== "string" || !/^[a-f0-9]{64}$/.test(proof))
+    return false;
+  try {
+    return (0, import_node_crypto.timingSafeEqual)(Buffer.from(proof, "hex"), Buffer.from(desktopDaemonProof(secret, role, challenge), "hex"));
+  } catch {
+    return false;
+  }
+}
+function verifyDesktopRenewalProof(secret, role, challenge, proof) {
+  if (typeof proof !== "string" || !/^[a-f0-9]{64}$/.test(proof))
+    return false;
+  try {
+    return (0, import_node_crypto.timingSafeEqual)(Buffer.from(proof, "hex"), Buffer.from(desktopRenewalProof(secret, role, challenge), "hex"));
+  } catch {
+    return false;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DESKTOP_DAEMON_PROOF_NAMESPACE,
+  DESKTOP_DAEMON_RENEWAL_NAMESPACE,
+  desktopDaemonProof,
+  desktopRenewalProof,
+  normalizeDesktopDaemonOwner,
+  verifyDesktopDaemonProof,
+  verifyDesktopRenewalProof
+});

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

@@ -51,9 +51,8 @@ export declare function describeDeviceKeySplit(profile: string): {
  * `createIfMissing: false` stops before step 2 (disabled+no_stored_key) and
  * never replaces anything: for a short-lived process that must only READ the
  * daemon's key while the daemon itself may be creating it (OSK-15990's
- * `skrrd device-proof`). The persist below is not an exclusive create, so a
- * second creator racing the daemon could leave the daemon holding one key in
- * memory and the disk another.
+ * `skrrd device-proof`). Readers and writers both take the profile lock so
+ * they cannot observe an incomplete write from another updated process.
  */
 export declare function initDeviceIdentity(profile: string, options?: {
     recoverUnreadable?: boolean;

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

@@ -47,6 +47,7 @@ __export(deviceIdentityBridge_exports, {
 module.exports = __toCommonJS(deviceIdentityBridge_exports);
 var import_node_fs = __toESM(require("node:fs"), 1);
 var import_node_path = __toESM(require("node:path"), 1);
+var import_proper_lockfile = __toESM(require("proper-lockfile"), 1);
 var import_deviceKey = require("./deviceKey.js");
 var import_credentialEnvelopeBridge = require("./credentialEnvelopeBridge.js");
 var import_profileStateDir = require("./profileStateDir.js");
@@ -63,6 +64,22 @@ const DEVICE_IDENTITY_FILES = [
 ];
 const DAEMON_NOT_FOUND_BACKOFF_MS = 15 * 60 * 1e3;
 let _state = { kind: "uninit" };
+let _initializing = null;
+async function withDeviceIdentityLock(profile, body) {
+  const dir = (0, import_profileStateDir.profileStateDir)(profile);
+  import_node_fs.default.mkdirSync(dir, { recursive: true, mode: 448 });
+  const release = await import_proper_lockfile.default.lock(dir, {
+    realpath: false,
+    lockfilePath: import_node_path.default.join(dir, ".device-identity.lock"),
+    stale: 10 * 60 * 1e3,
+    retries: { retries: 20, minTimeout: 100, maxTimeout: 500, factor: 1.25 }
+  });
+  try {
+    return await body();
+  } finally {
+    await release();
+  }
+}
 function __setStateForTest(next) {
   const prev = _state;
   _state = next;
@@ -72,6 +89,8 @@ function __getStateForTest() {
   return _state;
 }
 function profileConfigDir(profile) {
+  if (/^desktop-bg-[a-f0-9]{32}$/i.test(profile))
+    return (0, import_profileStateDir.profileStateDir)(profile);
   return (0, import_profileStateDir.resolveProfileStateDir)(profile, PRIVATE_KEY_FILENAME).dir;
 }
 function publicKeyPath(profile) {
@@ -162,14 +181,49 @@ function persistKeypair(profile, kp) {
   });
   return { envelopeProtected };
 }
+function readIndependentIdentityFile(file, sealed) {
+  if (typeof import_node_fs.default.constants.O_NOFOLLOW !== "number" || typeof import_node_fs.default.constants.O_NONBLOCK !== "number")
+    return null;
+  let fd;
+  try {
+    fd = import_node_fs.default.openSync(file, import_node_fs.default.constants.O_RDONLY | import_node_fs.default.constants.O_NOFOLLOW | import_node_fs.default.constants.O_NONBLOCK);
+  } catch {
+    return null;
+  }
+  try {
+    const before = import_node_fs.default.fstatSync(fd);
+    if (!before.isFile() || before.nlink !== 1 || before.size > 16384 || (before.mode & 63) !== 0 || typeof process.getuid === "function" && before.uid !== process.getuid())
+      return null;
+    const bytes = Buffer.alloc(before.size);
+    let offset = 0;
+    while (offset < bytes.length) {
+      const count = import_node_fs.default.readSync(fd, bytes, offset, bytes.length - offset, offset);
+      if (count <= 0)
+        return null;
+      offset += count;
+    }
+    const after = import_node_fs.default.fstatSync(fd);
+    const current = import_node_fs.default.lstatSync(file);
+    if (!current.isFile() || current.isSymbolicLink() || current.dev !== before.dev || current.ino !== before.ino || current.size !== before.size || current.nlink !== before.nlink || current.mode !== before.mode || current.uid !== before.uid || current.mtimeMs !== before.mtimeMs || current.ctimeMs !== before.ctimeMs || before.dev !== after.dev || before.ino !== after.ino || before.size !== after.size || before.nlink !== after.nlink || before.mode !== after.mode || before.uid !== after.uid || before.mtimeMs !== after.mtimeMs || before.ctimeMs !== after.ctimeMs)
+      return null;
+    const value = bytes.toString("utf8");
+    return sealed && !value.startsWith("osk-env1:") ? null : value;
+  } catch {
+    return null;
+  } finally {
+    import_node_fs.default.closeSync(fd);
+  }
+}
 function loadKeypair(profile) {
   const pubPath = publicKeyPath(profile);
   const privPath = privateKeyPath(profile);
-  if (!import_node_fs.default.existsSync(pubPath) || !import_node_fs.default.existsSync(privPath)) {
+  const independent = /^desktop-bg-[a-f0-9]{32}$/i.test(profile);
+  if (!independent && (!import_node_fs.default.existsSync(pubPath) || !import_node_fs.default.existsSync(privPath)))
+    return null;
+  const pubRaw = independent ? readIndependentIdentityFile(pubPath, false) : import_node_fs.default.readFileSync(pubPath, "utf-8");
+  const privRaw = independent ? readIndependentIdentityFile(privPath, true) : import_node_fs.default.readFileSync(privPath, "utf-8");
+  if (pubRaw === null || privRaw === null)
     return null;
-  }
-  const pubRaw = import_node_fs.default.readFileSync(pubPath, "utf-8");
-  const privRaw = import_node_fs.default.readFileSync(privPath, "utf-8");
   let publicJwk;
   let storedThumbprint;
   try {
@@ -270,14 +324,38 @@ async function consolidateDeviceIdentity(profile) {
   }
 }
 async function initDeviceIdentity(profile, options = {}) {
+  if (_initializing)
+    return _initializing;
   if (_state.kind !== "uninit")
     return;
-  if (typeof profile !== "string" || profile.length === 0) {
+  if (typeof profile !== "string" || !/^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/.test(profile)) {
     _state = { kind: "disabled", reason: "init_failed" };
-    emit("init_failed", false, { reason: "empty_profile" });
+    emit("init_failed", false, { reason: "invalid_profile" });
     return;
   }
-  await consolidateDeviceIdentity(profile);
+  const job = withDeviceIdentityLock(profile, async () => {
+    if (_state.kind === "uninit")
+      await initDeviceIdentityLocked(profile, options);
+  }).catch((err) => {
+    _state = { kind: "disabled", reason: "init_failed" };
+    emit("init_failed", false, {
+      profile,
+      reason: "identity_lock_unavailable",
+      message: err instanceof Error ? err.message : "unknown"
+    });
+  });
+  _initializing = job;
+  try {
+    await job;
+  } finally {
+    if (_initializing === job)
+      _initializing = null;
+  }
+}
+async function initDeviceIdentityLocked(profile, options = {}) {
+  const independent = /^desktop-bg-[a-f0-9]{32}$/i.test(profile);
+  if (!independent)
+    await consolidateDeviceIdentity(profile);
   let keypair = null;
   try {
     keypair = loadKeypair(profile);
@@ -300,12 +378,12 @@ async function initDeviceIdentity(profile, options = {}) {
     return;
   }
   const hasStoredKey = storedKeyMaterialExists(profile);
-  if (hasStoredKey && !options.recoverUnreadable) {
+  if (hasStoredKey && (!options.recoverUnreadable || independent)) {
     _state = { kind: "disabled", reason: "unreadable_key" };
     emit("recovery_required", false, { profile, reason: "stored_key_unreadable" });
     return;
   }
-  if (options.createIfMissing === false) {
+  if (options.createIfMissing === false || independent && options.createIfMissing !== true) {
     _state = { kind: "disabled", reason: "no_stored_key" };
     emit("no_stored_key", false, { profile });
     return;
@@ -347,21 +425,25 @@ async function initDeviceIdentity(profile, options = {}) {
   });
 }
 async function resetDeviceIdentity(opts) {
+  if (_initializing)
+    await _initializing;
   if (opts?.clearOnDisk && opts.profile) {
     const targets = [PUBLIC_KEY_FILENAME, PRIVATE_KEY_FILENAME].flatMap((name) => (0, import_profileStateDir.profileStateFilePathsToClear)(opts.profile, name));
-    for (const p of targets) {
-      try {
-        import_node_fs.default.unlinkSync(p);
-      } catch (err) {
-        if (err.code !== "ENOENT") {
-          emit("clear_failed", false, {
-            profile: opts.profile,
-            file: import_node_path.default.basename(p),
-            message: err?.message ?? "unknown"
-          });
+    await withDeviceIdentityLock(opts.profile, async () => {
+      for (const p of targets) {
+        try {
+          import_node_fs.default.unlinkSync(p);
+        } catch (err) {
+          if (err.code !== "ENOENT") {
+            emit("clear_failed", false, {
+              profile: opts.profile,
+              file: import_node_path.default.basename(p),
+              message: err?.message ?? "unknown"
+            });
+          }
         }
       }
-    }
+    });
   }
   _state = { kind: "uninit" };
 }

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;