@inner-security/scan 0.1.0

package/bundle/scan-cli.js

@@ -0,0 +1,808 @@
+#!/usr/bin/env node
+
+// src/args.ts
+var SHORT_ALIASES = {
+  h: "help"
+};
+function parseArgs(argv) {
+  const out = { _: [], flags: {} };
+  for (let i = 0; i < argv.length; i++) {
+    const tok = argv[i];
+    if (tok.startsWith("--")) {
+      const eq = tok.indexOf("=");
+      if (eq >= 0) {
+        out.flags[tok.slice(2, eq)] = tok.slice(eq + 1);
+      } else {
+        const key = tok.slice(2);
+        const next = argv[i + 1];
+        if (next !== void 0 && !next.startsWith("-")) {
+          out.flags[key] = next;
+          i++;
+        } else {
+          out.flags[key] = true;
+        }
+      }
+    } else if (tok.startsWith("-") && tok.length > 1) {
+      for (const ch of tok.slice(1)) {
+        out.flags[SHORT_ALIASES[ch] ?? ch] = true;
+      }
+    } else {
+      out._.push(tok);
+    }
+  }
+  return out;
+}
+function flagString(flags, key) {
+  const v = flags[key];
+  return typeof v === "string" ? v : void 0;
+}
+function flagBool(flags, key) {
+  return flags[key] === true || flags[key] === "true";
+}
+
+// ../verdict-client/dist/client.js
+var DEFAULT_API_URL = "http://localhost:8787";
+function isPending(item) {
+  return item.action === "PENDING";
+}
+function isEnvelope(item) {
+  return !isPending(item);
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function stripTrailingSlash(u) {
+  return u.replace(/\/+$/, "");
+}
+var VerdictClient = class {
+  baseUrl;
+  apiKey;
+  timeoutMs;
+  maxPollAttempts;
+  maxRetries;
+  fetchImpl;
+  cache;
+  constructor(opts = {}) {
+    this.baseUrl = stripTrailingSlash(opts.baseUrl ?? process.env.INNER_API_URL ?? DEFAULT_API_URL);
+    this.apiKey = opts.apiKey ?? process.env.INNER_API_KEY;
+    this.timeoutMs = opts.timeoutMs ?? 1e4;
+    this.maxPollAttempts = opts.maxPollAttempts ?? 8;
+    this.maxRetries = opts.maxRetries ?? 2;
+    this.fetchImpl = opts.fetchImpl ?? globalThis.fetch;
+    this.cache = opts.cache;
+    if (typeof this.fetchImpl !== "function") {
+      throw new Error("No fetch implementation available (Node >= 18 required, or pass fetchImpl).");
+    }
+  }
+  headers() {
+    const h = { "content-type": "application/json" };
+    if (this.apiKey)
+      h.authorization = `Bearer ${this.apiKey}`;
+    return h;
+  }
+  /** A single fetch with a per-request AbortController timeout. */
+  async fetchOnce(url, init) {
+    const ctrl = new AbortController();
+    const timer = setTimeout(() => ctrl.abort(), this.timeoutMs);
+    try {
+      return await this.fetchImpl(url, { ...init, signal: ctrl.signal });
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+  /**
+   * fetch with timeout + retries-with-backoff on transient failures (network
+   * error / timeout / 5xx). 404 is returned as-is (the poll path treats it as
+   * "not ready yet"); other 4xx are returned as-is for the caller to handle.
+   */
+  async fetchWithRetry(url, init) {
+    let lastErr;
+    let wait = 250;
+    for (let attempt = 0; attempt <= this.maxRetries; attempt++) {
+      try {
+        const res = await this.fetchOnce(url, init);
+        if (res.status >= 500 && attempt < this.maxRetries) {
+          await sleep(wait);
+          wait = Math.min(wait * 2, 5e3);
+          continue;
+        }
+        return res;
+      } catch (err) {
+        lastErr = err;
+        if (attempt < this.maxRetries) {
+          await sleep(wait);
+          wait = Math.min(wait * 2, 5e3);
+          continue;
+        }
+      }
+    }
+    throw lastErr instanceof Error ? lastErr : new Error(`Request to ${url} failed`);
+  }
+  /** Raw C1 batch call. Items may come back as VerdictEnvelope or PendingResponse. */
+  async getVerdicts(items) {
+    const body = { items };
+    const res = await this.fetchWithRetry(`${this.baseUrl}/v1/verdict`, {
+      method: "POST",
+      headers: this.headers(),
+      body: JSON.stringify(body)
+    });
+    if (!res.ok) {
+      throw new Error(`Verdict API POST /v1/verdict failed: ${res.status} ${res.statusText}`);
+    }
+    return await res.json();
+  }
+  /**
+   * Poll a PENDING job to resolution. Returns the resolved item (may still be
+   * PENDING if it never resolves within maxPollAttempts). 404 is treated as
+   * "not ready yet" and retried; a non-ok, non-404 response throws.
+   */
+  async pollVerdict(pending) {
+    let attempt = 0;
+    let waitMs = Math.max(250, pending.eta_ms || 1e3);
+    let last = pending;
+    const url = `${this.baseUrl}/v1/verdict/${encodeURIComponent(pending.job_id)}`;
+    while (attempt < this.maxPollAttempts) {
+      await sleep(Math.min(waitMs, 5e3));
+      const res = await this.fetchWithRetry(url, {
+        method: "GET",
+        headers: this.headers()
+      });
+      if (res.status === 404) {
+        attempt += 1;
+        waitMs = Math.min(waitMs * 2, 5e3);
+        continue;
+      }
+      if (!res.ok) {
+        throw new Error(`Verdict API GET /v1/verdict/${pending.job_id} failed: ${res.status} ${res.statusText}`);
+      }
+      last = await res.json();
+      if (!isPending(last))
+        return last;
+      attempt += 1;
+      waitMs = Math.min(waitMs * 2, 5e3);
+    }
+    return last;
+  }
+  /**
+   * Resolve a single item to a final envelope, polling through PENDING. Returns
+   * the envelope, or the unresolved PendingResponse if it never landed.
+   */
+  async resolveVerdict(item) {
+    const { results } = await this.getVerdicts([item]);
+    const first = results[0];
+    if (!first)
+      throw new Error("Verdict API returned no results for the request.");
+    if (isPending(first))
+      return this.pollVerdict(first);
+    return first;
+  }
+  /** Resolve a batch, polling each PENDING to resolution. Order matches input. */
+  async resolveVerdicts(items) {
+    const { results } = await this.getVerdicts(items);
+    return Promise.all(results.map((r) => isPending(r) ? this.pollVerdict(r) : Promise.resolve(r)));
+  }
+  /**
+   * High-level fail-open resolution (the CLI scan path). Returns one
+   * ResolvedItem per requested item. On a total API failure (network/timeout),
+   * falls back to the fail-open cache for every item; for individual
+   * missing/never-resolved items, falls back to the cache too. Items the cache
+   * cannot safely satisfy surface as 'unresolved' (UNKNOWN) so the operator
+   * decides — never a silent allow.
+   */
+  async resolve(items) {
+    if (items.length === 0)
+      return { resolved: [], degraded: false };
+    let response;
+    try {
+      response = await this.getVerdicts(items);
+    } catch {
+      return this.failOpen(items);
+    }
+    const results = response.results ?? [];
+    const resolved = [];
+    for (let i = 0; i < items.length; i++) {
+      const item = items[i];
+      const r = results[i];
+      if (!r) {
+        resolved.push(this.fromCacheOrUnresolved(item));
+        continue;
+      }
+      if (isPending(r)) {
+        let env;
+        try {
+          env = await this.pollVerdict(r);
+        } catch {
+          env = void 0;
+        }
+        if (env && isEnvelope(env)) {
+          this.cache?.put(item, env);
+          resolved.push({ item, envelope: env, source: "api" });
+        } else {
+          resolved.push(this.fromCacheOrUnresolved(item));
+        }
+        continue;
+      }
+      this.cache?.put(item, r);
+      resolved.push({ item, envelope: r, source: "api" });
+    }
+    return { resolved, degraded: false };
+  }
+  failOpen(items) {
+    const resolved = items.map((item) => {
+      const cached = this.cache?.get(item);
+      if (cached) {
+        return { item, envelope: cached, source: "cache", failedOpen: true };
+      }
+      return { item, source: "unresolved", failedOpen: true };
+    });
+    return { resolved, degraded: true };
+  }
+  fromCacheOrUnresolved(item) {
+    const cached = this.cache?.get(item);
+    if (cached)
+      return { item, envelope: cached, source: "cache" };
+    return { item, source: "unresolved" };
+  }
+};
+
+// src/config.ts
+var DEFAULT_PROXY_URL = "https://proxy.inner.dev";
+function stripTrailingSlash2(u) {
+  return u.replace(/\/+$/, "");
+}
+function resolveApiUrl(flagValue) {
+  const fromFlag = flagValue?.trim();
+  const fromEnv = process.env.INNER_API_URL?.trim();
+  const chosen = fromFlag || fromEnv || DEFAULT_API_URL;
+  return { url: stripTrailingSlash2(chosen), isDefault: !fromFlag && !fromEnv };
+}
+function resolveProxyUrl(flagValue) {
+  const fromFlag = flagValue?.trim();
+  const fromEnv = process.env.INNER_PROXY_URL?.trim();
+  const chosen = fromFlag || fromEnv || DEFAULT_PROXY_URL;
+  return { url: stripTrailingSlash2(chosen), isDefault: !fromFlag && !fromEnv };
+}
+function resolveConfig(opts = {}) {
+  const api = resolveApiUrl(opts.apiUrl);
+  const proxy = resolveProxyUrl(opts.proxyUrl);
+  return {
+    apiUrl: api.url,
+    proxyUrl: proxy.url,
+    apiUrlIsDefault: api.isDefault,
+    proxyUrlIsDefault: proxy.isDefault
+  };
+}
+
+// src/manifest.ts
+import { existsSync, readFileSync } from "fs";
+import { join } from "path";
+function uniqueItems(items) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const it of items) {
+    const k = `${it.ecosystem}:${it.name}:${it.version}`;
+    if (seen.has(k)) continue;
+    seen.add(k);
+    out.push(it);
+  }
+  return out;
+}
+function cleanVersion(raw) {
+  const trimmed = raw.trim();
+  if (!trimmed) return null;
+  if (trimmed === "*" || trimmed === "latest" || trimmed === "x" || trimmed === "X") return null;
+  const cleaned = trimmed.replace(/^[\^~>=<\s]+/, "").replace(/\s.*$/, "").replace(/^v/, "").trim();
+  if (!/^\d/.test(cleaned)) return null;
+  return cleaned;
+}
+function readNpmFromPackageJson(root) {
+  const p = join(root, "package.json");
+  if (!existsSync(p)) return { items: [], warnings: [] };
+  const items = [];
+  const warnings = [];
+  try {
+    const pkg = JSON.parse(readFileSync(p, "utf8"));
+    for (const block of [pkg.dependencies, pkg.devDependencies, pkg.optionalDependencies]) {
+      if (!block) continue;
+      for (const [name, spec] of Object.entries(block)) {
+        if (/^(workspace:|link:|file:|git\+|git:|github:|https?:)/.test(spec)) {
+          warnings.push(`package.json: skipped "${name}" (${spec}) \u2014 not registry-resolvable.`);
+          continue;
+        }
+        const alias = spec.match(/^npm:(@?[^@]+(?:\/[^@]+)?)@(.+)$/);
+        if (alias) {
+          const aliasName = alias[1];
+          const aliasVersion = cleanVersion(alias[2]);
+          if (!aliasVersion) {
+            warnings.push(`package.json: skipped "${name}" (${spec}) \u2014 alias has no concrete version.`);
+            continue;
+          }
+          items.push({ ecosystem: "npm", name: aliasName, version: aliasVersion });
+          continue;
+        }
+        const version = cleanVersion(spec);
+        if (!version) {
+          warnings.push(`package.json: skipped "${name}" (${spec}) \u2014 no concrete version (wildcard/tag/range).`);
+          continue;
+        }
+        items.push({ ecosystem: "npm", name, version });
+      }
+    }
+  } catch {
+  }
+  return { items, warnings };
+}
+function readNpmFromPackageLock(root) {
+  const p = join(root, "package-lock.json");
+  if (!existsSync(p)) return { items: [], warnings: [] };
+  const items = [];
+  try {
+    const lock = JSON.parse(readFileSync(p, "utf8"));
+    if (lock.packages) {
+      for (const [path, meta] of Object.entries(lock.packages)) {
+        if (!path.startsWith("node_modules/")) continue;
+        const name = path.slice(path.lastIndexOf("node_modules/") + "node_modules/".length);
+        if (!meta.version) continue;
+        items.push({ ecosystem: "npm", name, version: meta.version });
+      }
+    }
+    if (lock.dependencies && items.length === 0) {
+      for (const [name, meta] of Object.entries(lock.dependencies)) {
+        if (!meta.version) continue;
+        items.push({ ecosystem: "npm", name, version: meta.version });
+      }
+    }
+  } catch {
+  }
+  return { items, warnings: [] };
+}
+function readNpmFromYarnLock(root) {
+  const p = join(root, "yarn.lock");
+  if (!existsSync(p)) return { items: [], warnings: [] };
+  const items = [];
+  try {
+    const text = readFileSync(p, "utf8");
+    const lines = text.split(/\r?\n/);
+    let pendingNames = [];
+    for (const line of lines) {
+      if (/^[^\s].*:\s*$/.test(line) && !line.startsWith("#")) {
+        pendingNames = parseYarnHeaderNames(line.replace(/:\s*$/, ""));
+        continue;
+      }
+      const m = line.match(/^\s+version:?\s+"?([^"\s]+)"?/);
+      if (m && pendingNames.length) {
+        const version = m[1];
+        for (const name of pendingNames) items.push({ ecosystem: "npm", name, version });
+        pendingNames = [];
+      }
+    }
+  } catch {
+  }
+  return { items, warnings: [] };
+}
+function parseYarnHeaderNames(header) {
+  const names = /* @__PURE__ */ new Set();
+  for (let part of header.split(",")) {
+    part = part.trim().replace(/^"|"$/g, "");
+    if (!part) continue;
+    const at = part.lastIndexOf("@");
+    if (at <= 0) continue;
+    names.add(part.slice(0, at));
+  }
+  return [...names];
+}
+function readNpmFromPnpmLock(root) {
+  const p = join(root, "pnpm-lock.yaml");
+  if (!existsSync(p)) return { items: [], warnings: [] };
+  const items = [];
+  try {
+    const text = readFileSync(p, "utf8");
+    const re = /^\s*['"]?\/?((?:@[^/@\s]+\/)?[^/@\s'"]+)@(\d[^()'":\s]*)(?:\([^)]*\))*['"]?\s*:/gm;
+    let m;
+    while ((m = re.exec(text)) !== null) {
+      items.push({ ecosystem: "npm", name: m[1], version: m[2] });
+    }
+  } catch {
+  }
+  return { items, warnings: [] };
+}
+function readPypiFromRequirements(root) {
+  const items = [];
+  const warnings = [];
+  for (const file of ["requirements.txt"]) {
+    const p = join(root, file);
+    if (!existsSync(p)) continue;
+    try {
+      const text = readFileSync(p, "utf8");
+      for (let line of text.split(/\r?\n/)) {
+        line = line.replace(/\s+#.*$/, "").trim();
+        if (!line || line.startsWith("#")) continue;
+        if (line.startsWith("-") || line.includes("://")) {
+          warnings.push(`requirements.txt: skipped "${line.slice(0, 60)}" \u2014 not a simple pin.`);
+          continue;
+        }
+        const m = line.match(/^([A-Za-z0-9._-]+)(?:\[[^\]]*\])?\s*([=<>!~]=?)\s*([0-9][^\s;#]*)/);
+        if (m) {
+          items.push({ ecosystem: "pypi", name: m[1], version: m[3] });
+        } else {
+          warnings.push(`requirements.txt: skipped "${line.slice(0, 60)}" \u2014 no concrete version.`);
+        }
+      }
+    } catch {
+    }
+  }
+  return { items, warnings };
+}
+function readPypiFromPoetryLock(root) {
+  const p = join(root, "poetry.lock");
+  if (!existsSync(p)) return { items: [], warnings: [] };
+  const items = [];
+  try {
+    const text = readFileSync(p, "utf8");
+    const blocks = text.split(/\[\[package\]\]/);
+    for (const block of blocks) {
+      const name = block.match(/^\s*name\s*=\s*"([^"]+)"/m)?.[1];
+      const version = block.match(/^\s*version\s*=\s*"([^"]+)"/m)?.[1];
+      if (name && version) items.push({ ecosystem: "pypi", name, version });
+    }
+  } catch {
+  }
+  return { items, warnings: [] };
+}
+function readPypiFromUvLock(root) {
+  const p = join(root, "uv.lock");
+  if (!existsSync(p)) return { items: [], warnings: [] };
+  const items = [];
+  try {
+    const text = readFileSync(p, "utf8");
+    const blocks = text.split(/\[\[package\]\]/);
+    for (const block of blocks) {
+      const name = block.match(/^\s*name\s*=\s*"([^"]+)"/m)?.[1];
+      const version = block.match(/^\s*version\s*=\s*"([^"]+)"/m)?.[1];
+      if (name && version) items.push({ ecosystem: "pypi", name, version });
+    }
+  } catch {
+  }
+  return { items, warnings: [] };
+}
+function readPypiFromPyproject(root) {
+  const p = join(root, "pyproject.toml");
+  if (!existsSync(p)) return { items: [], warnings: [] };
+  const items = [];
+  const warnings = [];
+  try {
+    const text = readFileSync(p, "utf8");
+    const arr = text.match(/dependencies\s*=\s*\[([\s\S]*?)\]/);
+    if (arr) {
+      for (const m of arr[1].matchAll(/"([^"]+)"/g)) {
+        const spec = m[1];
+        const dm = spec.match(/^([A-Za-z0-9._-]+)(?:\[[^\]]*\])?\s*([=<>!~]=?)\s*([0-9][^\s;]*)/);
+        if (dm) items.push({ ecosystem: "pypi", name: dm[1], version: dm[3] });
+        else warnings.push(`pyproject.toml: skipped "${spec.slice(0, 60)}" \u2014 no concrete version.`);
+      }
+    }
+  } catch {
+  }
+  return { items, warnings };
+}
+function scanManifests(root = process.cwd()) {
+  const items = [];
+  const sources = [];
+  const ecosystems = /* @__PURE__ */ new Set();
+  const warnings = [];
+  const npmReaders = [
+    ["package-lock.json", readNpmFromPackageLock],
+    ["pnpm-lock.yaml", readNpmFromPnpmLock],
+    ["yarn.lock", readNpmFromYarnLock],
+    ["package.json", readNpmFromPackageJson]
+  ];
+  for (const [file, reader] of npmReaders) {
+    if (!existsSync(join(root, file))) continue;
+    const got = reader(root);
+    if (got.items.length) {
+      items.push(...got.items);
+      warnings.push(...got.warnings);
+      sources.push(file);
+      ecosystems.add("npm");
+      break;
+    }
+  }
+  const pypiReaders = [
+    ["poetry.lock", readPypiFromPoetryLock],
+    ["uv.lock", readPypiFromUvLock],
+    ["requirements.txt", readPypiFromRequirements],
+    ["pyproject.toml", readPypiFromPyproject]
+  ];
+  for (const [file, reader] of pypiReaders) {
+    if (!existsSync(join(root, file))) continue;
+    const got = reader(root);
+    if (got.items.length) {
+      items.push(...got.items);
+      warnings.push(...got.warnings);
+      sources.push(file);
+      ecosystems.add("pypi");
+      break;
+    }
+  }
+  return {
+    items: uniqueItems(items),
+    sources,
+    ecosystems: [...ecosystems],
+    warnings,
+    skipped: warnings.length
+  };
+}
+
+// src/cache.ts
+import { mkdirSync, readFileSync as readFileSync2, writeFileSync, existsSync as existsSync2 } from "fs";
+import { join as join2 } from "path";
+var CACHE_DIR_NAME = ".inner-cache";
+var CACHE_MAX_AGE_MS = 7 * 24 * 60 * 60 * 1e3;
+function cacheKey(item) {
+  return `${item.ecosystem}:${item.name}:${item.version}`;
+}
+function keyToFilename(key) {
+  return key.replace(/[^a-zA-Z0-9._-]/g, "_") + ".json";
+}
+var VerdictCache = class {
+  dir;
+  constructor(rootDir = process.cwd()) {
+    this.dir = join2(rootDir, CACHE_DIR_NAME);
+  }
+  pathFor(key) {
+    return join2(this.dir, keyToFilename(key));
+  }
+  /** Persist a resolved envelope as last-known-good. */
+  put(item, envelope) {
+    try {
+      if (!existsSync2(this.dir)) mkdirSync(this.dir, { recursive: true });
+      const entry = {
+        key: cacheKey(item),
+        cached_at: (/* @__PURE__ */ new Date()).toISOString(),
+        envelope
+      };
+      writeFileSync(this.pathFor(entry.key), JSON.stringify(entry, null, 2), "utf8");
+    } catch {
+    }
+  }
+  /**
+   * Read a last-known-good envelope that is safe to TRUST for resolution, or
+   * undefined on miss/parse error/untrusted entry.
+   *
+   * The cache is fail-OPEN: only a cached ALLOW that has not gone stale is a
+   * usable verdict. A cached BLOCK/REVIEW (or anything non-ALLOW), or an
+   * expired entry, is treated as a miss so the caller surfaces UNKNOWN and the
+   * operator decides — never a silent allow of a now-known-bad package.
+   */
+  get(item, now = /* @__PURE__ */ new Date()) {
+    try {
+      const p = this.pathFor(cacheKey(item));
+      if (!existsSync2(p)) return void 0;
+      const entry = JSON.parse(readFileSync2(p, "utf8"));
+      const envelope = entry.envelope;
+      if (!envelope || envelope.action !== "ALLOW") return void 0;
+      if (isStale(entry, now)) return void 0;
+      return envelope;
+    } catch {
+      return void 0;
+    }
+  }
+};
+function isStale(entry, now) {
+  const nowMs = now.getTime();
+  const expiresMs = Date.parse(entry.envelope?.expires_at ?? "");
+  if (!Number.isNaN(expiresMs)) return expiresMs <= nowMs;
+  const cachedMs = Date.parse(entry.cached_at ?? "");
+  if (!Number.isNaN(cachedMs)) return nowMs - cachedMs >= CACHE_MAX_AGE_MS;
+  return true;
+}
+
+// src/client.ts
+var VerdictClient2 = class {
+  client;
+  constructor(opts) {
+    const cache = opts.noCache ? void 0 : new VerdictCache(opts.cacheRoot);
+    this.client = new VerdictClient({
+      baseUrl: opts.apiUrl,
+      timeoutMs: opts.timeoutMs,
+      maxPollAttempts: opts.maxPollAttempts ?? 5,
+      // The CLI scan gate fails open FAST: no transient-retry before serving the
+      // last-known-good cache (CR-E1.1). A build must not hang on a slow/hung
+      // Verdict API. The shared client keeps retries for the MCP path, which has
+      // no build-latency contract and benefits from riding transient blips.
+      maxRetries: 0,
+      cache: cache ? {
+        get: (item) => cache.get(item),
+        put: (item, env) => cache.put(item, env)
+      } : void 0
+    });
+  }
+  /**
+   * Resolve a batch of items. Returns one ResolvedItem per requested item.
+   * On total API failure, falls back to the fail-open cache for every item.
+   */
+  resolve(items) {
+    return this.client.resolve(items);
+  }
+};
+
+// src/scan.ts
+function aggregate(resolved) {
+  const tally = {
+    scanned: resolved.length,
+    allowed: 0,
+    blocked: 0,
+    review: 0,
+    unknown: 0,
+    fromCache: 0
+  };
+  for (const r of resolved) {
+    if (r.source === "cache") tally.fromCache++;
+    if (!r.envelope) {
+      tally.unknown++;
+      continue;
+    }
+    const action = r.envelope.action;
+    switch (action) {
+      case "ALLOW":
+        tally.allowed++;
+        break;
+      case "BLOCK":
+        tally.blocked++;
+        break;
+      case "REVIEW":
+        tally.review++;
+        break;
+      default:
+        tally.unknown++;
+    }
+  }
+  return tally;
+}
+async function scan(opts = {}) {
+  const root = opts.root ?? process.cwd();
+  const cfg = resolveConfig({ apiUrl: opts.apiUrl });
+  const manifest = opts.manifest ?? scanManifests(root);
+  const client = new VerdictClient2({
+    apiUrl: cfg.apiUrl,
+    cacheRoot: root,
+    noCache: opts.noCache
+  });
+  const { resolved, degraded } = await client.resolve(manifest.items);
+  return {
+    tally: aggregate(resolved),
+    resolved,
+    sources: manifest.sources,
+    ecosystems: manifest.ecosystems,
+    degraded,
+    apiUrl: cfg.apiUrl,
+    apiUrlIsDefault: cfg.apiUrlIsDefault,
+    skipped: manifest.skipped,
+    warnings: manifest.warnings
+  };
+}
+function formatTally(t) {
+  return `${t.scanned} packages scanned, ${t.allowed} allowed, ${t.blocked} blocked`;
+}
+
+// src/scan-render.ts
+async function runScanCommand(opts) {
+  const result = await scan(opts);
+  if (opts.json) return writeJson(result);
+  return writeText(result);
+}
+function writeJson(result) {
+  process.stdout.write(
+    JSON.stringify(
+      {
+        tally: result.tally,
+        ecosystems: result.ecosystems,
+        sources: result.sources,
+        degraded: result.degraded,
+        apiUrl: result.apiUrl,
+        apiUrlIsDefault: result.apiUrlIsDefault,
+        skipped: result.skipped,
+        warnings: result.warnings,
+        items: result.resolved.map((r) => ({
+          ecosystem: r.item.ecosystem,
+          name: r.item.name,
+          version: r.item.version,
+          action: r.envelope?.action ?? "UNKNOWN",
+          status: r.envelope?.status,
+          source: r.source
+        }))
+      },
+      null,
+      2
+    ) + "\n"
+  );
+  return result.tally.blocked > 0 ? 1 : 0;
+}
+function writeText(result) {
+  const t = result.tally;
+  if (t.scanned === 0) {
+    process.stdout.write(
+      "No package manifest/lockfile found. Run inside a project with a package.json / requirements.txt / lockfile.\n"
+    );
+    return 0;
+  }
+  process.stdout.write("Inner scan \u2014 " + (result.ecosystems.join(", ") || "no ecosystem") + "\n");
+  if (result.sources.length) {
+    process.stdout.write("  sources: " + result.sources.join(", ") + "\n");
+  }
+  process.stdout.write("  " + formatTally(t) + "\n");
+  if (t.review) process.stdout.write(`  ${t.review} need review
+`);
+  if (t.unknown) process.stdout.write(`  ${t.unknown} unknown / unresolved
+`);
+  if (result.skipped) {
+    process.stdout.write(
+      `  \u26A0 ${result.skipped} manifest entr${result.skipped === 1 ? "y" : "ies"} skipped (unparseable \u2014 not scanned):
+`
+    );
+    for (const w of result.warnings) process.stdout.write(`    - ${w}
+`);
+  }
+  if (result.degraded) {
+    process.stdout.write(
+      `  (API unreachable \u2014 ${t.fromCache} resolved from fail-open cache, others marked unknown)
+`
+    );
+  }
+  if (result.apiUrlIsDefault) {
+    process.stdout.write(
+      `  note: using default Verdict API ${result.apiUrl} \u2014 set INNER_API_URL to the production endpoint.
+`
+    );
+  }
+  const blocked = result.resolved.filter((r) => r.envelope?.action === "BLOCK");
+  if (blocked.length) {
+    process.stdout.write("\nBLOCKED:\n");
+    for (const b of blocked) {
+      process.stdout.write(
+        `  \u2717 ${b.item.ecosystem}:${b.item.name}@${b.item.version}` + (b.envelope?.status ? ` (${b.envelope.status})` : "") + "\n"
+      );
+    }
+  }
+  return t.blocked > 0 ? 1 : 0;
+}
+
+// src/scan-cli.ts
+var HELP = `inner scan \u2014 zero-auth instant dependency scan (consumes Inner Verdict API / C1)
+
+Usage:
+  npx @inner-security/scan [options]
+
+Options:
+  --dir <path>      Project root to scan (default: cwd)
+  --api-url <url>   Verdict API base URL (default: $INNER_API_URL or local mock)
+  --json            Emit machine-readable JSON instead of the text tally
+  --no-cache        Do not read/write the fail-open .inner-cache/
+  -h, --help        Show this help
+
+Env:
+  INNER_API_URL     Verdict API base URL (overridden by --api-url)
+
+Exit codes:
+  0  no blocked packages
+  1  one or more BLOCKED packages found
+  2  usage / unexpected error
+`;
+async function main() {
+  const { flags } = parseArgs(process.argv.slice(2));
+  if (flagBool(flags, "help")) {
+    process.stdout.write(HELP);
+    return 0;
+  }
+  return runScanCommand({
+    root: flagString(flags, "dir"),
+    apiUrl: flagString(flags, "api-url"),
+    noCache: flagBool(flags, "no-cache"),
+    json: flagBool(flags, "json")
+  });
+}
+main().then((code) => process.exit(code)).catch((err) => {
+  process.stderr.write(`inner scan: ${err instanceof Error ? err.message : String(err)}
+`);
+  process.exit(2);
+});