@wardby/cli 0.1.0

package/dist/providers/jobs/docker.d.ts

@@ -0,0 +1,127 @@
+import type { JobHandle, JobResult, JobSpec, JobStatus, WorkspaceJobLauncher } from "./types.js";
+export declare const SAFE_WORKER_DIAGNOSTIC: RegExp;
+export interface DockerCommandOptions {
+    env?: Record<string, string>;
+    maxOutputBytes?: number;
+}
+export interface DockerCommandResult {
+    stdout: string;
+    stderr: string;
+}
+export interface DockerCommandRunner {
+    run(args: readonly string[], options?: DockerCommandOptions): Promise<DockerCommandResult>;
+}
+/**
+ * Docker failures never include daemon output in their public message -- that
+ * message reaches the agent owner. The operator still needs the reason, so the
+ * failing subcommand and a redacted, bounded slice of stderr ride along as the
+ * `cause`, which only the control-plane log walks (see describeFailure in
+ * ../executor/container.ts). Without it a provisioning failure is just
+ * `docker_command_failed:1`, which cost a live smoke two blind runs.
+ */
+export declare class DockerCommandError extends Error {
+    readonly exitCode: number | null;
+    readonly notFound: boolean;
+    readonly outputExceeded: boolean;
+    constructor(exitCode: number | null, notFound?: boolean, outputExceeded?: boolean, detail?: {
+        subcommand?: string;
+        stderr?: string;
+    });
+}
+export declare function isMissingDockerResource(stderr: string): boolean;
+export interface NodeDockerCommandRunnerOptions {
+    dockerBinary?: string;
+    path?: string;
+    homeDir: string;
+    dockerHost?: string;
+    dockerContext?: string;
+}
+/** Runs Docker with argument arrays and an explicit, minimal environment. */
+export declare class NodeDockerCommandRunner implements DockerCommandRunner {
+    private readonly options;
+    private readonly dockerBinary;
+    private readonly path;
+    constructor(options: NodeDockerCommandRunnerOptions);
+    run(args: readonly string[], options?: DockerCommandOptions): Promise<DockerCommandResult>;
+}
+export interface DockerArtifactTransfer {
+    seedDirectory(sourceDirectory: string, container: string, destination: string): Promise<void>;
+    seedInput(sourceFile: string, container: string): Promise<void>;
+    materializeDirectory(container: string, source: string, destination: string, maxBytes: number): Promise<void>;
+}
+export declare function dockerTransferEnvironment(path: string): NodeJS.ProcessEnv;
+/** Streams tar archives into the unprivileged keeper; no host bind mounts are used. */
+export declare class NodeDockerArtifactTransfer implements DockerArtifactTransfer {
+    private readonly dockerBinary;
+    private readonly path;
+    constructor(dockerBinary?: string, path?: string);
+    seedDirectory(sourceDirectory: string, container: string, destination: string): Promise<void>;
+    seedInput(sourceFile: string, container: string): Promise<void>;
+    materializeDirectory(container: string, source: string, destination: string, maxBytes: number): Promise<void>;
+}
+export declare function validateMaterializedWorkspace(root: string, maxBytes: number): Promise<void>;
+export interface DockerJobLauncherOptions {
+    stateRoot: string;
+    workspaceRoot: string;
+    proxyContainer: string;
+    resolveCapability: (runId: string) => Promise<string>;
+    /** Consult the durable application state before a startup sweep deletes resources. */
+    isRunActive: (runId: string, handle: JobHandle) => Promise<boolean>;
+    docker?: DockerCommandRunner;
+    transfer?: DockerArtifactTransfer;
+    now?: () => number;
+    /** Optional observer invoked after provisioning fails but before resources are cleaned up. */
+    onProvisionFailure?: (context: {
+        runId: string;
+        keeperContainer: string;
+    }) => Promise<void>;
+}
+export declare class DockerJobLauncher implements WorkspaceJobLauncher {
+    private readonly options;
+    private readonly stateRoot;
+    private readonly workspaceRoot;
+    private readonly docker;
+    private readonly transfer;
+    private readonly now;
+    private readonly locks;
+    private readonly timers;
+    private readonly ready;
+    constructor(options: DockerJobLauncherOptions);
+    launch(spec: JobSpec): Promise<JobHandle>;
+    status(handle: JobHandle): Promise<JobStatus>;
+    collect(handle: JobHandle): Promise<JobResult>;
+    materializeWorkspace(handle: JobHandle, destination: string): Promise<void>;
+    stop(handle: JobHandle, _reason?: string): Promise<void>;
+    remove(handle: JobHandle): Promise<void>;
+    private initialize;
+    private launchLocked;
+    private provision;
+    private refresh;
+    private stopRecord;
+    private sweepExpired;
+    private cleanupResources;
+    private removeContainerIfAttested;
+    private removeNetworkIfAttested;
+    private removeVolumeIfAttested;
+    private seedRun;
+    private readResultArtifact;
+    private readWorkerFailureDiagnostic;
+    private keeperName;
+    private assertHost;
+    private createAndAssert;
+    private waitForStorage;
+    private waitForToolRunner;
+    private validateInputArtifact;
+    private run;
+    private runIgnoreMissing;
+    private startContainer;
+    private inspect;
+    private findRecord;
+    private requireRecord;
+    private readRecord;
+    private allRecords;
+    private writeRecord;
+    private withRun;
+    private scheduleDeadline;
+    private clearDeadline;
+}