@skrr-ai/cli 0.1.115 → 0.1.116

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

@@ -1,94 +1,38 @@
 "use strict";
-/**
- * releaseKeys.ts — ed25519 public keys pinned into the daemon binary AND the
- * CLI that installs it.
- *
- * These are the trust anchors the self-updater (`update.ts`) uses to verify
- * the signed release manifest (`daemon/latest/daemon-version.json`) and the
- * downloaded binary artifact OFFLINE, before swapping its own binary. The
- * matching PRIVATE half lives ONLY in CI as the Secrets Manager secret
- * `OVERSKY_RELEASE_SIGNING_KEY` (ed25519, base64 PKCS8) — it is never checked
- * into the repo and never shipped in the binary.
- *
- * CURRENT STATE: a key is pinned (`daemon-2026-07`, provisioned 2026-07-13), so
- * self-update signature verification is FAIL-CLOSED — an unsigned or
- * badly-signed manifest or binary aborts the update.
- *
- * READ THE NEXT PARAGRAPH BEFORE EMPTYING THIS ARRAY.
- *
- * The empty array is not a safe default; it is a DISABLED SECURITY CONTROL.
- * With no key pinned, `update.ts` logs a warning and proceeds on TLS + SHA256
- * only — and the SHA256 comes from the same manifest fetched over the same
- * channel, so it defends against corruption in transit, not against a
- * compromised or spoofed update feed. That posture (mirrored from the desktop
- * `MANIFEST_PUBLIC_KEY=''` default) existed because the keypair had not been
- * minted yet. It has been minted. Removing the last entry below silently
- * re-disables offline verification on every daemon that ships the change, and
- * nothing in the build fails to tell you.
- *
- * To add a key (rotation, or re-provisioning after a compromise) run
- * `node scripts/generate-release-keypair.mjs`. It mints the ed25519 keypair,
- * prints the ready-to-paste `{ keyId, publicKeySpkiB64 }` line for the array
- * below, and prints the commands to store the PRIVATE half in the GitHub
- * secret `OVERSKY_RELEASE_SIGNING_KEY` + AWS Secrets Manager. Never commit the
- * private half; the CI signer reads `OVERSKY_RELEASE_SIGNING_KEY` and MUST
- * import `buildArtifactMessage` / `buildManifestMessage` from
- * `release-manifest.ts` rather than reimplementing them, so signer and verifier
- * can never drift. Add the *next* key alongside the current one BEFORE
- * rotating, so an in-flight rotation verifies against either — the full
- * procedure is the rotation runbook on the array below.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.OVERSKY_RELEASE_PUBLIC_KEYS = void 0;
-/**
- * Pinned release-signing public keys, newest first. Verification tries each
- * key in turn (key rotation: keep current + next together during a rotation
- * window). Non-empty → fail-closed, which is the state today. Empty →
- * verification DISABLED with only a logged warning; see the file header before
- * ever letting this array become empty.
- *
- * ZERO-DOWNTIME KEY-ROTATION RUNBOOK (config-only, no code change):
- *   1. Mint the next keypair: `node scripts/generate-release-keypair.mjs --force`.
- *   2. Pin its public half ABOVE the current key in the array below, and ship
- *      that daemon build so the fleet trusts BOTH keys.
- *   3. Store the new private half as the GH Actions secret
- *      OVERSKY_RELEASE_SIGNING_KEY_NEXT (+ optional OVERSKY_RELEASE_KEY_ID_NEXT
- *      label) — the signer then DUAL-SIGNS every release, emitting the additive
- *      v2 `sigs[]` envelope (scalar `sig` stays = the current/primary key so
- *      daemons that haven't picked up step 2 yet still verify).
- *   4. Cut one release during the overlap window; it verifies for daemons
- *      pinning the old key, the new key, or both (see release-manifest.test.ts
- *      "ROTATION headroom").
- *   5. Once the new-key build has saturated the fleet: promote NEXT→primary
- *      (rename the secret to OVERSKY_RELEASE_SIGNING_KEY), drop the old key from
- *      the array, and remove OVERSKY_RELEASE_SIGNING_KEY_NEXT. No downtime, and
- *      no further code change — the multi-sig machinery is already shipped.
- */
-/**
- * NOT ROTATED FOR THE skrr RENAME. Owner decision, 2026-08-31.
- *
- * A rename is not a compromise. Custody is already established (GH Actions
- * secret `OVERSKY_RELEASE_SIGNING_KEY` + AWS Secrets Manager), the keyId
- * `daemon-2026-07` is a date, not a brand, and no user ever sees any of it.
- *
- * The rotation procedure documented above is shipped and correct — it just has
- * nothing to do here. Running it would cost a fleet-saturation window (step 5)
- * and buy nothing, and the window is exactly when a self-update path is most
- * fragile. Rotate on a compromise or an expiry, not on a rename.
- *
- * The signed message prefix (`oversky-daemon-manifest`) stays for the same
- * reason: it lives inside the signed bytes, so changing it breaks verification
- * between old and new peers with zero user-visible benefit — the same call made
- * for `X-Oversky-Origin`.
- */
-exports.OVERSKY_RELEASE_PUBLIC_KEYS = [
-    // ── NEXT key goes ABOVE this line during a rotation (newest first). ──
-    // Provisioned 2026-07-13. Private half: GH Actions secret
-    // OVERSKY_RELEASE_SIGNING_KEY + AWS Secrets Manager
-    // (us-east-1: oversky/daemon/release-signing-key). Self-update signature
-    // verification is now FAIL-CLOSED.
-    {
-        keyId: 'daemon-2026-07',
-        publicKeySpkiB64: 'MCowBQYDK2VwAyEA7ArbRnkbRW354XZ4MNS1MRLCwrTFauQzsw4GP27mMfI=',
-    },
+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 releaseKeys_exports = {};
+__export(releaseKeys_exports, {
+  OVERSKY_RELEASE_PUBLIC_KEYS: () => OVERSKY_RELEASE_PUBLIC_KEYS
+});
+module.exports = __toCommonJS(releaseKeys_exports);
+const OVERSKY_RELEASE_PUBLIC_KEYS = [
+  // ── NEXT key goes ABOVE this line during a rotation (newest first). ──
+  // Provisioned 2026-07-13. Private half: GH Actions secret
+  // OVERSKY_RELEASE_SIGNING_KEY + AWS Secrets Manager
+  // (us-east-1: oversky/daemon/release-signing-key). Self-update signature
+  // verification is now FAIL-CLOSED.
+  {
+    keyId: "daemon-2026-07",
+    publicKeySpkiB64: "MCowBQYDK2VwAyEA7ArbRnkbRW354XZ4MNS1MRLCwrTFauQzsw4GP27mMfI="
+  }
 ];
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  OVERSKY_RELEASE_PUBLIC_KEYS
+});

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

@@ -1,300 +1,163 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TRUSTED_FEED_ORIGINS = exports.MAX_SIGS = void 0;
-exports.buildArtifactMessage = buildArtifactMessage;
-exports.buildManifestMessage = buildManifestMessage;
-exports.verifyArtifact = verifyArtifact;
-exports.verifyManifest = verifyManifest;
-exports.getDeltaFor = getDeltaFor;
-exports.isTrustedArtifactOrigin = isTrustedArtifactOrigin;
-/**
- * release-manifest.ts — signed daemon release manifest: types, canonical
- * signature messages, and offline ed25519 verification.
- *
- * PURE: depends only on `node:crypto` (plus the sibling `release-keys.ts` for
- * the pinned trust anchors). No Electron, no logger, no fs — so it is
- * unit-testable in isolation and safe to import from the CI release signer.
- *
- * SINGLE SOURCE OF TRUTH: `buildArtifactMessage` and `buildManifestMessage`
- * define the exact bytes that get signed. The CI signer MUST import these
- * functions rather than reimplement them — that is what eliminates
- * signer/verifier drift. Any change here is a wire-format change and must bump
- * the embedded `v1` tag.
- *
- * Mechanics mirror `desktop/src/main/updater/policySignature.ts`: the public
- * key is base64 DER-SPKI, verified with `crypto.verify(null, ...)` (ed25519
- * takes no digest algorithm).
- *
- * WHY IT LIVES IN auth-core NOW
- *
- * It lived in `daemon/src/release-manifest.ts`, and `firstPartyHarnessChannels.ts` beside
- * it recorded the reason for stopping there: "the installer, the signature
- * verification and the promotion machinery stay in the daemon, which is the
- * only process that performs them." That premise held exactly until the CLI
- * had to install the daemon — `skrr daemon install` on a machine with no
- * `skrrd` cannot ask the daemon to verify the daemon.
- *
- * So this is the same road that move was on, not a reversal of it. A MIRROR in
- * the CLI is the alternative and is the wrong one, with precedent: OSK-3894
- * shipped a mirrored harness-trust table and OSK-3897 removed it, because a
- * mirror proves two copies agree rather than proving there is one copy. For a
- * TRUST ROOT that argument is not stylistic — a second copy of the pinned keys
- * is a second thing that can be edited, and the edit that matters (emptying the
- * array) disables verification silently.
- *
- * `SignedReleasePolicy` did NOT move. It is the daemon's own decision envelope,
- * so the manifest is generic over it and the daemon narrows it back.
- */
-const node_crypto_1 = require("node:crypto");
-const releaseKeys_js_1 = require("./releaseKeys.js");
-// ---------------------------------------------------------------------------
-// Canonical signature messages — THE contract. Do not reformat casually.
-// ---------------------------------------------------------------------------
-/**
- * Canonical bytes signed for a single platform artifact. Newline-joined, fixed
- * field order, `v1` tag. `sha256` is lowercased so the message is stable
- * regardless of the hex casing the caller supplies.
- */
+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 releaseManifest_exports = {};
+__export(releaseManifest_exports, {
+  MAX_SIGS: () => MAX_SIGS,
+  TRUSTED_FEED_ORIGINS: () => TRUSTED_FEED_ORIGINS,
+  buildArtifactMessage: () => buildArtifactMessage,
+  buildManifestMessage: () => buildManifestMessage,
+  getDeltaFor: () => getDeltaFor,
+  isTrustedArtifactOrigin: () => isTrustedArtifactOrigin,
+  verifyArtifact: () => verifyArtifact,
+  verifyManifest: () => verifyManifest
+});
+module.exports = __toCommonJS(releaseManifest_exports);
+var import_node_crypto = require("node:crypto");
+var import_releaseKeys = require("./releaseKeys.js");
 function buildArtifactMessage(a) {
-    return [
-        'oversky-daemon-artifact',
-        'v1',
-        a.platform,
-        a.version,
-        a.sha256.toLowerCase(),
-        a.url,
-    ].join('\n');
+  return [
+    "oversky-daemon-artifact",
+    "v1",
+    a.platform,
+    a.version,
+    a.sha256.toLowerCase(),
+    a.url
+  ].join("\n");
 }
-/**
- * Canonical bytes signed for the whole manifest (excluding the top-level
- * `sig`). Platform keys are sorted so the message is independent of JSON key
- * order; each contributes `<platform>=<sha256-lower>`. `forceUpdate` is
- * serialized strictly (`String(forceUpdate === true)` → `"true"`/`"false"`).
- */
 function buildManifestMessage(m) {
-    return [
-        'oversky-daemon-manifest',
-        'v1',
-        m.version,
-        m.minimum,
-        String(m.forceUpdate === true),
-        ...Object.keys(m.platforms)
-            .sort()
-            .map((p) => p + '=' + m.platforms[p].sha256.toLowerCase()),
-    ].join('\n');
+  return [
+    "oversky-daemon-manifest",
+    "v1",
+    m.version,
+    m.minimum,
+    String(m.forceUpdate === true),
+    ...Object.keys(m.platforms).sort().map((p) => p + "=" + m.platforms[p].sha256.toLowerCase())
+  ].join("\n");
 }
-/**
- * Try `sigB64` against every pinned key (supports key rotation: current +
- * next). Never throws — a malformed key or signature is just a failed attempt.
- * Empty key set ⇒ `{ disabled: true }` so the caller can warn-and-proceed
- * (mirrors desktop `MANIFEST_PUBLIC_KEY=''`).
- */
 function verifyWithKeys(message, sigB64, keys) {
-    if (keys.length === 0)
-        return { disabled: true };
-    if (!sigB64)
-        return { ok: false, reason: 'missing signature' };
-    const msg = Buffer.from(message, 'utf8');
-    const sig = Buffer.from(sigB64, 'base64');
-    for (const k of keys) {
-        try {
-            const key = (0, node_crypto_1.createPublicKey)({
-                key: Buffer.from(k.publicKeySpkiB64, 'base64'),
-                format: 'der',
-                type: 'spki',
-            });
-            if ((0, node_crypto_1.verify)(null, msg, key, sig)) {
-                return { ok: true };
-            }
-        }
-        catch {
-            // Malformed key material or verify error → try the next pinned key.
-        }
+  if (keys.length === 0)
+    return { disabled: true };
+  if (!sigB64)
+    return { ok: false, reason: "missing signature" };
+  const msg = Buffer.from(message, "utf8");
+  const sig = Buffer.from(sigB64, "base64");
+  for (const k of keys) {
+    try {
+      const key = (0, import_node_crypto.createPublicKey)({
+        key: Buffer.from(k.publicKeySpkiB64, "base64"),
+        format: "der",
+        type: "spki"
+      });
+      if ((0, import_node_crypto.verify)(null, msg, key, sig)) {
+        return { ok: true };
+      }
+    } catch {
     }
-    return { ok: false, reason: 'signature did not verify against any pinned key' };
+  }
+  return { ok: false, reason: "signature did not verify against any pinned key" };
 }
-/**
- * Upper bound on signatures we will trial-verify per artifact/manifest. A
- * rotation window needs at most 2–3 (current + next). `sigs[]` is NOT part of
- * the signed bytes, so an attacker can pad it; this cap bounds the verify work
- * they can force to O(MAX_SIGS × pinnedKeys) — a few hundred microseconds even
- * at the cap. A valid signature placed beyond the cap is treated as absent.
- */
-exports.MAX_SIGS = 8;
-/**
- * v2 acceptance: `{ ok: true }` if ANY provided signature verifies against ANY
- * pinned key. This composes the two rotation axes — verifyWithKeys already
- * loops every pinned KEY (key rotation); this adds the every-SIGNATURE loop —
- * so a release dual-signed by [old, new] verifies for a daemon pinning only
- * [old], only [new], or both. That is what makes rotation zero-downtime.
- *
- * Posture is identical to v1:
- *  - empty pinned-key set ⇒ `{ disabled: true }` (fail-OPEN, unconfigured);
- *  - keys present but nothing verifies ⇒ `{ ok: false }` (fail-CLOSED);
- * and it never throws (per-key errors are swallowed inside verifyWithKeys).
- *
- * Security: `sigs[]` is attacker-malleable (not in the signed bytes), so trust
- * comes SOLELY from a real ed25519 verify against a pinned key. Padding with
- * garbage is inert; stripping every entry is at worst a denial-of-update
- * (liveness), never a forged accept. keyId is never consulted → no keyId
- * substitution. Each sig independently binds version/minimum/forceUpdate/
- * platform-shas, so cross-manifest splicing is blocked exactly as in v1.
- */
+const MAX_SIGS = 8;
 function verifyWithKeysMulti(message, sigs, keys) {
-    if (keys.length === 0)
-        return { disabled: true };
-    let sawSignature = false;
-    // Bound attacker-supplied work; a real rotation never needs more than a few.
-    for (const entry of sigs.slice(0, exports.MAX_SIGS)) {
-        const sigB64 = typeof entry?.sig === 'string' ? entry.sig : '';
-        if (!sigB64)
-            continue;
-        sawSignature = true;
-        const r = verifyWithKeys(message, sigB64, keys); // keys non-empty ⇒ never {disabled}
-        if ('ok' in r && r.ok)
-            return { ok: true };
-    }
-    return {
-        ok: false,
-        reason: sawSignature
-            ? 'no provided signature verified against any pinned key'
-            : 'missing signature',
-    };
+  if (keys.length === 0)
+    return { disabled: true };
+  let sawSignature = false;
+  for (const entry of sigs.slice(0, MAX_SIGS)) {
+    const sigB64 = typeof entry?.sig === "string" ? entry.sig : "";
+    if (!sigB64)
+      continue;
+    sawSignature = true;
+    const r = verifyWithKeys(message, sigB64, keys);
+    if ("ok" in r && r.ok)
+      return { ok: true };
+  }
+  return {
+    ok: false,
+    reason: sawSignature ? "no provided signature verified against any pinned key" : "missing signature"
+  };
 }
-/**
- * Verify a single platform artifact's `sig` over buildArtifactMessage(...).
- * `platform` is the `<platform>-<arch>` key; `version` is the manifest version
- * the artifact belongs to. Defaults to the baked-in pinned keys.
- */
-function verifyArtifact(platform, version, artifact, keys = releaseKeys_js_1.OVERSKY_RELEASE_PUBLIC_KEYS) {
-    let message;
-    try {
-        message = buildArtifactMessage({
-            platform,
-            version,
-            sha256: artifact.sha256,
-            url: artifact.url,
-        });
-    }
-    catch (err) {
-        // A malformed artifact (missing string fields) must fail-closed as a clean
-        // verification failure, never an uncaught throw.
-        return { ok: false, reason: `malformed artifact: ${err.message}` };
-    }
-    // v2: a present `sigs[]` is authoritative (any-of-N). Otherwise the v1 scalar
-    // path — byte-for-byte the prior behavior.
-    if (Array.isArray(artifact.sigs) && artifact.sigs.length > 0) {
-        return verifyWithKeysMulti(message, artifact.sigs, keys);
-    }
-    return verifyWithKeys(message, artifact.sig, keys);
+function verifyArtifact(platform, version, artifact, keys = import_releaseKeys.OVERSKY_RELEASE_PUBLIC_KEYS) {
+  let message;
+  try {
+    message = buildArtifactMessage({
+      platform,
+      version,
+      sha256: artifact.sha256,
+      url: artifact.url
+    });
+  } catch (err) {
+    return { ok: false, reason: `malformed artifact: ${err.message}` };
+  }
+  if (Array.isArray(artifact.sigs) && artifact.sigs.length > 0) {
+    return verifyWithKeysMulti(message, artifact.sigs, keys);
+  }
+  return verifyWithKeys(message, artifact.sig, keys);
 }
-/**
- * Verify the manifest's top-level `sig` over buildManifestMessage(this).
- * Defaults to the baked-in pinned keys.
- */
-function verifyManifest(manifest, keys = releaseKeys_js_1.OVERSKY_RELEASE_PUBLIC_KEYS) {
-    let message;
-    try {
-        message = buildManifestMessage(manifest);
-    }
-    catch (err) {
-        // A malformed manifest (e.g. a platform entry missing sha256) must
-        // fail-closed as a clean verification failure, never an uncaught throw.
-        return { ok: false, reason: `malformed manifest: ${err.message}` };
-    }
-    // v2: a present `sigs[]` is authoritative (any-of-N). Otherwise the v1 scalar
-    // path — byte-for-byte the prior behavior.
-    if (Array.isArray(manifest.sigs) && manifest.sigs.length > 0) {
-        return verifyWithKeysMulti(message, manifest.sigs, keys);
-    }
-    return verifyWithKeys(message, manifest.sig, keys);
+function verifyManifest(manifest, keys = import_releaseKeys.OVERSKY_RELEASE_PUBLIC_KEYS) {
+  let message;
+  try {
+    message = buildManifestMessage(manifest);
+  } catch (err) {
+    return { ok: false, reason: `malformed manifest: ${err.message}` };
+  }
+  if (Array.isArray(manifest.sigs) && manifest.sigs.length > 0) {
+    return verifyWithKeysMulti(message, manifest.sigs, keys);
+  }
+  return verifyWithKeys(message, manifest.sig, keys);
 }
-// ---------------------------------------------------------------------------
-// Differential updates (delta metadata lookup) — UNSIGNED, optimization only.
-// ---------------------------------------------------------------------------
-/**
- * Look up a delta patch that transforms `fromVersion`'s binary into this
- * artifact's binary. Returns null when none is advertised or the descriptor is
- * malformed — the caller then does a full download. PURE; validates shape only
- * (the delta is UNSIGNED, so trust comes from verifying the RECONSTRUCTED binary
- * against the signed `artifact.sha256`, not from this metadata).
- */
 function getDeltaFor(artifact, fromVersion) {
-    const deltas = artifact.deltas;
-    if (!deltas || typeof deltas !== 'object')
-        return null;
-    const d = deltas[fromVersion];
-    if (!d ||
-        typeof d.url !== 'string' ||
-        typeof d.sha256 !== 'string' ||
-        typeof d.size !== 'number' ||
-        !Number.isFinite(d.size) ||
-        d.size <= 0) {
-        return null;
-    }
-    return d;
+  const deltas = artifact.deltas;
+  if (!deltas || typeof deltas !== "object")
+    return null;
+  const d = deltas[fromVersion];
+  if (!d || typeof d.url !== "string" || typeof d.sha256 !== "string" || typeof d.size !== "number" || !Number.isFinite(d.size) || d.size <= 0) {
+    return null;
+  }
+  return d;
 }
-// ---------------------------------------------------------------------------
-// Trusted artifact origins
-// ---------------------------------------------------------------------------
-/**
- * Origins an artifact may be served from, beyond the feed base this run used.
- *
- * WHY A SET AND NOT THE ONE ORIGIN
- * --------------------------------
- * The pin used to require the artifact origin to EQUAL the feed base's
- * origin. That is correct with one host and unsatisfiable with two, which the
- * skrr rename creates:
- *
- *   - a shipped daemon/CLI has `updates.oversky.ai` compiled in, so a manifest
- *     advertising skrr.ai artifacts is refused and it can never self-update
- *     again — including to the build that would have fixed it;
- *   - a new build shipping `updates.skrr.ai` refuses the SAME manifest for the
- *     mirror-image reason.
- *
- * One manifest of absolute URLs therefore cannot serve both, and the update
- * path is the one thing that must not break: a client that cannot update
- * cannot be repaired remotely.
- *
- * Widening to a small, closed set of origins we publish keeps the property the
- * pin exists for: with keys pinned the ed25519 signature already binds the
- * URL, and this is defence-in-depth for when verification is disabled —
- * stopping a manifest-integrity failure from redirecting a download to an
- * ARBITRARY origin serving a hash-matching payload. An attacker gains nothing
- * from a second origin that is also ours.
- *
- * Both entries are removed down to one when no shipped client uses the old
- * host, per the add -> verify -> remove ordering.
- */
-exports.TRUSTED_FEED_ORIGINS = [
-    'https://updates.oversky.ai',
-    'https://updates.skrr.ai',
+const TRUSTED_FEED_ORIGINS = [
+  "https://updates.oversky.ai",
+  "https://updates.skrr.ai"
 ];
-/**
- * True when `candidate` may serve an artifact for a feed rooted at `feedBase`.
- *
- * The feed base's own origin always passes, so an override
- * (OVERSKY_DAEMON_UPDATE_FEED_BASE, a canary, a test server) keeps working
- * without being listed here.
- */
 function isTrustedArtifactOrigin(candidate, feedBase) {
-    let feedOrigin;
-    try {
-        feedOrigin = new URL(feedBase).origin;
-    }
-    catch {
-        return false;
-    }
-    // Callers hand over either a bare origin (the daemon's self-updater) or a
-    // full artifact URL (the CLI installer) — both spell the same check.
-    let candidateOrigin = candidate;
-    try {
-        candidateOrigin = new URL(candidate).origin;
-    }
-    catch {
-        /* not a URL — compare raw; it will not match anything */
-    }
-    if (candidateOrigin === feedOrigin)
-        return true;
-    return exports.TRUSTED_FEED_ORIGINS.includes(candidateOrigin);
+  let feedOrigin;
+  try {
+    feedOrigin = new URL(feedBase).origin;
+  } catch {
+    return false;
+  }
+  let candidateOrigin = candidate;
+  try {
+    candidateOrigin = new URL(candidate).origin;
+  } catch {
+  }
+  if (candidateOrigin === feedOrigin)
+    return true;
+  return TRUSTED_FEED_ORIGINS.includes(candidateOrigin);
 }
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MAX_SIGS,
+  TRUSTED_FEED_ORIGINS,
+  buildArtifactMessage,
+  buildManifestMessage,
+  getDeltaFor,
+  isTrustedArtifactOrigin,
+  verifyArtifact,
+  verifyManifest
+});