@wardby/cli 0.2.0 → 0.3.0

package/dist/providers/executor/composition.js

@@ -1,6 +1,7 @@
 import { tmpdir } from "node:os";
 import { resolve } from "node:path";
 import { loadCodingConcurrencyConfig, loadContainerExecutorConfig, loadGitHubVcsConfig, loadKubernetesJobConfig, loadProviderConfig, } from "../../config/providers.js";
+import { summarizeRegistryFetches } from "../../coding/registry/report.js";
 import { drainCodingQueue } from "../../core/coding-queue.js";
 import { logger } from "../../core/logger.js";
 import { EnvironmentCredentialResolver } from "../coding-proxy/environment-credentials.js";
@@ -15,6 +16,8 @@ import { KubernetesJobLauncher } from "../jobs/kubernetes.js";
 import { buildVcsProvider } from "../vcs/index.js";
 import { ContainerExecutor, PrismaContainerExecutionStore, RunCapabilityVault } from "./container.js";
 import { PrismaExecutionKindResolver, RoutingExecutor } from "./routing.js";
+import { createRepoAccessGate } from "../../core/repo-access.js";
+import { buildReviewHosts } from "../review-host/index.js";
 const compositionLog = logger.child({ module: "executor-composition" });
 /** Builds container execution only when Docker or Kubernetes is explicitly selected. */
 export function buildConfiguredExecutor(options) {
@@ -43,6 +46,15 @@ export function buildConfiguredExecutor(options) {
         if (!isRegistryDigest(config.workerImage)) {
             throw new Error("CODING_WORKER_IMAGE must be a registry digest (repo@sha256:...) when JOB_LAUNCHER=kubernetes.");
         }
+        for (const image of [config.claudeWorkerImage, config.claudeToolRunnerImage]) {
+            if (image !== undefined && !isRegistryDigest(image)) {
+                throw new Error("CODING_CLAUDE_WORKER_IMAGE and CODING_CLAUDE_TOOL_RUNNER_IMAGE must be registry digests (repo@sha256:...) when JOB_LAUNCHER=kubernetes.");
+            }
+        }
+        const claudePython = config.claudeToolRunnerImages["node-python"]?.["3.12"];
+        if (claudePython !== undefined && !isRegistryDigest(claudePython)) {
+            throw new Error("CODING_CLAUDE_TOOL_RUNNER_IMAGE_NODE_PYTHON_3_12 must be a registry digest (repo@sha256:...) when JOB_LAUNCHER=kubernetes.");
+        }
         const kubernetes = loadKubernetesJobConfig(env);
         // The preflight only runs on the first launch; a configuration that cannot work should
         // fail the process at start-up, not the first coding run an hour later.
@@ -58,6 +70,7 @@ export function buildConfiguredExecutor(options) {
             workspaceRoot,
             resolveCapability: (runId) => capabilities.get(runId),
             readyTimeoutMs: kubernetes.readyTimeoutMs,
+            enforcementExecTimeoutMs: kubernetes.enforcementExecTimeoutMs,
             preflight: async () => {
                 const { proxyIp } = await runKubernetesPreflight({
                     api,
@@ -101,11 +114,17 @@ export function buildConfiguredExecutor(options) {
         workerImage: config.workerImage,
         claudeWorkerImage: config.claudeWorkerImage,
         claudeToolRunnerImage: config.claudeToolRunnerImage,
+        claudeToolRunnerImages: config.claudeToolRunnerImages,
         additionalWorkerImages: config.additionalWorkerImages,
         credentialRef: config.credentialRef,
         anthropicCredentialRef: config.anthropicCredentialRef,
         limits: { cpus: config.cpus, memoryMb: config.memoryMb, pids: config.pids, diskMb: config.diskMb },
         maxDiskMb: config.maxDiskMb,
+        repoAccess: options.repoAccess ?? createRepoAccessGate({ db: options.db, hosts: buildReviewHosts(env) }),
+        registryReport: async (runId) => {
+            const rows = await options.db.registryFetch.findMany({ where: { runId }, orderBy: { createdAt: "asc" } });
+            return summarizeRegistryFetches(rows);
+        },
         onSlotReleased: () => {
             void drainCodingQueue({
                 db: options.db,

package/dist/providers/executor/container.d.ts

@@ -1,10 +1,18 @@
-import type { PrismaClient } from "@prisma/client";
+import type { PrismaClient } from "#prisma";
+import type { CodingProvider } from "../../coding/provider.js";
+import { type RepoAccessGate } from "../../core/repo-access.js";
 import { type CodingRunObserver } from "../../coding/observability.js";
 import { type CodingRunResult } from "../../coding/protocol.js";
 import type { ProxyProtocol } from "../coding-proxy/types.js";
 import type { JobHandle, JobResourceLimits, WorkspaceJobLauncher } from "../jobs/types.js";
 import type { VcsProvider } from "../vcs/types.js";
 import type { CodingImageSelector, ExecutionRecoveryResult, Executor, PersistedExecutionHandle } from "./types.js";
+/**
+ * Claude Code's commands run in its tool runner, which never reports back through the agent, so the
+ * host rewrites registry-proxy download URLs in collected lockfiles itself (the Codex driver does it
+ * in the worker). Best effort and symlink-safe (lockfiles.ts); a Codex workspace is left alone.
+ */
+export declare function normalizeCollectedLockfiles(provider: string, workspacePath: string): Promise<string[]>;
 export interface ContainerRunSnapshot {
     runId: string;
     status: string;
@@ -19,11 +27,15 @@ export interface ContainerRunSnapshot {
     provider: string;
     model: string;
     timeoutSec: number;
-    allowedEgress: unknown;
     protectedPaths: unknown;
+    /** Stored per-agent collection paths; see src/coding/collect-exclude.ts. */
+    collectExclude: unknown;
     /** Revision-in-place: set when this run continues another run's branch/PR. See preflight(). */
     rootCodingRunId: string | null;
     budgetUsd: number;
+    /** The agent's own per-run budget; `budgetUsd` is less when its budget group had less left. */
+    agentBudgetUsd?: number;
+    budgetGroupName?: string | null;
     tokensIn: number;
     tokensOut: number;
     costUsd: number;
@@ -32,7 +44,19 @@ export interface ContainerRunSnapshot {
     proxySessionId: string | null;
     result: unknown;
     workerImage: string | null;
+    /** Claude's tool-runner image, resolved at dispatch (CodingRun.toolImage); null on older rows and Codex runs. */
+    toolImage?: string | null;
     workspaceDiskMb: number | null;
+    /** Admin-requested debug trace, fixed at dispatch (CodingRun.debugTrace). */
+    debugTrace?: boolean;
+    /** Coding-run services resolved at dispatch (CodingRun.services); parsed with parseStoredServices. */
+    services?: unknown;
+    /** The terminal failure category, once the run has one (CodingRun.failureCategory). */
+    failureCategory?: string | null;
+    /** The agent's CURRENT coding-profile repository (null if the profile is gone); may differ from `repository`. */
+    profileRepository: string | null;
+    /** How the profile's repository was authorized (CodingAgentProfile.repositoryAuthorizedVia). */
+    repositoryAuthorizedVia: string | null;
 }
 /**
  * claimed: this caller owns provisioning. unavailable: someone else does, or
@@ -47,7 +71,7 @@ export interface ContainerExecutionStore {
     persistHandle(runId: string, claimId: string, handle: JobHandle): Promise<void>;
     heartbeat(runId: string): Promise<void>;
     complete(runId: string, status: "succeeded" | "budget_exhausted", result: CodingRunResult): Promise<void>;
-    terminate(runId: string, status: "failed" | "refused" | "lost" | "cancelled", error: string, audit?: CodingFailureAudit): Promise<void>;
+    terminate(runId: string, status: "failed" | "refused" | "lost" | "budget_exhausted" | "cancelled", error: string, audit?: CodingFailureAudit): Promise<void>;
 }
 export interface CodingFailureAudit {
     failureCategory: string;
@@ -64,7 +88,7 @@ export declare class PrismaContainerExecutionStore implements ContainerExecution
     persistHandle(runId: string, claimId: string, handle: JobHandle): Promise<void>;
     heartbeat(runId: string): Promise<void>;
     complete(runId: string, status: "succeeded" | "budget_exhausted", result: CodingRunResult): Promise<void>;
-    terminate(runId: string, status: "failed" | "refused" | "lost" | "cancelled", error: string, audit?: CodingFailureAudit): Promise<void>;
+    terminate(runId: string, status: "failed" | "refused" | "lost" | "budget_exhausted" | "cancelled", error: string, audit?: CodingFailureAudit): Promise<void>;
 }
 export interface CodingSessionController {
     createSession(input: {
@@ -79,6 +103,10 @@ export interface CodingSessionController {
         capability: string;
     }>;
     cancelSession(sessionId: string): Promise<void>;
+    /** Whether the proxy refused a request of this session for budget. */
+    budgetExhausted?(sessionId: string): Promise<boolean>;
+    /** The code of the first model-provider failure the proxy relayed for this session, if any. */
+    upstreamFailure?(sessionId: string): Promise<string | null>;
 }
 /** Plain capabilities live only for the short provisioning window. */
 export declare class RunCapabilityVault {
@@ -100,6 +128,12 @@ export interface ContainerExecutorOptions {
     credentialRef: string;
     claudeWorkerImage?: string;
     claudeToolRunnerImage?: string;
+    /**
+     * Claude tool-runner images for toolchains beyond the "node" baseline (claudeToolRunnerImage),
+     * keyed by toolchain, then version -- the same shape as additionalWorkerImages. Claude's agent
+     * image is the same for every toolchain; only the tool runner, which runs the commands, differs.
+     */
+    claudeToolRunnerImages?: Record<string, Record<string, string>>;
     anthropicCredentialRef?: string;
     limits: JobResourceLimits;
     /** Operator ceiling (MiB) on CodingRun.workspaceDiskMb; see coding_workspace_disk_exceeds_limit in jobSpec. */
@@ -117,6 +151,33 @@ export interface ContainerExecutorOptions {
      * than on the next scheduler tick. Never called for a run that was queued.
      */
     onSlotReleased?: () => void;
+    /**
+     * Loads this run's RegistryFetch ledger (composition.ts wires the Prisma
+     * query) so finalizeChanges can surface installed/refused packages in the
+     * PR body. Optional so tests and non-registry deployments can omit it;
+     * a rejection is swallowed and treated as "nothing to report" since a
+     * reporting failure must never fail the run itself.
+     */
+    registryReport?: (runId: string) => Promise<RegistryReport>;
+    /**
+     * Repository authorization: every run is checked, before its workspace is
+     * prepared, against the agent owner's current GitHub access (or a recorded
+     * admin/grandfathered approval of this exact repository).
+     */
+    repoAccess: RepoAccessGate;
+}
+/** A run's deduplicated served packages and refusals (see summarizeRegistryFetches). */
+export interface RegistryReport {
+    packages: Array<{
+        ecosystem: string;
+        name: string;
+        version: string;
+    }>;
+    packageRefusals: Array<{
+        ecosystem: string;
+        name: string;
+        reason: string;
+    }>;
 }
 export declare class ContainerExecutor implements Executor {
     private readonly options;
@@ -155,10 +216,33 @@ export declare class ContainerExecutor implements Executor {
      * that is otherwise healthy.
      */
     private whileHeartbeating;
+    /**
+     * The run may use its repository only if the agent's current owner still
+     * has write on it, or the profile's approval (admin or grandfathered)
+     * covers exactly this repository. A profile changed since dispatch no
+     * longer covers the run's repository, so that falls back to the owner's
+     * access. Throws RepoAccessError (refused before anything is cloned).
+     */
+    private authorizeRepository;
     private preflight;
     private finishTerminal;
+    /** The package report is informational: any failure loading it (a
+     *  rejection, a synchronous throw, or a malformed result) yields no
+     *  package section rather than failing finalization. */
+    private loadRegistryReport;
     private resultFor;
     resolveCodingWorkerImage(selector: CodingImageSelector): string;
+    /** Claude's tool-runner image for the agent's toolchain, at dispatch (Executor.resolveCodingToolImage); null for Codex. */
+    resolveCodingToolImage(selector: CodingImageSelector): string | null;
+    /** The tool runner is what runs a Claude agent's commands, so it is what the toolchain selects. */
+    private claudeToolImage;
+    /** Coding-run services: the repository's declaration at its base ref (Executor.readCodingServiceDeclaration). */
+    readCodingServiceDeclaration(input: {
+        repository: string;
+        baseRef: string;
+    }): Promise<string | null>;
+    /** The job launcher decides (Kubernetes and Docker start services for both providers). */
+    supportsCodingServices(provider: CodingProvider): boolean;
     private requireCurrent;
     private jobSpec;
     private credentialRef;
@@ -167,6 +251,24 @@ export declare class ContainerExecutor implements Executor {
     private preflightForCleanup;
     private abandon;
     private cleanupTerminal;
+    /** Whether the proxy refused this run's session for budget. Never throws. */
+    private outOfBudget;
+    /** The model-provider failure the proxy relayed for this run's session, classified. Never throws. */
+    private providerFailure;
+    /**
+     * A failure the model provider's refusal caused. The persisted error names
+     * the class only; the raw upstream code (a fixed identifier, never a message)
+     * goes to one operator line an alert can key on, and the failure itself is
+     * still logged under its diagnostic id.
+     */
+    private providerFailureOf;
+    /** The host-safe sentence for a run that ran out of budget. */
+    private budgetSentence;
+    /**
+     * A failure the proxy's budget refusal caused. The failure itself is still
+     * logged under its diagnostic id, so the operator keeps the real reason.
+     */
+    private budgetFailure;
     private emit;
     private terminal;
     /**