@sagentlab/navarch-runtime 0.1.88 → 0.1.89

package/README.md

@@ -72,7 +72,11 @@ machine.
 During a connected run, the runtime reports preparation, agent start, output
 activity, and completion checks to the control plane. Project members can see
 these phase updates in the task view. The activity signal contains no prompt
-or CLI output; the redacted transcript is uploaded when the run finishes.
+or CLI output. The redacted transcript is uploaded to the session's private
+transcript object every 10 seconds while the agent produces output (backing
+off to 30–60 seconds for multi-megabyte transcripts), and once more in full
+when the run finishes, so the task view can follow a connected run live.
+Live snapshots hold the current turn's stderr back until the turn ends.
 
 The machine operator selects **Claude Code**, **OpenAI Codex**, **Google
 Gemini CLI**, **OpenCode**, or an **Agent Client Protocol (ACP)** agent when connecting a worker. Any selected agent can

package/dist/adapters/acp.cjs

@@ -51,6 +51,7 @@ async function runAcpAdapter(options) {
     child.stdout.on("data", (chunk) => {
         options.onActivity?.();
         rawStdout.push(chunk);
+        options.onOutput?.("stdout", chunk.toString("utf8"));
         protocolInput.write(chunk);
     });
     child.stdout.on("end", () => protocolInput.end());
@@ -58,6 +59,7 @@ async function runAcpAdapter(options) {
     child.stderr.on("data", (chunk) => {
         options.onActivity?.();
         stderr.push(chunk);
+        options.onOutput?.("stderr", chunk);
     });
     child.on("error", (error) => {
         stderr.push(`\n${describeError(error)}`);

package/dist/adapters/claude.cjs

@@ -205,11 +205,15 @@ async function runOnHost(options, args) {
             onAbort();
         child.stdout.on("data", (d) => {
             options.onActivity?.();
-            stdout += d.toString();
+            const text = d.toString();
+            stdout += text;
+            options.onOutput?.("stdout", text);
         });
         child.stderr.on("data", (d) => {
             options.onActivity?.();
-            stderr += d.toString();
+            const text = d.toString();
+            stderr += text;
+            options.onOutput?.("stderr", text);
         });
         child.on("error", (err) => {
             clearTimeout(timer);
@@ -245,6 +249,8 @@ async function runViaDocker(options, args) {
             input: options.prompt,
             timeoutMs: options.timeoutMs,
             onActivity: options.onActivity,
+            onStdout: (chunk) => options.onOutput?.("stdout", chunk),
+            onStderr: (chunk) => options.onOutput?.("stderr", chunk),
             signal: options.signal,
         });
         return {

package/dist/adapters/codex.cjs

@@ -195,11 +195,15 @@ async function runOnHost(options, args) {
             onAbort();
         child.stdout.on("data", (d) => {
             options.onActivity?.();
-            stdout += d.toString();
+            const text = d.toString();
+            stdout += text;
+            options.onOutput?.("stdout", text);
         });
         child.stderr.on("data", (d) => {
             options.onActivity?.();
-            stderr += d.toString();
+            const text = d.toString();
+            stderr += text;
+            options.onOutput?.("stderr", text);
         });
         child.on("error", (err) => {
             clearTimeout(timer);
@@ -237,6 +241,8 @@ async function runViaDocker(options, args) {
             input: options.prompt,
             timeoutMs: options.timeoutMs,
             onActivity: options.onActivity,
+            onStdout: (chunk) => options.onOutput?.("stdout", chunk),
+            onStderr: (chunk) => options.onOutput?.("stderr", chunk),
             signal: options.signal,
             env: { ...process.env, ...options.env },
         });

package/dist/adapters/gemini.cjs

@@ -217,11 +217,15 @@ async function runOnHost(options, args) {
             onAbort();
         child.stdout.on("data", (data) => {
             options.onActivity?.();
-            stdout += data.toString();
+            const text = data.toString();
+            stdout += text;
+            options.onOutput?.("stdout", text);
         });
         child.stderr.on("data", (data) => {
             options.onActivity?.();
-            stderr += data.toString();
+            const text = data.toString();
+            stderr += text;
+            options.onOutput?.("stderr", text);
         });
         child.on("error", (err) => {
             clearTimeout(timer);
@@ -255,9 +259,10 @@ async function runViaDocker(options, args) {
         const result = await runner.run("docker", ["exec", "-i", ...forwardedEnv, containerName, "sh", "-c", command], { input: options.prompt,
             timeoutMs: options.timeoutMs,
             onActivity: options.onActivity,
+            onStdout: (chunk) => options.onOutput?.("stdout", chunk),
+            onStderr: (chunk) => options.onOutput?.("stderr", chunk),
             signal: options.signal,
-            env: { ...process.env, ...options.env },
-        });
+            env: { ...process.env, ...options.env }, });
         return {
             exitCode: result.code,
             timedOut: false,

package/dist/adapters/opencode.cjs

@@ -356,12 +356,16 @@ async function runOnHost(options, args, input = "") {
             onAbort();
         child.stdout.on("data", (data) => {
             options.onActivity?.();
-            stdout += data.toString();
+            const text = data.toString();
+            stdout += text;
+            options.onOutput?.("stdout", text);
             monitor.push("stdout", data.toString());
         });
         child.stderr.on("data", (data) => {
             options.onActivity?.();
-            stderr += data.toString();
+            const text = data.toString();
+            stderr += text;
+            options.onOutput?.("stderr", text);
             monitor.push("stderr", data.toString());
         });
         child.on("error", (error) => {
@@ -408,8 +412,8 @@ async function runViaDocker(options, args, input) {
             timeoutMs: options.timeoutMs,
             onActivity: options.onActivity,
             signal: controller.signal,
-            onStdout: (chunk) => { streamed.stdout = true; monitor.push("stdout", chunk); },
-            onStderr: (chunk) => { streamed.stderr = true; monitor.push("stderr", chunk); },
+            onStdout: (chunk) => { streamed.stdout = true; monitor.push("stdout", chunk); options.onOutput?.("stdout", chunk); },
+            onStderr: (chunk) => { streamed.stderr = true; monitor.push("stderr", chunk); options.onOutput?.("stderr", chunk); },
             env: { ...process.env, ...options.env },
         });
         // Also inspect runners that only return buffered output.

package/dist/adapters/pi.cjs

@@ -344,11 +344,15 @@ async function runOnHost(options, args, local = false) {
                 onAbort();
             child.stdout.on("data", (data) => {
                 options.onActivity?.();
-                stdout += data.toString();
+                const text = data.toString();
+                stdout += text;
+                options.onOutput?.("stdout", text);
             });
             child.stderr.on("data", (data) => {
                 options.onActivity?.();
-                stderr += data.toString();
+                const text = data.toString();
+                stderr += text;
+                options.onOutput?.("stderr", text);
             });
             child.on("error", (err) => {
                 clearTimeout(timer);
@@ -408,6 +412,8 @@ async function runViaDocker(options, args) {
             input: options.prompt,
             timeoutMs: options.timeoutMs,
             onActivity: options.onActivity,
+            onStdout: (chunk) => options.onOutput?.("stdout", chunk),
+            onStderr: (chunk) => options.onOutput?.("stderr", chunk),
             signal: options.signal,
             env: { ...process.env, ...options.env },
         });

package/dist/adapters/qoder.cjs

@@ -102,11 +102,15 @@ async function runOnHost(options, args) {
             onAbort();
         child.stdout.on("data", (d) => {
             options.onActivity?.();
-            stdout += d.toString();
+            const text = d.toString();
+            stdout += text;
+            options.onOutput?.("stdout", text);
         });
         child.stderr.on("data", (d) => {
             options.onActivity?.();
-            stderr += d.toString();
+            const text = d.toString();
+            stderr += text;
+            options.onOutput?.("stderr", text);
         });
         child.on("error", (err) => {
             clearTimeout(timer);
@@ -139,6 +143,8 @@ async function runViaDocker(options, args) {
             input: options.prompt,
             timeoutMs: options.timeoutMs,
             onActivity: options.onActivity,
+            onStdout: (chunk) => options.onOutput?.("stdout", chunk),
+            onStderr: (chunk) => options.onOutput?.("stderr", chunk),
             signal: options.signal,
         });
         return {

package/dist/live-transcript.cjs

@@ -0,0 +1,143 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LiveTranscriptPublisher = void 0;
+exports.renderSessionTranscript = renderSessionTranscript;
+exports.renderLiveTranscript = renderLiveTranscript;
+exports.liveUploadIntervalMs = liveUploadIntervalMs;
+/** The shape both the live snapshots and the completion upload use. */
+function renderSessionTranscript(attempts, redact) {
+    return attempts
+        .flatMap((attempt, index) => [
+        `# agent turn ${index + 1} stdout`,
+        redact(attempt.stdout),
+        "",
+        `# agent turn ${index + 1} stderr`,
+        redact(attempt.stderr),
+        "",
+    ])
+        .join("\n");
+}
+function renderLiveTranscript(attempts, currentStdout, redact, knownSecrets = []) {
+    const finished = attempts.length ? `${renderSessionTranscript(attempts, redact)}\n` : "";
+    const end = currentStdout.lastIndexOf("\n");
+    // A secret split across the cut would escape redaction, so redact whole lines only.
+    let complete = end >= 0 ? currentStdout.slice(0, end + 1) : "";
+    // Complete lines can still contain the beginning of a multiline secret.
+    // Hold that line and everything after it until redaction can see the value.
+    let safeEnd = complete.length;
+    for (const secret of knownSecrets) {
+        const newline = secret.indexOf("\n");
+        if (newline < 0)
+            continue;
+        const start = complete.lastIndexOf(secret.slice(0, newline + 1));
+        if (start >= 0 && complete.length - start < secret.length && secret.startsWith(complete.slice(start))) {
+            safeEnd = Math.min(safeEnd, complete.lastIndexOf("\n", start - 1) + 1);
+        }
+    }
+    const pem = /-----BEGIN ([A-Z0-9 ]*PRIVATE KEY)-----/g;
+    for (const match of complete.matchAll(pem)) {
+        if (!complete.includes(`-----END ${match[1]}-----`, match.index + match[0].length)) {
+            safeEnd = Math.min(safeEnd, complete.lastIndexOf("\n", match.index - 1) + 1);
+        }
+    }
+    complete = complete.slice(0, safeEnd);
+    return `${finished}# agent turn ${attempts.length + 1} stdout\n${redact(complete)}`;
+}
+/** Signed upload URLs last an hour; refresh well before that. */
+const UPLOAD_URL_TTL_MS = 45 * 60_000;
+const DEFAULT_INTERVAL_MS = 10_000;
+function liveUploadIntervalMs(bytes, baseMs = DEFAULT_INTERVAL_MS) {
+    if (bytes > 8 * 1024 * 1024)
+        return Math.max(baseMs, 60_000);
+    if (bytes > 1024 * 1024)
+        return Math.max(baseMs, 30_000);
+    return baseMs;
+}
+class LiveTranscriptPublisher {
+    options;
+    now;
+    intervalMs;
+    timer = null;
+    inFlight = null;
+    dirty = false;
+    stopped = false;
+    paused = false;
+    lastUploadedAt = 0;
+    lastUploaded = "";
+    uploadUrl = null;
+    published = null;
+    constructor(options) {
+        this.options = options;
+        this.now = options.now ?? Date.now;
+        this.intervalMs = options.intervalMs ?? DEFAULT_INTERVAL_MS;
+    }
+    /** Call whenever output arrives or a turn ends. */
+    markDirty() {
+        if (this.stopped)
+            return;
+        this.paused = false;
+        this.dirty = true;
+        this.schedule();
+    }
+    /** Locator of the last live snapshot that reached storage, if any. */
+    get publishedUrl() {
+        return this.published;
+    }
+    /** Cancels a pending upload and waits for an in-flight one, so neither can
+     * overwrite the completion transcript. A later markDirty() re-arms it. */
+    async idle() {
+        this.paused = true;
+        this.dirty = false;
+        if (this.timer)
+            clearTimeout(this.timer);
+        this.timer = null;
+        await this.inFlight;
+    }
+    async stop() {
+        this.stopped = true;
+        await this.idle();
+    }
+    schedule() {
+        if (this.timer || this.inFlight || this.stopped || this.paused)
+            return;
+        const gap = liveUploadIntervalMs(this.lastUploaded.length, this.intervalMs);
+        const wait = Math.max(0, this.lastUploadedAt + gap - this.now());
+        this.timer = setTimeout(() => {
+            this.timer = null;
+            this.inFlight = this.flush().finally(() => {
+                this.inFlight = null;
+                if (this.dirty)
+                    this.schedule();
+            });
+        }, wait);
+        this.timer.unref?.();
+    }
+    async flush() {
+        if (this.stopped)
+            return;
+        this.dirty = false;
+        const content = this.options.render();
+        if (content === this.lastUploaded)
+            return;
+        try {
+            if (!this.uploadUrl || this.now() - this.uploadUrl.at > UPLOAD_URL_TTL_MS) {
+                const { uploadUrl, publicUrl } = await this.options.requestUploadUrl();
+                this.uploadUrl = { url: uploadUrl, publicUrl, at: this.now() };
+            }
+            if (this.stopped)
+                return;
+            await this.options.upload(this.uploadUrl.url, content);
+            this.lastUploaded = content;
+            this.published = this.uploadUrl.publicUrl;
+        }
+        catch (error) {
+            // A rejected signature is refreshed on the next attempt.
+            this.uploadUrl = null;
+            this.options.onError?.(error);
+        }
+        finally {
+            this.lastUploadedAt = this.now();
+        }
+    }
+}
+exports.LiveTranscriptPublisher = LiveTranscriptPublisher;

package/dist/session.cjs

@@ -15,6 +15,7 @@ const index_cjs_1 = require("./adapters/index.cjs");
 const exit_conditions_cjs_1 = require("./exit-conditions.cjs");
 const redact_cjs_1 = require("./redact.cjs");
 const upload_cjs_1 = require("./upload.cjs");
+const live_transcript_cjs_1 = require("./live-transcript.cjs");
 const prompt_cjs_1 = require("./prompt.cjs");
 const mcp_config_cjs_1 = require("./mcp-config.cjs");
 const logger_cjs_1 = require("./logger.cjs");
@@ -441,6 +442,7 @@ async function runClaimedSession(deps, claimed, sessionId, lifecycle) {
         abortForRuntimeShutdown();
     lifecycle.enteredMainSessionTry = true;
     let browserEvidence;
+    let liveTranscript;
     try {
         reportActivity("preparing");
         await gitWorktree.prepare();
@@ -494,6 +496,18 @@ async function runClaimedSession(deps, claimed, sessionId, lifecycle) {
         const adapter = (0, index_cjs_1.selectAdapter)(runtime);
         const { bin, extraArgs } = adapterCommand(config, runtime);
         const attempts = [];
+        // The task view follows the run through periodic redacted snapshots of
+        // the same object the completion upload below finally overwrites.
+        let liveStdout = "";
+        liveTranscript = new live_transcript_cjs_1.LiveTranscriptPublisher({
+            requestUploadUrl: async () => {
+                const { upload_url, public_url } = await api.getTranscriptUploadUrl(leaseId);
+                return { uploadUrl: upload_url, publicUrl: public_url };
+            },
+            upload: upload_cjs_1.uploadTranscript,
+            render: () => (0, live_transcript_cjs_1.renderLiveTranscript)(attempts, liveStdout, (text) => (0, redact_cjs_1.redactText)(text, registry.list()), registry.list()),
+            onError: (error) => log.warn(`live transcript upload failed for ${leaseId}: ${(0, redact_cjs_1.redactText)(String(error), registry.list())}`),
+        });
         const agentBudgetStartedAt = node_perf_hooks_1.performance.now();
         const maxRuntimeMs = task.max_runtime_ms ?? config.sessionTimeoutMs;
         let nextPrompt = null;
@@ -544,6 +558,12 @@ async function runClaimedSession(deps, claimed, sessionId, lifecycle) {
                     dockerExec: sandbox ? { containerName: sandbox.name, runner: sandbox_cjs_1.nodeCommandRunner } : undefined,
                     signal: activeAbortController.signal,
                     onActivity: () => { outputObservedAt = Date.now(); outputUpdates += 1; },
+                    onOutput: (stream, chunk) => {
+                        if (stream !== "stdout")
+                            return;
+                        liveStdout += chunk;
+                        liveTranscript?.markDirty();
+                    },
                 }, task.idle_timeout_ms ?? config.sessionIdleTimeoutMs ?? 45 * 60_000, runtime === "opencode" ? config.opencodeStartupTimeoutMs : 0);
             activeAbortController = null;
             adapterRunning = false;
@@ -554,6 +574,8 @@ async function runClaimedSession(deps, claimed, sessionId, lifecycle) {
                 executionReport = { ...executionReport, model: turnResult.model };
             }
             attempts.push(turnResult);
+            liveStdout = "";
+            liveTranscript.markDirty();
             reportActivity("finishing");
             const capacityLimit = (0, adapter_capacity_cjs_1.detectAdapterCapacityLimit)(turnResult);
             if (capacityLimit) {
@@ -691,16 +713,8 @@ async function runClaimedSession(deps, claimed, sessionId, lifecycle) {
             if (mapping.leaseOutcome === "failed") {
                 log.warn(`adapter failed for ${leaseId}: ${(0, redact_cjs_1.redactText)(mapping.reportSummary, knownSecrets)}`);
             }
-            const transcript = attempts
-                .flatMap((attempt, index) => [
-                `# agent turn ${index + 1} stdout`,
-                (0, redact_cjs_1.redactText)(attempt.stdout, knownSecrets),
-                "",
-                `# agent turn ${index + 1} stderr`,
-                (0, redact_cjs_1.redactText)(attempt.stderr, knownSecrets),
-                "",
-            ])
-                .join("\n");
+            const transcript = (0, live_transcript_cjs_1.renderSessionTranscript)(attempts, (text) => (0, redact_cjs_1.redactText)(text, knownSecrets));
+            await liveTranscript.idle();
             let transcriptUrl;
             try {
                 const { upload_url, public_url } = await api.getTranscriptUploadUrl(leaseId);
@@ -711,6 +725,8 @@ async function runClaimedSession(deps, claimed, sessionId, lifecycle) {
                 // The message carries up to 500 chars of the storage response body, so
                 // redact it like every other warn in this block.
                 log.warn(`transcript upload failed for ${leaseId}: ${(0, redact_cjs_1.redactText)(String(err), knownSecrets)}`);
+                // The last live snapshot is still in storage; keep it reviewable.
+                transcriptUrl = liveTranscript.publishedUrl ?? undefined;
             }
             const redactedReport = (0, redact_cjs_1.redactText)(mapping.reportSummary, knownSecrets);
             const completion = {
@@ -800,6 +816,9 @@ async function runClaimedSession(deps, claimed, sessionId, lifecycle) {
         }
     }
     catch (err) {
+        await liveTranscript?.stop();
+        // A live snapshot already in storage is the best transcript a crash has.
+        const crashTranscriptUrl = lastCompletion?.transcript_url ?? liveTranscript?.publishedUrl;
         const knownSecrets = registry.list();
         // NavarchApiError's message is only the status line; the control plane's
         // explanation rides in `err.body`. Keep it in the agent log (redacted like
@@ -820,9 +839,7 @@ async function runClaimedSession(deps, claimed, sessionId, lifecycle) {
             failed_before_start: !adapterStarted,
             evidence_urls: lastCompletion?.evidence_urls ?? [],
             cost: lastCompletion?.cost ?? { tokens_in: 0, tokens_out: 0, cost_usd: 0 },
-            ...(lastCompletion?.transcript_url
-                ? { transcript_url: lastCompletion.transcript_url }
-                : {}),
+            ...(crashTranscriptUrl ? { transcript_url: crashTranscriptUrl } : {}),
             exit_status: "crashed",
             agent_type: runtime,
             ...executionReport,
@@ -830,6 +847,7 @@ async function runClaimedSession(deps, claimed, sessionId, lifecycle) {
             .catch((completeErr) => log.warn(`complete() after crash also failed: ${String(completeErr)}`));
     }
     finally {
+        await liveTranscript?.stop();
         deps.shutdownSignal?.removeEventListener("abort", abortForRuntimeShutdown);
         sessionClosing = true;
         clearInterval(heartbeatTimer);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sagentlab/navarch-runtime",
-  "version": "0.1.88",
+  "version": "0.1.89",
   "description": "Navarch machine-side session manager: claims delivery tasks and runs them through local coding agents.",
   "type": "commonjs",
   "license": "MIT",