@akira-tl/forgerelay 0.8.8 → 0.8.10

package/scripts/debug/traffic/traffic-audit.mjs

@@ -14,10 +14,12 @@ import { join, resolve } from "node:path";
 import { setTimeout as delay } from "node:timers/promises";
 import { activityRefreshDelayMs } from "../../../src/ui/activity/model.ts";
 import { debugRoot, repoRoot } from "../runtime.mjs";
+import { jsonRequest, curlRequest, jsonLogEntries, requestLogEntries, requestBodiesForRpc, countBy, waitForHealth, stopServer, assertPortsFree, jsonBytes, formatBytes } from "./support.mjs";
+
 
 const mode = process.argv[2] ?? "all";
 if (!["all", "local", "relay"].includes(mode)) {
-  throw new Error("Usage: scripts/debug/traffic/run.sh [all|local|relay]");
+  throw new Error("Usage: npm run traffic:audit -- [all|local|relay]");
 }
 
 const trafficRoot = resolve(debugRoot, "traffic-audit");
@@ -637,7 +639,7 @@ function authorizeHost(baseUrl, mcpUrl, ownerToken) {
       redirect_uri: redirectUri,
       code_challenge: challenge,
       code_challenge_method: "S256",
-      scope: "devspace",
+      scope: "forgerelay",
       resource: mcpUrl,
       state: "traffic-audit",
       owner_token: ownerToken,
@@ -746,162 +748,3 @@ function parseMcpMessage(body, expectedId) {
   return messages.find((message) => message.id === expectedId) ?? messages[0];
 }
 
-function jsonRequest(url, options = {}) {
-  const response = curlRequest({
-    method: options.method ?? "GET",
-    url,
-    headers: options.headers,
-    body: options.body,
-  });
-  return { ...response, json: JSON.parse(response.body) };
-}
-
-function curlRequest({ method = "GET", url, headers = {}, body }) {
-  const marker = `__FORGERELAY_TRAFFIC_${randomUUID()}__`;
-  const args = [
-    "--silent",
-    "--show-error",
-    "--max-time",
-    "20",
-    "--request",
-    method,
-    "--dump-header",
-    "-",
-    "--output",
-    "-",
-    "--write-out",
-    `\n${marker}%{http_code}|%{size_upload}|%{size_download}|%{size_request}|%{size_header}`,
-  ];
-  for (const [name, value] of Object.entries(headers)) args.push("--header", `${name}: ${value}`);
-  if (body !== undefined) args.push("--data-binary", "@-");
-  args.push(url);
-
-  const result = spawnSync("curl", args, {
-    cwd: repoRoot,
-    input: body,
-    encoding: "utf8",
-    maxBuffer: 40 * 1024 * 1024,
-  });
-  if (result.status !== 0) {
-    throw new Error(`curl ${method} ${url} failed: ${result.stderr.trim() || `exit ${result.status}`}`);
-  }
-  const statusMarker = `\n${marker}`;
-  const markerIndex = result.stdout.lastIndexOf(statusMarker);
-  assert.notEqual(markerIndex, -1, `curl response did not contain status marker for ${url}`);
-  const rawResponse = result.stdout.slice(0, markerIndex);
-  const stats = result.stdout.slice(markerIndex + statusMarker.length).trim().split("|");
-  const [status, sizeUpload, sizeDownload, sizeRequest, sizeHeader] = stats.map(Number);
-  const separator = rawResponse.indexOf("\r\n\r\n") >= 0 ? "\r\n\r\n" : "\n\n";
-  const headerEnd = rawResponse.indexOf(separator);
-  assert.notEqual(headerEnd, -1, `curl response did not contain headers for ${url}`);
-  const headerBlock = rawResponse.slice(0, headerEnd);
-  const responseBody = rawResponse.slice(headerEnd + separator.length);
-  const responseHeaders = new Map();
-  for (const line of headerBlock.split(/\r?\n/).slice(1)) {
-    const colon = line.indexOf(":");
-    if (colon < 0) continue;
-    responseHeaders.set(line.slice(0, colon).trim().toLowerCase(), line.slice(colon + 1).trim());
-  }
-  return {
-    status,
-    headers: responseHeaders,
-    body: responseBody,
-    sizeUpload,
-    sizeDownload,
-    sizeRequest,
-    sizeHeader,
-  };
-}
-
-function jsonLogEntries(path) {
-  if (!existsSync(path)) return [];
-  return readFileSync(path, "utf8")
-    .split(/\r?\n/)
-    .filter(Boolean)
-    .flatMap((line) => {
-      try {
-        return [JSON.parse(line)];
-      } catch {
-        return [];
-      }
-    });
-}
-
-function requestLogEntries(path) {
-  return jsonLogEntries(path).filter((entry) => entry.event === "http_request");
-}
-
-function requestBodiesForRpc(entries, rpcTarget) {
-  const requestIds = new Set(entries
-    .filter((entry) => entry.event === "mcp_request" && entry.rpcTarget === rpcTarget)
-    .map((entry) => entry.requestId)
-    .filter(Boolean));
-  return entries
-    .filter((entry) => entry.event === "http_request" && requestIds.has(entry.requestId))
-    .map((entry) => Number(entry.contentLength ?? 0))
-    .filter((value) => Number.isFinite(value));
-}
-
-function countBy(values, keyFor) {
-  const result = {};
-  for (const value of values) {
-    const key = keyFor(value);
-    result[key] = (result[key] ?? 0) + 1;
-  }
-  return result;
-}
-
-async function waitForHealth(child, baseUrl) {
-  for (let attempt = 0; attempt < 80; attempt += 1) {
-    if (child.exitCode !== null) throw new Error(`debug server exited before health check: ${child.exitCode}`);
-    try {
-      const response = jsonRequest(`${baseUrl}/healthz`);
-      if (response.status === 200) return;
-    } catch {
-      // still starting
-    }
-    await delay(100);
-  }
-  throw new Error(`debug server did not become healthy on ${baseUrl}`);
-}
-
-async function stopServer(child) {
-  if (child.exitCode !== null) return;
-  child.kill("SIGTERM");
-  const exited = once(child, "exit");
-  await Promise.race([
-    exited,
-    delay(3000).then(() => {
-      if (child.exitCode === null) child.kill("SIGKILL");
-    }),
-  ]);
-}
-
-async function assertPortsFree(ports) {
-  const script = [
-    "const net=require('node:net');",
-    `const ports=${JSON.stringify(ports)};`,
-    "let pending=ports.length; let bad=[];",
-    "for(const port of ports){const s=net.connect({host:'127.0.0.1',port}); s.setTimeout(250);",
-    "s.once('connect',()=>{bad.push(port);s.destroy();done();});",
-    "s.once('error',()=>{s.destroy();done();}); s.once('timeout',()=>{s.destroy();done();});}",
-    "function done(){if(--pending===0){if(bad.length){console.error('busy:'+bad.join(','));process.exit(2)}}}",
-  ].join("");
-  const result = spawnSync(process.execPath, ["-e", script], { encoding: "utf8" });
-  if (result.status !== 0) throw new Error(`reserved debug port already in use: ${result.stderr.trim()}`);
-}
-
-function jsonBytes(value) {
-  if (value === undefined) return 0;
-  return Buffer.byteLength(JSON.stringify(value), "utf8");
-}
-
-function formatBytes(value) {
-  const bytes = Number(value);
-  if (!Number.isFinite(bytes)) return String(value);
-  if (bytes < 1024) return `${bytes.toFixed(0)} B`;
-  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KiB`;
-  if (bytes < 1024 * 1024 * 1024) return `${(bytes / (1024 * 1024)).toFixed(2)} MiB`;
-  return `${(bytes / (1024 * 1024 * 1024)).toFixed(2)} GiB`;
-}
-

package/scripts/{lsp-interop-support.test.mjs → lsp/interop-support.test.mjs}

@@ -3,7 +3,7 @@ import { chmodSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { delimiter, join } from "node:path";
 import test from "node:test";
-import { findExecutable, probeExecutable } from "./lsp-interop-support.mjs";
+import { findExecutable, probeExecutable } from "./interop-support.mjs";
 
 const root = mkdtempSync(join(tmpdir(), "forgerelay-lsp-preflight-test-"));
 

package/scripts/{lsp-interop.mjs → lsp/interop.mjs}

@@ -2,10 +2,10 @@ import assert from "node:assert/strict";
 import { mkdirSync, rmSync, writeFileSync } from "node:fs";
 import { dirname, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
-import { CodeIntelligenceManager } from "../dist/lsp/runtime/manager.js";
-import { findExecutable, probeExecutable } from "./lsp-interop-support.mjs";
+import { CodeIntelligenceManager } from "../../dist/lsp/runtime/manager.js";
+import { findExecutable, probeExecutable } from "./interop-support.mjs";
 
-const repoRoot = resolve(fileURLToPath(new URL("..", import.meta.url)));
+const repoRoot = resolve(fileURLToPath(new URL("../..", import.meta.url)));
 const interopRoot = resolve(repoRoot, ".forgerelay-debug", "lsp-interop");
 const fixtures = [
   {

package/scripts/release/publish.mjs

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 import { execFileSync, spawnSync } from "node:child_process";
-import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from "node:fs";
+import { mkdirSync, readFileSync, readdirSync, writeFileSync } from "node:fs";
 import { basename, dirname, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 
@@ -28,6 +28,7 @@ if (head !== tagHead) {
 if (!gitSucceeds(["merge-base", "--is-ancestor", tagHead, "origin/main"])) {
   throw new Error(`${releaseTag} does not point to a commit contained in origin/main`);
 }
+const notesPath = prepareReleaseNotes(releaseTag);
 
 const packages = readdirSync(packageDir).filter((name) => name.endsWith(".tgz"));
 if (packages.length !== 1) {
@@ -53,7 +54,6 @@ if (npmPackageExists(packageSpec)) {
 if (ghReleaseExists(releaseTag)) {
   console.log(`GitHub Release ${releaseTag} already exists; leaving it unchanged.`);
 } else {
-  const notesPath = prepareReleaseNotes(releaseTag);
   const args = [
     "release",
     "create",
@@ -128,13 +128,16 @@ function ghReleaseExists(tag) {
 
 function prepareReleaseNotes(tag) {
   const manualNotes = join(repoRoot, "docs", "releases", `${tag}.md`);
-  const notes = existsSync(manualNotes)
-    ? readFileSync(manualNotes, "utf8")
-    : execFileSync(process.execPath, ["scripts/release-version.mjs", "notes", tag], {
-        cwd: repoRoot,
-        encoding: "utf8",
-        stdio: ["ignore", "pipe", "inherit"],
-      });
+  let notes;
+  try {
+    notes = readFileSync(manualNotes, "utf8");
+  } catch (error) {
+    if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+      throw new Error(`Missing dedicated release notes: docs/releases/${tag}.md`);
+    }
+    throw error;
+  }
+  if (!notes.trim()) throw new Error(`Dedicated release notes are empty: docs/releases/${tag}.md`);
   const tempRoot = resolve(process.env.RUNNER_TEMP ?? join(repoRoot, ".forgerelay-debug"));
   mkdirSync(tempRoot, { recursive: true });
   const notesPath = join(tempRoot, `release-notes-${tag}.md`);

package/scripts/release/release-gate.test.mjs

@@ -69,7 +69,9 @@ test("release runtime and local parity share the checked-in Node contract", asyn
 
   const source = await readFile(resolve(repoRoot, "scripts/release-parity.mjs"), "utf8");
   assert.match(source, /readFileSync\(join\(repoRoot, "\.nvmrc"\), "utf8"\)/);
-  assert.match(source, /const NPM_VERSION = "10\.9\.3"/);
+  assert.match(source, /const NPM_VERSION = "11\.19\.1"/);
+  const ciWorkflow = await readFile(resolve(repoRoot, ".github/workflows/ci.yml"), "utf8");
+  assert.match(ciWorkflow, /npm install --global npm@11\.19\.1/);
   assert.ok(source.includes('["npm", "ci", "--no-audit", "--no-fund"]'));
   assert.ok(source.includes('["npm", "run", "ci:verify"]'));
   assert.ok(source.includes('["npm", "run", "release:pack"]'));

package/scripts/release/release-version.test.mjs

@@ -14,6 +14,7 @@ async function createFixture(t) {
   const root = await mkdtemp(join(tmpdir(), "forgerelay-release-version-"));
   t.after(() => rm(root, { recursive: true, force: true }));
   await mkdir(join(root, "scripts"), { recursive: true });
+  await mkdir(join(root, "docs", "releases"), { recursive: true });
   await cp(sourceScript, join(root, "scripts", "release-version.mjs"));
 
   const pkg = {
@@ -88,8 +89,19 @@ test("release version tooling prepares and validates an rc release", async (t) =
   const checked = await runRelease(root, "check");
   assert.match(checked.stdout, /release metadata is consistent at 0\.6\.0-rc\.1/);
 
+  await assert.rejects(
+    () => runRelease(root, "tag", "v0.6.0-rc.1"),
+    (error) => {
+      assert.match(String(error.stderr ?? error), /missing dedicated release notes: docs\/releases\/v0\.6\.0-rc\.1\.md/);
+      return true;
+    },
+  );
+  await writeFile(
+    join(root, "docs", "releases", "v0.6.0-rc.1.md"),
+    "# ForgeRelay v0.6.0-rc.1\n\nRelease candidate notes.\n",
+  );
   const tagged = await runRelease(root, "tag", "v0.6.0-rc.1");
-  assert.match(tagged.stdout, /release tag v0\.6\.0-rc\.1 matches package version and changelog/);
+  assert.match(tagged.stdout, /release tag v0\.6\.0-rc\.1 matches package version, changelog, and dedicated release notes/);
 
   const notes = await runRelease(root, "notes", "v0.6.0-rc.1");
   assert.match(notes.stdout, /Release candidate behavior/);

package/scripts/release-parity.mjs

@@ -5,7 +5,7 @@ import { cpSync, mkdirSync, mkdtempSync, readFileSync, rmSync } from "node:fs";
 import { dirname, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 
-const NPM_VERSION = "10.9.3";
+const NPM_VERSION = "11.19.1";
 const repoRoot = resolve(dirname(fileURLToPath(import.meta.url)), "..");
 const NODE_VERSION = readFileSync(join(repoRoot, ".nvmrc"), "utf8").trim();
 const debugRoot = join(repoRoot, ".forgerelay-debug");

package/scripts/release-proof.mjs

@@ -29,6 +29,20 @@ function packageVersion() {
   return pkg.version;
 }
 
+function requireDedicatedReleaseNotes(version) {
+  const path = join(process.cwd(), "docs", "releases", `v${version}.md`);
+  let notes;
+  try {
+    notes = readFileSync(path, "utf8");
+  } catch (error) {
+    if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+      throw new Error(`missing dedicated release notes: docs/releases/v${version}.md`);
+    }
+    throw error;
+  }
+  if (!notes.trim()) throw new Error(`dedicated release notes are empty: docs/releases/v${version}.md`);
+}
+
 function gitDir() {
   const path = git(["rev-parse", "--git-dir"]);
   return path.startsWith("/") ? path : join(process.cwd(), path);
@@ -138,6 +152,7 @@ function checkHookTag() {
   if (tag !== expectedTag) {
     throw new Error(`tag ${tag} does not match package version ${version}; expected ${expectedTag}`);
   }
+  requireDedicatedReleaseNotes(version);
 
   let tagHead;
   try {

package/scripts/release-proof.test.mjs

@@ -1,6 +1,6 @@
 import assert from "node:assert/strict";
 import { execFile } from "node:child_process";
-import { mkdtemp, rm, writeFile } from "node:fs/promises";
+import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import test from "node:test";
@@ -25,6 +25,8 @@ test("release tag hook gate uses repository facts instead of requiring a local p
   const root = await mkdtemp(join(tmpdir(), "forgerelay-release-proof-"));
   t.after(() => rm(root, { recursive: true, force: true }));
   await writeFile(join(root, "package.json"), JSON.stringify({ version: "1.2.3" }) + "\n");
+  await mkdir(join(root, "docs", "releases"), { recursive: true });
+  await writeFile(join(root, "docs", "releases", "v1.2.3.md"), "# v1.2.3\n\nDedicated notes.\n");
   await writeFile(join(root, "tracked.txt"), "verified\n");
   await git(root, ["init"]);
   await git(root, ["config", "user.email", "proof@example.com"]);
@@ -102,10 +104,34 @@ test("release tag hook gate uses repository facts instead of requiring a local p
   );
 });
 
+test("release tag hook gate rejects a matching tag when dedicated notes are missing", async (t) => {
+  const root = await mkdtemp(join(tmpdir(), "forgerelay-release-proof-"));
+  t.after(() => rm(root, { recursive: true, force: true }));
+  await writeFile(join(root, "package.json"), JSON.stringify({ version: "1.4.0" }) + "\n");
+  await git(root, ["init"]);
+  await git(root, ["config", "user.email", "proof@example.com"]);
+  await git(root, ["config", "user.name", "Release Proof Test"]);
+  await git(root, ["add", "."]);
+  await git(root, ["commit", "-m", "release 1.4.0"]);
+  await git(root, ["tag", "v1.4.0"]);
+
+  await assert.rejects(
+    () => runProof(root, "check-hook", {
+      FORGERELAY_HOOK_PAYLOAD: JSON.stringify({ command: "git push origin v1.4.0" }),
+    }),
+    (error) => {
+      assert.match(String(error.stderr ?? error), /missing dedicated release notes: docs\/releases\/v1\.4\.0\.md/);
+      return true;
+    },
+  );
+});
+
 test("release tag hook gate accepts an rc tag for the package version", async (t) => {
   const root = await mkdtemp(join(tmpdir(), "forgerelay-release-proof-"));
   t.after(() => rm(root, { recursive: true, force: true }));
   await writeFile(join(root, "package.json"), JSON.stringify({ version: "0.6.0-rc.1" }) + "\n");
+  await mkdir(join(root, "docs", "releases"), { recursive: true });
+  await writeFile(join(root, "docs", "releases", "v0.6.0-rc.1.md"), "# v0.6.0-rc.1\n\nDedicated RC notes.\n");
   await git(root, ["init"]);
   await git(root, ["config", "user.email", "proof@example.com"]);
   await git(root, ["config", "user.name", "Release Proof Test"]);

package/scripts/release-version.mjs

@@ -35,7 +35,8 @@ switch (command) {
     if (value !== expectedTag) {
       fail(`tag ${JSON.stringify(value)} does not match package version; expected ${expectedTag}`);
     }
-    console.log(`release tag ${value} matches package version and changelog`);
+    await requireReleaseNotes(state.pkg.version);
+    console.log(`release tag ${value} matches package version, changelog, and dedicated release notes`);
     break;
   }
   case "prepare": {
@@ -203,6 +204,20 @@ function getUnreleasedBody(changelog) {
   return changelog.slice(bodyStart, bodyEnd).trim();
 }
 
+async function requireReleaseNotes(version) {
+  const path = resolve(repoRoot, "docs", "releases", `v${version}.md`);
+  let content;
+  try {
+    content = await readFile(path, "utf8");
+  } catch (error) {
+    if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+      fail(`missing dedicated release notes: docs/releases/v${version}.md`);
+    }
+    throw error;
+  }
+  if (!content.trim()) fail(`dedicated release notes are empty: docs/releases/v${version}.md`);
+}
+
 function getReleaseBody(changelog, version) {
   const heading = `## [${version}]`;
   const headingIndex = changelog.indexOf(heading);

package/scripts/wiki/sync.mjs

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 import {
-  cpSync,
+  copyFileSync,
   existsSync,
   mkdtempSync,
   readdirSync,
@@ -49,7 +49,13 @@ function validateWikiSource(directory) {
   }
 
   const files = listFiles(directory);
-  const names = new Set(files.map((file) => file.relativePath));
+  const destinationNames = files.map((file) => wikiDestinationName(file.relativePath));
+  const names = new Set(destinationNames);
+  if (names.size !== destinationNames.length) {
+    const duplicates = destinationNames.filter((name, index) => destinationNames.indexOf(name) !== index);
+    fail(`Wiki source contains duplicate flattened page names:
+${[...new Set(duplicates)].map((name) => `- ${name}`).join("\n")}`);
+  }
 
   for (const required of ["Home.md", "_Sidebar.md"]) {
     if (!names.has(required)) {
@@ -59,7 +65,7 @@ function validateWikiSource(directory) {
 
   const invalidNames = files
     .map((file) => file.relativePath)
-    .filter((name) => !isSafeWikiPath(name));
+    .filter((name) => !isSafeWikiSourcePath(name));
   if (invalidNames.length > 0) {
     fail(`Wiki source contains unsupported paths:\n${invalidNames.map((name) => `- ${name}`).join("\n")}`);
   }
@@ -67,7 +73,7 @@ function validateWikiSource(directory) {
   const markdownNames = new Set(
     files
       .filter((file) => file.relativePath.endsWith(".md"))
-      .map((file) => file.relativePath),
+      .map((file) => wikiDestinationName(file.relativePath)),
   );
   const brokenLinks = [];
 
@@ -86,7 +92,7 @@ function validateWikiSource(directory) {
       }
 
       const candidate = target.endsWith(".md") ? target : `${target}.md`;
-      if (!markdownNames.has(candidate)) {
+      if (!markdownNames.has(wikiDestinationName(candidate))) {
         brokenLinks.push(`${file.relativePath}: ${rawTarget}`);
       }
     }
@@ -169,8 +175,8 @@ function mirrorSource(source, destination) {
     rmSync(join(destination, entry), { recursive: true, force: true });
   }
 
-  for (const entry of readdirSync(source)) {
-    cpSync(join(source, entry), join(destination, entry), { recursive: true });
+  for (const file of listFiles(source)) {
+    copyFileSync(file.absolutePath, join(destination, wikiDestinationName(file.relativePath)));
   }
 }
 
@@ -191,10 +197,15 @@ function listFiles(directory, prefix = "") {
   return files.sort((left, right) => left.relativePath.localeCompare(right.relativePath));
 }
 
-function isSafeWikiPath(relativePath) {
+function wikiDestinationName(relativePath) {
+  return basename(relativePath);
+}
+
+function isSafeWikiSourcePath(relativePath) {
   if (!relativePath.endsWith(".md")) return false;
-  if (relativePath.includes("/")) return false;
-  return !/[\\:*?"<>|]/.test(relativePath) && basename(relativePath) === relativePath;
+  return relativePath
+    .split("/")
+    .every((segment) => segment.length > 0 && !/[\\:*?"<>|]/.test(segment));
 }
 
 function isExternalOrAnchorLink(target) {

package/dist/activity/bash-output-store.js

@@ -1,127 +0,0 @@
-import { randomUUID } from "node:crypto";
-import { StringDecoder } from "node:string_decoder";
-import { openDatabase } from "../db/client.js";
-export class BashOutputStore {
-    database;
-    now;
-    nextOutputId;
-    nextSequences = new Map();
-    constructor(stateDir, options = {}) {
-        this.database = openDatabase(stateDir);
-        this.now = options.now ?? (() => new Date());
-        this.nextOutputId = options.outputId ?? (() => `out_${randomUUID().replaceAll("-", "")}`);
-    }
-    begin(input) {
-        const outputId = this.nextOutputId();
-        const startedAt = this.now().toISOString();
-        this.database.sqlite.prepare(`insert into bash_output_streams (
-        id, activity_id, turn_id, conversation_scope_id, process_id,
-        workspace_id, workspace_root, command, tty, status, timed_out, started_at
-      ) values (?, ?, ?, ?, ?, ?, ?, ?, ?, 'running', 0, ?)`).run(outputId, input.activityId, input.turnId, input.conversationScopeId ?? null, input.processId, input.workspaceId, input.workspaceRoot, input.command, input.tty ? 1 : 0, startedAt);
-        this.nextSequences.set(outputId, 1);
-        return outputId;
-    }
-    append(outputId, channel, data) {
-        const bytes = typeof data === "string" ? Buffer.from(data, "utf8") : Buffer.from(data);
-        if (bytes.length === 0)
-            return;
-        const sequence = this.nextSequence(outputId);
-        this.database.sqlite.prepare(`insert into bash_output_chunks (output_id, sequence, channel, data, created_at)
-       values (?, ?, ?, ?, ?)`).run(outputId, sequence, channel, bytes, this.now().toISOString());
-    }
-    markReturned(outputId) {
-        this.database.sqlite.prepare("update bash_output_streams set returned = 1 where id = ?").run(outputId);
-    }
-    claimCompletion(outputId) {
-        const claimedAt = this.now().toISOString();
-        const claimed = this.database.sqlite.prepare(`update bash_output_streams
-       set completion_claimed_at = ?
-       where id = ? and returned = 1 and status != 'running' and completion_claimed_at is null`).run(claimedAt, outputId);
-        return claimed.changes === 1 ? this.read(outputId) : undefined;
-    }
-    finish(outputId, input) {
-        const status = input.error || input.timedOut || input.signal || (input.exitCode !== undefined && input.exitCode !== 0)
-            ? "failed"
-            : "done";
-        this.database.sqlite.prepare(`update bash_output_streams
-       set status = ?, exit_code = ?, signal = ?, timed_out = ?, error = ?, finished_at = ?
-       where id = ?`).run(status, input.exitCode ?? null, input.signal ?? null, input.timedOut ? 1 : 0, input.error ?? null, this.now().toISOString(), outputId);
-    }
-    read(outputId) {
-        const stream = this.database.sqlite.prepare("select * from bash_output_streams where id = ?").get(outputId);
-        if (!stream)
-            return undefined;
-        const rows = this.database.sqlite.prepare(`select * from bash_output_chunks
-       where output_id = ?
-       order by sequence asc`).all(outputId);
-        const decoded = decodeChunks(rows);
-        return {
-            outputId: stream.id,
-            activityId: stream.activity_id,
-            turnId: stream.turn_id,
-            ...(stream.conversation_scope_id ? { conversationScopeId: stream.conversation_scope_id } : {}),
-            processId: stream.process_id,
-            workspaceId: stream.workspace_id,
-            workspaceRoot: stream.workspace_root,
-            command: stream.command,
-            tty: stream.tty === 1,
-            output: decoded.map((chunk) => chunk.data).join(""),
-            chunks: decoded,
-            status: isBashOutputStatus(stream.status) ? stream.status : "failed",
-            ...(stream.exit_code !== null ? { exitCode: stream.exit_code } : {}),
-            ...(stream.signal ? { signal: stream.signal } : {}),
-            timedOut: stream.timed_out === 1,
-            ...(stream.error ? { error: stream.error } : {}),
-            returned: stream.returned === 1,
-            startedAt: stream.started_at,
-            ...(stream.finished_at ? { finishedAt: stream.finished_at } : {}),
-        };
-    }
-    close() {
-        this.database.close();
-    }
-    nextSequence(outputId) {
-        const known = this.nextSequences.get(outputId);
-        if (known !== undefined) {
-            this.nextSequences.set(outputId, known + 1);
-            return known;
-        }
-        const row = this.database.sqlite.prepare("select coalesce(max(sequence), 0) as sequence from bash_output_chunks where output_id = ?").get(outputId);
-        const sequence = row.sequence + 1;
-        this.nextSequences.set(outputId, sequence + 1);
-        return sequence;
-    }
-}
-function decodeChunks(rows) {
-    const decoders = new Map();
-    const chunks = [];
-    const lastChunkIndex = new Map();
-    for (const row of rows) {
-        if (!isBashOutputChannel(row.channel)) {
-            throw new Error(`Unknown Bash output channel: ${row.channel}`);
-        }
-        const decoder = decoders.get(row.channel) ?? new StringDecoder("utf8");
-        decoders.set(row.channel, decoder);
-        const data = decoder.write(row.data);
-        chunks.push({ sequence: row.sequence, channel: row.channel, data });
-        lastChunkIndex.set(row.channel, chunks.length - 1);
-    }
-    for (const [channel, decoder] of decoders) {
-        const tail = decoder.end();
-        if (!tail)
-            continue;
-        const index = lastChunkIndex.get(channel);
-        if (index === undefined)
-            continue;
-        const chunk = chunks[index];
-        if (chunk)
-            chunk.data += tail;
-    }
-    return chunks;
-}
-function isBashOutputChannel(value) {
-    return value === "stdout" || value === "stderr" || value === "pty" || value === "process";
-}
-function isBashOutputStatus(value) {
-    return value === "running" || value === "done" || value === "failed";
-}