attesso 0.4.1 → 0.6.1

package/src/store.mjs

@@ -5,11 +5,19 @@
 //   config.json  the recorded head (count + hash), the only thing that makes a
 //                truncated log visible
 //   lock         held while appending, so two agents cannot interleave writes
-import { closeSync, existsSync, mkdirSync, openSync, readFileSync, renameSync, unlinkSync, writeFileSync, writeSync } from 'node:fs';
-import { join } from 'node:path';
-import { buildEntry, entryHash, newSigningKey, signEntry } from './ledger.mjs';
-import { evaluate, policyDigest, validatePolicy } from './policy.mjs';
-import { evaluatePath, rulesDigest, validateRules } from './rules.mjs';
+import { randomBytes } from 'node:crypto';
+import { channel } from 'node:diagnostics_channel';
+import { closeSync, existsSync, fsyncSync, ftruncateSync, linkSync, mkdirSync, openSync, readFileSync, readSync, renameSync, statSync, unlinkSync, writeFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { buildEntry, entryHash, newSigningKey, signEntry, verifyEntry, verifyHead, verifyStep } from './ledger.mjs';
+import { DEFAULT_TOOLS, loadTools } from './classify.mjs';
+import { decide } from './decide.mjs';
+import { parseLine, parseTail } from './jsonl.mjs';
+import { policyDigest, validatePolicy } from './policy.mjs';
+import { rulesDigest, rulesForProfile, validateRules } from './rules.mjs';
+import { toolGate, manifestDigest, toolsDigest } from './toolpin.mjs';
+import { evaluatePathScope, validatePathsConfig } from './fs-paths.mjs';
+import { forEachEntry, forEachEntrySync } from './stream.mjs';
 
 export function paths(dir) {
   return {
@@ -17,48 +25,247 @@ export function paths(dir) {
     key: join(dir, 'key.json'),
     policy: join(dir, 'policy.json'),
     rules: join(dir, 'rules.json'),
+    fsPaths: join(dir, 'paths.json'),
+    uiIndex: join(dir, 'ui-index.json'),
     ledger: join(dir, 'ledger.jsonl'),
     config: join(dir, 'config.json'),
     lock: join(dir, 'lock'),
+    policies: join(dir, 'policies'),
+    tools: join(dir, 'tools.json'),
+    toolLock: join(dir, 'tools.lock.json'),
+    toolsSnapshots: join(dir, 'tools'),
+    mcpSnapshots: join(dir, 'mcp'),
   };
 }
 
 const readJson = (path) => JSON.parse(readFileSync(path, 'utf8'));
 
+// In-process monitoring: no dependency, no output, no cost when nobody listens.
+const decisionChannel = channel('bounds.decision');
+
+function publishDecision(entry) {
+  if (!decisionChannel.hasSubscribers) return;
+  try {
+    decisionChannel.publish({
+      seq: entry.seq,
+      at: entry.at,
+      action: entry.action,
+      decision: entry.decision,
+      code: entry.code,
+      rule: entry.rule ?? null,
+      capability: entry.capability ?? null,
+      trust: entry.trust ?? null,
+      args_hash: entry.args_hash ?? null,
+      policy_digest: entry.policy_digest,
+      rules_digest: entry.rules_digest ?? null,
+      tools_digest: entry.tools_digest ?? null,
+      tool_pin: entry.tool_pin ?? null,
+      mcp_digest: entry.mcp_digest ?? null,
+      entry_hash: entryHash(entry),
+      kid: entry.kid,
+    });
+  } catch {
+    // publish runs subscribers synchronously; a subscriber that throws is a bug
+    // in the subscriber, not a reason to fail the decision that was recorded.
+  }
+}
+
 function writeJson(path, value) {
-  const temporary = `${path}.tmp`;
-  writeFileSync(temporary, `${JSON.stringify(value, null, 2)}\n`, { mode: 0o600 });
+  const temporary = `${path}.${process.pid}.tmp`;
+  const text = `${JSON.stringify(value, null, 2)}\n`;
+  const handle = openSync(temporary, 'w', 0o600);
+  try {
+    writeFileSync(handle, text);
+    fsyncSync(handle);
+  } finally {
+    closeSync(handle);
+  }
   renameSync(temporary, path);
+  fsyncDir(dirname(path));
+}
+
+function writeEntry(file, entry) {
+  const handle = openSync(file.ledger, 'a', 0o600);
+  try {
+    writeFileSync(handle, `${JSON.stringify(entry)}\n`);
+    fsyncSync(handle);
+  } finally {
+    closeSync(handle);
+  }
+}
+
+function readAt(fd, buffer, position) {
+  let offset = 0;
+  while (offset < buffer.length) {
+    const bytes = readSync(fd, buffer, offset, buffer.length - offset, position + offset);
+    if (bytes === 0) break;
+    offset += bytes;
+  }
+  return offset;
+}
+
+// A crash can leave a line without its newline. A parseable line is kept (its
+// signature still decides whether it counts); an unparseable tail was never an
+// entry and is dropped. The head count is untouched, so a real truncation still
+// fails the append instead of being papered over. This reads backwards so an
+// old ledger is not loaded into memory just to repair its last line.
+function repairTornTail(file) {
+  const size = statSync(file.ledger).size;
+  if (size === 0) return;
+  const fd = openSync(file.ledger, 'r+');
+  try {
+    const last = Buffer.alloc(1);
+    readAt(fd, last, size - 1);
+    if (last[0] === 0x0a) return;
+
+    let newline = -1;
+    let end = size - 1;
+    while (end >= 0 && newline === -1) {
+      const start = Math.max(0, end - 64 * 1024 + 1);
+      const chunk = Buffer.alloc(end - start + 1);
+      readAt(fd, chunk, start);
+      const at = chunk.lastIndexOf(0x0a);
+      if (at !== -1) newline = start + at;
+      end = start - 1;
+    }
+    const cut = newline + 1;
+    const tail = Buffer.alloc(size - cut);
+    readAt(fd, tail, cut);
+    let complete = false;
+    try {
+      JSON.parse(tail.toString('utf8'));
+      complete = true;
+    } catch {
+      // The tail is a partial write, not an entry.
+    }
+    if (complete) {
+      const handle = openSync(file.ledger, 'a', 0o600);
+      try {
+        writeFileSync(handle, '\n');
+        fsyncSync(handle);
+      } finally {
+        closeSync(handle);
+      }
+      return;
+    }
+    ftruncateSync(fd, cut);
+    fsyncSync(fd);
+  } finally {
+    closeSync(fd);
+  }
+}
+
+// A rename is durable once the directory entry is flushed; Windows cannot open a
+// directory for fsync, so this is best-effort there.
+function fsyncDir(path) {
+  let handle;
+  try {
+    handle = openSync(path, 'r');
+    fsyncSync(handle);
+  } catch {
+    // Directory fsync is unavailable on this platform; the file fsync still ran.
+  } finally {
+    if (handle !== undefined) closeSync(handle);
+  }
+}
+
+// A decision names the exact policy and rules bytes that judged it, so a receipt
+// can carry them later. Content addressed, written once, never rewritten.
+const snapshotBase = (dir, kind) => (kind === 'tools' ? paths(dir).toolsSnapshots : paths(dir).policies);
+const snapshotFile = (dir, digest, kind) => join(snapshotBase(dir, kind), `${digest}.json`);
+
+function writeSnapshot(dir, digest, value, kind = 'policy') {
+  const file = snapshotFile(dir, digest, kind);
+  if (existsSync(file)) return;
+  mkdirSync(snapshotBase(dir, kind), { recursive: true, mode: 0o700 });
+  writeJson(file, value);
+}
+
+export function readToolLock(dir) {
+  const file = paths(dir).toolLock;
+  return existsSync(file) ? JSON.parse(readFileSync(file, 'utf8')) : null;
+}
+
+export function writeToolLock(dir, lock) {
+  return withLock(dir, () => {
+    writeJson(paths(dir).toolLock, lock);
+    return lock;
+  });
+}
+
+export function writeMcpManifest(dir, manifest) {
+  const digest = manifestDigest(manifest);
+  writeSnapshot(dir, digest, manifest, 'mcp');
+  return digest;
 }
 
 export function isInitialised(dir) {
   return existsSync(paths(dir).key);
 }
 
-export function init(dir) {
+export function readKey(dir) {
+  return readJson(paths(dir).key);
+}
+
+export function readConfig(dir) {
+  return readJson(paths(dir).config);
+}
+
+export function readSnapshot(dir, digest, kind = 'policy') {
+  const file = snapshotFile(dir, digest, kind);
+  if (!existsSync(file)) throw new Error(`SNAPSHOT_MISSING: ${kind} ${digest} was not archived with this entry`);
+  return readJson(file);
+}
+
+export function init(dir, { profile = 'balanced' } = {}) {
   if (isInitialised(dir)) {
     throw new Error(`${dir} already holds a ledger; refusing to replace its key`);
   }
+  const rules = rulesForProfile(profile);
   mkdirSync(dir, { recursive: true, mode: 0o700 });
-  const file = paths(dir);
-  const key = newSigningKey();
-  writeJson(file.key, { version: 1, kid: key.kid, public: key.publicPem, private: key.privatePem });
-  // Record everything by default and let rules.json decide: a policy that names
-  // one action refuses every other action, so a fresh install could not log the
-  // very commands its own README shows.
-  writeJson(file.policy, {
-    version: 1,
-    action: '*',
+  return withLock(dir, () => {
+    // Two processes that saw an empty directory must not both create a key.
+    // The first one wins; the second sees the key under the same lock.
+    if (isInitialised(dir)) {
+      throw new Error(`${dir} already holds a ledger; refusing to replace its key`);
+    }
+    const file = paths(dir);
+    const key = newSigningKey();
+    // Record everything by default and let rules.json decide: a policy that names
+    // one action refuses every other action, so a fresh install could not log the
+    // very commands its own README shows.
+    writeJson(file.policy, {
+      version: 1,
+      action: '*',
+    });
+    writeJson(file.config, { version: 1, head: { count: 0, hash: 'genesis' } });
+    writeJson(file.tools, DEFAULT_TOOLS);
+    writeJson(file.rules, rules);
+    writeFileSync(file.ledger, '', { mode: 0o600 });
+    // The key is the readiness marker; writing it last means a crash during init
+    // leaves a directory that is still uninitialised, not one that half works.
+    writeJson(file.key, { version: 1, kid: key.kid, public: key.publicPem, private: key.privatePem });
+    return { dir, kid: key.kid, profile };
   });
-  writeJson(file.config, { version: 1, head: { count: 0, hash: 'genesis' } });
-  writeJson(file.rules, {
-    version: 1,
-    rules: [
-      { id: 'no-send-after-untrusted-read', deny: { capabilities: ['send', 'execute'] }, if_path: { trust: 'untrusted', capability: 'read' } },
-    ],
+}
+
+// An existing ledger can adopt a shipped profile without touching its key,
+// head or entries. The previous rules stay beside the ledger for rollback.
+export function setRulesProfile(dir, profile = 'balanced') {
+  const next = rulesForProfile(profile);
+  validateRules(next);
+  return withLock(dir, () => {
+    const file = paths(dir);
+    const previous = existsSync(file.rules) ? readFileSync(file.rules, 'utf8') : null;
+    const previousDigest = previous === null ? undefined : rulesDigest(JSON.parse(previous));
+    const nextDigest = rulesDigest(next);
+    if (previousDigest === nextDigest) {
+      return { profile, changed: false, previous: previousDigest, digest: nextDigest };
+    }
+    if (previous !== null) renameSync(file.rules, `${file.rules}.bak`);
+    writeJson(file.rules, next);
+    return { profile, changed: true, previous: previousDigest, digest: nextDigest };
   });
-  writeFileSync(file.ledger, '', { mode: 0o600 });
-  return { dir, kid: key.kid };
 }
 
 export function readState(dir) {
@@ -75,16 +282,43 @@ export function readState(dir) {
 export function readEntries(dir) {
   const text = readFileSync(paths(dir).ledger, 'utf8');
   if (text === '') return [];
-  return text
-    .split('\n')
-    .filter((line) => line !== '')
-    .map((line, index) => {
-      try {
-        return JSON.parse(line);
-      } catch {
-        throw new Error(`ledger line ${index + 1} is not JSON; the file was edited or truncated mid-line`);
-      }
+  const lines = text.split('\n');
+  const trailing = lines.pop();
+  const entries = lines.map((line, index) => parseLine(line, index + 1));
+  // A reader can catch an append mid-line. A partial tail is not an entry and
+  // is ignored; the recorded head still makes a real truncation visible.
+  if (trailing !== '') {
+    const entry = parseTail(trailing, lines.length + 1);
+    if (entry !== undefined) entries.push(entry);
+  }
+  return entries;
+}
+
+// Stream the same checks verifyChain performs over an array. This is the
+// path that keeps a year-old ledger from being loaded into memory at once.
+export async function verifyLedger(dir) {
+  const file = paths(dir);
+  let key;
+  let head;
+  try {
+    key = readKey(dir);
+    head = readConfig(dir).head;
+  } catch (error) {
+    return { ok: false, reason: error.message };
+  }
+  let previous = 'genesis';
+  let count = 0;
+  try {
+    await forEachEntry(file.ledger, (entry, index) => {
+      const step = verifyStep(entry, index - 1, previous, key.public);
+      if (!step.ok) throw new Error(step.reason);
+      previous = step.hash;
+      count = index;
     });
+  } catch (error) {
+    return { ok: false, reason: error.message, kid: key.kid };
+  }
+  return { ...verifyHead(count, previous, head), kid: key.kid, count };
 }
 
 function processAlive(pid) {
@@ -96,51 +330,170 @@ function processAlive(pid) {
   }
 }
 
+// A writer waits for a live holder instead of failing the decision. The process
+// is short-lived, so a synchronous sleep is the simplest correct backoff.
+function sleepSync(ms) {
+  Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+}
+
+const LOCK_WAIT_MS = () => Number(process.env.ATTESSO_LOCK_WAIT_MS ?? 5000);
+const LOCK_RETRY_MS = 25;
+
+// Create the lock with its owner already inside, then link it into place. A
+// plain O_EXCL create leaves an empty file for a moment, and a waiter that reads
+// it in that window would reclaim a live lock. The token lets the holder remove
+// only its own lock, never one a later process created after reclaiming it.
+function acquireLock(lock) {
+  const token = `${process.pid}.${randomBytes(6).toString('hex')}`;
+  const candidate = `${lock}.${token}`;
+  const handle = openSync(candidate, 'wx', 0o600);
+  try {
+    writeFileSync(handle, token);
+    fsyncSync(handle);
+  } finally {
+    closeSync(handle);
+  }
+  try {
+    linkSync(candidate, lock);
+    return token;
+  } catch (error) {
+    if (error.code === 'EEXIST') return null;
+    throw error;
+  } finally {
+    try {
+      unlinkSync(candidate);
+    } catch {
+      // The candidate was already removed; the lock name is what matters.
+    }
+  }
+}
+
 function withLock(dir, run) {
   const { lock } = paths(dir);
-  for (let attempt = 0; attempt < 2; attempt += 1) {
-    try {
-      const handle = openSync(lock, 'wx', 0o600);
-      writeSync(handle, String(process.pid));
-      closeSync(handle);
+  const deadline = Date.now() + LOCK_WAIT_MS();
+  for (;;) {
+    const token = acquireLock(lock);
+    if (token) {
       try {
         return run();
       } finally {
-        unlinkSync(lock);
+        try {
+          if (readFileSync(lock, 'utf8').trim() === token) unlinkSync(lock);
+        } catch {
+          // The lock is already gone; nothing to undo.
+        }
       }
-    } catch (error) {
-      if (error.code !== 'EEXIST') throw error;
-      const holder = Number(readFileSync(lock, 'utf8'));
-      if (!processAlive(holder)) {
-        unlinkSync(lock);
+    }
+    let raw = '';
+    try {
+      raw = readFileSync(lock, 'utf8').trim();
+    } catch {
+      // The holder released it between link and read; retry immediately.
+      continue;
+    }
+    const holder = Number(raw.split('.')[0]);
+    if (raw === '' || !Number.isInteger(holder) || holder <= 0) {
+      throw new Error(`the ledger lock at ${lock} has no owner; remove it if no attesso process is running`);
+    }
+    if (!processAlive(holder)) {
+      // Only unlink the lock we judged stale, not one a new holder just linked.
+      let current = '';
+      try {
+        current = readFileSync(lock, 'utf8').trim();
+      } catch {
         continue;
       }
+      if (current === raw) {
+        try {
+          unlinkSync(lock);
+        } catch {
+          // Someone else reclaimed it first; the next iteration takes it.
+        }
+      }
+      continue;
+    }
+    if (Date.now() >= deadline) {
       throw new Error(`another attesso process (pid ${holder}) holds the ledger; retry when it finishes`);
     }
+    sleepSync(LOCK_RETRY_MS + Math.floor(Math.random() * LOCK_RETRY_MS));
+  }
+}
+
+export function withLedgerLock(dir, run) {
+  return withLock(dir, run);
+}
+
+// A crash can leave signed lines whose head update never landed. Verify the
+// tail while collecting only the task history the rules need, so append does
+// not hold the whole ledger in memory.
+function reconcileHead(dir, head, task, publicPem) {
+  let count = 0;
+  let lastHash = head.hash;
+  const history = [];
+  forEachEntrySync(paths(dir).ledger, (entry, index) => {
+    count = index;
+    if (index > head.count) {
+      if (entry.seq !== index) throw new Error(`entry ${index} carries seq ${entry.seq}`);
+      if (entry.prev !== lastHash) throw new Error(`entry ${entry.seq} does not chain to the entry before it`);
+      if (!verifyEntry(entry, publicPem)) throw new Error(`entry ${entry.seq} signature does not verify`);
+      lastHash = entryHash(entry);
+    }
+    if ((entry.task ?? null) === (task ?? null)) history.push(entry);
+  });
+  if (count < head.count) {
+    throw new Error(`config records ${head.count} entries, the log holds ${count}; the ledger was truncated`);
   }
-  throw new Error('could not take the ledger lock');
+  if (count === head.count) return { head, history };
+  const repaired = { count, hash: lastHash };
+  writeJson(paths(dir).config, { version: 1, head: repaired });
+  return { head: repaired, history };
 }
 
-export function append(dir, proposal, { now = new Date() } = {}) {
+export function append(dir, proposal, { now = new Date(), control } = {}) {
   return withLock(dir, () => {
     const file = paths(dir);
+    repairTornTail(file);
     const key = readJson(file.key);
     const config = readJson(file.config);
     const policy = validatePolicy(readJson(file.policy));
     const rules = existsSync(file.rules) ? validateRules(readJson(file.rules)) : null;
-    const history = readEntries(dir).filter((entry) => (entry.task ?? null) === (proposal.task ?? null));
-    const policyVerdict = evaluate(policy, proposal, now);
-    const pathVerdict = policyVerdict.decision === 'ALLOW'
-      ? evaluatePath(rules, history, proposal, now)
+    const pathConfig = existsSync(file.fsPaths) ? validatePathsConfig(readJson(file.fsPaths)) : null;
+    const tools = loadTools(dir);
+    const toolsHash = toolsDigest(tools);
+    const toolLock = readToolLock(dir);
+    const toolHash =
+      typeof proposal.tool_hash === 'string' && proposal.tool_hash !== ''
+        ? proposal.tool_hash
+        : typeof proposal.tool_definition_hash === 'string' && proposal.tool_definition_hash !== ''
+          ? proposal.tool_definition_hash
+          : undefined;
+    const mcpDigest =
+      typeof proposal.mcp_digest === 'string' && proposal.mcp_digest !== '' ? proposal.mcp_digest : undefined;
+    const toolVerdict = toolGate(toolLock, toolsHash, { ...proposal, tool_hash: toolHash });
+    const policyHash = policyDigest(policy);
+    const rulesHash = rules ? rulesDigest(rules) : undefined;
+    const reconciled = reconcileHead(dir, config.head, proposal.task ?? null, key.public);
+    const head = reconciled.head;
+    const history = reconciled.history;
+    const controlVerdict = control
+      ? {
+          decision: 'DENY',
+          code: control.mode === 'stop' ? 'TASK_STOPPED' : 'TASK_PAUSED',
+          rule: `control.${control.mode}`,
+        }
       : null;
-    const verdict = pathVerdict ?? policyVerdict;
-    const meta = pathVerdict?.tainted_by === undefined
-      ? proposal.meta
-      : { ...(proposal.meta ?? {}), rule: pathVerdict.rule, tainted_by: pathVerdict.tainted_by };
-    const seq = config.head.count + 1;
+    const pathVerdict = pathConfig ? evaluatePathScope(pathConfig, proposal) : null;
+    const verdict = controlVerdict ?? toolVerdict ?? pathVerdict ?? decide({ policy, rules, history, proposal, now });
+    const toolPin = toolLock
+      ? (toolVerdict?.tool_pin ?? (toolHash ? 'verified' : 'unverified'))
+      : undefined;
+    const meta = { ...(proposal.meta ?? {}) };
+    const argsHash = proposal.args_hash ?? meta.args_hash;
+    delete meta.args_hash;
+    const seq = head.count + 1;
     const entry = buildEntry({
       seq,
-      prev: config.head.hash,
+      prev: head.hash,
       action: proposal.action,
       subject: proposal.subject,
       amount: proposal.amount,
@@ -150,18 +503,26 @@ export function append(dir, proposal, { now = new Date() } = {}) {
       capability: proposal.capability,
       decision: verdict.decision,
       code: verdict.code,
-      policyDigest: policyDigest(policy),
+      rule: verdict.rule,
+      taintedBy: verdict.tainted_by,
+      argsHash,
+      policyDigest: policyHash,
+      rulesDigest: rulesHash,
+      toolsDigest: toolsHash,
+      toolHash,
+      toolPin,
+      mcpDigest,
+      control,
       kid: key.kid,
       at: now.toISOString(),
     });
     entry.sig = signEntry(entry, key.private);
-    const handle = openSync(file.ledger, 'a', 0o600);
-    try {
-      writeSync(handle, `${JSON.stringify(entry)}\n`);
-    } finally {
-      closeSync(handle);
-    }
+    writeSnapshot(dir, policyHash, policy);
+    if (rules) writeSnapshot(dir, rulesHash, rules);
+    writeSnapshot(dir, toolsHash, tools, 'tools');
+    writeEntry(file, entry);
     writeJson(file.config, { version: 1, head: { count: seq, hash: entryHash(entry) } });
+    publishDecision(entry);
     return entry;
   });
 }

package/src/stream.mjs

@@ -0,0 +1,72 @@
+// Read a JSONL ledger one line at a time. The rules match readEntries: a
+// complete malformed line is corruption, a malformed final fragment is a writer
+// caught mid-line and is ignored, and a parseable fragment without a newline is
+// still an entry.
+import { closeSync, createReadStream, openSync, readSync } from 'node:fs';
+import { StringDecoder } from 'node:string_decoder';
+import { parseLine, parseTail } from './jsonl.mjs';
+
+// The async reader feeds report and verify; append needs the same byte-exact
+// framing without turning every caller into an async function.
+export function forEachEntrySync(file, onEntry, { startOffset = 0 } = {}) {
+  const fd = openSync(file, 'r');
+  const decoder = new StringDecoder('utf8');
+  const chunk = Buffer.alloc(64 * 1024);
+  let buffer = '';
+  let index = 0;
+  let offset = startOffset;
+  let readOffset = startOffset;
+  try {
+    let bytes;
+    while ((bytes = readSync(fd, chunk, 0, chunk.length, readOffset)) > 0) {
+      readOffset += bytes;
+      buffer += decoder.write(chunk.subarray(0, bytes));
+      let newline;
+      while ((newline = buffer.indexOf('\n')) !== -1) {
+        const line = buffer.slice(0, newline);
+        buffer = buffer.slice(newline + 1);
+        const start = offset;
+        offset += Buffer.byteLength(line, 'utf8') + 1;
+        index += 1;
+        const keep = onEntry(parseLine(line, index), index, start, offset);
+        if (keep === false) return;
+      }
+    }
+    buffer += decoder.end();
+    if (buffer !== '') {
+      const start = offset;
+      offset += Buffer.byteLength(buffer, 'utf8');
+      const entry = parseTail(buffer, index + 1);
+      if (entry !== undefined) onEntry(entry, index + 1, start, offset);
+    }
+  } finally {
+    closeSync(fd);
+  }
+}
+
+export async function forEachEntry(file, onEntry) {
+  const stream = createReadStream(file);
+  const decoder = new StringDecoder('utf8');
+  let buffer = '';
+  let index = 0;
+
+  const handle = async (line, tail) => {
+    index += 1;
+    const entry = tail ? parseTail(line, index) : parseLine(line, index);
+    if (entry === undefined) return;
+    await onEntry(entry, index);
+  };
+
+  for await (const chunk of stream) {
+    buffer += decoder.write(chunk);
+    let at = buffer.indexOf('\n');
+    while (at !== -1) {
+      const line = buffer.slice(0, at);
+      buffer = buffer.slice(at + 1);
+      await handle(line, false);
+      at = buffer.indexOf('\n');
+    }
+  }
+  buffer += decoder.end();
+  if (buffer !== '') await handle(buffer, true);
+}