npmcordon 0.0.0-stage → 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Sahil Kumar Singh
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,14 @@
-# Temporary Holding Version
+# npmcordon
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+The command line guard of [Cordon](https://github.com/SahilKumar75/cordon), a circuit breaker for npm dependencies. It reads the Sealed list from the SealRegistry contract and blocks sealed package versions in your lockfile before npm installs or runs them.
+
+Testnet prototype: npm lockfile v2 and v3 only, and one operator runs every detector and the guardian key today.
+
+```sh
+export CHAIN_ID=84532 RPC_URL=https://sepolia.base.org
+export REGISTRY_ADDRESS=0x07DCC100d48fBA912fEf3e14F61d1162596a0E8F REGISTRY_START_BLOCK=55415999
+export GUARD_CACHE_DIR=$HOME/.cordon
+npx npmcordon check --lockfile path/to/project
+```
+
+Exit code 0 means allowed, 1 blocked, 2 unavailable. Other commands: install, audit, rollback, sidecar. Details, limits and the demo are in the [repository](https://github.com/SahilKumar75/cordon).

package/dist/cordon.js

@@ -0,0 +1,1250 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { execFile, spawn } from "node:child_process";
+import { parseArgs, promisify } from "node:util";
+
+// src/audit.ts
+import { existsSync as existsSync3, readdirSync, readFileSync as readFileSync2, statSync as statSync2 } from "node:fs";
+import { basename as basename2, dirname as dirname3, isAbsolute, join as join4 } from "node:path";
+import { Parser, list as listTar } from "tar";
+
+// ../shared/src/constants.ts
+var productName = "Cordon";
+var ecosystem = "npm";
+var entryStatusNames = ["Sealed", "Unsealed", "Cleared", "Suspect"];
+var detectorIds = ["staticScripts", "sandboxCanary", "advisoryFeed"];
+var timelineKinds = ["published", "verdict", "sealed", "guardBlocked", "unsealed", "resealed", "promoted", "cleared"];
+var guardOutcomes = ["allowed", "blocked", "unavailable"];
+var listSources = ["chain", "snapshot", "none"];
+var zeroHash = `0x${"0".repeat(64)}`;
+
+// ../shared/src/schemas.ts
+import { z } from "zod";
+var hex32Schema = z.string().regex(/^0x[0-9a-f]{64}$/);
+var addressSchema = z.string().regex(/^0x[0-9a-fA-F]{40}$/);
+var signatureSchema = z.string().regex(/^0x[0-9a-fA-F]+$/);
+var packageVersionSchema = z.object({
+  name: z.string().min(1).max(214),
+  version: z.string().min(1)
+});
+var scanRequestSchema = packageVersionSchema.extend({
+  tarballUrl: z.string().url(),
+  integrity: z.string().min(1),
+  publishedAt: z.string().datetime()
+});
+var replayRequestSchema = z.object({
+  advisoryId: z.string().min(1)
+});
+var replayTimelineSchema = z.object({
+  replay: z.literal(true),
+  advisoryId: z.string().min(1),
+  advisoryUrl: z.string().url(),
+  packages: z.array(packageVersionSchema).min(1),
+  events: z.array(
+    z.object({
+      label: z.string().min(1),
+      at: z.string().datetime(),
+      sourceUrl: z.string().url()
+    })
+  )
+});
+var findingSchema = z.object({
+  rule: z.string().min(1),
+  detail: z.string(),
+  file: z.string().nullable()
+});
+var evidenceSchema = packageVersionSchema.extend({
+  detector: z.enum(detectorIds),
+  integrity: z.string().min(1),
+  malicious: z.boolean(),
+  simulated: z.boolean(),
+  findings: z.array(findingSchema),
+  advisoryUrl: z.string().url().nullable(),
+  observedAt: z.string().datetime()
+});
+var verdictSchema = z.object({
+  key: hex32Schema,
+  detector: z.enum(detectorIds),
+  detectorAddress: addressSchema,
+  evidenceHash: hex32Schema,
+  malicious: z.boolean(),
+  simulated: z.boolean(),
+  txHash: hex32Schema.nullable(),
+  submittedAt: z.string().datetime()
+});
+var attestationSchema = verdictSchema.merge(packageVersionSchema);
+var detectorInfoSchema = z.object({
+  id: z.enum(detectorIds),
+  address: addressSchema,
+  simulated: z.boolean()
+});
+var registryChangeSchema = packageVersionSchema.extend({
+  seq: z.number().int().nonnegative(),
+  publishedAt: z.string().datetime(),
+  tarballUrl: z.string().url(),
+  integrity: z.string().min(1)
+});
+var scanResponseSchema = packageVersionSchema.extend({
+  key: hex32Schema,
+  verdicts: z.array(verdictSchema),
+  failures: z.array(z.object({ detector: z.enum(detectorIds), error: z.string() }))
+});
+var sealEntrySchema = packageVersionSchema.extend({
+  key: hex32Schema,
+  status: z.enum(entryStatusNames),
+  sealedAt: z.string().datetime().nullable(),
+  votes: z.number().int().nonnegative(),
+  suspectUntil: z.string().datetime().nullable()
+});
+var sealedSnapshotSchema = z.object({
+  product: z.literal(productName),
+  chainId: z.number().int().positive(),
+  registry: addressSchema,
+  blockNumber: z.number().int().nonnegative(),
+  generatedAt: z.string().datetime(),
+  entries: z.array(sealEntrySchema),
+  timelineHeads: z.array(z.object({ key: hex32Schema, hash: hex32Schema }))
+});
+var signedSnapshotSchema = z.object({
+  snapshot: sealedSnapshotSchema,
+  signer: addressSchema,
+  signature: signatureSchema
+});
+var timelineEventSchema = z.object({
+  key: hex32Schema,
+  kind: z.enum(timelineKinds),
+  at: z.string().datetime(),
+  actor: z.string().min(1),
+  ref: z.string().nullable(),
+  prevHash: hex32Schema,
+  hash: hex32Schema
+});
+var stopwatchSchema = packageVersionSchema.extend({
+  key: hex32Schema,
+  simulated: z.boolean(),
+  publishedAt: z.string().datetime(),
+  firstVerdictAt: z.string().datetime().nullable(),
+  sealedAt: z.string().datetime().nullable(),
+  firstBlockAt: z.string().datetime().nullable()
+});
+var guardBlockSchema = packageVersionSchema.extend({
+  key: hex32Schema,
+  lockfilePath: z.string(),
+  alreadyInstalled: z.boolean()
+});
+var guardSuspectSchema = packageVersionSchema.extend({
+  key: hex32Schema,
+  lockfilePath: z.string(),
+  votes: z.number().int().nonnegative(),
+  suspectUntil: z.string().datetime().nullable(),
+  allowed: z.boolean()
+});
+var guardReportSchema = z.object({
+  product: z.literal(productName),
+  service: z.string().nullable(),
+  lockfile: z.string(),
+  checkedAt: z.string().datetime(),
+  listSource: z.enum(listSources),
+  fallback: z.object({ minAgeDays: z.number().int().positive(), placeholder: z.boolean() }).nullable(),
+  packagesChecked: z.number().int().nonnegative(),
+  blocked: z.array(guardBlockSchema),
+  suspect: z.array(guardSuspectSchema),
+  snapshotAgeSeconds: z.number().int().nonnegative().nullable(),
+  nonRegistrySources: z.array(
+    packageVersionSchema.extend({
+      resolved: z.string(),
+      kind: z.enum(["git", "github", "commit", "tarball", "file", "other"]),
+      lockfilePath: z.string()
+    })
+  ),
+  hookFiles: z.array(z.object({ path: z.string(), tool: z.string() })),
+  tooYoung: z.array(packageVersionSchema.extend({ publishedAt: z.string().datetime().nullable() })),
+  rollback: z.array(z.object({ name: z.string(), from: z.string(), to: z.string().nullable() })),
+  advice: z.array(z.string()),
+  outcome: z.enum(guardOutcomes)
+});
+var signedGuardReportSchema = z.object({
+  report: guardReportSchema,
+  signer: addressSchema,
+  signature: signatureSchema
+});
+var reportAckSchema = z.object({
+  recorded: z.number().int().nonnegative()
+});
+var serviceStatusSchema = z.object({
+  service: z.string().min(1),
+  healthy: z.boolean(),
+  report: guardReportSchema,
+  updatedAt: z.string().datetime()
+});
+var apiErrorSchema = z.object({
+  error: z.string()
+});
+
+// ../shared/src/hashing.ts
+import { encodeAbiParameters, keccak256, toBytes } from "viem";
+function stableStringify(value) {
+  if (Array.isArray(value)) return `[${value.map(stableStringify).join(",")}]`;
+  if (value !== null && typeof value === "object") {
+    const entries = Object.entries(value).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0);
+    return `{${entries.map(([key, item]) => `${JSON.stringify(key)}:${stableStringify(item)}`).join(",")}}`;
+  }
+  return JSON.stringify(value);
+}
+function hashJson(value) {
+  return keccak256(toBytes(stableStringify(value)));
+}
+function sealKeyOf(name, version) {
+  return keccak256(
+    encodeAbiParameters([{ type: "string" }, { type: "string" }, { type: "string" }], [ecosystem, name, version])
+  );
+}
+function snapshotDigestOf(snapshot) {
+  return hashJson(snapshot);
+}
+function guardReportDigestOf(report) {
+  return hashJson(report);
+}
+
+// ../shared/src/chain.ts
+import { defineChain } from "viem";
+
+// ../shared/src/abis/sealRegistry.ts
+var sealKeyInput = { name: "key", type: "bytes32" };
+var sealRegistryAbi = [
+  {
+    type: "constructor",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "guardian", type: "address" },
+      { name: "detectors", type: "address[]" },
+      { name: "quorum_", type: "uint16" },
+      { name: "disputeWindow_", type: "uint64" },
+      { name: "voteLifetime_", type: "uint64" },
+      { name: "maxSealsPerDay_", type: "uint16" }
+    ]
+  },
+  { type: "function", name: "DETECTOR_ROLE", stateMutability: "view", inputs: [], outputs: [{ name: "", type: "bytes32" }] },
+  { type: "function", name: "GUARDIAN_ROLE", stateMutability: "view", inputs: [], outputs: [{ name: "", type: "bytes32" }] },
+  { type: "function", name: "quorum", stateMutability: "view", inputs: [], outputs: [{ name: "", type: "uint16" }] },
+  { type: "function", name: "disputeWindow", stateMutability: "view", inputs: [], outputs: [{ name: "", type: "uint64" }] },
+  { type: "function", name: "voteLifetime", stateMutability: "view", inputs: [], outputs: [{ name: "", type: "uint64" }] },
+  { type: "function", name: "maxSealsPerDay", stateMutability: "view", inputs: [], outputs: [{ name: "", type: "uint16" }] },
+  {
+    type: "function",
+    name: "keyOf",
+    stateMutability: "pure",
+    inputs: [
+      { name: "ecosystem", type: "string" },
+      { name: "name", type: "string" },
+      { name: "version", type: "string" }
+    ],
+    outputs: [{ name: "", type: "bytes32" }]
+  },
+  {
+    type: "function",
+    name: "submitVerdict",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "ecosystem", type: "string" },
+      { name: "name", type: "string" },
+      { name: "version", type: "string" },
+      { name: "evidenceHash", type: "bytes32" }
+    ],
+    outputs: [{ name: "key", type: "bytes32" }]
+  },
+  {
+    type: "function",
+    name: "promote",
+    stateMutability: "nonpayable",
+    inputs: [sealKeyInput, { name: "reasonHash", type: "bytes32" }],
+    outputs: []
+  },
+  {
+    type: "function",
+    name: "clear",
+    stateMutability: "nonpayable",
+    inputs: [sealKeyInput, { name: "reasonHash", type: "bytes32" }],
+    outputs: []
+  },
+  {
+    type: "function",
+    name: "unseal",
+    stateMutability: "nonpayable",
+    inputs: [sealKeyInput, { name: "reasonHash", type: "bytes32" }],
+    outputs: []
+  },
+  {
+    type: "function",
+    name: "reseal",
+    stateMutability: "nonpayable",
+    inputs: [sealKeyInput, { name: "reasonHash", type: "bytes32" }],
+    outputs: []
+  },
+  {
+    type: "function",
+    name: "getSeal",
+    stateMutability: "view",
+    inputs: [sealKeyInput],
+    outputs: [
+      {
+        name: "",
+        type: "tuple",
+        components: [
+          { name: "status", type: "uint8" },
+          { name: "votes", type: "uint16" },
+          { name: "firstVoteAt", type: "uint64" },
+          { name: "sealedAt", type: "uint64" },
+          { name: "unsealedAt", type: "uint64" },
+          { name: "clearedAt", type: "uint64" }
+        ]
+      }
+    ]
+  },
+  { type: "function", name: "isSealed", stateMutability: "view", inputs: [sealKeyInput], outputs: [{ name: "", type: "bool" }] },
+  {
+    type: "function",
+    name: "hasVoted",
+    stateMutability: "view",
+    inputs: [sealKeyInput, { name: "detector", type: "address" }],
+    outputs: [{ name: "", type: "bool" }]
+  },
+  {
+    type: "function",
+    name: "canVote",
+    stateMutability: "view",
+    inputs: [sealKeyInput, { name: "detector", type: "address" }],
+    outputs: [{ name: "", type: "bool" }]
+  },
+  { type: "function", name: "liveVotes", stateMutability: "view", inputs: [sealKeyInput], outputs: [{ name: "", type: "uint16" }] },
+  { type: "function", name: "isSuspect", stateMutability: "view", inputs: [sealKeyInput], outputs: [{ name: "", type: "bool" }] },
+  { type: "function", name: "flaggedKeyCount", stateMutability: "view", inputs: [], outputs: [{ name: "", type: "uint256" }] },
+  {
+    type: "function",
+    name: "flaggedKeys",
+    stateMutability: "view",
+    inputs: [
+      { name: "offset", type: "uint256" },
+      { name: "limit", type: "uint256" }
+    ],
+    outputs: [
+      { name: "keys", type: "bytes32[]" },
+      { name: "statuses", type: "uint8[]" },
+      { name: "votes", type: "uint16[]" }
+    ]
+  },
+  { type: "function", name: "sealedKeyCount", stateMutability: "view", inputs: [], outputs: [{ name: "", type: "uint256" }] },
+  {
+    type: "function",
+    name: "sealedKeys",
+    stateMutability: "view",
+    inputs: [
+      { name: "offset", type: "uint256" },
+      { name: "limit", type: "uint256" }
+    ],
+    outputs: [
+      { name: "keys", type: "bytes32[]" },
+      { name: "statuses", type: "uint8[]" }
+    ]
+  },
+  {
+    type: "event",
+    name: "VerdictSubmitted",
+    anonymous: false,
+    inputs: [
+      { name: "key", type: "bytes32", indexed: true },
+      { name: "detector", type: "address", indexed: true },
+      { name: "evidenceHash", type: "bytes32", indexed: false },
+      { name: "votes", type: "uint16", indexed: false },
+      { name: "at", type: "uint64", indexed: false }
+    ]
+  },
+  {
+    type: "event",
+    name: "Sealed",
+    anonymous: false,
+    inputs: [
+      { name: "key", type: "bytes32", indexed: true },
+      { name: "ecosystem", type: "string", indexed: false },
+      { name: "name", type: "string", indexed: false },
+      { name: "version", type: "string", indexed: false },
+      { name: "votes", type: "uint16", indexed: false },
+      { name: "at", type: "uint64", indexed: false }
+    ]
+  },
+  {
+    type: "event",
+    name: "Unsealed",
+    anonymous: false,
+    inputs: [
+      { name: "key", type: "bytes32", indexed: true },
+      { name: "guardian", type: "address", indexed: true },
+      { name: "reasonHash", type: "bytes32", indexed: false },
+      { name: "at", type: "uint64", indexed: false }
+    ]
+  },
+  {
+    type: "event",
+    name: "Resealed",
+    anonymous: false,
+    inputs: [
+      { name: "key", type: "bytes32", indexed: true },
+      { name: "guardian", type: "address", indexed: true },
+      { name: "reasonHash", type: "bytes32", indexed: false },
+      { name: "at", type: "uint64", indexed: false }
+    ]
+  },
+  {
+    type: "event",
+    name: "Promoted",
+    anonymous: false,
+    inputs: [
+      { name: "key", type: "bytes32", indexed: true },
+      { name: "guardian", type: "address", indexed: true },
+      { name: "reasonHash", type: "bytes32", indexed: false },
+      { name: "at", type: "uint64", indexed: false }
+    ]
+  },
+  {
+    type: "event",
+    name: "Cleared",
+    anonymous: false,
+    inputs: [
+      { name: "key", type: "bytes32", indexed: true },
+      { name: "guardian", type: "address", indexed: true },
+      { name: "reasonHash", type: "bytes32", indexed: false },
+      { name: "at", type: "uint64", indexed: false }
+    ]
+  },
+  { type: "error", name: "InvalidConfig", inputs: [] },
+  { type: "error", name: "EmptyEvidence", inputs: [] },
+  { type: "error", name: "InvalidEcosystem", inputs: [] },
+  { type: "error", name: "RolesFrozen", inputs: [] },
+  {
+    type: "error",
+    name: "DuplicateVote",
+    inputs: [sealKeyInput, { name: "detector", type: "address" }]
+  },
+  { type: "error", name: "AlreadySealed", inputs: [sealKeyInput] },
+  { type: "error", name: "KeyUnsealed", inputs: [sealKeyInput] },
+  { type: "error", name: "NotSealed", inputs: [sealKeyInput] },
+  { type: "error", name: "NotUnsealed", inputs: [sealKeyInput] },
+  { type: "error", name: "KeyCleared", inputs: [sealKeyInput] },
+  { type: "error", name: "NotSuspect", inputs: [sealKeyInput] },
+  { type: "error", name: "DisputeWindowOpen", inputs: [{ name: "opensAt", type: "uint64" }] },
+  { type: "error", name: "SealRateLimited", inputs: [{ name: "day", type: "uint64" }] },
+  {
+    type: "error",
+    name: "AccessControlUnauthorizedAccount",
+    inputs: [
+      { name: "account", type: "address" },
+      { name: "neededRole", type: "bytes32" }
+    ]
+  }
+];
+
+// src/check.ts
+import { join as join3 } from "node:path";
+import { privateKeyToAccount } from "viem/accounts";
+
+// src/lockfile.ts
+import { existsSync, readFileSync, statSync } from "node:fs";
+import { basename, dirname, join } from "node:path";
+var lockfileNames = ["npm-shrinkwrap.json", "package-lock.json"];
+var hiddenLockfileName = ".package-lock.json";
+var maxLockfileBytes = 64 * 1024 * 1024;
+var defaultRegistryUrl = "https://registry.npmjs.org";
+var gitPattern = /^git(\+[a-z]+)?:/;
+var githubPattern = /^(github:|https?:\/\/codeload\.github\.com\/)|^[\w.]+\/[\w.]+(#.*)?$/;
+var semverPattern = /^\d+\.\d+\.\d+([+-][\w.]+)*$/;
+function originOf(url) {
+  return URL.canParse(url) ? new URL(url).origin : null;
+}
+function sourceKindOf(entry, registryUrl) {
+  const source = entry.resolved ?? entry.version;
+  if (gitPattern.test(source) || githubPattern.test(source)) {
+    if (source.includes("#")) return "commit";
+    return gitPattern.test(source) ? "git" : "github";
+  }
+  if (source.startsWith("file:")) return "file";
+  if (/^https?:\/\//.test(source)) return originOf(source) === originOf(registryUrl) ? null : "tarball";
+  return semverPattern.test(source) ? null : "other";
+}
+function nonRegistrySourcesOf(entries, lockfilePath, registryUrl) {
+  return entries.flatMap((entry) => {
+    const kind = sourceKindOf(entry, registryUrl);
+    return kind ? [{ name: entry.name, version: entry.version, resolved: entry.resolved ?? entry.version, kind, lockfilePath }] : [];
+  });
+}
+function resolveLockfilePath(target) {
+  if (!existsSync(target) || !statSync(target).isDirectory()) return target;
+  const found = lockfileNames.map((name) => join(target, name)).find((path) => existsSync(path));
+  return found ?? join(target, lockfileNames[1]);
+}
+function directoryOf(target) {
+  return existsSync(target) && statSync(target).isDirectory() ? target : dirname(target);
+}
+function readJson(path) {
+  try {
+    return JSON.parse(readFileSync(path, "utf8"));
+  } catch (error) {
+    if (error instanceof SyntaxError || error.code === "ENOENT") return null;
+    throw new Error(`cannot read ${path}: ${error.message}`);
+  }
+}
+var tarballPathPattern = /\/((?:@[^/]+\/)?[^/@][^/]*)\/-\/([^/]+)\.tgz$/;
+function tarballIdentityOf(resolved) {
+  if (!resolved || !URL.canParse(resolved)) return null;
+  const match = tarballPathPattern.exec(decodeURIComponent(new URL(resolved).pathname));
+  if (!match) return null;
+  const name = match[1];
+  const file = match[2];
+  const unscoped = name.slice(name.lastIndexOf("/") + 1);
+  if (!file.startsWith(`${unscoped}-`)) return null;
+  return { name, version: file.slice(unscoped.length + 1) };
+}
+function entriesOf(packages) {
+  return Object.entries(packages).flatMap(([path, entry]) => {
+    if (!path.includes("node_modules/") || entry.link === true) return [];
+    if (typeof entry.version !== "string") return [];
+    const declared = typeof entry.name === "string" ? entry.name : path.slice(path.lastIndexOf("node_modules/") + "node_modules/".length);
+    const resolved = typeof entry.resolved === "string" ? entry.resolved : null;
+    const fetched = tarballIdentityOf(resolved);
+    return [{ name: fetched?.name ?? declared, version: fetched?.version ?? entry.version, path, resolved }];
+  });
+}
+function readLockfile(path, acceptedNames = lockfileNames) {
+  if (!existsSync(path)) return { ok: false, path, reason: `no lockfile at ${path}` };
+  if (!acceptedNames.includes(basename(path))) {
+    return { ok: false, path, reason: `${path} is not ${acceptedNames.join(" or ")}, the only formats supported here` };
+  }
+  if (statSync(path).size > maxLockfileBytes) return { ok: false, path, reason: `${path} is larger than ${maxLockfileBytes} bytes` };
+  const parsed = readJson(path);
+  if (parsed === null || typeof parsed !== "object") return { ok: false, path, reason: `${path} is not valid JSON` };
+  if (parsed.lockfileVersion !== 2 && parsed.lockfileVersion !== 3) {
+    return { ok: false, path, reason: `${path} has lockfileVersion ${String(parsed.lockfileVersion)}, only 2 and 3 are supported` };
+  }
+  if (parsed.packages === null || typeof parsed.packages !== "object") {
+    return { ok: false, path, reason: `${path} has no packages section` };
+  }
+  return { ok: true, path, entries: entriesOf(parsed.packages) };
+}
+
+// src/registry.ts
+function packumentReader(registryUrl, fetchFn, warn, timeoutMs) {
+  const cache = /* @__PURE__ */ new Map();
+  let warned = false;
+  const load = async (name) => {
+    if (!registryUrl) return null;
+    const url = `${registryUrl.replace(/\/$/, "")}/${name.replace("/", "%2f")}`;
+    return fetchFn(url, { signal: AbortSignal.timeout(timeoutMs) }).then((response) => {
+      if (!response.ok) throw new Error(`${url} answered ${response.status}`);
+      return response.json();
+    }).catch((error) => {
+      if (!warned) warn(`registry metadata unavailable, first failure: ${error.message}`);
+      warned = true;
+      return null;
+    });
+  };
+  return (name) => {
+    const known = cache.get(name) ?? load(name);
+    cache.set(name, known);
+    return known;
+  };
+}
+function publishedAtOf(packument, version) {
+  const raw = packument?.time?.[version];
+  const time = raw ? Date.parse(raw) : Number.NaN;
+  return Number.isNaN(time) ? null : new Date(time);
+}
+function isOlderThan(publishedAt, days, now) {
+  return publishedAt !== null && now.getTime() - publishedAt.getTime() >= days * 864e5;
+}
+function coreOf(version) {
+  const match = /^(\d+)\.(\d+)\.(\d+)/.exec(version);
+  return match ? match.slice(1).map(Number) : [];
+}
+function compareCores(left, right) {
+  const a = coreOf(left);
+  const b = coreOf(right);
+  const index = [0, 1, 2].find((position) => a[position] !== b[position]);
+  return index === void 0 ? 0 : (a[index] ?? -1) - (b[index] ?? -1);
+}
+function isRelease(version) {
+  return /^\d+\.\d+\.\d+(\+.*)?$/.test(version);
+}
+
+// src/rollback.ts
+async function proposeOne(target, limits, readPackument) {
+  const packument = await readPackument(target.name);
+  const versions = Object.keys(packument?.versions ?? packument?.time ?? {});
+  const isSafe = (version) => !limits.sealedKeys.has(sealKeyOf(target.name, version)) && (limits.minAgeDays === 0 || isOlderThan(publishedAtOf(packument, version), limits.minAgeDays, limits.now));
+  const candidates = versions.filter((version) => isRelease(version) && compareCores(version, target.version) < 0 && isSafe(version));
+  return { name: target.name, from: target.version, to: candidates.sort(compareCores).at(-1) ?? null };
+}
+function proposeRollbacks(targets, limits, readPackument) {
+  const unique = [...new Map(targets.map((target) => [`${target.name}@${target.version}`, target])).values()];
+  return Promise.all(unique.map((target) => proposeOne(target, limits, readPackument)));
+}
+function overridesOf(rollback) {
+  const proposals = rollback.flatMap(({ name, to }) => to === null ? [] : [[name, to]]);
+  return { overrides: Object.fromEntries(proposals) };
+}
+
+// src/sealedList.ts
+import { existsSync as existsSync2, mkdirSync, writeFileSync } from "node:fs";
+import { dirname as dirname2, join as join2 } from "node:path";
+import { createPublicClient, http, verifyMessage } from "viem";
+var noneStatus = 0;
+var sealedStatus = 1;
+var unsealedStatus = 2;
+var pageSize = 500n;
+var cacheFileName = "sealedSnapshot.json";
+var knownFileName = "knownSealed.json";
+var clockSkewSeconds = 60;
+async function readSuspects(client, registry) {
+  const total = await client.readContract({ address: registry, abi: sealRegistryAbi, functionName: "flaggedKeyCount" });
+  const suspects = /* @__PURE__ */ new Map();
+  for (let offset = 0n; offset < total; offset += pageSize) {
+    const [page, statuses, votes] = await client.readContract({
+      address: registry,
+      abi: sealRegistryAbi,
+      functionName: "flaggedKeys",
+      args: [offset, pageSize]
+    });
+    page.forEach((key, index) => {
+      const live = votes[index] ?? 0;
+      if (statuses[index] === noneStatus && live > 0) suspects.set(key.toLowerCase(), { votes: live, suspectUntil: null });
+    });
+  }
+  return suspects;
+}
+async function readChain(settings, registry, chainId) {
+  const transport = settings.transport ?? http(settings.rpcUrl ?? void 0, { retryCount: 0, timeout: settings.httpTimeoutMs });
+  const client = createPublicClient({ transport });
+  const remoteChainId = await client.getChainId();
+  if (remoteChainId !== chainId) throw new Error(`RPC reports chain ${remoteChainId}, expected ${chainId}`);
+  const total = await client.readContract({ address: registry, abi: sealRegistryAbi, functionName: "sealedKeyCount" });
+  const sealed = /* @__PURE__ */ new Set();
+  const unsealed = /* @__PURE__ */ new Set();
+  for (let offset = 0n; offset < total; offset += pageSize) {
+    const [page, statuses] = await client.readContract({
+      address: registry,
+      abi: sealRegistryAbi,
+      functionName: "sealedKeys",
+      args: [offset, pageSize]
+    });
+    page.forEach((key, index) => {
+      if (statuses[index] === sealedStatus) sealed.add(key.toLowerCase());
+      if (statuses[index] === unsealedStatus) unsealed.add(key.toLowerCase());
+    });
+  }
+  return { client, sealed, unsealed, suspects: await readSuspects(client, registry) };
+}
+async function hasUnsealEvent(read, registry, key, fromBlock) {
+  if (!read.unsealed.has(key)) return false;
+  const logs = await read.client.getContractEvents({ address: registry, abi: sealRegistryAbi, eventName: "Unsealed", args: { key }, fromBlock: BigInt(fromBlock) }).catch(() => []);
+  return logs.length > 0;
+}
+async function chainList(settings, known) {
+  const { registryAddress, chainId } = settings;
+  if (!registryAddress || chainId === null || !(settings.transport || settings.rpcUrl)) return null;
+  const read = await readChain(settings, registryAddress, chainId).catch((error) => {
+    settings.warn(`chain unavailable: ${error.message.split("\n")[0]}`);
+    return null;
+  });
+  if (!read) return null;
+  const dropped = [...known].filter((key) => !read.sealed.has(key));
+  const explained = await Promise.all(dropped.map((key) => hasUnsealEvent(read, registryAddress, key, settings.registryStartBlock ?? 0)));
+  const unexplained = dropped.filter((_, index) => !explained[index]);
+  if (unexplained.length) {
+    settings.warn(
+      `chain list rejected: it drops ${unexplained.length} previously sealed version(s) with no matching Unsealed event (${unexplained.join(", ")}), so the guard uses the signed snapshot and keeps them blocked`
+    );
+    return null;
+  }
+  return { source: "chain", keys: read.sealed, suspects: read.suspects, snapshotAgeSeconds: null };
+}
+async function snapshotProblem(signed, settings) {
+  const { snapshot } = signed;
+  if (!settings.snapshotSigner || settings.snapshotMaxAgeSeconds === null) return "snapshot signer or max age not configured";
+  if (signed.signer.toLowerCase() !== settings.snapshotSigner.toLowerCase()) return "snapshot signer is not GUARD_SNAPSHOT_SIGNER";
+  const digest = snapshotDigestOf(snapshot);
+  const valid = await verifyMessage({ address: settings.snapshotSigner, message: { raw: digest }, signature: signed.signature });
+  if (!valid) return "snapshot signature does not verify";
+  if (snapshot.chainId !== settings.chainId) return `snapshot chainId ${snapshot.chainId} does not match CHAIN_ID`;
+  if (snapshot.registry.toLowerCase() !== settings.registryAddress?.toLowerCase()) return "snapshot registry does not match REGISTRY_ADDRESS";
+  const generatedAt = Date.parse(snapshot.generatedAt);
+  if (generatedAt > settings.now().getTime() + clockSkewSeconds * 1e3) return "snapshot generatedAt is in the future";
+  if (snapshotAgeOf(signed, settings) > settings.snapshotMaxAgeSeconds) return "snapshot is older than GUARD_SNAPSHOT_MAX_AGE_SECONDS";
+  return null;
+}
+function snapshotAgeOf(signed, settings) {
+  return Math.max(0, Math.floor((settings.now().getTime() - Date.parse(signed.snapshot.generatedAt)) / 1e3));
+}
+async function acceptSnapshot(raw, origin, settings) {
+  const parsed = signedSnapshotSchema.safeParse(raw);
+  if (!parsed.success) {
+    settings.warn(`${origin} snapshot rejected: malformed`);
+    return null;
+  }
+  const problem = await snapshotProblem(parsed.data, settings).catch(() => "snapshot signature is malformed");
+  if (problem) settings.warn(`${origin} snapshot rejected: ${problem}`);
+  return problem ? null : parsed.data;
+}
+async function loadSnapshot(settings) {
+  const cache = settings.cacheDir ? join2(settings.cacheDir, cacheFileName) : null;
+  if (settings.snapshotUrl) {
+    const fetched = await settings.fetchFn(settings.snapshotUrl, { signal: AbortSignal.timeout(settings.httpTimeoutMs) }).then((response) => {
+      if (!response.ok) throw new Error(`snapshot request answered ${response.status}`);
+      return response.json();
+    }).catch((error) => {
+      settings.warn(`snapshot fetch failed: ${error.message}`);
+      return null;
+    });
+    const accepted = fetched === null ? null : await acceptSnapshot(fetched, "fetched", settings);
+    if (accepted && cache) {
+      mkdirSync(dirname2(cache), { recursive: true });
+      writeFileSync(cache, JSON.stringify(accepted));
+    }
+    if (accepted) return accepted;
+  }
+  if (!cache || !existsSync2(cache)) return null;
+  return acceptSnapshot(readJson(cache), "cached", settings);
+}
+function knownPath(settings) {
+  return settings.cacheDir ? join2(settings.cacheDir, knownFileName) : null;
+}
+function readKnown(settings) {
+  const path = knownPath(settings);
+  const stored = path ? readJson(path) : null;
+  const sameRegistry = stored?.chainId === settings.chainId && stored?.registry?.toLowerCase() === settings.registryAddress?.toLowerCase();
+  return new Set(sameRegistry ? stored?.keys ?? [] : []);
+}
+function writeKnown(settings, keys) {
+  const path = knownPath(settings);
+  if (!path) return;
+  mkdirSync(dirname2(path), { recursive: true });
+  writeFileSync(path, JSON.stringify({ chainId: settings.chainId, registry: settings.registryAddress, keys: [...keys] }));
+}
+async function snapshotList(settings, known) {
+  const signed = await loadSnapshot(settings);
+  const entries = signed?.snapshot.entries ?? [];
+  const keys = new Set(entries.filter((entry) => entry.status === "Sealed").map((entry) => entry.key));
+  const unsealed = new Set(entries.filter((entry) => entry.status === "Unsealed").map((entry) => entry.key));
+  const suspects = new Map(
+    entries.filter((entry) => entry.status === "Suspect").map((entry) => [entry.key, { votes: entry.votes, suspectUntil: entry.suspectUntil }])
+  );
+  const kept = [...known].filter((key) => !keys.has(key) && !unsealed.has(key));
+  if (kept.length) settings.warn(`${kept.length} previously sealed version(s) missing from the available list stay blocked: ${kept.join(", ")}`);
+  kept.forEach((key) => keys.add(key));
+  if (!signed) return { source: "none", keys, suspects, snapshotAgeSeconds: null };
+  return { source: "snapshot", keys, suspects, snapshotAgeSeconds: snapshotAgeOf(signed, settings) };
+}
+async function loadSealedList(settings) {
+  const known = readKnown(settings);
+  const list = await chainList(settings, known) ?? await snapshotList(settings, known);
+  writeKnown(settings, list.keys);
+  return list;
+}
+
+// src/check.ts
+var placeholderFallbackMinAgeDays = 3;
+var exitCodes = { allowed: 0, blocked: 1, unavailable: 2 };
+var npmGitSetting = { name: "allow-git", minimumVersion: "11.10.0" };
+var installedAdvice = [
+  "First remove persistence: background daemons or services the package installed, and IDE or coding agent hooks, extensions and config it added. Some payloads destroy files when a stolen token is revoked, so do this before revoking anything.",
+  "Then rotate every credential that was reachable when that version was installed, including npm tokens, cloud keys, CI secrets and SSH keys.",
+  "A runtime stop does not undo theft that happened at install time."
+];
+function fallbackOf(settings) {
+  if (settings.fallbackMinAgeDays !== null) return { minAgeDays: settings.fallbackMinAgeDays, placeholder: false };
+  settings.warn(
+    `GUARD_FALLBACK_MIN_AGE_DAYS is unset: the age fallback is using the placeholder of ${placeholderFallbackMinAgeDays} days. The team sets N in docs/decisions.md.`
+  );
+  return { minAgeDays: placeholderFallbackMinAgeDays, placeholder: true };
+}
+function blocksOf(entries, list, lockfilePath, assumeInstalled) {
+  return entries.flatMap((entry) => {
+    const key = sealKeyOf(entry.name, entry.version);
+    if (!list.keys.has(key)) return [];
+    const installed = readJson(join3(directoryOf(lockfilePath), entry.path, "package.json"));
+    const alreadyInstalled = assumeInstalled || installed?.name === entry.name && installed.version === entry.version;
+    return [{ name: entry.name, version: entry.version, key, lockfilePath, alreadyInstalled }];
+  });
+}
+function suspectsOf(entries, list, lockfilePath, settings) {
+  return entries.flatMap((entry) => {
+    const key = sealKeyOf(entry.name, entry.version);
+    const info = list.suspects.get(key);
+    if (!info || list.keys.has(key)) return [];
+    const allowed = !settings.suspectBlocks || settings.allowSuspect.includes(`${entry.name}@${entry.version}`);
+    return [{ name: entry.name, version: entry.version, key, lockfilePath, votes: info.votes, suspectUntil: info.suspectUntil, allowed }];
+  });
+}
+function suspectAdvice(suspects) {
+  const unique = [...new Map(suspects.map((suspect) => [suspect.key, suspect])).values()];
+  return unique.map(({ name, version, votes, allowed }) => {
+    const flagged = `${name}@${version} is Suspect: ${votes} detector${votes === 1 ? "" : "s"} flagged it and quorum is not reached yet.`;
+    return allowed ? `Warning: ${flagged} It does not block this run.` : `${flagged} Review the evidence on the dashboard, wait for the guardian, or allow this one version with --allow-suspect ${name}@${version}.`;
+  });
+}
+async function findTooYoung(entries, days, readPackument, now) {
+  const unique = [...new Map(entries.map((entry) => [`${entry.name}@${entry.version}`, entry])).values()];
+  const dated = await Promise.all(
+    unique.map(async (entry) => ({ entry, publishedAt: publishedAtOf(await readPackument(entry.name), entry.version) }))
+  );
+  const young = dated.filter(({ publishedAt }) => !isOlderThan(publishedAt, days, now));
+  const tooYoung = young.map(({ entry, publishedAt }) => ({
+    name: entry.name,
+    version: entry.version,
+    publishedAt: publishedAt?.toISOString() ?? null
+  }));
+  const unreadable = young.filter(({ publishedAt }) => publishedAt === null).map(({ entry }) => `${entry.name}@${entry.version}`);
+  return { tooYoung, unreadable };
+}
+function nonRegistryVerdict(sources, allow) {
+  if (!sources.length) return { blocks: false, advice: [] };
+  const listed = [...new Set(sources.map(({ name, version, kind }) => `${name}@${version} (${kind})`))].join(", ");
+  const effect = allow ? "were allowed by GUARD_ALLOW_NON_REGISTRY_SOURCES" : "block the outcome";
+  return {
+    blocks: !allow,
+    advice: [
+      `Warning: ${listed} come from a source other than the npm registry and ${effect}. Such sources can run prepare scripts even with scripts disabled and bypass the Sealed list.`
+    ]
+  };
+}
+function adviceFor(blocked) {
+  return blocked.some((block) => block.alreadyInstalled) ? installedAdvice : [];
+}
+async function checkLockfile(settings) {
+  const now = settings.now();
+  const path = resolveLockfilePath(settings.lockfile);
+  const read = readLockfile(path);
+  const report = {
+    product: productName,
+    service: settings.service,
+    lockfile: path,
+    checkedAt: now.toISOString(),
+    listSource: "none",
+    snapshotAgeSeconds: null,
+    fallback: null,
+    packagesChecked: 0,
+    blocked: [],
+    suspect: [],
+    nonRegistrySources: [],
+    hookFiles: [],
+    tooYoung: [],
+    rollback: [],
+    advice: [],
+    outcome: "unavailable"
+  };
+  if (!read.ok) return { ...report, advice: [read.reason] };
+  const list = await loadSealedList(settings);
+  const fallback = list.source === "none" ? fallbackOf(settings) : null;
+  const ageLimit = Math.max(fallback?.minAgeDays ?? 0, settings.minAgeDays);
+  const readPackument = packumentReader(settings.registryUrl, settings.fetchFn, settings.warn, settings.httpTimeoutMs);
+  const blocked = blocksOf(read.entries, list, path, settings.assumeInstalled);
+  const suspect = suspectsOf(read.entries, list, path, settings);
+  const heldSuspects = suspect.filter((entry) => !entry.allowed);
+  const { tooYoung, unreadable } = ageLimit > 0 ? await findTooYoung(read.entries, ageLimit, readPackument, now) : { tooYoung: [], unreadable: [] };
+  const limits = { sealedKeys: /* @__PURE__ */ new Set([...list.keys, ...list.suspects.keys()]), minAgeDays: ageLimit, now };
+  const rollback = await proposeRollbacks([...blocked, ...heldSuspects, ...tooYoung], limits, readPackument);
+  const sources = nonRegistrySourcesOf(read.entries, path, settings.registryUrl ?? defaultRegistryUrl);
+  const git = nonRegistryVerdict(sources, settings.allowNonRegistrySources);
+  const unreadableAdvice = unreadable.length ? [`Publish time could not be read for ${unreadable.join(", ")}, so these count as too young.`] : [];
+  const fallbackAdvice = fallback ? [
+    `Warning: the Sealed list was not checked because neither the chain nor a valid signed snapshot was available. Versions younger than ${fallback.minAgeDays} days were blocked by the age fallback.`,
+    ...fallback.placeholder ? [`N is the placeholder of ${fallback.minAgeDays} days until the team sets GUARD_FALLBACK_MIN_AGE_DAYS.`] : []
+  ] : [];
+  return {
+    ...report,
+    listSource: list.source,
+    snapshotAgeSeconds: list.snapshotAgeSeconds,
+    fallback,
+    packagesChecked: read.entries.length,
+    blocked,
+    suspect,
+    nonRegistrySources: sources,
+    tooYoung,
+    rollback,
+    advice: [...fallbackAdvice, ...git.advice, ...unreadableAdvice, ...suspectAdvice(suspect), ...adviceFor(blocked)],
+    outcome: blocked.length || heldSuspects.length || tooYoung.length || git.blocks ? "blocked" : "allowed"
+  };
+}
+async function sendReport(report, settings) {
+  if (!settings.reportUrl || !settings.reporterPrivateKey) return false;
+  const account = privateKeyToAccount(settings.reporterPrivateKey);
+  const signature = await account.signMessage({ message: { raw: guardReportDigestOf(report) } });
+  const body = JSON.stringify({ report, signer: account.address, signature });
+  const response = await settings.fetchFn(settings.reportUrl, { method: "POST", headers: { "content-type": "application/json" }, body, signal: AbortSignal.timeout(settings.httpTimeoutMs) }).catch((error) => ({ ok: false, status: error.message }));
+  if (!response.ok) settings.warn(`report not delivered: ${response.status}`);
+  return response.ok;
+}
+async function installChecked(settings, npm, gitSetting = npmGitSetting) {
+  const report = await checkLockfile({ ...settings, lockfile: directoryOf(settings.lockfile) });
+  if (report.outcome !== "allowed") return { report, exitCode: exitCodes[report.outcome] };
+  const supported = compareCores(await npm.version(), gitSetting.minimumVersion) >= 0;
+  const gitFlags = supported ? [`--${gitSetting.name}=none`] : [];
+  return { report, exitCode: await npm.run("npm", ["ci", "--ignore-scripts", ...gitFlags], directoryOf(report.lockfile)) };
+}
+
+// src/audit.ts
+var skippedDirs = /* @__PURE__ */ new Set(["node_modules", ".git", ".pnpm_store"]);
+var tarballPattern = /\/((?:@[^/]+(?:\/|%2[fF]))?([^/]+))\/-\/([^/]+)\.tgz$/;
+var claudeSettingsPattern = /(?:^|\/)\.claude\/settings(?:\.local)?\.json$/;
+var vscodeTasksPattern = /(?:^|\/)\.vscode\/tasks\.json$/;
+var folderOpenPattern = /"runOn"\s*:\s*"folderOpen"/;
+var hookAdvice = "Inspect and remove the editor and coding agent hook files listed under hookFiles before revoking any token: they can run again when the project opens and some payloads destroy files when a token is revoked.";
+var installedManifestPattern = /(?:^|\/)node_modules\/(?:@[^/]+\/)?[^/@.][^/]*\/package\.json$/;
+function filesUnder(dir) {
+  return readdirSync(dir, { withFileTypes: true }).flatMap((entry) => {
+    const path = join4(dir, entry.name);
+    if (!entry.isDirectory()) return [path];
+    if (entry.name === "node_modules") return existsSync3(join4(path, hiddenLockfileName)) ? [join4(path, hiddenLockfileName)] : [];
+    return skippedDirs.has(entry.name) ? [] : filesUnder(path);
+  });
+}
+function referencedFiles(root, words) {
+  return words.flatMap((word) => {
+    const token = word.replace(/["']/g, "").replace(/^\$\{?(CLAUDE_PROJECT_DIR|workspaceFolder)\}?/, root);
+    if (!token || token.startsWith("-")) return [];
+    const path = isAbsolute(token) ? token : join4(root, token);
+    return existsSync3(path) && statSync2(path).isFile() ? [path] : [];
+  });
+}
+function claudeHookFiles(file) {
+  const settings = readJson(file);
+  const groups = Object.values(settings?.hooks ?? {}).flat();
+  if (!groups.length) return [];
+  const commands = groups.flatMap((group) => group.hooks ?? []).flatMap((hook) => typeof hook.command === "string" ? [hook.command] : []);
+  const root = dirname3(dirname3(file));
+  return [file, ...referencedFiles(root, commands.flatMap((command) => command.split(/\s+/)))].map((path) => ({ path, tool: "claude" }));
+}
+function tasksOf(text) {
+  try {
+    return JSON.parse(text).tasks ?? [];
+  } catch (error) {
+    if (error instanceof SyntaxError) return [];
+    throw error;
+  }
+}
+function vscodeHookFiles(file) {
+  const text = readFileSync2(file, "utf8");
+  if (!folderOpenPattern.test(text)) return [];
+  const tasks = tasksOf(text.replace(/^\s*\/\/.*$/gm, ""));
+  const words = tasks.filter((task) => task.runOptions?.runOn === "folderOpen").flatMap((task) => [task.command, ...Array.isArray(task.args) ? task.args : []]).flatMap((word) => typeof word === "string" ? word.split(/\s+/) : []);
+  return [file, ...referencedFiles(dirname3(dirname3(file)), words)].map((path) => ({ path, tool: "vscode" }));
+}
+function scanPath(dir, registryUrl) {
+  if (!existsSync3(dir)) return { found: [], problems: [`no directory at ${dir}`], hookFiles: [] };
+  const files = filesUnder(dir);
+  const auditedNames = [...lockfileNames, hiddenLockfileName];
+  const reads = files.filter((file) => auditedNames.includes(basename2(file))).map((file) => readLockfile(file, auditedNames));
+  const hookFiles = files.flatMap((file) => {
+    if (claudeSettingsPattern.test(file)) return claudeHookFiles(file);
+    return vscodeTasksPattern.test(file) ? vscodeHookFiles(file) : [];
+  });
+  return {
+    found: reads.flatMap((read) => read.ok ? read.entries.map(({ name, version }) => ({ name, version, source: read.path })) : []),
+    sources: reads.flatMap((read) => read.ok ? nonRegistrySourcesOf(read.entries, read.path, registryUrl) : []),
+    problems: reads.flatMap((read) => read.ok ? [] : [read.reason]),
+    hookFiles
+  };
+}
+function packageFromTarballUrl(url) {
+  const match = tarballPattern.exec(url);
+  if (!match?.[1] || !match[2] || !match[3]?.startsWith(`${match[2]}-`)) return null;
+  return { name: decodeURIComponent(match[1]), version: match[3].slice(match[2].length + 1) };
+}
+function cacheKeysOf(file) {
+  return readFileSync2(file, "utf8").split("\n").flatMap((line) => {
+    const tab = line.indexOf("	");
+    if (tab === -1) return [];
+    try {
+      const key = JSON.parse(line.slice(tab + 1)).key;
+      return typeof key === "string" ? [key] : [];
+    } catch (error) {
+      if (error instanceof SyntaxError) return [];
+      throw error;
+    }
+  });
+}
+function scanCache(dir) {
+  const index = [join4(dir, "_cacache", "index-v5"), join4(dir, "index-v5")].find((path) => existsSync3(path));
+  if (!index) return { found: [], problems: [`no npm cache index under ${dir}`], hookFiles: [] };
+  const found = filesUnder(index).flatMap(
+    (file) => cacheKeysOf(file).flatMap((key) => {
+      const pkg = packageFromTarballUrl(key);
+      return pkg ? [{ ...pkg, source: file }] : [];
+    })
+  );
+  return { found, problems: [], hookFiles: [] };
+}
+function readBody(entry) {
+  const chunks = [];
+  entry.on("data", (chunk) => chunks.push(chunk));
+  return new Promise((resolve) => entry.on("end", () => resolve(Buffer.concat(chunks).toString("utf8"))));
+}
+function scanLayer(layer, source, scan) {
+  const reads = [];
+  const parser = new Parser({
+    strict: true,
+    onReadEntry: (entry) => {
+      if (!installedManifestPattern.test(entry.path)) return entry.resume();
+      const where = `${source}:${layer.path}:${entry.path}`;
+      reads.push(
+        readBody(entry).then((text) => {
+          try {
+            const manifest = JSON.parse(text);
+            if (typeof manifest.name === "string" && typeof manifest.version === "string") {
+              scan.found.push({ name: manifest.name, version: manifest.version, source: where });
+            }
+          } catch (error) {
+            if (!(error instanceof SyntaxError)) throw error;
+            scan.problems.push(`unreadable package.json at ${where}`);
+          }
+        })
+      );
+    }
+  });
+  const done = new Promise((resolve) => {
+    parser.on("end", resolve);
+    parser.on("error", (error) => {
+      scan.problems.push(`unreadable layer ${source}:${layer.path}: ${error.message}`);
+      resolve();
+    });
+  });
+  layer.pipe(parser);
+  return done.then(() => Promise.all(reads)).then(() => void 0);
+}
+async function layersOf(file) {
+  let manifestText = null;
+  await listTar({
+    file,
+    filter: (path) => path === "manifest.json",
+    onReadEntry: (entry) => {
+      manifestText = readBody(entry);
+    }
+  });
+  if (!manifestText) return null;
+  try {
+    const manifest = JSON.parse(await manifestText);
+    return new Set(manifest.flatMap((image) => Array.isArray(image.Layers) ? image.Layers.map(String) : []));
+  } catch (error) {
+    if (error instanceof SyntaxError || error instanceof TypeError) return null;
+    throw error;
+  }
+}
+async function scanImage(file) {
+  if (!existsSync3(file)) return { found: [], problems: [`no saved image at ${file}`], hookFiles: [] };
+  const layers = await layersOf(file);
+  if (!layers) return { found: [], problems: [`no readable manifest.json in ${file}`], hookFiles: [] };
+  const scan = { found: [], problems: [], hookFiles: [] };
+  const scans = [];
+  await listTar({
+    file,
+    onReadEntry: (entry) => {
+      if (layers.has(entry.path)) scans.push(scanLayer(entry, file, scan));
+      else entry.resume();
+    }
+  });
+  await Promise.all(scans);
+  return scan;
+}
+async function audit(settings) {
+  const scans = [
+    ...settings.paths.map((path) => scanPath(path, settings.registryUrl ?? defaultRegistryUrl)),
+    ...settings.cacheDirs.map(scanCache),
+    ...await Promise.all(settings.dockerImages.map(scanImage))
+  ];
+  const found = scans.flatMap((scan) => scan.found);
+  const sources = scans.flatMap((scan) => scan.sources ?? []);
+  const git = nonRegistryVerdict(sources, settings.allowNonRegistrySources);
+  const hookFiles = [...new Map(scans.flatMap((scan) => scan.hookFiles).map((hook) => [hook.path, hook])).values()];
+  const list = await loadSealedList(settings);
+  const problems = [...scans.flatMap((scan) => scan.problems), ...list.source === "none" ? ["The Sealed list was unavailable, so installed versions could not be checked."] : []];
+  const hits = found.flatMap(({ name, version, source }) => {
+    const key = sealKeyOf(name, version);
+    return list.keys.has(key) ? [{ name, version, key, lockfilePath: source, alreadyInstalled: true }] : [];
+  });
+  const blocked = [...new Map(hits.map((block) => [`${block.key}${block.lockfilePath}`, block])).values()];
+  const suspect = found.flatMap(({ name, version, source }) => {
+    const key = sealKeyOf(name, version);
+    const info = list.suspects.get(key);
+    return info && !list.keys.has(key) ? [{ name, version, key, lockfilePath: source, ...info, allowed: true }] : [];
+  });
+  const limits = { sealedKeys: list.keys, minAgeDays: settings.minAgeDays, now: settings.now() };
+  const rollback = await proposeRollbacks(blocked, limits, packumentReader(settings.registryUrl, settings.fetchFn, settings.warn, settings.httpTimeoutMs));
+  return {
+    product: productName,
+    service: settings.service,
+    lockfile: [...settings.paths, ...settings.cacheDirs, ...settings.dockerImages].join(", "),
+    checkedAt: settings.now().toISOString(),
+    listSource: list.source,
+    snapshotAgeSeconds: list.snapshotAgeSeconds,
+    fallback: null,
+    packagesChecked: found.length,
+    blocked,
+    suspect,
+    nonRegistrySources: sources,
+    hookFiles,
+    tooYoung: [],
+    rollback,
+    advice: [...problems, ...git.advice, ...hookFiles.length ? [hookAdvice] : [], ...suspectAdvice(suspect), ...adviceFor(blocked)],
+    outcome: blocked.length || git.blocks ? "blocked" : problems.length ? "unavailable" : "allowed"
+  };
+}
+
+// src/sidecar.ts
+import { createServer } from "node:http";
+function listen(server, port) {
+  return new Promise((resolve) => server.listen(port, "127.0.0.1", () => resolve(server.address().port)));
+}
+async function startSidecar(settings) {
+  let status = null;
+  const refresh = async () => {
+    const report = await checkLockfile({ ...settings, assumeInstalled: true, suspectBlocks: false });
+    const changed = status?.report.outcome !== report.outcome;
+    status = { service: settings.service, healthy: report.outcome === "allowed", report, updatedAt: report.checkedAt };
+    if (changed) await sendReport(report, settings);
+    return status;
+  };
+  const server = createServer((request, response) => {
+    const healthy = status?.healthy === true;
+    if (request.url === "/health") return response.writeHead(healthy ? 200 : 503).end(healthy ? "ok" : "blocked or unavailable");
+    if (request.url === "/status" && status) return response.writeHead(200, { "content-type": "application/json" }).end(JSON.stringify(status));
+    return response.writeHead(request.url === "/status" ? 503 : 404).end();
+  });
+  const timer = setInterval(() => refresh().catch((error) => settings.warn(`sidecar check failed: ${error.message}`)), settings.intervalSeconds * 1e3);
+  const port = await listen(server, settings.port);
+  await refresh();
+  return {
+    url: `http://127.0.0.1:${port}`,
+    refresh,
+    close: () => {
+      clearInterval(timer);
+      return new Promise((resolve) => server.close(() => resolve()));
+    }
+  };
+}
+
+// src/cli.ts
+var usage = "usage: cordon <check|install|audit|rollback|sidecar> [--lockfile path] [--service name] [--path dir]... [--cache dir]... [--docker image.tar]... [--port n] [--allow-suspect name@version]...";
+var defaultHttpTimeoutMs = 5e3;
+function numberFrom(env, name, minimum) {
+  const raw = env[name];
+  if (raw === void 0 || raw === "") return null;
+  const value = Number(raw);
+  if (!Number.isInteger(value) || value < minimum) throw new Error(`${name} must be an integer of at least ${minimum}, got ${raw}`);
+  return value;
+}
+function textFrom(env, name) {
+  return env[name] ? env[name] : null;
+}
+function flagFrom(env, name) {
+  const raw = env[name] ?? "";
+  if (!["", "true", "false"].includes(raw)) throw new Error(`${name} must be true or false, got ${raw}`);
+  return raw === "true";
+}
+function settingsFromEnv(env, flags) {
+  return {
+    lockfile: flags.lockfile ?? process.cwd(),
+    service: flags.service ?? null,
+    fallbackMinAgeDays: numberFrom(env, "GUARD_FALLBACK_MIN_AGE_DAYS", 1),
+    minAgeDays: numberFrom(env, "GUARD_MIN_AGE_DAYS", 0) ?? 0,
+    registryUrl: textFrom(env, "NPM_REGISTRY_URL") ?? defaultRegistryUrl,
+    allowNonRegistrySources: flagFrom(env, "GUARD_ALLOW_NON_REGISTRY_SOURCES"),
+    allowSuspect: flags["allow-suspect"] ?? [],
+    suspectBlocks: true,
+    chainId: numberFrom(env, "CHAIN_ID", 1),
+    rpcUrl: textFrom(env, "RPC_URL"),
+    registryAddress: textFrom(env, "REGISTRY_ADDRESS"),
+    registryStartBlock: numberFrom(env, "REGISTRY_START_BLOCK", 0),
+    snapshotUrl: textFrom(env, "GUARD_SNAPSHOT_URL"),
+    snapshotSigner: textFrom(env, "GUARD_SNAPSHOT_SIGNER"),
+    snapshotMaxAgeSeconds: numberFrom(env, "GUARD_SNAPSHOT_MAX_AGE_SECONDS", 1),
+    cacheDir: textFrom(env, "GUARD_CACHE_DIR"),
+    reportUrl: textFrom(env, "GUARD_REPORT_URL"),
+    reporterPrivateKey: textFrom(env, "GUARD_REPORTER_PRIVATE_KEY"),
+    assumeInstalled: false,
+    fetchFn: fetch,
+    httpTimeoutMs: numberFrom(env, "GUARD_HTTP_TIMEOUT_MS", 1) ?? defaultHttpTimeoutMs,
+    now: () => /* @__PURE__ */ new Date(),
+    warn: (message) => process.stderr.write(`${message}
+`)
+  };
+}
+var systemNpm = {
+  run: (command, args, cwd) => new Promise((resolve, reject) => {
+    const child = spawn(command, args, { cwd, stdio: "inherit" });
+    child.on("error", reject);
+    child.on("exit", (code) => resolve(code ?? 1));
+  }),
+  version: async () => (await promisify(execFile)("npm", ["--version"])).stdout.trim()
+};
+function printJson(value) {
+  process.stdout.write(`${JSON.stringify(value, null, 2)}
+`);
+}
+async function reported(report, settings) {
+  printJson(report);
+  await sendReport(report, settings);
+  return exitCodes[report.outcome];
+}
+async function run(argv, env, npm = systemNpm) {
+  const { positionals, values } = parseArgs({
+    args: argv,
+    allowPositionals: true,
+    options: {
+      lockfile: { type: "string" },
+      service: { type: "string" },
+      path: { type: "string", multiple: true },
+      cache: { type: "string", multiple: true },
+      docker: { type: "string", multiple: true },
+      port: { type: "string" },
+      "allow-suspect": { type: "string", multiple: true }
+    }
+  });
+  const settings = settingsFromEnv(env, values);
+  const command = positionals[0];
+  if (command === "check") return reported(await checkLockfile(settings), settings);
+  if (command === "install") {
+    const { report, exitCode } = await installChecked(settings, npm);
+    await reported(report, settings);
+    return exitCode;
+  }
+  if (command === "audit") {
+    const paths = values.path ?? [];
+    const scope = { paths: paths.length || values.cache || values.docker ? paths : [process.cwd()], cacheDirs: values.cache ?? [], dockerImages: values.docker ?? [] };
+    return reported(await audit({ ...settings, ...scope }), settings);
+  }
+  if (command === "rollback") {
+    const report = await checkLockfile(settings);
+    printJson({ report, ...overridesOf(report.rollback) });
+    return exitCodes[report.outcome];
+  }
+  if (command === "sidecar") {
+    const port = numberFrom({ "--port": values.port }, "--port", 0);
+    if (!values.service || !values.lockfile || port === null) throw new Error("sidecar needs --lockfile, --service and --port");
+    const intervalSeconds = numberFrom(env, "POLL_INTERVAL_SECONDS", 1);
+    if (intervalSeconds === null) throw new Error("sidecar needs POLL_INTERVAL_SECONDS");
+    const sidecar = await startSidecar({ ...settings, service: values.service, port, intervalSeconds });
+    process.stderr.write(`sidecar for ${values.service} listening on ${sidecar.url}
+`);
+    return new Promise(() => void 0);
+  }
+  throw new Error(usage);
+}
+function main() {
+  run(process.argv.slice(2), process.env).then((code) => process.exit(code)).catch((error) => {
+    process.stderr.write(`${error.message}
+`);
+    process.exit(exitCodes.unavailable);
+  });
+}
+if ("" === process.argv[1]) main();
+
+// entry.ts
+main();

package/package.json

@@ -1,6 +1,35 @@
 {
   "name": "npmcordon",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0",
+  "description": "Guard for Cordon: blocks npm package versions sealed in the SealRegistry contract before they install or run. Testnet prototype.",
+  "license": "MIT",
+  "type": "module",
+  "bin": {
+    "cordon": "dist/cordon.js"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=22"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/SahilKumar75/cordon.git"
+  },
+  "homepage": "https://github.com/SahilKumar75/cordon#readme",
+  "keywords": [
+    "npm",
+    "supply chain",
+    "security",
+    "lockfile",
+    "ethereum"
+  ],
+  "dependencies": {
+    "tar": "^7.4.0",
+    "viem": "^2.21.0",
+    "zod": "^3.25.0"
+  }
+}