@wardby/cli 0.5.3 → 0.7.0

package/dist/native-worker/ledger.js

@@ -0,0 +1,245 @@
+/**
+ * The native sandbox gateway's durable state (native sandbox phase 3): one
+ * session per sandbox-mode run, and one call row per worker callId. Modelled on
+ * the coding proxy's PrismaProxyLedger — a model call reserves against the
+ * session budget under a row lock on the session before the provider is
+ * called, and is settled at its actual cost after — so any control-plane
+ * replica can serve any call, and a restart loses nothing.
+ */
+import { ReviewReadLedger } from "../core/review-reads.js";
+const LEDGER_TX = { maxWait: 5_000, timeout: 20_000 };
+function toSession(row) {
+    return { ...row, budgetUsd: Number(row.budgetUsd) };
+}
+export class PrismaGatewayLedger {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    async createSession(input) {
+        return toSession(await this.db.nativeGatewaySession.create({ data: input }));
+    }
+    /** The session a capability belongs to, whatever its status; the caller decides what each status allows. */
+    async findSessionByCapabilityHash(capabilityHash) {
+        const row = await this.db.nativeGatewaySession.findUnique({ where: { capabilityHash } });
+        return row ? toSession(row) : null;
+    }
+    /** Records that the worker's network isolation was proven: the gateway serves it from now on. */
+    async markNetworkReady(sessionId, at = new Date()) {
+        await this.db.nativeGatewaySession.updateMany({
+            where: { id: sessionId, networkReadyAt: null },
+            data: { networkReadyAt: at },
+        });
+    }
+    /** markNetworkReady by the session's run (a launcher knows the run, not the session). */
+    async markNetworkReadyForRun(runId, at = new Date()) {
+        await this.db.nativeGatewaySession.updateMany({
+            where: { runId, networkReadyAt: null },
+            data: { networkReadyAt: at },
+        });
+    }
+    /**
+     * Adds one request's review reads to the session's saved ones, under the session's row lock:
+     * reads only add, so parallel tool calls of one run each keep what they read.
+     */
+    async mergeReviewReads(sessionId, reads) {
+        await this.db.$transaction(async (tx) => {
+            const locked = await tx.$queryRaw `
+        SELECT "reviewReads" FROM "NativeGatewaySession" WHERE "id" = ${sessionId} FOR UPDATE`;
+            if (!locked[0])
+                return;
+            const saved = ReviewReadLedger.fromJSON(locked[0].reviewReads);
+            saved.merge(reads);
+            await tx.nativeGatewaySession.update({
+                where: { id: sessionId },
+                data: { reviewReads: saved.toJSON() },
+            });
+        }, LEDGER_TX);
+    }
+    async endSession(sessionId, status) {
+        await this.db.nativeGatewaySession.updateMany({ where: { id: sessionId, status: "active" }, data: { status } });
+    }
+    /** Reserves `reservationUsd` for a model call, or says why not. Serialized per session. */
+    async reserve(input) {
+        return this.db.$transaction(async (tx) => {
+            const locked = await tx.$queryRaw `
+        SELECT "status", "deadlineAt", "budgetUsd" FROM "NativeGatewaySession" WHERE "id" = ${input.sessionId} FOR UPDATE`;
+            const session = locked[0];
+            if (!session || session.status !== "active")
+                return { outcome: "inactive", reason: "ended" };
+            if (input.now.getTime() >= session.deadlineAt.getTime())
+                return { outcome: "inactive", reason: "expired" };
+            const existing = await tx.nativeGatewayCall.findUnique({
+                where: { sessionId_callId: { sessionId: input.sessionId, callId: input.callId } },
+            });
+            if (existing)
+                return { outcome: "duplicate" };
+            const held = await heldUsd(tx, input.sessionId);
+            if (held + input.reservationUsd >= Number(session.budgetUsd)) {
+                await tx.nativeGatewaySession.updateMany({
+                    where: { id: input.sessionId, budgetExhaustedAt: null },
+                    data: { budgetExhaustedAt: input.now },
+                });
+                return { outcome: "budget_exhausted" };
+            }
+            await tx.nativeGatewayCall.create({
+                data: {
+                    sessionId: input.sessionId,
+                    callId: input.callId,
+                    method: "llm.stream",
+                    status: "reserved",
+                    reservationUsd: input.reservationUsd,
+                },
+            });
+            return { outcome: "reserved" };
+        }, LEDGER_TX);
+    }
+    /** Settles a reserved (or uncertain) model call at what it actually cost. */
+    async complete(sessionId, callId, usage) {
+        await this.db.nativeGatewayCall.updateMany({
+            where: { sessionId, callId, status: { in: ["reserved", "uncertain"] } },
+            data: {
+                status: "completed",
+                actualCostUsd: usage.costUsd,
+                inputTokens: usage.inputTokens,
+                outputTokens: usage.outputTokens,
+                cachedInputTokens: usage.cachedInputTokens,
+                cacheWriteTokens: usage.cacheWriteTokens,
+                costEstimated: false,
+                completedAt: new Date(),
+            },
+        });
+    }
+    /** Frees a reservation the provider never billed (it refused the request). */
+    async release(sessionId, callId) {
+        await this.db.nativeGatewayCall.updateMany({
+            where: { sessionId, callId, status: "reserved" },
+            data: { status: "released", completedAt: new Date() },
+        });
+    }
+    /**
+     * The outcome is unknown (the connection broke mid-call). Without an estimate the
+     * reservation stays held; with one, the call counts at the estimate instead.
+     */
+    async markUncertain(sessionId, callId, estimate) {
+        await this.db.nativeGatewayCall.updateMany({
+            where: { sessionId, callId, status: "reserved" },
+            data: {
+                status: "uncertain",
+                ...(estimate
+                    ? {
+                        actualCostUsd: estimate.costUsd,
+                        inputTokens: estimate.inputTokens,
+                        outputTokens: estimate.outputTokens,
+                        cachedInputTokens: estimate.cachedInputTokens,
+                        cacheWriteTokens: estimate.cacheWriteTokens,
+                        costEstimated: true,
+                    }
+                    : {}),
+            },
+        });
+    }
+    /**
+     * Median output tokens of the session's completed model calls (all on the run's one model), or
+     * undefined before the first one: the output of a call cut with nothing streamed.
+     */
+    async medianOutputTokens(sessionId) {
+        const rows = await this.db.$queryRaw `
+      SELECT percentile_disc(0.5) WITHIN GROUP (ORDER BY "outputTokens") AS "median"
+      FROM "NativeGatewayCall"
+      WHERE "sessionId" = ${sessionId} AND "method" = 'llm.stream' AND "status" = 'completed'
+        AND "outputTokens" IS NOT NULL`;
+        const median = rows[0]?.median ?? null;
+        return median === null ? undefined : Number(median);
+    }
+    async totals(sessionId) {
+        const completed = await this.db.nativeGatewayCall.aggregate({
+            where: {
+                sessionId,
+                method: "llm.stream",
+                OR: [{ status: "completed" }, { status: "uncertain", costEstimated: true }],
+            },
+            _sum: {
+                inputTokens: true,
+                outputTokens: true,
+                cachedInputTokens: true,
+                cacheWriteTokens: true,
+                actualCostUsd: true,
+            },
+        });
+        return {
+            tokensIn: completed._sum.inputTokens ?? 0,
+            tokensOut: completed._sum.outputTokens ?? 0,
+            cachedInputTokens: completed._sum.cachedInputTokens ?? 0,
+            cacheWriteTokens: completed._sum.cacheWriteTokens ?? 0,
+            costUsd: Number(completed._sum.actualCostUsd ?? 0),
+            heldUsd: await heldUsd(this.db, sessionId),
+        };
+    }
+    /** Claims a one-shot call by callId: the first claimant runs it, a repeat waits or replays. */
+    async claim(sessionId, callId, method) {
+        const created = await this.db.nativeGatewayCall.createMany({
+            data: [{ sessionId, callId, method, status: "pending" }],
+            skipDuplicates: true,
+        });
+        if (created.count === 1)
+            return { outcome: "claimed" };
+        const row = await this.db.nativeGatewayCall.findUnique({ where: { sessionId_callId: { sessionId, callId } } });
+        if (row?.status === "completed")
+            return { outcome: "done", result: row.result };
+        return { outcome: "in_flight" };
+    }
+    async recordResult(sessionId, callId, result) {
+        await this.db.nativeGatewayCall.updateMany({
+            where: { sessionId, callId },
+            data: { status: "completed", result, completedAt: new Date() },
+        });
+    }
+    /** A delegation's durable progress: its sub-agent, whether it waits for budget, and its child run once started. */
+    async setDelegation(sessionId, callId, state) {
+        await this.db.nativeGatewayCall.updateMany({
+            where: { sessionId, callId, status: { in: ["pending", "waiting_budget"] } },
+            data: {
+                status: state.status,
+                childAgentId: state.childAgentId,
+                ...(state.childRunId ? { childRunId: state.childRunId } : {}),
+            },
+        });
+    }
+    async delegation(sessionId, callId) {
+        const row = await this.db.nativeGatewayCall.findUnique({ where: { sessionId_callId: { sessionId, callId } } });
+        if (!row)
+            return null;
+        const status = row.status === "waiting_budget" ? "waiting_budget" : row.status === "completed" ? "completed" : "pending";
+        return { status, childRunId: row.childRunId, childAgentId: row.childAgentId, createdAt: row.createdAt };
+    }
+    /** The sub-agents other delegations of this run are waiting for budget to start. */
+    async waitingChildAgentIds(sessionId, exceptCallId) {
+        const rows = await this.db.nativeGatewayCall.findMany({
+            where: { sessionId, status: "waiting_budget", callId: { not: exceptCallId }, childAgentId: { not: null } },
+            select: { childAgentId: true },
+        });
+        return rows.map((row) => row.childAgentId);
+    }
+    /** Delegations of this session whose child run is started and not yet reported. */
+    async openDelegationChildren(sessionId) {
+        const rows = await this.db.nativeGatewayCall.findMany({
+            where: { sessionId, status: "pending", childRunId: { not: null } },
+            select: { childRunId: true },
+        });
+        return rows.map((row) => row.childRunId);
+    }
+}
+async function heldUsd(db, sessionId) {
+    const rows = await db.$queryRaw `
+    SELECT COALESCE(SUM(
+      CASE
+        WHEN "status" = 'completed' THEN COALESCE("actualCostUsd", 0)
+        WHEN "status" = 'uncertain' AND "costEstimated" THEN COALESCE("actualCostUsd", 0)
+        WHEN "status" IN ('reserved', 'uncertain') THEN COALESCE("reservationUsd", 0)
+        ELSE 0
+      END
+    ), 0) AS "held"
+    FROM "NativeGatewayCall" WHERE "sessionId" = ${sessionId} AND "method" = 'llm.stream'`;
+    return Number(rows[0]?.held ?? 0);
+}

package/dist/native-worker/loopback.d.ts

@@ -0,0 +1,12 @@
+/**
+ * The in-process harness transport: the worker and gateway in one process,
+ * with every message (worker input, requests, results, stream events, errors)
+ * forced through a JSON round trip so nothing crosses by reference — the same
+ * shape a real transport has. For tests and local development; never a
+ * sandbox (the worker runs in the server's own process).
+ */
+import type { NativeGateway, WorkerLauncher } from "./gateway.js";
+import { type GatewayTransport } from "./worker.js";
+export declare function createLoopbackTransport(gateway: NativeGateway): GatewayTransport;
+/** Runs the worker in this process over the loopback transport. */
+export declare const loopbackLauncher: WorkerLauncher;

package/dist/native-worker/loopback.js

@@ -0,0 +1,44 @@
+/**
+ * The in-process harness transport: the worker and gateway in one process,
+ * with every message (worker input, requests, results, stream events, errors)
+ * forced through a JSON round trip so nothing crosses by reference — the same
+ * shape a real transport has. For tests and local development; never a
+ * sandbox (the worker runs in the server's own process).
+ */
+import { parseMessage, toGatewayError, WorkerInputSchema } from "./protocol.js";
+import { runNativeWorker } from "./worker.js";
+const wire = (value) => (value === undefined ? value : JSON.parse(JSON.stringify(value)));
+export function createLoopbackTransport(gateway) {
+    return {
+        async call(request) {
+            try {
+                return wire(await gateway.call(wire(request)));
+            }
+            catch (err) {
+                throw toGatewayError(err);
+            }
+        },
+        async *stream(request) {
+            try {
+                for await (const event of gateway.stream(wire(request)))
+                    yield wire(event);
+            }
+            catch (err) {
+                throw toGatewayError(err);
+            }
+        },
+    };
+}
+/** Runs the worker in this process over the loopback transport. */
+export const loopbackLauncher = {
+    async run(input, gateway) {
+        try {
+            const parsed = parseMessage(JSON.stringify(input), WorkerInputSchema);
+            await runNativeWorker(parsed, createLoopbackTransport(gateway));
+            return { exitCode: 0 };
+        }
+        catch {
+            return { exitCode: 1 };
+        }
+    },
+};

package/dist/native-worker/main.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Native sandbox worker process entry. Reads its WorkerInput as the first line
+ * on stdin, runs the run's engine against the gateway on stdin/stdout
+ * (stdio.ts), and exits 0 once it has sent its result. stdout carries only
+ * protocol frames; diagnostics (and the shared logger) go to stderr, without any secret value the
+ * worker received (stderr-redaction.ts).
+ */
+export {};

package/dist/native-worker/main.js

@@ -0,0 +1,85 @@
+/**
+ * Native sandbox worker process entry. Reads its WorkerInput as the first line
+ * on stdin, runs the run's engine against the gateway on stdin/stdout
+ * (stdio.ts), and exits 0 once it has sent its result. stdout carries only
+ * protocol frames; diagnostics (and the shared logger) go to stderr, without any secret value the
+ * worker received (stderr-redaction.ts).
+ */
+import { readFile, stat } from "node:fs/promises";
+import { parseMessage, WorkerInputSchema } from "./protocol.js";
+import { createHttpTransport } from "./http-transport.js";
+import { createStdioTransport } from "./stdio.js";
+import { flushStderrRedaction, installStderrRedaction, rememberSecretValue } from "./stderr-redaction.js";
+import { WARM_WORKER_UNCLAIMED_EXIT } from "./warm-delivery.js";
+import { runNativeWorker } from "./worker.js";
+function firstLine() {
+    return new Promise((resolve, reject) => {
+        let buffer = "";
+        const onData = (chunk) => {
+            buffer += chunk.toString();
+            const newline = buffer.indexOf("\n");
+            if (newline >= 0) {
+                process.stdin.off("data", onData);
+                resolve(buffer.slice(0, newline));
+            }
+        };
+        process.stdin.on("data", onData);
+        process.stdin.once("end", () => reject(new Error("stdin closed before the worker input arrived")));
+    });
+}
+class UnclaimedError extends Error {
+}
+/**
+ * A warm pool worker (NATIVE_WORKER_INPUT_WAIT_MS set) starts before any run exists: it waits for
+ * its input file, delivered after a run claims it (warm-delivery.ts), and gives up after the wait.
+ */
+async function waitForFile(file, waitMs) {
+    const until = Date.now() + waitMs;
+    for (;;) {
+        if (await stat(file).then(() => true, () => false))
+            return;
+        if (Date.now() >= until)
+            throw new UnclaimedError("no run claimed this warm worker in time");
+        await new Promise((resolve) => setTimeout(resolve, 50));
+    }
+}
+/**
+ * The input's source: a file when NATIVE_WORKER_INPUT_FILE names one (a Kubernetes pod mounts it
+ * read-only from the run's Secret; a warm worker waits for it), otherwise the first line on stdin
+ * (Docker, local).
+ */
+async function readInput() {
+    const file = process.env.NATIVE_WORKER_INPUT_FILE;
+    if (!file)
+        return firstLine();
+    const waitMs = Number(process.env.NATIVE_WORKER_INPUT_WAIT_MS ?? "");
+    if (Number.isFinite(waitMs) && waitMs > 0)
+        await waitForFile(file, waitMs);
+    return (await readFile(file, "utf8")).trim();
+}
+async function main() {
+    const input = parseMessage(await readInput(), WorkerInputSchema);
+    if (input.gateway)
+        rememberSecretValue(input.gateway.capability);
+    // The gateway answers only after the worker asks, so choosing the transport after the input
+    // line misses nothing.
+    const transport = input.gateway
+        ? createHttpTransport({ url: input.gateway.url, capability: input.gateway.capability })
+        : createStdioTransport(process.stdin, process.stdout);
+    await runNativeWorker(input, transport);
+}
+const fail = (err) => {
+    // Anything still buffered for its line's end goes out first, so the failure line stands alone.
+    flushStderrRedaction();
+    if (err instanceof UnclaimedError) {
+        process.stderr.write(`native sandbox worker: ${err.message}\n`);
+        process.exit(WARM_WORKER_UNCLAIMED_EXIT);
+    }
+    process.stderr.write(`native sandbox worker failed: ${err instanceof Error ? err.message : String(err)}\n`);
+    process.exit(1);
+};
+installStderrRedaction();
+// Node's own report of an uncaught error would bypass the redaction: fail the same way instead.
+process.on("uncaughtException", fail);
+process.on("unhandledRejection", fail);
+main().then(() => process.exit(0), fail);