@skrr-ai/cli 0.1.115 → 0.1.117

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

@@ -1,67 +1,53 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
+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 });
 };
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.resolveConfigRoot = resolveConfigRoot;
-exports.configRootPath = configRootPath;
-exports.isConfigRootOverridden = isConfigRootOverridden;
-const node_os_1 = require("node:os");
-const node_path_1 = __importDefault(require("node:path"));
-/**
- * The skrr root — the single definition of where this machine keeps its skrr
- * state.
- *
- * It lives here because BOTH binaries need the same answer and neither owns it.
- * `skrr` and `skrrd` keep separate credentials on purpose, but they share one
- * root, and every place that re-derived it became a place they could disagree.
- * They did, twice in one day:
- *
- *   - The CLI's engine path honoured `OVERSKY_CONFIG_DIR` while its config did
- *     not, so a relocated root moved the engine and left the credentials in
- *     `$HOME`. Fixed by teaching `config.ts` the variable — which promptly
- *     re-created the split in the mirror image, because the engine resolver still read
- *     only the old name.
- *   - The daemon then had the same shape, and fixing the CLI's half turned it
- *     into a CLI/daemon divergence: with the variable set, the two halves of one
- *     product disagreed about where the credentials live.
- *
- * Each of those was a correct local fix that created the next defect, because
- * the root was being DERIVED rather than READ. Teaching every site the same list
- * of variable names only defers the problem to whenever the list changes again —
- * which is exactly what `SKRR_CONFIG_DIR` did.
- *
- * So: one function, and a boundary test that fails if anything re-derives it.
- *
- * `SKRR_CONFIG_DIR` is the spelling for anything new (root `CLAUDE.md`) and wins
- * when both are set. `OVERSKY_CONFIG_DIR` keeps working because existing installs,
- * the engine resolver and the daemon all read it, and breaking a documented
- * override to tidy a name would be a worse trade than carrying two.
- *
- * Takes `env` rather than reading the global so a caller can resolve a root for a
- * child process it is about to spawn, and so tests need no process-wide mutation.
- */
+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 configRoot_exports = {};
+__export(configRoot_exports, {
+  configRootPath: () => configRootPath,
+  isConfigRootOverridden: () => isConfigRootOverridden,
+  resolveConfigRoot: () => resolveConfigRoot
+});
+module.exports = __toCommonJS(configRoot_exports);
+var import_node_os = require("node:os");
+var import_node_path = __toESM(require("node:path"), 1);
 function resolveConfigRoot(env = process.env) {
-    const override = (env.SKRR_CONFIG_DIR || env.OVERSKY_CONFIG_DIR)?.trim();
-    return override || node_path_1.default.join((0, node_os_1.homedir)(), '.skrr');
+  const override = (env.SKRR_CONFIG_DIR || env.OVERSKY_CONFIG_DIR)?.trim();
+  return override || import_node_path.default.join((0, import_node_os.homedir)(), ".skrr");
 }
-/** A path under the skrr root, e.g. `configRootPath(env, 'daemon', 'logs')`. */
 function configRootPath(env, ...segments) {
-    return node_path_1.default.join(resolveConfigRoot(env), ...segments);
+  return import_node_path.default.join(resolveConfigRoot(env), ...segments);
 }
-/**
- * Has the operator explicitly relocated the root?
- *
- * A distinct question from "what is the root", and it has a real caller: the
- * legacy-location fallbacks exist to find state left by an older layout under
- * `$HOME`, and once someone has POINTED the root somewhere, guessing at
- * `$HOME` is no longer a helpful fallback — it is a different machine's data.
- *
- * Shared for the same reason as `resolveConfigRoot`: this check was copied to
- * three call sites, each spelling the variable list itself, so adding
- * `SKRR_CONFIG_DIR` to the resolver silently left the copies answering the old
- * question.
- */
 function isConfigRootOverridden(env = process.env) {
-    return Boolean((env.SKRR_CONFIG_DIR || env.OVERSKY_CONFIG_DIR)?.trim());
+  return Boolean((env.SKRR_CONFIG_DIR || env.OVERSKY_CONFIG_DIR)?.trim());
 }
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  configRootPath,
+  isConfigRootOverridden,
+  resolveConfigRoot
+});

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

@@ -1,230 +1,163 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
+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 });
 };
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.KEY_LEN = exports.ENVELOPE_MAGIC = void 0;
-exports.generateDek = generateDek;
-exports.buildCredentialAad = buildCredentialAad;
-exports.sealBuffer = sealBuffer;
-exports.openBuffer = openBuffer;
-exports.wrap = wrap;
-exports.unwrap = unwrap;
-exports.encrypt = encrypt;
-exports.decrypt = decrypt;
-exports.serialize = serialize;
-exports.deserialize = deserialize;
-exports.isEnvelopeString = isEnvelopeString;
-/**
- * credentialEnvelope.ts — at-rest envelope encryption primitives (L12 Layer 0).
- *
- * NAMING NOTE — this module is the "credential at-rest envelope." It is
- * structurally distinct from `daemon/src/envelope-encryption.ts`, which
- * encrypts wire-protocol session envelopes with a server-known DEK. The
- * two should never share a key, a serialized format, or a rotation
- * policy. We deliberately do NOT use the bare word "envelope" in this
- * module's filename to avoid that confusion; future readers grepping for
- * "envelope" must hit a name that immediately disambiguates which layer
- * they are looking at.
- *
- * Threat model — what this module protects:
- *   - Cold copy of `~/Library/Keychains/login.keychain-db` taken from a
- *     sleeping laptop and brute-forced offline.
- *   - Backup snapshot of `~/.skrr/...` in Time Machine / Backblaze /
- *     Restic that ends up on a less-trusted disk.
- *   - Same-UID malware that reads the on-disk JSON file backend without
- *     standing up an OS prompt.
- *
- * What it does NOT protect:
- *   - Privileged on-host malware (root) reading the daemon's process memory.
- *   - Server-side compromise of refresh tokens that the server already
- *     holds by design.
- *
- * Hierarchy:
- *   plaintext credential
- *     ─ AES-256-GCM(DEK, nonce, AAD) ─▶ sealed credential blob
- *   plaintext DEK (32 bytes, generated locally)
- *     ─ AES-256-GCM(KEK, nonce, AAD) ─▶ wrapped DEK blob
- *   KEK (platform-native; Secure Enclave / DPAPI / libsecret-derived)
- *     never appears in JS memory in unwrappable form.
- *
- * This module owns ONLY the AES-256-GCM primitive plus the serialized
- * format. Platform KEK acquisition lives in `./kek/`. DEK lifecycle
- * (generation, rotation, persistence) lives in the daemon-side bridge.
- */
-const node_crypto_1 = __importDefault(require("node:crypto"));
-const aead_js_1 = require("./aead.js");
-/** Serialized magic prefix. Bumped only on a breaking format change. */
-exports.ENVELOPE_MAGIC = 'osk-env1';
-/** Key length in bytes (256 bits). */
-exports.KEY_LEN = aead_js_1.AEAD_KEY_LEN;
-/** Nonce length in bytes (96 bits — GCM standard). */
-const NONCE_LEN = aead_js_1.AEAD_NONCE_LEN;
-/** GCM authentication tag length in bytes (128 bits). */
-const TAG_LEN = aead_js_1.AEAD_TAG_LEN;
-/**
- * Generate a fresh 256-bit Data Encryption Key. Uses Node's crypto-random
- * source (libsodium-grade on macOS/Linux, BCryptGenRandom on Windows).
- */
+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 credentialEnvelope_exports = {};
+__export(credentialEnvelope_exports, {
+  ENVELOPE_MAGIC: () => ENVELOPE_MAGIC,
+  KEY_LEN: () => KEY_LEN,
+  buildCredentialAad: () => buildCredentialAad,
+  decrypt: () => decrypt,
+  deserialize: () => deserialize,
+  encrypt: () => encrypt,
+  generateDek: () => generateDek,
+  isEnvelopeString: () => isEnvelopeString,
+  openBuffer: () => openBuffer,
+  sealBuffer: () => sealBuffer,
+  serialize: () => serialize,
+  unwrap: () => unwrap,
+  wrap: () => wrap
+});
+module.exports = __toCommonJS(credentialEnvelope_exports);
+var import_node_crypto = __toESM(require("node:crypto"), 1);
+var import_aead = require("./aead.js");
+const ENVELOPE_MAGIC = "osk-env1";
+const KEY_LEN = import_aead.AEAD_KEY_LEN;
+const NONCE_LEN = import_aead.AEAD_NONCE_LEN;
+const TAG_LEN = import_aead.AEAD_TAG_LEN;
 function generateDek() {
-    return node_crypto_1.default.randomBytes(exports.KEY_LEN);
+  return import_node_crypto.default.randomBytes(KEY_LEN);
 }
-/**
- * Build the canonical AAD for binding a sealed credential to a specific
- * profile + envelope version. Including profile in the AAD prevents an
- * attacker who copies a sealed blob from profile `dev` into profile
- * `prod`'s slot from getting a successful decrypt — the AAD won't match.
- *
- * Stable string format so a re-derivation in a future process produces
- * the exact same AAD bytes for the same profile.
- */
 function buildCredentialAad(profile, version = 1) {
-    if (typeof profile !== 'string' || profile.length === 0) {
-        throw new Error('buildCredentialAad: profile must be a non-empty string');
-    }
-    if (!Number.isInteger(version) || version < 1) {
-        throw new Error('buildCredentialAad: version must be a positive integer');
-    }
-    return Buffer.from(`oversky:cred:v${version}:profile=${profile}`, 'utf-8');
+  if (typeof profile !== "string" || profile.length === 0) {
+    throw new Error("buildCredentialAad: profile must be a non-empty string");
+  }
+  if (!Number.isInteger(version) || version < 1) {
+    throw new Error("buildCredentialAad: version must be a positive integer");
+  }
+  return Buffer.from(`oversky:cred:v${version}:profile=${profile}`, "utf-8");
 }
-/**
- * Low-level AEAD seal. The shared primitive used by both DEK-wrapping and
- * credential-encryption — the only difference between those operations is
- * the semantic role of the key, not the cipher. Caller chooses the AAD.
- */
 function sealBuffer(plaintext, key, aad) {
-    if (!Buffer.isBuffer(plaintext)) {
-        throw new TypeError('sealBuffer: plaintext must be a Buffer');
-    }
-    if (!Buffer.isBuffer(key) || key.length !== exports.KEY_LEN) {
-        throw new TypeError(`sealBuffer: key must be a ${exports.KEY_LEN}-byte Buffer`);
-    }
-    const { nonce, ct, tag } = (0, aead_js_1.aeadSeal)(plaintext, key, aad);
-    return { v: 1, nonce, ct, tag };
+  if (!Buffer.isBuffer(plaintext)) {
+    throw new TypeError("sealBuffer: plaintext must be a Buffer");
+  }
+  if (!Buffer.isBuffer(key) || key.length !== KEY_LEN) {
+    throw new TypeError(`sealBuffer: key must be a ${KEY_LEN}-byte Buffer`);
+  }
+  const { nonce, ct, tag } = (0, import_aead.aeadSeal)(plaintext, key, aad);
+  return { v: 1, nonce, ct, tag };
 }
-/**
- * Low-level AEAD open. Throws on tag mismatch (wrong key, AAD mismatch,
- * truncated/corrupted ciphertext) — never silently returns garbage.
- */
 function openBuffer(sealed, key, aad) {
-    if (!sealed || sealed.v !== 1) {
-        throw new Error('openBuffer: unsupported envelope version');
-    }
-    if (!Buffer.isBuffer(key) || key.length !== exports.KEY_LEN) {
-        throw new TypeError(`openBuffer: key must be a ${exports.KEY_LEN}-byte Buffer`);
-    }
-    if (!Buffer.isBuffer(sealed.nonce) || sealed.nonce.length !== NONCE_LEN) {
-        throw new Error('openBuffer: invalid nonce length');
-    }
-    if (!Buffer.isBuffer(sealed.tag) || sealed.tag.length !== TAG_LEN) {
-        throw new Error('openBuffer: invalid auth tag length');
-    }
-    if (!Buffer.isBuffer(sealed.ct)) {
-        throw new Error('openBuffer: invalid ciphertext');
-    }
-    return (0, aead_js_1.aeadOpen)(sealed, key, aad);
+  if (!sealed || sealed.v !== 1) {
+    throw new Error("openBuffer: unsupported envelope version");
+  }
+  if (!Buffer.isBuffer(key) || key.length !== KEY_LEN) {
+    throw new TypeError(`openBuffer: key must be a ${KEY_LEN}-byte Buffer`);
+  }
+  if (!Buffer.isBuffer(sealed.nonce) || sealed.nonce.length !== NONCE_LEN) {
+    throw new Error("openBuffer: invalid nonce length");
+  }
+  if (!Buffer.isBuffer(sealed.tag) || sealed.tag.length !== TAG_LEN) {
+    throw new Error("openBuffer: invalid auth tag length");
+  }
+  if (!Buffer.isBuffer(sealed.ct)) {
+    throw new Error("openBuffer: invalid ciphertext");
+  }
+  return (0, import_aead.aeadOpen)(sealed, key, aad);
 }
-/**
- * Wrap a 32-byte DEK under a KEK. The wrapped DEK is what gets persisted
- * to disk — the KEK itself never leaves its platform store.
- */
 function wrap(dek, kek, aad) {
-    if (!Buffer.isBuffer(dek) || dek.length !== exports.KEY_LEN) {
-        throw new TypeError(`wrap: dek must be a ${exports.KEY_LEN}-byte Buffer`);
-    }
-    return sealBuffer(dek, kek, aad);
+  if (!Buffer.isBuffer(dek) || dek.length !== KEY_LEN) {
+    throw new TypeError(`wrap: dek must be a ${KEY_LEN}-byte Buffer`);
+  }
+  return sealBuffer(dek, kek, aad);
 }
-/**
- * Unwrap a previously-wrapped DEK using the same KEK. AAD must match the
- * value used at wrap time or the GCM tag check fails.
- */
 function unwrap(wrapped, kek, aad) {
-    const out = openBuffer(wrapped, kek, aad);
-    if (out.length !== exports.KEY_LEN) {
-        throw new Error(`unwrap: unwrapped DEK has wrong length (got ${out.length})`);
-    }
-    return out;
+  const out = openBuffer(wrapped, kek, aad);
+  if (out.length !== KEY_LEN) {
+    throw new Error(`unwrap: unwrapped DEK has wrong length (got ${out.length})`);
+  }
+  return out;
 }
-/**
- * Encrypt a credential (string or Buffer) under a DEK. Strings are
- * encoded as UTF-8 before sealing; the open path returns a Buffer so the
- * caller decides how to interpret it.
- */
 function encrypt(plaintext, dek, aad) {
-    const buf = typeof plaintext === 'string' ? Buffer.from(plaintext, 'utf-8') : plaintext;
-    return sealBuffer(buf, dek, aad);
+  const buf = typeof plaintext === "string" ? Buffer.from(plaintext, "utf-8") : plaintext;
+  return sealBuffer(buf, dek, aad);
 }
-/**
- * Decrypt a credential previously sealed with `encrypt`. Returns the raw
- * plaintext bytes; UTF-8-decode at the call site if the original was a
- * string.
- */
 function decrypt(sealed, dek, aad) {
-    return openBuffer(sealed, dek, aad);
+  return openBuffer(sealed, dek, aad);
 }
-// ---------------------------------------------------------------------------
-// String serialization — keychain slots and JSON files store strings, so a
-// SealedBlob has to round-trip through a single text token.
-//
-// Format:  osk-env1:<b64u(nonce)>:<b64u(ct)>:<b64u(tag)>
-// Length:  ~88 chars for a typical 100-byte plaintext (well under the
-//          keychain's per-slot limit).
-// ---------------------------------------------------------------------------
-/** URL-safe base64 (no padding) — keychain-friendly, no `=` to confuse parsers. */
 function b64u(buf) {
-    return buf.toString('base64').replace(/=+$/, '').replace(/\+/g, '-').replace(/\//g, '_');
+  return buf.toString("base64").replace(/=+$/, "").replace(/\+/g, "-").replace(/\//g, "_");
 }
 function b64uDecode(s) {
-    const padded = s.replace(/-/g, '+').replace(/_/g, '/');
-    const pad = padded.length % 4;
-    return Buffer.from(pad === 0 ? padded : padded + '='.repeat(4 - pad), 'base64');
+  const padded = s.replace(/-/g, "+").replace(/_/g, "/");
+  const pad = padded.length % 4;
+  return Buffer.from(pad === 0 ? padded : padded + "=".repeat(4 - pad), "base64");
 }
-/**
- * Serialize a SealedBlob to a single text token. Stable across processes
- * and platforms — same blob serializes to the same string everywhere.
- */
 function serialize(sealed) {
-    if (!sealed || sealed.v !== 1) {
-        throw new Error('serialize: unsupported envelope version');
-    }
-    return `${exports.ENVELOPE_MAGIC}:${b64u(sealed.nonce)}:${b64u(sealed.ct)}:${b64u(sealed.tag)}`;
+  if (!sealed || sealed.v !== 1) {
+    throw new Error("serialize: unsupported envelope version");
+  }
+  return `${ENVELOPE_MAGIC}:${b64u(sealed.nonce)}:${b64u(sealed.ct)}:${b64u(sealed.tag)}`;
 }
-/**
- * Parse a serialized envelope string. Returns null on any malformed
- * input — callers should treat null as "this is not an envelope" and
- * fall through to the legacy plaintext path.
- *
- * Deliberately tolerant: garbage in returns null, never throws. Throws
- * are reserved for the cipher path so a wrong key surfaces as a real
- * authentication failure instead of being silently swallowed.
- */
 function deserialize(s) {
-    if (typeof s !== 'string' || s.length === 0)
-        return null;
-    const parts = s.split(':');
-    if (parts.length !== 4)
-        return null;
-    if (parts[0] !== exports.ENVELOPE_MAGIC)
-        return null;
-    try {
-        const nonce = b64uDecode(parts[1]);
-        const ct = b64uDecode(parts[2]);
-        const tag = b64uDecode(parts[3]);
-        if (nonce.length !== NONCE_LEN || tag.length !== TAG_LEN)
-            return null;
-        return { v: 1, nonce, ct, tag };
-    }
-    catch {
-        return null;
-    }
+  if (typeof s !== "string" || s.length === 0)
+    return null;
+  const parts = s.split(":");
+  if (parts.length !== 4)
+    return null;
+  if (parts[0] !== ENVELOPE_MAGIC)
+    return null;
+  try {
+    const nonce = b64uDecode(parts[1]);
+    const ct = b64uDecode(parts[2]);
+    const tag = b64uDecode(parts[3]);
+    if (nonce.length !== NONCE_LEN || tag.length !== TAG_LEN)
+      return null;
+    return { v: 1, nonce, ct, tag };
+  } catch {
+    return null;
+  }
 }
-/**
- * Cheap structural check — does this string LOOK like a serialized
- * envelope? Used by dual-read paths to decide whether to attempt a
- * decrypt or to treat the value as legacy plaintext. A true return does
- * NOT guarantee the contents are valid; the actual decrypt is what
- * authenticates the value.
- */
 function isEnvelopeString(s) {
-    return typeof s === 'string' && s.startsWith(`${exports.ENVELOPE_MAGIC}:`);
+  return typeof s === "string" && s.startsWith(`${ENVELOPE_MAGIC}:`);
 }
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ENVELOPE_MAGIC,
+  KEY_LEN,
+  buildCredentialAad,
+  decrypt,
+  deserialize,
+  encrypt,
+  generateDek,
+  isEnvelopeString,
+  openBuffer,
+  sealBuffer,
+  serialize,
+  unwrap,
+  wrap
+});