@wardby/cli 0.1.0 → 0.2.1

package/dist/providers/auth/self-hosted.d.ts

@@ -1,4 +1,4 @@
-import type { PrismaClient } from "@prisma/client";
+import type { PrismaClient } from "#prisma";
 import type { AuthProfile, AuthProvider, AuthTokens, VerifiedToken } from "./types.js";
 import { Credentials } from "../../mcp/auth/self-hosted/credentials.js";
 import { Sessions } from "../../mcp/auth/self-hosted/session.js";
@@ -34,7 +34,7 @@ export declare class SelfHostedAuthProvider implements AuthProvider {
     consentPage(sessionToken: string, interactionId: string): Promise<{
         interaction: {
             client: {
-                metadata: import("@prisma/client/runtime/library").JsonValue;
+                metadata: import("@prisma/client/runtime/client").JsonValue;
                 createdAt: Date;
                 clientId: string;
             };

package/dist/providers/coding-proxy/prisma-ledger.d.ts

@@ -1,4 +1,4 @@
-import type { PrismaClient } from "@prisma/client";
+import type { PrismaClient } from "#prisma";
 import type { CreateProxySessionInput, ProxyLedger, ProxyRequest, ProxySession, ProxyUsage, ReserveProxyRequestInput, ReserveProxyRequestResult } from "./types.js";
 export type PrismaProxyLedgerDb = Pick<PrismaClient, "$transaction" | "$queryRaw" | "$executeRaw">;
 export declare class PrismaProxyLedger implements ProxyLedger {

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

@@ -1,4 +1,4 @@
-import type { PrismaClient } from "@prisma/client";
+import type { PrismaClient } from "#prisma";
 import { startDenyPortListener } from "./deny-port.js";
 import { startCodingProxyServer, type CodingProxyServerHandle } from "./server.js";
 import type { ProxyAuditSink } from "./types.js";

package/dist/providers/datastore/postgres.d.ts

@@ -1,7 +1,7 @@
 /**
  * Postgres-backed default Datastore adapter, via the `DatastoreEntry` table.
  */
-import type { PrismaClient } from "@prisma/client";
+import type { PrismaClient } from "#prisma";
 import type { Datastore, DatastoreSetOptions, DatastoreValue } from "./types.js";
 import type { SecretCipher } from "../secrets/types.js";
 export type DatastoreDb = Pick<PrismaClient, "datastoreEntry" | "datastore" | "$queryRaw">;

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

@@ -1,4 +1,4 @@
-import type { PrismaClient } from "@prisma/client";
+import type { PrismaClient } from "#prisma";
 import type { ProviderRegistry } from "../index.js";
 import { type ProviderConfig } from "../../config/providers.js";
 import type { Executor } from "./types.js";

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

@@ -1,4 +1,4 @@
-import type { PrismaClient } from "@prisma/client";
+import type { PrismaClient } from "#prisma";
 import { type ProviderConfig } from "../../config/providers.js";
 import type { KubernetesApi } from "../jobs/kubernetes-api.js";
 import type { Executor } from "./types.js";

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

@@ -1,4 +1,4 @@
-import type { PrismaClient } from "@prisma/client";
+import type { PrismaClient } from "#prisma";
 import { type CodingRunObserver } from "../../coding/observability.js";
 import { type CodingRunResult } from "../../coding/protocol.js";
 import type { ProxyProtocol } from "../coding-proxy/types.js";

package/dist/providers/executor/container.js

@@ -3,6 +3,7 @@ import { mkdir, realpath, rename, rm, writeFile } from "node:fs/promises";
 import { join, resolve, sep } from "node:path";
 import { CodingProfileSchema } from "../../coding/profile.js";
 import { logger } from "../../core/logger.js";
+import { ensurePrivateDirectory } from "../../core/private-directory.js";
 import { codingRunObserver } from "../../coding/observability.js";
 import { CODING_PROTOCOL_VERSION, CodingRunResultSchema, CodingTaskInputSchema, parseCodingAgentOutputJson, redactAndTruncate, } from "../../coding/protocol.js";
 import { getModelPricing } from "../llm/pricing.js";
@@ -597,7 +598,7 @@ export class ContainerExecutor {
                 const reason = collected?.diagnostic ?? collected?.reason ?? jobState;
                 this.emit({ stage: "collected", runId: run.runId, jobId: handle.id });
                 const status = jobState === "lost" ? "lost" : "failed";
-                const failure = this.failure(`job_${reason}`);
+                const failure = this.failure(`job_${reason}`, { issues: collected?.diagnosticIssues });
                 await this.options.store.terminate(run.runId, status, failure.error, failure.audit);
                 this.terminal(run, status, failure.audit);
                 return;
@@ -755,7 +756,7 @@ export class ContainerExecutor {
         throw new Error("coding_provider_not_configured:claude-code");
     }
     async writeInput(run, deadlineAt) {
-        await mkdir(this.artifactRoot, { recursive: true, mode: 0o700 });
+        await ensurePrivateDirectory(this.artifactRoot);
         const rootReal = await realpath(this.artifactRoot);
         const directory = resolve(rootReal, run.runId);
         if (!directory.startsWith(`${rootReal}${sep}`))
@@ -881,7 +882,13 @@ export class ContainerExecutor {
         // keyed by the same diagnostic id. Token-shaped values are redacted, and a
         // cause chain is kept because the outer message is often just a wrapper.
         // A user asking to stop is not a failure, so it gets the same id at info.
-        const line = { diagnosticId, category, reason: describeFailure(error) };
+        // `issues` names only which output-schema fields failed (see SAFE_CODING_OUTPUT_ISSUE).
+        const line = {
+            diagnosticId,
+            category,
+            reason: describeFailure(error),
+            ...(options.issues ? { issues: options.issues } : {}),
+        };
         if (options.cancelled === true)
             containerLog.info(line, "coding run cancelled; the persisted error is its id only");
         else

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

@@ -12,7 +12,7 @@
  * stale-heartbeat detection is unchanged; the reconciler consults
  * `recover()` (Task 6) before declaring a DBOS run lost.
  */
-import type { PrismaClient } from "@prisma/client";
+import type { PrismaClient } from "#prisma";
 import type { ProviderRegistry } from "../index.js";
 import type { DbosConfig } from "../../config/providers.js";
 import { type RunnerDb } from "../../core/runner.js";

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

@@ -1,5 +1,16 @@
 import type { JobHandle, JobResult, JobSpec, JobStatus, WorkspaceJobLauncher } from "./types.js";
 export declare const SAFE_WORKER_DIAGNOSTIC: RegExp;
+export interface WorkerDiagnostic {
+    diagnostic: string;
+    diagnosticIssues?: string[];
+}
+/**
+ * Worker output is untrusted: recognizes only the fixed `{"error": code}` line,
+ * plus an optional `issues` list whose every entry must pass the shared pattern.
+ * A list with any entry that does not is dropped whole rather than filtered, so
+ * a malformed worker cannot smuggle a partial value through.
+ */
+export declare function parseWorkerDiagnosticLine(line: string): WorkerDiagnostic | undefined;
 export interface DockerCommandOptions {
     env?: Record<string, string>;
     maxOutputBytes?: number;

package/dist/providers/jobs/docker.js

@@ -3,7 +3,9 @@ import { spawn } from "node:child_process";
 import { lstat, mkdir, mkdtemp, open, opendir, readdir, readFile, readlink, realpath, rename, rm, unlink, } from "node:fs/promises";
 import { dirname, isAbsolute, join, resolve, sep } from "node:path";
 import { logger } from "../../core/logger.js";
-import { parseCodingAgentOutputJson, redactAndTruncate, MAX_CODING_ARTIFACT_BYTES } from "../../coding/protocol.js";
+import { ensurePrivateDirectory } from "../../core/private-directory.js";
+import { readBoundedRegularFile } from "../../coding-worker/artifact.js";
+import { parseCodingAgentOutputJson, redactAndTruncate, MAX_CODING_ARTIFACT_BYTES, MAX_CODING_OUTPUT_ISSUES, SAFE_CODING_OUTPUT_ISSUE, } from "../../coding/protocol.js";
 import { assertDockerHostSupportsIsolation, assertClaudeAgentContainerInspection, assertClaudeToolRunnerContainerInspection, assertIsolationNetworkInspection, assertKeeperContainerInspection, assertProxyContainerInspection, assertStorageVolumeInspection, assertWorkerContainerInspection, buildDockerIsolationPlan, } from "./docker-isolation.js";
 import { replaceDirectoryFromStaging } from "./workspace-swap.js";
 const BACKEND = "docker";
@@ -13,6 +15,31 @@ const MAX_DOCKER_SEED_DIAGNOSTIC_BYTES = 4 * 1024;
 const MAX_WORKSPACE_ENTRIES = 100_000;
 const TERMINAL_PHASES = new Set(["succeeded", "failed", "stopped", "lost", "removed"]);
 export const SAFE_WORKER_DIAGNOSTIC = /^(?:worker_[a-z_]+|coding_[a-z_]+|wardby_[a-z_]+)$/;
+/**
+ * Worker output is untrusted: recognizes only the fixed `{"error": code}` line,
+ * plus an optional `issues` list whose every entry must pass the shared pattern.
+ * A list with any entry that does not is dropped whole rather than filtered, so
+ * a malformed worker cannot smuggle a partial value through.
+ */
+export function parseWorkerDiagnosticLine(line) {
+    let value;
+    try {
+        value = JSON.parse(line);
+    }
+    catch {
+        return undefined;
+    }
+    if (typeof value?.error !== "string" || !SAFE_WORKER_DIAGNOSTIC.test(value.error))
+        return undefined;
+    const issues = value.issues;
+    const safeIssues = Array.isArray(issues) &&
+        issues.length > 0 &&
+        issues.length <= MAX_CODING_OUTPUT_ISSUES &&
+        issues.every((issue) => typeof issue === "string" && SAFE_CODING_OUTPUT_ISSUE.test(issue))
+        ? issues
+        : undefined;
+    return { diagnostic: value.error, ...(safeIssues ? { diagnosticIssues: safeIssues } : {}) };
+}
 const dockerLog = logger.child({ module: "docker-jobs" });
 /**
  * Docker failures never include daemon output in their public message -- that
@@ -440,7 +467,7 @@ export class DockerJobLauncher {
             if (current.phase === "failed" && !current.result.diagnostic) {
                 const diagnostic = await this.readWorkerFailureDiagnostic(current);
                 if (diagnostic) {
-                    current.result = { ...current.result, diagnostic };
+                    current.result = { ...current.result, ...diagnostic };
                     await this.writeRecord(current);
                 }
             }
@@ -500,7 +527,7 @@ export class DockerJobLauncher {
         });
     }
     async initialize() {
-        await mkdir(this.stateRoot, { recursive: true, mode: 0o700 });
+        await ensurePrivateDirectory(this.stateRoot);
         await mkdir(join(this.stateRoot, ".home"), { recursive: true, mode: 0o700 });
         await realpath(this.stateRoot);
         const records = await this.allRecords();
@@ -792,13 +819,7 @@ export class DockerJobLauncher {
         const target = join(staging, "result.json");
         try {
             await this.run(["container", "cp", `${this.keeperName(record)}:/run/wardby/storage/output/result.json`, target]);
-            const metadata = await lstat(target);
-            if (!metadata.isFile() || metadata.isSymbolicLink() || metadata.size > MAX_CODING_ARTIFACT_BYTES) {
-                throw new Error("docker_result_artifact_invalid");
-            }
-            const raw = await readFile(target, "utf8");
-            if (Buffer.byteLength(raw, "utf8") > MAX_CODING_ARTIFACT_BYTES)
-                throw new Error("docker_result_artifact_invalid");
+            const raw = await readBoundedRegularFile(target, MAX_CODING_ARTIFACT_BYTES, "docker_result_artifact_invalid");
             const output = parseCodingAgentOutputJson(raw);
             if (output.runId !== record.runId)
                 throw new Error("docker_result_run_mismatch");
@@ -818,14 +839,9 @@ export class DockerJobLauncher {
             const logs = await this.run(["container", "logs", "--tail", "8", record.handle.id]);
             const raw = `${logs.stdout}\n${logs.stderr}`;
             for (const line of raw.split("\n").reverse()) {
-                try {
-                    const value = JSON.parse(line);
-                    if (typeof value.error === "string" && SAFE_WORKER_DIAGNOSTIC.test(value.error))
-                        return value.error;
-                }
-                catch {
-                    // Worker output is untrusted; only parse one fixed JSON shape.
-                }
+                const diagnostic = parseWorkerDiagnosticLine(line);
+                if (diagnostic)
+                    return diagnostic;
             }
         }
         catch {

package/dist/providers/jobs/kubernetes.js

@@ -31,7 +31,7 @@ import { isIP } from "node:net";
 import { logger } from "../../core/logger.js";
 import { MAX_CODING_ARTIFACT_BYTES, parseCodingAgentOutputJson } from "../../coding/protocol.js";
 import { CODING_PROXY_DENY_PORT, CODING_PROXY_PORT } from "./docker-isolation.js";
-import { SAFE_WORKER_DIAGNOSTIC } from "./docker.js";
+import { parseWorkerDiagnosticLine } from "./docker.js";
 import { KubernetesAlreadyExistsError, KubernetesConflictError } from "./kubernetes-api.js";
 import { ENFORCEMENT_PROBE_DENY_REACHABLE, ENFORCEMENT_PROBE_PROVEN, ENFORCEMENT_PROBE_DENY_REFUSED, ENFORCEMENT_PROBE_PROXY_UNREACHABLE, KEEPER_CONTAINER, KEEPER_SEEDED_MARKER, KUBERNETES_ISOLATION_ERROR, STORAGE_ROOT, WORKER_CONTAINER, assertRunNetworkPolicyMatches, assertRunPodMatches, buildCapabilitySecret, buildRunNetworkPolicy, buildRunPod, enforcementProbeScript, kubernetesRunNames, kubernetesRunNamesForToken, runLabels, validateKubernetesSpec, } from "./kubernetes-isolation.js";
 import { readProxyWitness } from "./kubernetes-witness.js";
@@ -428,7 +428,7 @@ export class KubernetesJobLauncher {
         if (phase === "failed" && !result.diagnostic) {
             const diagnostic = await this.readWorkerDiagnostic(names);
             if (diagnostic)
-                result = { ...result, diagnostic };
+                result = { ...result, ...diagnostic };
         }
         if (phase === "succeeded" && !result.resultArtifact) {
             result = { ...result, resultArtifact: await this.readResultArtifact(names, record.runId) };
@@ -715,14 +715,9 @@ export class KubernetesJobLauncher {
             return undefined;
         }
         for (const line of raw.split("\n").reverse()) {
-            try {
-                const value = JSON.parse(line);
-                if (typeof value?.error === "string" && SAFE_WORKER_DIAGNOSTIC.test(value.error))
-                    return value.error;
-            }
-            catch {
-                // Worker output is untrusted; only one fixed JSON shape is recognized.
-            }
+            const diagnostic = parseWorkerDiagnosticLine(line);
+            if (diagnostic)
+                return diagnostic;
         }
         return undefined;
     }

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

@@ -45,6 +45,8 @@ export interface JobResult {
     resultArtifact?: string;
     /** Fixed worker-owned failure code; never raw container output. */
     diagnostic?: string;
+    /** Output-schema failure locations (`path:code`) that passed SAFE_CODING_OUTPUT_ISSUE; never values. */
+    diagnosticIssues?: string[];
 }
 /**
  * Lifecycle invariants implemented by every launcher:

package/dist/providers/memory/postgres.d.ts

@@ -6,7 +6,7 @@
  * schema.prisma). Every other operation goes through the normal Prisma
  * Client since it never touches `contentTsv`.
  */
-import type { PrismaClient } from "@prisma/client";
+import type { PrismaClient } from "#prisma";
 import type { AgentMemorySearchHit, AgentMemoryStore } from "./types.js";
 export type AgentMemoryDb = Pick<PrismaClient, "agentMemory" | "$executeRaw" | "$queryRaw">;
 export declare class PostgresAgentMemory implements AgentMemoryStore {

package/dist/providers/vcs/git.js

@@ -2,6 +2,7 @@ import { spawn } from "node:child_process";
 import { lstat, mkdir, opendir, readFile, readlink, realpath, rm } from "node:fs/promises";
 import { isAbsolute, resolve, sep } from "node:path";
 import { fileURLToPath } from "node:url";
+import { ensurePrivateDirectory } from "../../core/private-directory.js";
 import { MAX_REDACTED_SPAN, redactTokenShapedValues, normalizeGitHubRepository, normalizeGitRef, } from "../../coding/protocol.js";
 import { isSafeGitHubInstallationToken } from "./github.js";
 export const DEFAULT_MAX_CHANGED_FILES = 1_000;
@@ -220,7 +221,7 @@ export class GitVcsProvider {
     }
     async prepareWorkspace(input) {
         const normalized = this.validateInput(input);
-        await mkdir(this.rootDir, { recursive: true, mode: 0o700 });
+        await ensurePrivateDirectory(this.rootDir);
         await mkdir(resolve(this.rootDir, ".home"), { recursive: true, mode: 0o700 });
         const runRoot = resolve(this.rootDir, normalized.runId);
         if (!directChild(this.rootDir, runRoot))

package/dist/quickstart/config.d.ts

@@ -0,0 +1,30 @@
+export type QuickstartProvider = "openai" | "anthropic";
+export type McpClient = "none" | "codex" | "claude" | "both";
+export interface QuickstartState {
+    version: 1;
+    projectDir: string;
+    composeProject: string;
+    postgresPort: number;
+    provider: QuickstartProvider;
+    model: string;
+    packageVersion: string;
+    createdAt: string;
+}
+export interface QuickstartPaths {
+    projectDir: string;
+    wardbyDir: string;
+    envFile: string;
+    stateFile: string;
+}
+export declare function resolveProjectDir(cwd?: string, env?: NodeJS.ProcessEnv): string;
+export declare function quickstartPaths(projectDir: string): QuickstartPaths;
+export declare function composeProjectName(projectDir: string): string;
+export declare function parseEnvFile(contents: string): Record<string, string>;
+export declare function readQuickstartEnv(paths: QuickstartPaths): Record<string, string>;
+export declare function writeQuickstartEnv(paths: QuickstartPaths, values: Record<string, string>): void;
+export declare function readQuickstartState(paths: QuickstartPaths): QuickstartState | undefined;
+export declare function writeQuickstartState(paths: QuickstartPaths, state: QuickstartState): void;
+export declare function generatedSecret(): string;
+export declare function ensureWardbyIgnored(projectDir: string): void;
+export declare function defaultModel(provider: QuickstartProvider): string;
+export declare function providerKeyName(provider: QuickstartProvider): "OPENAI_API_KEY" | "ANTHROPIC_API_KEY";

package/dist/quickstart/config.js

@@ -0,0 +1,106 @@
+import { createHash, randomBytes } from "node:crypto";
+import { chmodSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { basename, join, resolve } from "node:path";
+export function resolveProjectDir(cwd = process.cwd(), env = process.env) {
+    return resolve(env.WARDBY_PROJECT_DIR || cwd);
+}
+export function quickstartPaths(projectDir) {
+    const wardbyDir = join(projectDir, ".wardby");
+    return {
+        projectDir,
+        wardbyDir,
+        envFile: join(wardbyDir, ".env"),
+        stateFile: join(wardbyDir, "state.json"),
+    };
+}
+export function composeProjectName(projectDir) {
+    const slug = basename(projectDir)
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "")
+        .slice(0, 30);
+    const digest = createHash("sha256").update(resolve(projectDir)).digest("hex").slice(0, 10);
+    return `wardby-${slug || "project"}-${digest}`;
+}
+export function parseEnvFile(contents) {
+    const values = {};
+    for (const rawLine of contents.split(/\r?\n/)) {
+        const line = rawLine.trim();
+        if (!line || line.startsWith("#"))
+            continue;
+        const equals = line.indexOf("=");
+        if (equals <= 0)
+            continue;
+        const key = line.slice(0, equals).trim();
+        const rawValue = line.slice(equals + 1).trim();
+        if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(key))
+            continue;
+        if (rawValue.startsWith('"') && rawValue.endsWith('"')) {
+            try {
+                values[key] = JSON.parse(rawValue);
+                continue;
+            }
+            catch {
+                // Preserve malformed quoted values verbatim so setup never destroys them.
+            }
+        }
+        values[key] = rawValue.startsWith("'") && rawValue.endsWith("'") ? rawValue.slice(1, -1) : rawValue;
+    }
+    return values;
+}
+export function readQuickstartEnv(paths) {
+    if (!existsSync(paths.envFile))
+        return {};
+    return parseEnvFile(readFileSync(paths.envFile, "utf8"));
+}
+export function writeQuickstartEnv(paths, values) {
+    mkdirSync(paths.wardbyDir, { recursive: true, mode: 0o700 });
+    const heading = [
+        "# Managed by `wardby quickstart`.",
+        "# Keep this file private; it contains local credentials and encryption keys.",
+    ];
+    const lines = Object.entries(values)
+        .sort(([left], [right]) => left.localeCompare(right))
+        .map(([key, value]) => `${key}=${JSON.stringify(value)}`);
+    writeFileSync(paths.envFile, `${[...heading, ...lines].join("\n")}\n`, { mode: 0o600 });
+    chmodSync(paths.wardbyDir, 0o700);
+    chmodSync(paths.envFile, 0o600);
+}
+export function readQuickstartState(paths) {
+    if (!existsSync(paths.stateFile))
+        return undefined;
+    const value = JSON.parse(readFileSync(paths.stateFile, "utf8"));
+    if (value.version !== 1 ||
+        typeof value.projectDir !== "string" ||
+        typeof value.composeProject !== "string" ||
+        typeof value.postgresPort !== "number" ||
+        (value.provider !== "openai" && value.provider !== "anthropic") ||
+        typeof value.model !== "string" ||
+        typeof value.packageVersion !== "string" ||
+        typeof value.createdAt !== "string") {
+        throw new Error(`invalid Wardby quickstart state: ${paths.stateFile}`);
+    }
+    return value;
+}
+export function writeQuickstartState(paths, state) {
+    mkdirSync(paths.wardbyDir, { recursive: true, mode: 0o700 });
+    writeFileSync(paths.stateFile, `${JSON.stringify(state, null, 2)}\n`, { mode: 0o600 });
+    chmodSync(paths.stateFile, 0o600);
+}
+export function generatedSecret() {
+    return randomBytes(32).toString("hex");
+}
+export function ensureWardbyIgnored(projectDir) {
+    const gitignore = join(projectDir, ".gitignore");
+    const existing = existsSync(gitignore) ? readFileSync(gitignore, "utf8") : "";
+    if (existing.split(/\r?\n/).some((line) => line.trim() === ".wardby/"))
+        return;
+    const prefix = existing.length > 0 && !existing.endsWith("\n") ? "\n" : "";
+    writeFileSync(gitignore, `${existing}${prefix}\n# Wardby local runtime and credentials\n.wardby/\n`);
+}
+export function defaultModel(provider) {
+    return provider === "openai" ? "gpt-5.6-luna" : "claude-haiku-4-5";
+}
+export function providerKeyName(provider) {
+    return provider === "openai" ? "OPENAI_API_KEY" : "ANTHROPIC_API_KEY";
+}

package/dist/quickstart/index.d.ts

@@ -0,0 +1,5 @@
+export declare function quickstartCommand(args: string[]): Promise<void>;
+export declare function doctorCommand(args: string[]): Promise<void>;
+export declare function statusCommand(args: string[]): Promise<void>;
+export declare function logsCommand(args: string[]): Promise<void>;
+export declare function downCommand(args: string[]): Promise<void>;