@wardby/cli 0.5.2 → 0.6.0

package/dist/providers/chat/fake.js

@@ -0,0 +1,39 @@
+export class FakeChatProvider {
+    name = "slack";
+    posts = [];
+    updates = [];
+    channels = new Map();
+    queuedErrors = {
+        postMessage: [],
+        updateMessage: [],
+        channelInfo: [],
+        authTest: [],
+    };
+    nextTs = 1;
+    failNext(method, err) {
+        this.queuedErrors[method].push(err);
+    }
+    consumeFailure(method) {
+        const err = this.queuedErrors[method].shift();
+        if (err)
+            throw err;
+    }
+    async postMessage(channelId, msg, opts = {}) {
+        this.consumeFailure("postMessage");
+        const ts = `${this.nextTs++}.000`;
+        this.posts.push({ channelId, ts, msg, threadTs: opts.threadTs, broadcast: opts.broadcast });
+        return { ts };
+    }
+    async updateMessage(channelId, ts, msg) {
+        this.consumeFailure("updateMessage");
+        this.updates.push({ channelId, ts, msg });
+    }
+    async channelInfo(channel) {
+        this.consumeFailure("channelInfo");
+        return this.channels.get(channel) ?? null;
+    }
+    async authTest() {
+        this.consumeFailure("authTest");
+        return { team: "fake", botUserId: "UFAKE" };
+    }
+}

package/dist/providers/chat/index.d.ts

@@ -0,0 +1,4 @@
+import type { ChatProviderRegistry } from "./types.js";
+export * from "./types.js";
+/** One provider per configured chat service; empty when Slack is not configured. */
+export declare function buildChatProviders(env?: NodeJS.ProcessEnv, fetchImpl?: typeof fetch): ChatProviderRegistry;

package/dist/providers/chat/index.js

@@ -0,0 +1,8 @@
+import { loadSlackConfig } from "../../config/providers.js";
+import { SlackChatProvider } from "./slack.js";
+export * from "./types.js";
+/** One provider per configured chat service; empty when Slack is not configured. */
+export function buildChatProviders(env = process.env, fetchImpl) {
+    const slack = loadSlackConfig(env);
+    return slack ? { slack: new SlackChatProvider(slack, fetchImpl) } : {};
+}

package/dist/providers/chat/slack.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Slack Web API client for workflow notifications: chat.postMessage,
+ * chat.update, conversations.info, auth.test. Plain fetch (JSON bodies for
+ * writes, form-encoded for reads), bot token. Every failure becomes a ChatError with a normalized code the
+ * dispatcher acts on; Slack's own error string is kept for the operator.
+ */
+import type { SlackConfig } from "../../config/providers.js";
+import { type ChatMessage, type ChatProvider } from "./types.js";
+export declare class SlackChatProvider implements ChatProvider {
+    private readonly config;
+    private readonly fetchImpl;
+    readonly name: "slack";
+    constructor(config: SlackConfig, fetchImpl?: typeof fetch);
+    /**
+     * `form` for read methods (conversations.info, auth.test): Slack accepts JSON
+     * bodies only on write methods and answers a read method's JSON body with
+     * invalid_arguments.
+     */
+    private call;
+    private messageBody;
+    postMessage(channelId: string, msg: ChatMessage, opts?: {
+        threadTs?: string;
+        broadcast?: boolean;
+    }): Promise<{
+        ts: string;
+    }>;
+    updateMessage(channelId: string, ts: string, msg: ChatMessage): Promise<void>;
+    channelInfo(channel: string): Promise<{
+        id: string;
+        name: string;
+        isPrivate: boolean;
+    } | null>;
+    authTest(): Promise<{
+        team: string;
+        botUserId: string;
+    }>;
+}

package/dist/providers/chat/slack.js

@@ -0,0 +1,105 @@
+import { ChatError } from "./types.js";
+const CHANNEL_UNREACHABLE = new Set(["channel_not_found", "not_in_channel", "is_archived"]);
+const AUTH_FAILED = new Set([
+    "invalid_auth",
+    "not_authed",
+    "token_revoked",
+    "token_expired",
+    "account_inactive",
+    "missing_scope",
+]);
+const TIMEOUT_MS = 10_000;
+function classify(slackError) {
+    if (CHANNEL_UNREACHABLE.has(slackError))
+        return "channel_unreachable";
+    if (AUTH_FAILED.has(slackError))
+        return "auth_failed";
+    if (slackError === "message_not_found")
+        return "message_not_found";
+    if (slackError === "ratelimited")
+        return "rate_limited";
+    return "transient";
+}
+export class SlackChatProvider {
+    config;
+    fetchImpl;
+    name = "slack";
+    constructor(config, fetchImpl = fetch) {
+        this.config = config;
+        this.fetchImpl = fetchImpl;
+    }
+    /**
+     * `form` for read methods (conversations.info, auth.test): Slack accepts JSON
+     * bodies only on write methods and answers a read method's JSON body with
+     * invalid_arguments.
+     */
+    async call(method, body, encoding = "json") {
+        let res;
+        try {
+            res = await this.fetchImpl(`${this.config.apiBaseUrl}/${method}`, {
+                method: "POST",
+                headers: {
+                    authorization: `Bearer ${this.config.botToken}`,
+                    "content-type": encoding === "json" ? "application/json; charset=utf-8" : "application/x-www-form-urlencoded",
+                },
+                body: encoding === "json"
+                    ? JSON.stringify(body)
+                    : new URLSearchParams(Object.fromEntries(Object.entries(body).map(([k, v]) => [k, String(v)]))).toString(),
+                signal: AbortSignal.timeout(TIMEOUT_MS),
+            });
+        }
+        catch (err) {
+            throw new ChatError("transient", err instanceof Error ? err.message : String(err));
+        }
+        if (res.status === 429) {
+            const seconds = Number(res.headers.get("retry-after") ?? "1");
+            throw new ChatError("rate_limited", "ratelimited", (Number.isFinite(seconds) && seconds > 0 ? seconds : 1) * 1000);
+        }
+        if (!res.ok)
+            throw new ChatError("transient", `http_${res.status}`);
+        const json = (await res.json().catch(() => ({ ok: false, error: "invalid_json" })));
+        if (json.ok !== true) {
+            const slackError = typeof json.error === "string" ? json.error : "unknown_error";
+            throw new ChatError(classify(slackError), slackError);
+        }
+        return json;
+    }
+    messageBody(msg) {
+        return {
+            text: msg.text,
+            ...(msg.blocks ? { blocks: msg.blocks } : {}),
+            ...(this.config.customize && msg.username ? { username: msg.username } : {}),
+            ...(this.config.customize && msg.iconEmoji ? { icon_emoji: msg.iconEmoji } : {}),
+        };
+    }
+    async postMessage(channelId, msg, opts = {}) {
+        const json = await this.call("chat.postMessage", {
+            channel: channelId,
+            ...this.messageBody(msg),
+            ...(opts.threadTs ? { thread_ts: opts.threadTs } : {}),
+            ...(opts.threadTs && opts.broadcast ? { reply_broadcast: true } : {}),
+            unfurl_links: false,
+            unfurl_media: false,
+        });
+        return { ts: String(json.ts) };
+    }
+    async updateMessage(channelId, ts, msg) {
+        await this.call("chat.update", { channel: channelId, ts, ...this.messageBody(msg) });
+    }
+    async channelInfo(channel) {
+        try {
+            const json = await this.call("conversations.info", { channel }, "form");
+            const c = json.channel;
+            return { id: c.id, name: c.name, isPrivate: c.is_private === true };
+        }
+        catch (err) {
+            if (err instanceof ChatError && err.code === "channel_unreachable")
+                return null;
+            throw err;
+        }
+    }
+    async authTest() {
+        const json = await this.call("auth.test", {}, "form");
+        return { team: String(json.team), botUserId: String(json.user_id) };
+    }
+}

package/dist/providers/chat/types.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Host-neutral chat surface for outbound workflow notifications. Slack is
+ * the first (and only) implementation (./slack.ts). wardby only ever posts
+ * or updates messages here — it never reads channel history or listens for
+ * events.
+ */
+export declare const CHAT_PROVIDERS: readonly ["slack"];
+export type ChatProviderName = (typeof CHAT_PROVIDERS)[number];
+export type ChatErrorCode = "rate_limited" | "channel_unreachable" | "auth_failed" | "message_not_found" | "transient";
+export declare class ChatError extends Error {
+    readonly code: ChatErrorCode;
+    readonly slackError: string;
+    readonly retryAfterMs?: number | undefined;
+    constructor(code: ChatErrorCode, slackError: string, retryAfterMs?: number | undefined);
+}
+export interface ChatMessage {
+    text: string;
+    blocks?: unknown[];
+    username?: string;
+    iconEmoji?: string;
+}
+export interface ChatProvider {
+    readonly name: ChatProviderName;
+    postMessage(channelId: string, msg: ChatMessage, opts?: {
+        threadTs?: string;
+        broadcast?: boolean;
+    }): Promise<{
+        ts: string;
+    }>;
+    updateMessage(channelId: string, ts: string, msg: ChatMessage): Promise<void>;
+    /** null when the bot cannot see the channel; throws ChatError("auth_failed") on missing scope. */
+    channelInfo(channel: string): Promise<{
+        id: string;
+        name: string;
+        isPrivate: boolean;
+    } | null>;
+    authTest(): Promise<{
+        team: string;
+        botUserId: string;
+    }>;
+}
+export type ChatProviderRegistry = Partial<Record<ChatProviderName, ChatProvider>>;

package/dist/providers/chat/types.js

@@ -0,0 +1,19 @@
+/**
+ * Host-neutral chat surface for outbound workflow notifications. Slack is
+ * the first (and only) implementation (./slack.ts). wardby only ever posts
+ * or updates messages here — it never reads channel history or listens for
+ * events.
+ */
+export const CHAT_PROVIDERS = ["slack"];
+export class ChatError extends Error {
+    code;
+    slackError;
+    retryAfterMs;
+    constructor(code, slackError, retryAfterMs) {
+        super(`chat_error:${code}:${slackError}`);
+        this.code = code;
+        this.slackError = slackError;
+        this.retryAfterMs = retryAfterMs;
+        this.name = "ChatError";
+    }
+}

package/dist/providers/coding-proxy/mock-upstream.d.ts

@@ -0,0 +1,33 @@
+/**
+ * A fake model upstream for load tests: a `fetch` that never opens a socket.
+ * It answers an OpenAI Responses streaming request with one assistant message
+ * whose text is the coding worker's final JSON (`outcome: "no_changes"`), so a
+ * run finishes without tool calls, changes or a pull request. Enabled only by
+ * `mockUpstreamFromEnv` (see its guard). Never use outside a load test.
+ *
+ * Codex/OpenAI Responses only (ruling R1): any other host, including the
+ * Anthropic Messages endpoint, gets a 501 rather than a fabricated reply.
+ */
+export interface MockUpstreamConfig {
+    latencyMs: number;
+    jitterMs: number;
+    inputTokens: number;
+    outputTokens: number;
+}
+export declare const DEFAULT_MOCK_UPSTREAM: MockUpstreamConfig;
+/** The runId the coding worker's prompt names, or null when the request carries none. */
+export declare function extractRunId(body: string): string | null;
+/**
+ * Builds a `fetch` that simulates the OpenAI Responses streaming endpoint for
+ * load tests: no socket, no credential forwarding, deterministic latency and
+ * token counts. `sleep` is injectable so tests can assert on the delay without
+ * waiting it out.
+ */
+export declare function createMockUpstream(overrides?: Partial<MockUpstreamConfig>, sleep?: (ms: number) => Promise<void>): typeof globalThis.fetch;
+/**
+ * The mock model upstream is a load-test seam inside a production binary, so
+ * it needs two deliberate switches: WARDBY_LOAD_TEST=1 and
+ * WARDBY_CODING_PROXY_MOCK_UPSTREAM=1. One without the other, or any other
+ * value, refuses to start the proxy rather than silently picking a side.
+ */
+export declare function mockUpstreamFromEnv(env: NodeJS.ProcessEnv): MockUpstreamConfig | null;

package/dist/providers/coding-proxy/mock-upstream.js

@@ -0,0 +1,116 @@
+export const DEFAULT_MOCK_UPSTREAM = {
+    latencyMs: 5000,
+    jitterMs: 0,
+    inputTokens: 1200,
+    outputTokens: 80,
+};
+const RUN_ID = /The final JSON runId must be ([A-Za-z0-9][A-Za-z0-9_-]*)\./;
+/** The runId the coding worker's prompt names, or null when the request carries none. */
+export function extractRunId(body) {
+    return RUN_ID.exec(body)?.[1] ?? null;
+}
+const sse = (event, data) => `event: ${event}\ndata: ${JSON.stringify(data)}\n\n`;
+async function bodyText(input, init) {
+    const raw = init?.body;
+    if (typeof raw === "string")
+        return raw;
+    if (raw instanceof Uint8Array)
+        return Buffer.from(raw).toString("utf8");
+    if (input instanceof Request)
+        return input.text();
+    return "";
+}
+/**
+ * Builds a `fetch` that simulates the OpenAI Responses streaming endpoint for
+ * load tests: no socket, no credential forwarding, deterministic latency and
+ * token counts. `sleep` is injectable so tests can assert on the delay without
+ * waiting it out.
+ */
+export function createMockUpstream(overrides = {}, sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms))) {
+    const config = { ...DEFAULT_MOCK_UPSTREAM, ...overrides };
+    return async (input, init) => {
+        const url = new URL(typeof input === "string" || input instanceof URL ? input : input.url);
+        if (url.hostname !== "api.openai.com") {
+            return Response.json({ error: { code: "mock_upstream_protocol_unsupported" } }, { status: 501 });
+        }
+        const runId = extractRunId(await bodyText(input, init));
+        if (!runId)
+            return Response.json({ error: { code: "mock_upstream_no_run_id" } }, { status: 400 });
+        await sleep(config.latencyMs + Math.floor(Math.random() * (config.jitterMs + 1)));
+        const text = JSON.stringify({
+            schemaVersion: 1,
+            runId,
+            outcome: "no_changes",
+            summary: "Load test: no changes.",
+            tag: null,
+            tests: [],
+        });
+        const id = `resp_mock_${runId}`;
+        const item = {
+            id: `msg_${runId}`,
+            type: "message",
+            role: "assistant",
+            status: "completed",
+            content: [{ type: "output_text", text, annotations: [] }],
+        };
+        const usage = {
+            input_tokens: config.inputTokens,
+            input_tokens_details: { cached_tokens: 0 },
+            output_tokens: config.outputTokens,
+            output_tokens_details: { reasoning_tokens: 0 },
+            total_tokens: config.inputTokens + config.outputTokens,
+        };
+        const stream = sse("response.created", { type: "response.created", response: { id, status: "in_progress", output: [] } }) +
+            sse("response.output_item.added", {
+                type: "response.output_item.added",
+                output_index: 0,
+                item: { ...item, status: "in_progress", content: [] },
+            }) +
+            sse("response.output_text.delta", {
+                type: "response.output_text.delta",
+                output_index: 0,
+                content_index: 0,
+                item_id: item.id,
+                delta: text,
+            }) +
+            sse("response.output_item.done", { type: "response.output_item.done", output_index: 0, item }) +
+            sse("response.completed", {
+                type: "response.completed",
+                response: { id, status: "completed", output: [item], usage },
+            });
+        return new Response(stream, { status: 200, headers: { "content-type": "text/event-stream" } });
+    };
+}
+const FLAG_LOAD = "WARDBY_LOAD_TEST";
+const FLAG_MOCK = "WARDBY_CODING_PROXY_MOCK_UPSTREAM";
+function nonNegativeInt(env, name, fallback) {
+    const raw = env[name];
+    if (raw === undefined || raw === "")
+        return fallback;
+    // Plain decimal digits only: no sign, hex, exponent, or whitespace.
+    const n = /^\d+$/.test(raw) ? Number(raw) : NaN;
+    if (!Number.isSafeInteger(n) || n < 0) {
+        throw new Error(`mock_upstream_guard: ${name} must be a non-negative integer`);
+    }
+    return n;
+}
+/**
+ * The mock model upstream is a load-test seam inside a production binary, so
+ * it needs two deliberate switches: WARDBY_LOAD_TEST=1 and
+ * WARDBY_CODING_PROXY_MOCK_UPSTREAM=1. One without the other, or any other
+ * value, refuses to start the proxy rather than silently picking a side.
+ */
+export function mockUpstreamFromEnv(env) {
+    const load = env[FLAG_LOAD];
+    const mock = env[FLAG_MOCK];
+    if (load === undefined && mock === undefined)
+        return null;
+    if (load !== "1" || mock !== "1") {
+        throw new Error(`mock_upstream_guard: set both ${FLAG_LOAD}=1 and ${FLAG_MOCK}=1 to use the mock upstream, or neither`);
+    }
+    return {
+        ...DEFAULT_MOCK_UPSTREAM,
+        latencyMs: nonNegativeInt(env, "WARDBY_LOAD_MOCK_LATENCY_MS", DEFAULT_MOCK_UPSTREAM.latencyMs),
+        jitterMs: nonNegativeInt(env, "WARDBY_LOAD_MOCK_JITTER_MS", DEFAULT_MOCK_UPSTREAM.jitterMs),
+    };
+}

package/dist/providers/coding-proxy/registry/prisma-store.d.ts

@@ -1,4 +1,5 @@
 import type { PrismaClient } from "#prisma";
+import type { FileDependency } from "../../../coding/registry/types.js";
 import type { ApprovedVersion, PlanRefusedVersion, RegistryFetchRecord, RegistryRunContext, RegistryStore, StoredVersionFact } from "./store.js";
 export declare class PrismaRegistryStore implements RegistryStore {
     private readonly db;
@@ -6,6 +7,8 @@ export declare class PrismaRegistryStore implements RegistryStore {
     findRunByRegistryTokenHash(hash: string, now: Date): Promise<RegistryRunContext | null>;
     isAllowedDependency(runId: string, ecosystem: string, name: string): Promise<boolean>;
     addAllowances(runId: string, ecosystem: string, names: readonly string[]): Promise<void>;
+    allowedExtras(runId: string, ecosystem: string, name: string): Promise<string[]>;
+    addExtraAllowances(runId: string, ecosystem: string, dependencies: readonly FileDependency[]): Promise<void>;
     recordFetch(record: RegistryFetchRecord): Promise<void>;
     usage(runId: string): Promise<{
         files: number;

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

@@ -1,3 +1,4 @@
+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. */
 const FACT_QUERY_CHUNK = 500;
@@ -26,6 +27,9 @@ export class PrismaRegistryStore {
         };
     }
     async isAllowedDependency(runId, ecosystem, name) {
+        // An extra's row (`name[extra]`) is never a package allowance.
+        if (name.includes("["))
+            return false;
         const row = await this.db.registryAllowance.findUnique({
             where: { runId_ecosystem_name: { runId, ecosystem, name } },
             select: { runId: true },
@@ -40,6 +44,19 @@ export class PrismaRegistryStore {
             skipDuplicates: true,
         });
     }
+    async allowedExtras(runId, ecosystem, name) {
+        const rows = await this.db.registryAllowance.findMany({
+            where: { runId, ecosystem, name: { startsWith: `${name}[` } },
+            select: { name: true },
+        });
+        return rows
+            .map((row) => extraOfAllowanceName(row.name, name))
+            .filter((extra) => extra !== null)
+            .sort();
+    }
+    async addExtraAllowances(runId, ecosystem, dependencies) {
+        await this.addAllowances(runId, ecosystem, dependencies.flatMap((dependency) => dependency.extras.map((extra) => extraAllowanceName(dependency.name, extra))));
+    }
     async recordFetch(record) {
         await this.db.registryFetch.create({ data: record });
     }

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

@@ -209,5 +209,9 @@ export declare class RegistryService {
      *  exactly what was reserved: the declared size when known, or the bytes
      *  actually streamed when it was not. */
     private releaseDownload;
+    /** The extras the run allows for `name`: those its allowlist entries name
+     *  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;
     private download;
 }

package/dist/providers/coding-proxy/registry/service.js

@@ -168,7 +168,7 @@ function versionDependencies(adapter, meta, version) {
 function isPackageName(adapter, name) {
     try {
         const entry = adapter.parseAllowlistEntry(name);
-        return !entry.wildcard && entry.range === undefined && entry.name === name;
+        return !entry.wildcard && entry.range === undefined && entry.extras === undefined && entry.name === name;
     }
     catch {
         return false;
@@ -962,6 +962,16 @@ export class RegistryService {
         else
             this.inFlight.set(runId, slot);
     }
+    /** The extras the run allows for `name`: those its allowlist entries name
+     *  plus those a served parent's dependency line asked of it. They decide
+     *  which of the package's extra-gated dependencies its files allow. */
+    async allowedExtras(adapter, context, name) {
+        const entries = parseAllowlist(context.allowlist, this.options.adapters).get(adapter.id) ?? [];
+        const extras = new Set(entries.flatMap((entry) => (!entry.wildcard && entry.name === name ? (entry.extras ?? []) : [])));
+        for (const extra of await this.options.store.allowedExtras(context.runId, adapter.id, name))
+            extras.add(extra);
+        return [...extras].sort();
+    }
     async download(adapter, context, name, route, file, signal) {
         const { limits, store } = this.options;
         const runId = context.runId;
@@ -1097,8 +1107,15 @@ export class RegistryService {
                         served.bytes += bytes;
                         if (adapter.dependenciesFromFile && buffered.length > 0) {
                             const body = Buffer.concat(buffered);
-                            const names = await adapter.dependenciesFromFile(route, body).catch(() => []);
-                            await store.addAllowances(context.runId, adapter.id, names.map((dependency) => adapter.normalizeName(dependency)));
+                            const extras = await this.allowedExtras(adapter, context, name);
+                            const dependencies = (await adapter.dependenciesFromFile(route, body, extras).catch(() => [])).map((dependency) => ({ name: adapter.normalizeName(dependency.name), extras: dependency.extras }));
+                            await store.addAllowances(context.runId, adapter.id, dependencies.map((dependency) => dependency.name));
+                            // Dependency extras are followed only below a package the run
+                            // allows with extras (an entry naming extras, or a dependency
+                            // such a package asked for with extras): a plain entry follows
+                            // no extras, its own or its dependencies'.
+                            if (extras.length > 0)
+                                await store.addExtraAllowances(context.runId, adapter.id, dependencies);
                         }
                         controller.close();
                     }

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

@@ -1,5 +1,5 @@
 import type { PackageAllowlist } from "../../../coding/registry/allowlist.js";
-import type { DeclaredDependency } from "../../../coding/registry/types.js";
+import type { DeclaredDependency, FileDependency } from "../../../coding/registry/types.js";
 export interface RegistryRunContext {
     runId: string;
     deadlineAt: Date;
@@ -41,6 +41,17 @@ export interface PlanRefusedVersion {
     /** Set for a too-new refusal: it lapses once the version is old enough. */
     publishedAt?: Date | null;
 }
+/**
+ * An extra a run allows for a package (PyPI `uvicorn[standard]`) is kept as
+ * an allowance row named `name[extra]`, beside the package's own row. No
+ * registry route can ask for that name (routes accept only valid package
+ * names, which never contain `[`), so the row never allows a fetch itself:
+ * it only tells the proxy which of the package's extra-gated dependencies
+ * to follow when it serves the package's files.
+ */
+export declare function extraAllowanceName(name: string, extra: string): string;
+/** The extra in an allowance row name for `name`, or null when the row is not one of its extras. */
+export declare function extraOfAllowanceName(rowName: string, name: string): string | null;
 /** Run-scoped store over the registry-only token session lookup and the
  *  RegistryAllowance/RegistryFetch tables (Task 5). Backs the registry proxy:
  *  it never sees the model capability, only the derived registry token. */
@@ -48,6 +59,10 @@ export interface RegistryStore {
     findRunByRegistryTokenHash(hash: string, now: Date): Promise<RegistryRunContext | null>;
     isAllowedDependency(runId: string, ecosystem: string, name: string): Promise<boolean>;
     addAllowances(runId: string, ecosystem: string, names: readonly string[]): Promise<void>;
+    /** The extras the run allows for `name` (normalized, sorted). */
+    allowedExtras(runId: string, ecosystem: string, name: string): Promise<string[]>;
+    /** Records extras the run allows for each package (an existing one is kept). */
+    addExtraAllowances(runId: string, ecosystem: string, dependencies: readonly FileDependency[]): Promise<void>;
     recordFetch(record: RegistryFetchRecord): Promise<void>;
     usage(runId: string): Promise<{
         files: number;
@@ -99,6 +114,8 @@ export declare class MemoryRegistryStore implements RegistryStore {
     findRunByRegistryTokenHash(hash: string, now: Date): Promise<RegistryRunContext | null>;
     isAllowedDependency(runId: string, ecosystem: string, name: string): Promise<boolean>;
     addAllowances(runId: string, ecosystem: string, names: readonly string[]): Promise<void>;
+    allowedExtras(runId: string, ecosystem: string, name: string): Promise<string[]>;
+    addExtraAllowances(runId: string, ecosystem: string, dependencies: readonly FileDependency[]): Promise<void>;
     recordFetch(record: RegistryFetchRecord): Promise<void>;
     usage(runId: string): Promise<{
         files: number;

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

@@ -1,3 +1,22 @@
+/**
+ * An extra a run allows for a package (PyPI `uvicorn[standard]`) is kept as
+ * an allowance row named `name[extra]`, beside the package's own row. No
+ * registry route can ask for that name (routes accept only valid package
+ * names, which never contain `[`), so the row never allows a fetch itself:
+ * it only tells the proxy which of the package's extra-gated dependencies
+ * to follow when it serves the package's files.
+ */
+export function extraAllowanceName(name, extra) {
+    return `${name}[${extra}]`;
+}
+/** The extra in an allowance row name for `name`, or null when the row is not one of its extras. */
+export function extraOfAllowanceName(rowName, name) {
+    const prefix = `${name}[`;
+    if (!rowName.startsWith(prefix) || !rowName.endsWith("]"))
+        return null;
+    const extra = rowName.slice(prefix.length, -1);
+    return /^[a-z0-9](?:[a-z0-9-]*[a-z0-9])?$/.test(extra) ? extra : null;
+}
 /** In-memory adapter for tests. `contexts` is settable directly so tests can
  *  seed a run without going through a full proxy session. */
 export class MemoryRegistryStore {
@@ -15,12 +34,26 @@ export class MemoryRegistryStore {
         return context && context.deadlineAt > now ? context : null;
     }
     async isAllowedDependency(runId, ecosystem, name) {
+        // An extra's row (`name[extra]`) is never a package allowance.
+        if (name.includes("["))
+            return false;
         return this.allowances.has(`${runId}\0${ecosystem}\0${name}`);
     }
     async addAllowances(runId, ecosystem, names) {
         for (const name of names)
             this.allowances.add(`${runId}\0${ecosystem}\0${name}`);
     }
+    async allowedExtras(runId, ecosystem, name) {
+        const prefix = `${runId}\0${ecosystem}\0`;
+        return [...this.allowances]
+            .filter((key) => key.startsWith(prefix))
+            .map((key) => extraOfAllowanceName(key.slice(prefix.length), name))
+            .filter((extra) => extra !== null)
+            .sort();
+    }
+    async addExtraAllowances(runId, ecosystem, dependencies) {
+        await this.addAllowances(runId, ecosystem, dependencies.flatMap((dependency) => dependency.extras.map((extra) => extraAllowanceName(dependency.name, extra))));
+    }
     async recordFetch(record) {
         this.fetches.push({ ...record, createdAt: new Date() });
     }

package/dist/providers/coding-proxy/runtime.js

@@ -1,7 +1,9 @@
+import { logger } from "../../core/logger.js";
 import { REGISTRY_ADAPTERS } from "../../coding/registry/adapters.js";
 import { CODING_PROXY_ALIAS, CODING_PROXY_DENY_PORT, CODING_PROXY_PORT } from "../jobs/docker-isolation.js";
 import { startDenyPortListener } from "./deny-port.js";
 import { EnvironmentCredentialResolver } from "./environment-credentials.js";
+import { createMockUpstream, mockUpstreamFromEnv } from "./mock-upstream.js";
 import { CodingProxy } from "./proxy.js";
 import { PrismaProxyLedger } from "./prisma-ledger.js";
 import { OsvAudit } from "./registry/audit.js";
@@ -38,10 +40,19 @@ export function createRegistryUpstream(pinned) {
 /** Starts the trusted proxy with the fixed worker-only Docker endpoint, plus the deny port the enforcement witness probes. */
 export async function startConfiguredCodingProxy(options) {
     const env = options.env ?? process.env;
+    // Throws (mock_upstream_guard) on a partial or malformed setting, before anything listens.
+    const mock = mockUpstreamFromEnv(env);
+    if (mock) {
+        logger.warn({ module: "coding-proxy-runtime", event: "proxy.mock_upstream_enabled" }, "coding proxy: MOCK MODEL UPSTREAM ENABLED (load test). No request reaches a model provider; never use this on a real deployment.");
+    }
+    const audit = mock
+        ? (event) => options.audit?.({ ...event, mockUpstream: true })
+        : options.audit;
     const proxy = new CodingProxy({
         ledger: new PrismaProxyLedger(options.db),
         credentials: new EnvironmentCredentialResolver(env),
-        audit: options.audit,
+        audit,
+        ...(mock ? { fetch: createMockUpstream(mock) } : {}),
     });
     const buildPinnedFetch = options.createPinnedFetch ?? createPinnedProxyFetch;
     const upstreamHosts = [...new Set([...REGISTRY_ADAPTERS.values()].flatMap((adapter) => adapter.upstreamHosts))];

package/dist/providers/coding-proxy/types.d.ts

@@ -124,6 +124,8 @@ export interface ProxyAuditEvent {
     /** For a failed stream: the upstream response's content type and encoding headers, for diagnosis. */
     contentType?: string;
     contentEncoding?: string;
+    /** Set on every event while the load-test mock upstream is enabled. */
+    mockUpstream?: boolean;
 }
 export type ProxyAuditSink = (event: ProxyAuditEvent) => void;
 export interface CredentialResolver {