@wardby/cli 0.5.3 → 0.7.0

package/dist/providers/coding-proxy/registry/prisma-store.js

@@ -1,3 +1,4 @@
+import { isPackageAuditMode, parsePackageAuditVerdict } from "../../../coding/registry/audit-mode.js";
 import { extraAllowanceName, extraOfAllowanceName } from "./store.js";
 /** Versions looked up per query, so a 5000-entry lockfile is a handful of
  *  bounded queries rather than one enormous OR. */
@@ -14,7 +15,17 @@ export class PrismaRegistryStore {
                 runId: true,
                 status: true,
                 deadlineAt: true,
-                run: { select: { packageAllowlist: true, packagePolicy: true } },
+                run: {
+                    select: {
+                        packageAllowlist: true,
+                        packagePolicy: true,
+                        repository: true,
+                        workerImage: true,
+                        toolImage: true,
+                        dependencyCache: true,
+                        packageAuditMode: true,
+                    },
+                },
             },
         });
         if (!session || session.status !== "active" || session.deadlineAt <= now)
@@ -24,6 +35,10 @@ export class PrismaRegistryStore {
             deadlineAt: session.deadlineAt,
             allowlist: (session.run.packageAllowlist ?? {}),
             policy: session.run.packagePolicy,
+            repository: session.run.repository,
+            cacheImage: session.run.toolImage ?? session.run.workerImage,
+            dependencyCache: session.run.dependencyCache,
+            packageAudit: isPackageAuditMode(session.run.packageAuditMode) ? session.run.packageAuditMode : null,
         };
     }
     async isAllowedDependency(runId, ecosystem, name) {
@@ -36,6 +51,15 @@ export class PrismaRegistryStore {
         });
         return row !== null;
     }
+    async findAllowance(runId, ecosystem, name) {
+        // An extra's row (`name[extra]`) is never a package allowance.
+        if (name.includes("["))
+            return null;
+        return this.db.registryAllowance.findUnique({
+            where: { runId_ecosystem_name: { runId, ecosystem, name } },
+            select: { auditedVia: true },
+        });
+    }
     async addAllowances(runId, ecosystem, names) {
         if (names.length === 0)
             return;
@@ -44,6 +68,32 @@ export class PrismaRegistryStore {
             skipDuplicates: true,
         });
     }
+    async addAuditedAllowances(runId, ecosystem, names, auditedVia) {
+        if (names.length === 0)
+            return;
+        // Insert-only (the proxy has no UPDATE): an existing row keeps its first writer.
+        await this.db.registryAllowance.createMany({
+            data: [...new Set(names)].map((name) => ({ runId, ecosystem, name, auditedVia })),
+            skipDuplicates: true,
+        });
+    }
+    async recordAudit(record) {
+        await this.db.registryAuditRecord.createMany({
+            data: [
+                {
+                    runId: record.runId,
+                    ecosystem: record.ecosystem,
+                    name: record.name,
+                    version: record.version,
+                    relation: record.relation,
+                    via: record.via ?? null,
+                    sizeBytes: record.sizeBytes ?? null,
+                    advisories: record.advisories.map(({ id, severity, summary }) => ({ id, severity, summary })),
+                },
+            ],
+            skipDuplicates: true,
+        });
+    }
     async allowedExtras(runId, ecosystem, name) {
         const rows = await this.db.registryAllowance.findMany({
             where: { runId, ecosystem, name: { startsWith: `${name}[` } },
@@ -73,18 +123,15 @@ export class PrismaRegistryStore {
     }
     async listFetches(runId) {
         const rows = await this.db.registryFetch.findMany({ where: { runId }, orderBy: { createdAt: "asc" } });
-        return rows.map((row) => ({
-            runId: row.runId,
-            ecosystem: row.ecosystem,
-            name: row.name,
-            version: row.version ?? undefined,
-            filename: row.filename ?? undefined,
-            integrity: row.integrity ?? undefined,
-            sizeBytes: row.sizeBytes ?? undefined,
-            outcome: row.outcome,
-            reason: row.reason ?? undefined,
-            createdAt: row.createdAt,
-        }));
+        return rows.map(fetchRecordOf);
+    }
+    async listRecentRefusals(runId, since, limit) {
+        const rows = await this.db.registryFetch.findMany({
+            where: { runId, outcome: "refused", createdAt: { gte: since } },
+            orderBy: { createdAt: "desc" },
+            take: limit,
+        });
+        return rows.map(fetchRecordOf);
     }
     async getVersionFacts(ecosystem, versions) {
         const facts = [];
@@ -117,7 +164,13 @@ export class PrismaRegistryStore {
                 publishedAt: fact.publishedAt,
                 integrity: fact.integrity,
                 downloadUrl: fact.downloadUrl,
-                dependencies: fact.dependencies.map(({ key, name, range }) => ({ key, name, range })),
+                dependencies: fact.dependencies.map(({ key, name, range, extras, when }) => ({
+                    key,
+                    name,
+                    range,
+                    ...(extras ? { extras: [...extras] } : {}),
+                    ...(when ? { when: [...when] } : {}),
+                })),
             })),
             skipDuplicates: true,
         });
@@ -126,14 +179,32 @@ export class PrismaRegistryStore {
         if (versions.length === 0)
             return;
         await this.db.registryApprovedVersion.createMany({
-            data: versions.map(({ name, version, integrity }) => ({ runId, ecosystem, name, version, integrity })),
+            data: versions.map(({ name, version, integrity, acceptedAdvisories, audit }) => ({
+                runId,
+                ecosystem,
+                name,
+                version,
+                integrity,
+                acceptedAdvisories: [...(acceptedAdvisories ?? [])],
+                ...(audit
+                    ? {
+                        audit: {
+                            relation: audit.relation,
+                            ...(audit.via ? { via: audit.via } : {}),
+                            ...(audit.advisories?.length
+                                ? { advisories: audit.advisories.map(({ id, severity, summary }) => ({ id, severity, summary })) }
+                                : {}),
+                        },
+                    }
+                    : {}),
+            })),
             skipDuplicates: true,
         });
     }
     async findApprovedVersion(runId, ecosystem, name, version) {
         const approval = await this.db.registryApprovedVersion.findUnique({
             where: { runId_ecosystem_name_version: { runId, ecosystem, name, version } },
-            select: { integrity: true },
+            select: { integrity: true, acceptedAdvisories: true, audit: true },
         });
         if (!approval)
             return null;
@@ -141,7 +212,15 @@ export class PrismaRegistryStore {
             where: { ecosystem_name_version: { ecosystem, name, version } },
             select: { downloadUrl: true },
         });
-        return fact ? { integrity: approval.integrity, downloadUrl: fact.downloadUrl } : null;
+        const audit = parsePackageAuditVerdict(approval.audit);
+        return fact
+            ? {
+                integrity: approval.integrity,
+                downloadUrl: fact.downloadUrl,
+                acceptedAdvisories: approval.acceptedAdvisories,
+                ...(audit ? { audit } : {}),
+            }
+            : null;
     }
     async refusePlanVersions(runId, ecosystem, versions) {
         if (versions.length === 0)
@@ -165,4 +244,28 @@ export class PrismaRegistryStore {
             select: { code: true, reason: true, publishedAt: true },
         });
     }
+    async recordDependencyCacheLockHash(runId, lockHash, max) {
+        // One statement, so a concurrent seal or plan can never slip past a check.
+        await this.db.$executeRaw `
+      UPDATE "CodingProxySession"
+      SET "dependencyCacheLockHashes" = array_append("dependencyCacheLockHashes", ${lockHash})
+      WHERE "runId" = ${runId}
+        AND "dependencyCacheSealedAt" IS NULL
+        AND NOT (${lockHash} = ANY("dependencyCacheLockHashes"))
+        AND cardinality("dependencyCacheLockHashes") < ${max}`;
+    }
+}
+function fetchRecordOf(row) {
+    return {
+        runId: row.runId,
+        ecosystem: row.ecosystem,
+        name: row.name,
+        version: row.version ?? undefined,
+        filename: row.filename ?? undefined,
+        integrity: row.integrity ?? undefined,
+        sizeBytes: row.sizeBytes ?? undefined,
+        outcome: row.outcome,
+        reason: row.reason ?? undefined,
+        createdAt: row.createdAt,
+    };
 }

package/dist/providers/coding-proxy/registry/service.d.ts

@@ -1,15 +1,32 @@
-import { RegistryError, type Integrity, type RegistryAdapter, type UpstreamFetch } from "../../../coding/registry/types.js";
+import { RegistryError, type Integrity, type PackageMetadata, type RegistryAdapter, type UpstreamFetch } from "../../../coding/registry/types.js";
 import type { OsvAudit } from "./audit.js";
-import type { RegistryStore } from "./store.js";
+import { type RegistryStore } from "./store.js";
 export declare const DEFAULT_MAX_GRAPH_PACKAGES = 3000;
 export declare const DEFAULT_GRAPH_TIMEOUT_MS = 180000;
 /** Graph-walk expansions in flight at once across every run, so one run's
  *  walk cannot starve the others' upstream fetches -- or the proxy's event
  *  loop: parsing packuments is CPU work on the same loop that carries model
  *  traffic (per-walk 2 and global 3 since a live install at 4/6 on 500m
- *  expired a ledger transaction). The walk is only the fallback now; lockfile
- *  verification answers most installs without it. */
+ *  expired a ledger transaction). The walk is only the fallback now: a
+ *  download of a version the run has not resolved starts one (and a
+ *  metadata miss, only after a failed or partial lockfile plan), and
+ *  lockfile verification answers most of those without it. */
 export declare const DEFAULT_MAX_GRAPH_CONCURRENCY = 3;
+/** Byte budget of the graph walk's memo of expanded packages (kept
+ *  versions and their declared dependencies), across every run. */
+export declare const DEFAULT_GRAPH_MEMO_BYTES: number;
+/** How long a memoized expansion is reused. Safe for that long: a kept
+ *  version depends on the release-age cutoff, which only moves forward (a
+ *  stale entry can only omit a version that has since become old enough,
+ *  which fails closed), and on the OSV audit, which is itself cached for an
+ *  hour (audit.ts). The walk's view of advisories can therefore lag by the
+ *  audit cache TTL plus 15 minutes; that only affects which names the walk
+ *  allows, because every served version is re-audited through keptVersions
+ *  and malware is never allowed. A version published upstream within the TTL is
+ *  too new to be kept under any non-zero minReleaseAgeDays; with
+ *  minReleaseAgeDays 0 it is omitted until the entry expires (fails
+ *  closed). */
+export declare const GRAPH_MEMO_TTL_MS: number;
 /** Lockfile plans read and verified at once across every run: with the
  *  20 MiB body cap, this bounds the lockfile text held at once. */
 export declare const DEFAULT_PLAN_CONCURRENCY = 2;
@@ -47,6 +64,13 @@ export interface RegistryRequest {
     token: string;
     signal: AbortSignal;
 }
+export interface RegistryRefusalsRequest {
+    token: string;
+    /** Only refusals recorded at or after this time; the last 15 minutes when absent or invalid. */
+    since?: Date;
+}
+/** The most refusals `GET /registry/-/refusals` returns (distinct, newest first). */
+export declare const MAX_LISTED_REFUSALS = 20;
 export interface RegistryPlanRequest {
     ecosystem: string;
     token: string;
@@ -57,7 +81,16 @@ export interface RegistryPlanRequest {
     readBody(): Promise<string>;
     signal: AbortSignal;
 }
-export declare function errorResponse(error: RegistryError): RegistryResponse;
+/**
+ * Why kept versions leave nothing to download, or null when some file is
+ * servable: every allowed file newer than the release-age limit
+ * (`wardby_version_filtered`), or no allowed file at all, such as a Python
+ * package with only source distributions (`wardby_file_not_allowed`).
+ */
+export declare function unservableReason(meta: PackageMetadata, keep: ReadonlySet<string>, keptFiles: ReadonlySet<string>): "wardby_version_filtered" | "wardby_file_not_allowed" | null;
+export declare function errorResponse(error: RegistryError): Extract<RegistryResponse, {
+    body: string;
+}>;
 export declare const DEFAULT_METADATA_CACHE_ENTRIES = 500;
 /** Byte budget of the metadata cache, by each entry's approximate retained
  *  size. Entries are trimmed (an npm package's is a few MB at most, for
@@ -93,6 +126,17 @@ export declare class RegistryService {
      *  across replicas. */
     private readonly inFlight;
     private readonly tallies;
+    /** Expanded packages of the graph walks (`runId\0ecosystem\0name`),
+     *  least recently used first, so a package reached again under a new
+     *  range, in a later request of the same run, is not read again.
+     *  Run-scoped by key: a package's kept versions depend on the run's
+     *  policy and allowlist range. Bounded to `graphMemoBytes`; entries
+     *  expire GRAPH_MEMO_TTL_MS after they are computed, and a run's entries
+     *  are dropped when the run is released. */
+    private readonly graphMemo;
+    /** Sum of the memo entries' `bytes`. */
+    private graphMemoTotal;
+    private readonly graphMemoBytes;
     private readonly walkSlots;
     private readonly planSlots;
     private readonly versionUpstream;
@@ -119,28 +163,47 @@ export declare class RegistryService {
         /** Time one on-demand graph walk may take (default 180 s). */
         graphTimeoutMs?: number;
         /** Graph-walk expansions in flight at once across every run
-         *  (default 16). */
+         *  (default 3). */
         maxGraphConcurrency?: number;
         /** Entries a lockfile plan may have (default 5000). */
         planMaxEntries?: number;
         /** Time one lockfile plan may take (default 120 s). */
         planTimeoutMs?: number;
+        /** Time reading one pnpm or yarn lockfile (in a worker thread) may
+         *  take (default 15 s). */
+        planParseTimeoutMs?: number;
         /** Lockfile plans read and verified at once across every run (default 2). */
         planConcurrency?: number;
         /** Lockfile plans one run may make (default 20). */
         planMaxPerRun?: number;
     });
+    /**
+     * `GET /registry/-/refusals`: the run's recent refusals (package, code and the
+     * shared hint), for a client that does not print the registry's 403 body
+     * (pip, uv). Authenticated with the run's registry token. Names come from the
+     * run's own requests; nothing else (no URL, no token) is returned.
+     */
+    refusals(request: RegistryRefusalsRequest): Promise<Extract<RegistryResponse, {
+        body: string;
+    }>>;
     /** `POST /registry/<ecosystem>/-/plan`: verifies a lockfile against the
      *  registry and approves exactly its verified, reachable name@version
      *  pairs for the run (plan.ts). Answers `{ approved, refused }`. */
     plan(request: RegistryPlanRequest): Promise<RegistryResponse>;
     private planLockfile;
+    private runPlan;
     private verifyPlan;
     /** One refused row per plan refusal, within the run's refusal cap, and
      *  once per run however often the same lockfile is planned. */
     private recordPlanRefusals;
     handle(request: RegistryRequest): Promise<RegistryResponse>;
     private dispatch;
+    /** The allowances serving a package's metadata grows: its kept versions'
+     *  dependencies, and, for an audited package, each tagged with the
+     *  top-level audited package that declared it (its own name for a
+     *  top-level one, which is also recorded for itself so its later
+     *  downloads read as top-level). */
+    private allowServed;
     private hostAllowed;
     /** Served usage for the run, seeded once from the store and then kept
      *  current in-process as downloads complete. */
@@ -151,23 +214,38 @@ export declare class RegistryService {
      *  version (the same filter the metadata path applies: root range,
      *  release age, advisories), transitively. Each newly found name is
      *  recorded as an allowance as the walk goes, exactly as if its
-     *  parent's metadata had been served. A scoped wildcard root cannot be
-     *  enumerated, so it is never a starting point. */
+     *  parent's metadata had been served. Only a download asks, or a
+     *  metadata miss after a failed or partial lockfile plan (see
+     *  `authorize`). A scoped wildcard root cannot be enumerated, so it is
+     *  never a starting point. */
     private resolveInGraph;
     /** The answer for a name the walk did not find: unavailable while any
      *  node could not be expanded (the audit, if any failure was the
      *  audit's), otherwise absent. */
     private graphMiss;
+    /** One walk, logged once when it stops, with its progress (and, on a
+     *  timeout, its frontier) taken before `running` is cleared. */
     private walkGraph;
-    /** The kept versions of one package inside the edge's range, and each
-     *  one's declared dependencies, through the same metadata cache and
-     *  `keptVersions` filter the metadata path uses (a root's allowlist range
-     *  applies there), within the process-wide walk concurrency cap. `"*"`
-     *  selects every kept version; a range no kept version satisfies selects
-     *  none. A package npm doesn't have, or whose metadata is too large,
-     *  definitively selects nothing; any other failure (upstream error or
-     *  timeout, audit unavailable) is transient and reported for retry. */
+    private expandGraph;
+    /** The kept versions of one package inside any of the ranges that reached
+     *  it, and each one's declared dependencies, through the same metadata
+     *  cache and `keptVersions` filter the metadata path uses (a root's
+     *  allowlist range applies there), within the process-wide walk
+     *  concurrency cap. A `"*"` edge selects every kept version; a range no
+     *  kept version satisfies selects none. A package npm doesn't have, or
+     *  whose metadata is too large, definitively selects nothing; any other
+     *  failure (upstream error or timeout, audit unavailable) is transient
+     *  and reported for retry. */
     private graphNode;
+    /** A package's kept versions for the run's walk, from the memo or
+     *  computed (and memoized). A failed computation is not memoized, so its
+     *  retry really retries. */
+    private keptForGraph;
+    private dropMemo;
+    private putMemo;
+    /** Memoizes an expansion, least recently used evicted first, within the
+     *  byte budget. An entry larger than the whole budget is not kept. */
+    private memoize;
     /** A package's metadata, cached. `render` asks for the form
      *  `renderMetadata` can serve; a cached entry fetched without it (by the
      *  graph walk or a download) is fetched again with it, and replaces it. */
@@ -213,5 +291,8 @@ export declare class RegistryService {
      *  plus those a served parent's dependency line asked of it. They decide
      *  which of the package's extra-gated dependencies its files allow. */
     private allowedExtras;
+    /** One RegistryAuditRecord (the first served file of a version wins) and
+     *  its `registry.audited` log line. */
+    private recordAudit;
     private download;
 }