@parley-im/parley 0.0.0-stage → 0.1.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 James Turnshek
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,135 @@
-# Temporary Holding Version
+# parley
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Send someone a link. They open a private chat with your own Claude or Codex, running read-only in your project folder, and tell it what they think. It asks follow-up questions, answers their questions by reading the code, and saves everything for you.
+
+The agent runs on your computer, with your Claude or Codex login and plan. Links live on **parley.im**, which passes the conversation between the tester's browser and your computer **end-to-end encrypted**: it can't read what's said.
+
+## Using it
+
+Link your computer to your parley.im account once:
+
+```bash
+parley login
+```
+
+Then, from any Claude Code or Codex session:
+
+> Make a parley so Sam can give feedback on the new onboarding. Sam's testing on their phone.
+
+Your agent writes a brief from what it knows and hands back a link like `https://parley.im/s/…#…`. Send Sam the whole link: the part after `#` is the conversation's key. Later:
+
+> Anything new from testers? Summarize it and file the bugs.
+
+> We're done with Sam's session.
+
+Or from a terminal:
+
+```bash
+parley new --tester Sam --brief "Sam is trying the new onboarding on their phone. Find out where they got stuck."
+parley list              # open sessions: new messages, replies used, spend (--ended, --all)
+parley show <id> --new   # what came in since you last read it
+parley limit <id> 150    # let a session give 150 replies in total
+parley end <id>          # kill the link; keep the transcript
+parley delete <id>       # erase it
+parley panel             # open your control panel
+parley whoami | logout
+```
+
+## How it fits together
+
+```
+tester's browser ──wss──▶ parley.im (Cloudflare Worker) ◀──wss── your computer (parley server)
+   key from #            sender accounts, open sessions,            agent runs here, transcripts
+   seals everything      relays ciphertext, stores none of it       and screenshots stay here,
+                                                                    holds each session's key
+```
+
+- **Accounts are for senders only**, signed in with Google and keyed on the verified email, so a later sign-in method with the same email joins the same account. Testers never sign in: the link is their access.
+- **`parley login`** works like `gh auth login`: your computer shows a code, you approve it at parley.im while signed in, and the computer gets its own token. Unlink computers from your account page on parley.im.
+- **Your computer connects out** to parley.im over a WebSocket; nothing listens for the internet on your machine. The server starts on demand (or `parley start`) and holds that connection.
+- **parley.im stores** accounts, linked computers, and each open session's id and title (the project name, for link previews). It forgets a session the moment it ends. Messages and screenshots only pass through, encrypted, between the tester's browser and your computer; screenshots cross in pieces over the same connection, and your computer serves them back to the page.
+
+### End-to-end encryption
+
+Each session has a random 256-bit key, kept in your parley database and in the link after the `#`, which browsers never send to a server. Every request, reply, live update and screenshot is sealed with AES-256-GCM (fresh IV each time) and bound to its session and direction, so parley.im can't read or alter anything, or move it between sessions. Your computer refuses requests older than five minutes or seen before, so replays go nowhere. `src/seal.ts` and `web/seal.js` are the two halves; the tests check they read each other.
+
+What it doesn't hide, said plainly on the tester's info sheet: parley.im knows who sent a link, the project name, and when messages pass; the page's code comes from parley.im, so the promise relies on parley.im serving it honestly (a strict Content-Security-Policy means the key can only ever go back to parley.im); and Claude or Codex reads the conversation to reply. Anyone with the whole link can read and join the chat.
+
+## What the tester gets
+
+A chat page built for phones first, in a plain technical style (a transcript, not chat bubbles). The header shows who's answering (the model, once the first reply names it) and how many replies are left; the ⓘ sheet explains who sent it (verified by parley.im), what the agent can and can't do, that everything is saved and encrypted, and when the link stops working. Replies stream in as plain conversation; the agent's lookups only show in your view. Markdown renders, tables and quotes included; HTML stays text. Screenshots can be pasted, dropped or picked. If they're at the bottom, the view stays there through streaming, images, resizing and the keyboard (on iOS the page pins itself above the keyboard); long conversations load older messages as you scroll up. If your computer is asleep, the page still loads and says so.
+
+## What the interviewer can do
+
+Each session is a fresh agent conversation in the project folder, guided by a charter (`src/charter.ts`), your brief, and the project's CLAUDE.md and AGENTS.md. It talks about the product as a user sees it and only gets into files and internals when asked.
+
+- **Claude:** `claude -p --restricted --tools Read,Grep,Glob --strict-mcp-config`. No command, write or web tools, reads confined to the project, your MCP servers left out.
+- **Codex:** `codex exec --sandbox read-only --ignore-user-config`, with apps, browser, computer use, plugins, hooks and web search off; your model and reasoning effort carry over.
+
+Each reply records which model answered, on which login (`auth: "none"` means your subscription, not an API key), and what it would cost at API prices.
+
+## Your control panel
+
+`http://localhost:4748`, only reachable from your computer: your parley.im connection, totals (open sessions, new messages, replies, spend), every session with its replies against its limit, and buttons to copy a link, add replies, end or delete. Opening a session shows the conversation with what each reply looked at, plus the brief and controls. A **New session** form makes one without an agent.
+
+## Keeping it in hand
+
+- **Reply limit:** 100 per session by default (`replyLimit`, or per session); then it pauses until you add more.
+- **Anti-spam:** per session, a burst of 20 messages, then one every 3 seconds; parley.im also rate-limits each tester connection.
+- **Message size:** up to 20,000 characters, refused with the count if longer.
+- **End** kills the link at once and parley.im forgets the session; **delete** also erases the transcript and screenshots on your computer.
+
+## Pieces
+
+| | |
+|---|---|
+| `src/server.ts` | Your control panel (4748) and local development links (4747) |
+| `src/relay.ts` | The connection to parley.im: answers sealed requests, pushes sealed updates |
+| `src/api.ts` | What a viewer can do with a session, shared by both |
+| `src/seal.ts`, `web/seal.js` | The encryption, Node and browser halves |
+| `src/account.ts` | `parley login`, credentials, and what parley.im is told |
+| `src/runner.ts`, `src/agents/` | One reply at a time per session; Claude and Codex adapters |
+| `src/mcp.ts` | `create_session`, `list_sessions`, `get_transcript`, `set_reply_limit`, `end_session` |
+| `src/db.ts` | SQLite in `~/.parley`: sessions (with keys), messages, turns |
+| `web/` | Chat page, session view, control panel; parley.im serves the tester page's files from here too |
+| `relay/` | parley.im: Worker, a Durable Object per linked computer, D1; the front page's animation is `web/home.js` |
+
+## Setup
+
+Requires Node 24+ on macOS or Linux, and Claude Code and/or Codex logged in.
+
+```bash
+npm install -g @parley-im/parley
+parley install   # registers the MCP server with Claude Code and Codex
+parley login
+```
+
+From a checkout instead: `npm install`, then `ln -s "$PWD/bin/parley" ~/.local/bin/parley`. `bin/parley` runs `src/` directly when it's there and the compiled `dist/` otherwise.
+
+### Publishing
+
+The npm package is `@parley-im/parley` (the parley-im org; plain `parley` is taken) and ships `bin/`, `dist/` and `web/`. `npm publish` builds `dist/` first (`npm run build`). Bump `version` in package.json each time.
+
+## Config
+
+`~/.parley/config.json`: `relayUrl` (default `https://parley.im`), `ownerName` (defaults to your account's first name), `replyLimit`, ports, and `claude`/`codex` model and effort overrides. Without `parley login`, links are local-only (`http://localhost:4747/...`), for development.
+
+## Running parley.im
+
+`relay/` is a Cloudflare Worker (`wrangler.jsonc`) with a Durable Object per linked computer and a D1 database (`migrations/`). Signed out, `/` is a wordless animation; signed in, it's your dashboard (open sessions, linked computers and whether they're online). `/docs` is the install guide. Secrets: `SESSION_SECRET` (random), `GOOGLE_CLIENT_ID` and `GOOGLE_CLIENT_SECRET` (a Google OAuth web client with redirect URI `https://parley.im/auth/google/callback`).
+
+```bash
+cd relay
+npx wrangler d1 migrations apply parley --remote
+npx wrangler deploy
+```
+
+## Development
+
+```bash
+npm test               # server, store, renderer, encryption; no model calls
+npm run test:relay     # end to end through a local parley.im (wrangler dev): login, encrypted chat, the real page, screenshots, ending, unlinking
+npm run check          # types (and `npm run check` in relay/)
+```
+
+For a local relay by hand: `cd relay && npx wrangler dev --local --port 8799 --local-upstream 127.0.0.1:8799` with `DEV_LOGIN=1` in `.dev.vars` (a sign-in form instead of Google), and `"relayUrl": "http://127.0.0.1:8799"` in a separate `PARLEY_HOME`.

package/bin/parley

@@ -0,0 +1,15 @@
+#!/usr/bin/env node
+// The parley command. From a checkout it runs the TypeScript in src/; the
+// npm package ships only the compiled dist/.
+import { existsSync } from "node:fs";
+
+// node:sqlite still announces itself as experimental; keep that out of
+// parley's output.
+const emit = process.emitWarning;
+process.emitWarning = (warning, ...rest) => {
+  if (String(warning).includes("SQLite")) return;
+  return emit.call(process, warning, ...rest);
+};
+
+const source = new URL("../src/cli.ts", import.meta.url);
+await import(existsSync(source) ? source.href : new URL("../dist/cli.js", import.meta.url).href);

package/dist/account.js

@@ -0,0 +1,79 @@
+import { existsSync, readFileSync, writeFileSync, rmSync, chmodSync } from "node:fs";
+import { hostname } from "node:os";
+import { paths } from "./config.js";
+export function readCredentials(config) {
+    if (!existsSync(paths.credentials))
+        return null;
+    try {
+        const creds = JSON.parse(readFileSync(paths.credentials, "utf8"));
+        // Linked to a different relay (say, a local one during development).
+        return creds.relayUrl === config.relayUrl ? creds : null;
+    }
+    catch {
+        return null;
+    }
+}
+export function writeCredentials(creds) {
+    writeFileSync(paths.credentials, JSON.stringify(creds, null, 2) + "\n", { mode: 0o600 });
+    chmodSync(paths.credentials, 0o600);
+}
+export function clearCredentials() {
+    rmSync(paths.credentials, { force: true });
+}
+// How the interviewer and tester pages refer to you.
+export function ownerName(config) {
+    const creds = readCredentials(config);
+    return config.ownerName ?? creds?.account.givenName ?? creds?.account.name ?? null;
+}
+async function call(creds, path, init = {}) {
+    const res = await fetch(`${creds.relayUrl}${path}`, {
+        ...init,
+        headers: { authorization: `Bearer ${creds.token}`, "content-type": "application/json", ...init.headers },
+        signal: AbortSignal.timeout(15_000),
+    });
+    if (res.status === 401)
+        throw Object.assign(new Error("This computer isn't linked to parley.im anymore. Run parley login."), { unlinked: true });
+    if (!res.ok)
+        throw new Error((await res.json().catch(() => null))?.message ?? `parley.im answered ${res.status}`);
+    return res.json();
+}
+// What parley.im is told about a session: its id and a title for link
+// previews. Never the conversation, and never the key.
+export const relay = {
+    register: (creds, s) => call(creds, "/api/sessions", { method: "POST", body: JSON.stringify({ id: s.token, title: s.project_name }) }),
+    end: (creds, s) => call(creds, `/api/sessions/${s.token}/end`, { method: "POST" }),
+    remove: (creds, s) => call(creds, `/api/sessions/${s.token}`, { method: "DELETE" }),
+    sync: (creds, open) => call(creds, "/api/sessions/sync", { method: "POST", body: JSON.stringify({ open: open.map((s) => ({ id: s.token, title: s.project_name })) }) }),
+    unlink: (creds) => call(creds, "/api/device", { method: "DELETE" }),
+};
+// `parley login`: the same pattern as `gh auth login`. This computer asks
+// for a code, you approve it in your browser while signed in, and it gets a
+// token of its own.
+export async function login(config, show) {
+    const start = await fetch(`${config.relayUrl}/api/device/start`, {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({ name: hostname().replace(/\.local$/, "") }),
+    });
+    if (!start.ok)
+        throw new Error(`Couldn't reach ${config.relayUrl} (${start.status}).`);
+    const { device_code, user_code, verify_url, expires_in, interval } = (await start.json());
+    show(user_code, verify_url);
+    const deadline = Date.now() + expires_in * 1000;
+    while (Date.now() < deadline) {
+        await new Promise((r) => setTimeout(r, interval * 1000));
+        const poll = (await (await fetch(`${config.relayUrl}/api/device/poll`, {
+            method: "POST",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify({ device_code }),
+        })).json());
+        if (poll.status === "approved") {
+            const creds = { relayUrl: config.relayUrl, token: poll.token, device: poll.device, account: poll.account };
+            writeCredentials(creds);
+            return creds;
+        }
+        if (poll.status === "expired")
+            break;
+    }
+    throw new Error("The code expired before it was approved. Run parley login again.");
+}

package/dist/agents/claude.js

@@ -0,0 +1,134 @@
+import { readFileSync, realpathSync } from "node:fs";
+import { sep } from "node:path";
+import { randomUUID } from "node:crypto";
+import { runJsonLines } from "./process.js";
+// Claude Code in print mode, one process per turn, resumed by session id.
+// --restricted drops every tool that runs code and ignores settings files,
+// --tools narrows it further to reading, and --strict-mcp-config keeps your
+// MCP servers (mail, calendar, ...) out of reach. CLAUDE.md still loads, so
+// the interviewer knows the project the way your own sessions do.
+export function runClaudeTurn(input, events) {
+    const { session, config } = input;
+    const agentSessionId = session.agent_session_id ?? randomUUID();
+    const args = [
+        "-p",
+        "--output-format", "stream-json",
+        "--input-format", "stream-json",
+        "--verbose",
+        "--include-partial-messages",
+        "--restricted",
+        "--tools", "Read,Grep,Glob",
+        "--strict-mcp-config",
+        "--permission-prompts", "none",
+        "--disable-slash-commands",
+        "--append-system-prompt", input.charter,
+        "--name", `parley: ${session.tester}`,
+    ];
+    const model = session.model ?? config.claude.model;
+    if (model)
+        args.push("--model", model);
+    if (config.claude.effort)
+        args.push("--effort", config.claude.effort);
+    if (session.agent_session_id)
+        args.push("--resume", agentSessionId);
+    else
+        args.push("--session-id", agentSessionId);
+    const content = [];
+    for (const image of input.images) {
+        content.push({
+            type: "image",
+            source: { type: "base64", media_type: image.mediaType, data: readFileSync(image.path).toString("base64") },
+        });
+    }
+    content.push({ type: "text", text: input.text });
+    const stdin = JSON.stringify({ type: "user", message: { role: "user", content } }) + "\n";
+    const texts = [];
+    let streamedAny = false;
+    let result = null;
+    let init = null;
+    const proc = runJsonLines({
+        bin: config.claude.bin,
+        args,
+        cwd: session.project_dir,
+        stdin,
+        onLine(event) {
+            if (event.type === "system" && event.subtype === "init")
+                init = event;
+            else if (event.type === "stream_event") {
+                const e = event.event;
+                if (e?.type === "content_block_start" && e.content_block?.type === "text" && streamedAny)
+                    events.onBreak();
+                if (e?.type === "content_block_delta" && e.delta?.type === "text_delta") {
+                    streamedAny = true;
+                    events.onDelta(e.delta.text);
+                }
+            }
+            else if (event.type === "assistant" && !event.parent_tool_use_id) {
+                for (const block of event.message?.content ?? []) {
+                    if (block.type === "text" && block.text.trim())
+                        texts.push(block.text.trim());
+                    if (block.type === "tool_use")
+                        events.onActivity(describeTool(block.name, block.input, session.project_dir));
+                }
+            }
+            else if (event.type === "result") {
+                result = event;
+            }
+        },
+    });
+    const done = proc.exited.then(({ code, stderr }) => {
+        // A result line means Claude recorded the conversation, so later turns
+        // can resume it even if this one ended in an error.
+        if (result && !session.agent_session_id)
+            events.onAgentSessionId(result.session_id ?? agentSessionId);
+        if (!result || result.is_error) {
+            const reason = result?.result || result?.errors?.join("; ") || stderr.trim() || `claude exited with code ${code}`;
+            throw new Error(reason);
+        }
+        return {
+            text: texts.join("\n\n") || String(result.result ?? "").trim(),
+            usage: {
+                // Which model answered and which login it ran on. "none" means no
+                // API key, so it ran on your claude.ai subscription.
+                model: Object.keys(result.modelUsage ?? {})[0] ?? init?.model ?? null,
+                auth: init?.apiKeySource ?? null,
+                // What the turn would cost at API prices; a subscription isn't billed this.
+                cost_usd: result.total_cost_usd ?? null,
+                duration_ms: result.duration_ms ?? null,
+                num_turns: result.num_turns ?? null,
+                ...result.usage,
+            },
+        };
+    });
+    return { done, cancel: proc.cancel };
+}
+function describeTool(name, input, root) {
+    const roots = [root, safeRealpath(root)];
+    const rel = (p) => {
+        for (const r of roots) {
+            if (p === r)
+                return ".";
+            if (p?.startsWith(r + sep))
+                return p.slice(r.length + 1);
+        }
+        return p;
+    };
+    switch (name) {
+        case "Read":
+            return `Reading ${rel(input?.file_path)}`;
+        case "Grep":
+            return `Searching the code for “${input?.pattern}”${input?.path ? ` in ${rel(input.path)}` : ""}`;
+        case "Glob":
+            return `Looking for files matching ${input?.pattern}`;
+        default:
+            return `Using ${name}`;
+    }
+}
+function safeRealpath(p) {
+    try {
+        return realpathSync(p);
+    }
+    catch {
+        return p;
+    }
+}

package/dist/agents/codex.js

@@ -0,0 +1,128 @@
+import { existsSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { runJsonLines } from "./process.js";
+// Features that reach beyond reading the project. Off for every turn.
+const DISABLED_FEATURES = [
+    "apps",
+    "browser_use",
+    "browser_use_external",
+    "computer_use",
+    "in_app_browser",
+    "image_generation",
+    "multi_agent",
+    "plugins",
+    "remote_plugin",
+    "hooks",
+];
+// Codex exec, one process per turn, resumed by thread id. Your config.toml is
+// ignored (it carries your full-access sandbox and MCP servers); only its
+// model and reasoning effort are carried over. The sandbox is read-only, so
+// Codex can run commands like rg and cat but cannot write or reach the network.
+export function runCodexTurn(input, events) {
+    const { session, config } = input;
+    const defaults = readCodexDefaults();
+    const model = session.model ?? config.codex.model ?? defaults.model;
+    const effort = config.codex.effort ?? defaults.effort;
+    const args = [
+        "exec",
+        "--json",
+        "--ignore-user-config",
+        "--skip-git-repo-check",
+        "--sandbox", "read-only",
+        "--cd", session.project_dir,
+        "-c", `sandbox_mode="read-only"`,
+        "-c", `approval_policy="never"`,
+        "-c", `web_search="disabled"`,
+        "-c", `developer_instructions=${JSON.stringify(input.charter)}`,
+    ];
+    for (const feature of DISABLED_FEATURES)
+        args.push("--disable", feature);
+    if (model)
+        args.push("--model", model);
+    if (effort)
+        args.push("-c", `model_reasoning_effort=${JSON.stringify(effort)}`);
+    if (session.agent_session_id)
+        args.push("resume", session.agent_session_id);
+    for (const image of input.images)
+        args.push(`--image=${image.path}`);
+    args.push("-");
+    const texts = [];
+    let usage = null;
+    let failure = null;
+    let lastError = null;
+    let threadId = null;
+    const commands = new Set();
+    const proc = runJsonLines({
+        bin: config.codex.bin,
+        args,
+        cwd: session.project_dir,
+        stdin: input.text,
+        onLine(event) {
+            switch (event.type) {
+                case "thread.started":
+                    threadId = event.thread_id;
+                    break;
+                case "item.started":
+                case "item.completed":
+                    // Commands the sandbox refuses can skip straight to completed.
+                    if (event.item?.type === "command_execution" && !commands.has(event.item.id)) {
+                        commands.add(event.item.id);
+                        events.onActivity(describeCommand(event.item.command));
+                    }
+                    if (event.type === "item.completed" && event.item?.type === "agent_message" && event.item.text?.trim()) {
+                        if (texts.length)
+                            events.onBreak();
+                        texts.push(event.item.text.trim());
+                        events.onDelta(event.item.text.trim());
+                    }
+                    break;
+                case "turn.completed":
+                    usage = event.usage ?? null;
+                    break;
+                case "turn.failed":
+                    failure = event.error?.message ?? "Codex turn failed";
+                    break;
+                case "error":
+                    lastError = event.message ?? null;
+                    break;
+            }
+        },
+    });
+    const done = proc.exited.then(({ code, stderr }) => {
+        if (threadId && !session.agent_session_id)
+            events.onAgentSessionId(threadId);
+        if (failure || !texts.length) {
+            throw new Error(failure ?? lastError ?? (stderr.trim() || `codex exited with code ${code}`));
+        }
+        return { text: texts.join("\n\n"), usage: { model: model ?? null, effort: effort ?? null, ...(usage ?? {}) } };
+    });
+    return { done, cancel: proc.cancel };
+}
+function describeCommand(command) {
+    let text = String(command ?? "");
+    const wrapped = text.match(/^(?:\/bin\/)?(?:ba|z)?sh -l?c ['"]?([\s\S]*?)['"]?$/);
+    if (wrapped)
+        text = wrapped[1];
+    text = text.replace(/\s+/g, " ").trim();
+    if (text.length > 90)
+        text = text.slice(0, 87) + "...";
+    return `Looking through the code: ${text}`;
+}
+// Top-level `model` and `model_reasoning_effort` from ~/.codex/config.toml.
+function readCodexDefaults() {
+    const file = join(process.env.CODEX_HOME ?? join(homedir(), ".codex"), "config.toml");
+    const found = { model: null, effort: null };
+    if (!existsSync(file))
+        return found;
+    for (const line of readFileSync(file, "utf8").split("\n")) {
+        if (/^\s*\[/.test(line))
+            break;
+        const m = line.match(/^\s*(model|model_reasoning_effort)\s*=\s*"([^"]*)"/);
+        if (m?.[1] === "model")
+            found.model = m[2];
+        if (m?.[1] === "model_reasoning_effort")
+            found.effort = m[2];
+    }
+    return found;
+}

package/dist/agents/process.js

@@ -0,0 +1,47 @@
+import { spawn } from "node:child_process";
+import { cleanEnv } from "../config.js";
+const TURN_LIMIT_MS = 15 * 60 * 1000;
+// Runs one agent turn as a child process that prints JSON lines.
+export function runJsonLines(opts) {
+    const child = spawn(opts.bin, opts.args, {
+        cwd: opts.cwd,
+        env: cleanEnv(),
+        stdio: ["pipe", "pipe", "pipe"],
+    });
+    let stderr = "";
+    let buffer = "";
+    const timer = setTimeout(() => child.kill("SIGTERM"), TURN_LIMIT_MS);
+    child.stdout.setEncoding("utf8");
+    child.stdout.on("data", (chunk) => {
+        buffer += chunk;
+        let newline;
+        while ((newline = buffer.indexOf("\n")) >= 0) {
+            const line = buffer.slice(0, newline).trim();
+            buffer = buffer.slice(newline + 1);
+            if (!line)
+                continue;
+            let event;
+            try {
+                event = JSON.parse(line);
+            }
+            catch {
+                continue;
+            }
+            opts.onLine(event);
+        }
+    });
+    child.stderr.setEncoding("utf8");
+    child.stderr.on("data", (chunk) => {
+        stderr = (stderr + chunk).slice(-4000);
+    });
+    child.stdin.on("error", () => { });
+    child.stdin.end(opts.stdin);
+    const exited = new Promise((resolve, reject) => {
+        child.on("error", reject);
+        child.on("close", (code) => {
+            clearTimeout(timer);
+            resolve({ code, stderr });
+        });
+    });
+    return { exited, cancel: () => child.kill("SIGTERM") };
+}

package/dist/agents/types.js

@@ -0,0 +1 @@
+export {};