pi-supernova 0.9.1 → 0.10.0

package/src/fs/workspace.js

@@ -1,4 +1,5 @@
 import {remapReadError} from "./file-io.js";
+import { retireProcessTree } from "./process-tree.js";
 import * as fs from "node:fs/promises";
 import * as path from "node:path";
 import { spawn } from "node:child_process";
@@ -45,7 +46,7 @@ async function realpathNearest(target) {
     try {
       return await fs.realpath(probe);
     } catch (err) {
-      if (err?.code !== "ENOENT" && err?.code !== "ENOTDIR") remapReadError(err, target);
+      if (err?.code !== "ENOENT" && err?.code !== "ENOTDIR") await remapReadError(err, target);
       const parent = path.dirname(probe);
 
       if (parent === probe) throw err;
@@ -137,21 +138,22 @@ function commandTimeoutMs(options) {
   return Math.max(1, Math.min(2_147_483_647, Math.floor(requestedTimeout)));
 }
 
-function spawnCommand(argv, options, cwd) {
-  return spawn(argv[0], argv.slice(1), {
-    cwd, env: options.env ?? process.env, stdio: ["ignore", "pipe", "pipe"], detached: process.platform !== "win32",
-  });
-}
+export function commandSpawnError(error, command) {
+  if (error?.code === "EACCES" || error?.code === "EPERM") return new Error("cannot execute " + command + ": permission denied (is it executable?)");
 
-function signalProcessTree(child, signal) {
-  if (!child.pid) return;
+  if (error?.code === "ENOENT") return new Error("command not found: " + command);
 
-  if (process.platform === "win32") {
-    const killer = spawn("taskkill", ["/pid", String(child.pid), "/t", "/f"], { stdio: "ignore" });
-    killer.on("error", () => child.kill(signal));
-  } else {
-    try { process.kill(-child.pid, signal); } catch (err) { if (err.code !== "ESRCH") child.kill(signal); }
-  }
+  if (error?.code === "ENOTDIR") return new Error("cannot run " + command + ": the working directory is not a directory");
+
+  return error;
+}
+
+export function spawnCommand(argv, options, cwd = options.cwd) {
+  try {
+    return spawn(argv[0], argv.slice(1), {
+      cwd, env: options.env ?? process.env, stdio: options.stdio ?? ["ignore", "pipe", "pipe"], detached: process.platform !== "win32", windowsHide:true,
+    });
+  } catch (error) { throw commandSpawnError(error,argv[0]); }
 }
 
 function failCommand(state, error) {
@@ -171,11 +173,29 @@ function failCommand(state, error) {
 }
 
 function terminateCommand(state, error) {
-  if (state.settled || state.terminationError) return;
-  state.terminationError = error;
-  signalProcessTree(state.child, "SIGTERM");
-  // Keep ownership after the direct child exits: descendants may ignore SIGTERM.
-  state.escalation = setTimeout(() => { signalProcessTree(state.child, "SIGKILL"); failCommand(state, error); }, 150);
+  if (state.settled) return;
+  state.terminationError ??= error;
+
+  if (state.stopping) return;
+  clearTimeout(state.timer);
+  state.stopping = retireProcessTree(state).then(()=>{
+    if (state.terminationError) {
+      failCommand(state,state.terminationError);
+
+      return;
+    }
+
+    state.settled = true;
+    state.cleanup();
+    state.resolve({ stdout:state.stdout, stderr:state.stderr,
+      exitCode:state.exitCode ?? (128 + (constants.signals[state.signal] ?? 1)),
+      signal:state.signal, outputTruncated:state.outputTruncated });
+  }).catch(cause=>{
+    state.child.stdout.destroy();
+    state.child.stderr.destroy();
+    const prefix = state.terminationError ? state.terminationError.message + "; " : "";
+    failCommand(state,new Error(prefix + "command cleanup failed: " + cause.message));
+  });
 }
 
 function appendCommandOutput(state, current, chunk) {
@@ -186,33 +206,14 @@ function appendCommandOutput(state, current, chunk) {
   return remaining ? current + chunk.slice(0, remaining) : current;
 }
 
-function onCommandClose(state, code, signal) {
-  if (state.settled) return;
-
-  if (state.terminationError) {
-    // A closed pipe alone says nothing about descendants. Only ESRCH proves
-    // the owned POSIX group is gone; otherwise retain the escalation timer.
-    if (process.platform !== "win32" && state.child.pid) {
-      try { process.kill(-state.child.pid, 0); }
-      catch (error) { if (error.code === "ESRCH") failCommand(state, state.terminationError); }
-    }
-
-    return;
-  }
-
-  state.settled = true;
-  state.cleanup();
-  state.resolve({ stdout: state.stdout, stderr: state.stderr, exitCode: code ?? (128 + (constants.signals[signal] ?? 1)), signal, outputTruncated: state.outputTruncated });
-}
-
 function attachCommandIO(state, options, argv, timeoutMs) {
   const { child } = state;
   const onAbort = () => terminateCommand(state, new Error("aborted"));
   state.cleanup = () => {
     clearTimeout(state.timer);
-    clearTimeout(state.escalation);
     options.signal?.removeEventListener("abort", onAbort);
   };
+
   state.timer = setTimeout(() => terminateCommand(state, new Error(
     "command timed out after " + timeoutMs + "ms: " + truncateChars(options.commandLabel ?? argv.join(" "), 240, "command").text
     + "\nhint: Increase this bash timeoutMs and the outer supernova timeoutMs, or split the work. Sleeps and every command in a shell chain share the same limit."
@@ -221,13 +222,16 @@ function attachCommandIO(state, options, argv, timeoutMs) {
   child.stderr.setEncoding("utf8");
   child.stdout.on("data", chunk => { state.stdout = appendCommandOutput(state, state.stdout, chunk); });
   child.stderr.on("data", chunk => { state.stderr = appendCommandOutput(state, state.stderr, chunk); });
-  child.on("error", error => {
-    if (error?.code === "EACCES" || error?.code === "EPERM") failCommand(state, new Error("cannot execute " + argv[0] + ": permission denied (is it executable?)"));
-    else if (error?.code === "ENOENT") failCommand(state, new Error("command not found: " + argv[0]));
-    else if (error?.code === "ENOTDIR") failCommand(state, new Error("cannot run " + argv[0] + ": the working directory is not a directory"));
-    else failCommand(state, error);
+  child.on("error", error => failCommand(state,commandSpawnError(error,argv[0])));
+  child.once("exit", (code, signal) => {
+    state.processExited = true;
+    state.exitCode = code;
+    state.signal = signal;
+    // An orphan can retain the pipes forever. Begin retirement at leader exit,
+    // then wait for close and group disappearance before reporting completion.
+    terminateCommand(state);
   });
-  child.on("close", (code, signal) => onCommandClose(state, code, signal));
+  child.once("close", () => { state.processClosed = true; });
   options.signal?.addEventListener("abort", onAbort, { once: true });
 
   if (options.signal?.aborted) onAbort();
@@ -243,7 +247,8 @@ export async function runCommand(argv, options = {}) {
     const child = spawnCommand(argv, options, cwd);
     attachCommandIO({
       child, resolve, reject, stdout: "", stderr: "", settled: false,
-      outputTruncated: false, terminationError: undefined, escalation: undefined,
+      outputTruncated: false, terminationError: undefined, stopping: undefined,
+      groups:new Set(child.pid ? [child.pid] : []), killedGroups:new Set(),
       maxOutputChars, timer: undefined, cleanup() {},
     }, options, argv, timeoutMs);
   });

package/src/output/bottleneck.js

@@ -167,6 +167,7 @@ function packageBatchItems(batch, details, maxChars) {
   const itemErrors = (details.itemErrors ?? []).map(error => boundItemError(error, maxChars, batch.length));
   let remaining = maxChars;
   let truncated = false;
+
   const items = batch.map((item, index) => {
     const share = details.independent === true ? maxChars : Math.floor(remaining / (batch.length - index));
     const bounded = boundBatchItem(item, share);
@@ -223,14 +224,26 @@ function attachTruncation(result, truncated, batch, text, config, maxChars, capp
 
 export function packageHostResult(raw, config) {
   const details = detailsOf(raw);
+
   if (raw && Object.hasOwn(raw, READ_VALUE)) {
     const batch = batchFromDetails(details);
     const result = {ok: !hostResultFailed(raw), value: raw[READ_VALUE], typed: true, cloneItems: details?.jsonMany === true, truncated: details?.outputTruncated === true};
     attachDetails(result, details, batch);
-    if (batch) { result.items = batch; result.itemErrors = details.itemErrors ?? []; }
+
+    if (isString(details?.sourcePath)) result.sourcePath = details.sourcePath;
+
+    if (batch) {
+      result.items = batch;
+      result.itemErrors = details.itemErrors ?? [];
+
+      if (details.sourcePaths) result.sourcePaths = details.sourcePaths;
+    }
+
     if (details?.streamed) result.streamed = true;
+
     return result;
   }
+
   const maxChars = config.maxCallResultChars ?? 65536;
   const batch = batchFromDetails(details);
   const text = batch ? "" : extractRawString(raw);

package/src/runtime/guest-api.js

@@ -15,16 +15,20 @@ function unwrapValue(res) {
   return res;
 }
 
-function unwrapRead(res, args) {
+function unwrapRead(res, args, observe) {
   const value = unwrapValue(res);
 
   if ((args.complete === true || args.json !== undefined) && res?.truncated) throw new Error("incomplete read: complete:true or json refuses truncated host output");
 
-  return decodeReadItem(args, value, res);
+  const decoded = decodeReadItem(args, value, res);
+  observe?.(args,res);
+
+  return decoded;
 }
 
 function decodeReadItem(args, value, res) {
   if (!res?.typed) return decodeReadValue(args, value);
+
   // JSON selectors used to cross RPC as separately encoded JSON values. Keep
   // their mutable results independent, but put the copies in the guest heap.
   return res.cloneItems ? value.map(item => structuredClone(item)) : value;
@@ -59,18 +63,22 @@ function missingResolvedIndex(values, paths) {
 
 function settleReadItem(wave, index, res) {
   const job = wave[index];
+
   if (!job) throw new Error("invalid streamed read index: " + index);
   wave[index] = null; // Release resolver closures and their potentially large values.
-  try { job.resolve(unwrapRead(res,job.args)); }
+
+  try { job.resolve(unwrapRead(res,job.args,job.observe)); }
   catch (error) { job.reject(error); }
 }
 
 function settleInlineWave(wave,res,received) {
   unwrapValue(res);
+
   if (received || !Array.isArray(res.items) || res.items.length !== wave.length) throw new Error("invalid batch read response");
+
   for (let i=0;i<wave.length;i++) {
     const error = res.itemErrors?.[i];
-    settleReadItem(wave,i,{...res,ok:!error,value:error ?? res.items[i],items:undefined});
+    settleReadItem(wave,i,{...res,ok:!error,value:error ?? res.items[i],sourcePath:res.sourcePaths?.[i],items:undefined});
   }
 }
 
@@ -78,24 +86,32 @@ async function rpcReadWave(rpc, wave) {
   if (wave.length === 1) {
     const res = leanEnvelope(await rpc("call",["read",wave[0].args]));
     settleReadItem(wave,0,res);
+
     return;
   }
+
   const args = {...wave[0].args,path:wave.map(job=>job.args.path),_independent:true};
   let received = 0, last;
+
   const onItem = (index,res) => {
     if (!Number.isInteger(index) || !wave[index] || last?.index === index) throw new Error("invalid streamed read response");
     received++;
+
     // Keep the final read pending until the host RPC/barrier itself has settled.
     // An awaited batch must never look complete while its host call is running.
     if (received === wave.length) last = {index,res};
     else settleReadItem(wave,index,res);
   };
+
   const res = leanEnvelope(await rpc("call",["read",args],onItem));
+
   if (res?.streamed) {
     if (received !== wave.length || !last) throw new Error("incomplete streamed read response");
     settleReadItem(wave,last.index,last.res);
+
     return;
   }
+
   settleInlineWave(wave,res,received);
 }
 
@@ -118,7 +134,7 @@ function enqueueCompatibleRead(readState, flushReads, args) {
   if (readState.queued.length && readState.queued[0].key !== key) flushReads();
 
   const promise = new Promise((resolve, reject) => {
-    readState.queued.push({ args, key, resolve, reject });
+    readState.queued.push({ args, key, resolve, reject, observe:readState.observe });
 
     if (readState.queued.length === 1) queueMicrotask(flushReads);
   });
@@ -128,12 +144,16 @@ function enqueueCompatibleRead(readState, flushReads, args) {
 
 async function readManyPaths(readOne, args, paths) {
   assertReadPaths(paths);
+
   const values = await Promise.all(paths.map(async item => {
     try { return await readOne({...args,path:item}); }
     catch (error) { throwReadPathError(item,error.message); }
   }));
+
   const missing = args.resolve ? missingResolvedIndex(values,paths) : -1;
+
   if (missing >= 0) throwReadPathError(paths[missing],"not_found");
+
   return values;
 }
 
@@ -193,12 +213,13 @@ export function buildGuestApi(rpc, batchRead) {
     if (checkpoint) throw new Error("edit checkpoints cannot overlap or nest; await the current checkpoint");
     const token = {};
     checkpoint = token;
+
     try { return await runSpeculation(fn, token, checkpointScope, drainReads, rpc); }
     finally { checkpoint = null; }
   }
 
   // Coalesce already-started compatible reads without rewriting JS control flow.
-  const readState = { queued: [], waves: new Set() };
+  const readState = { queued: [], waves: new Set(), observe:noteReadPath };
 
   function flushReads() {
     const pending = readState.queued;
@@ -227,26 +248,21 @@ export function buildGuestApi(rpc, batchRead) {
     const args = normalizeRead(gatherReadArgs(p, a, b));
     p = args.path;
 
-    if (Array.isArray(p)) {
-      const values = await readManyPaths(read, args, p);
-      for (const item of p) if (isString(item)) noteReadPath({ path: item }, values);
-
-      return values;
-    }
+    if (Array.isArray(p)) return await readManyPaths(read, args, p);
 
-    const readValue = !batchRead
-      ? unwrapRead(await invoke("read", args), args)
+    return !batchRead
+      ? unwrapRead(await invoke("read", args), args, noteReadPath)
       : await enqueueCompatibleRead(readState, flushReads, args);
-    noteReadPath(args, readValue);
-
-    return readValue;
   };
 
   const readFiles = new Set();
 
-  function noteReadPath(args, value) {
-    if (isString(args.path) && looksLikePath(args.path)) readFiles.add(args.path);
-    if (isObject(value) && isString(value.path) && looksLikePath(value.path)) readFiles.add(value.path);
+  function noteReadPath(args, envelope) {
+    if (isString(args.path) && args.resolve !== true && args.query === undefined && args.evidence !== true) readFiles.add(args.path);
+
+    // A document may itself contain path/status fields. Only adapter provenance,
+    // carried separately through scalar, inline and streamed replies, names a read.
+    if (isString(envelope.sourcePath)) readFiles.add(envelope.sourcePath);
   }
 
   const write = async (p, content) => {

package/src/runtime/reference.js

@@ -1,16 +1,13 @@
 // Standing tool description: sent on every request. No result or history compression.
-export const REFERENCE = `JS body/async arrow: read/write/edit/bash; no fs/import/require. file: workspace scripts; data: literals (≤48000 JSON chars).
-read(path|paths,offset=1,limit?) → raw text/text[]; directories → entries; images: PNG/JPEG/GIF/WebP (≤16 images/20 MiB).
-Text ≤64 MiB internally; complete:true requires the whole file. Display alone is capped; return a summary or read(path,{offset:1,limit:80}). Larger files/JSONL: bounded bash parser.
-read({path,json:selector}) → parsed JSON: ".field", ".a[0:3]", ".a.length", quoted keys, true; input ≤16 MiB, selections ≤64 MiB storage, no jq. Values retain their types.
-read("symbol or question") = read({query,resolve:true}) → view; check status; view.text is a span, not the file.
-read(path,{about}) → windows; read({query,evidence:true}) → ranked evidence; read({path,outline:true}) → declarations.
-write(path,text) replaces unread workspace files; write({path,content,append:true}) appends without reading. After read: edit or replace:true.
-edit(path,oldText,newText) | edit({path,edits:[{oldText,newText}]}) unique exact read text; returns numbered windows/checks/references.
-edit(view,text) replaces span; edit(view,old,new) uniquely matches within it. edit(async()=>{...}) checkpoint: merge on success, rollback/rethrow on failure.
-bash(command,{cwd?,timeoutMs?}) | bash({command,args}) literal argv for scripts; bounded output, nonzero throws. Outer timeoutMs caps ALL waits/commands; bash inherits unless overridden.
-Edits commit on success/before bash. Promise.allSettled keeps partial results.
-programs:[{code?,file?,data?}] inherits source/data; entries override. mergeData:true shallow object merge (entry keys win).
-Promise.all: ≤8 reads or disjoint-file mutations; same-file serial; bash/checkpoint barriers.
-Fresh guests/separate commits. Sequential failure stops; prior commits stay. parallel:true for disjoint entries. ONE call for known work; split for new decisions.
+export const REFERENCE = `JS body/async arrow; read/write/edit/bash, no fs/import/require. file: workspace JS; data: literals ≤48000 JSON chars.
+read(path|paths,offset=1,limit?) → text/text[]; dirs→entries; PNG/JPEG/GIF/WebP ≤16/20MiB.
+Text ≤64 MiB internally; complete:true requires whole file. Display capped: summarize or read(path,{offset:1,limit:80}); larger files via bash.
+read({path,json:true|selector}) → JSON, no jq (16MiB input/64MiB selection). Values retain their types.
+read("symbol or question") = read({query,resolve:true}) → view; check status; view.text is a span. read(path,{about}) windows; read({query,evidence:true}) evidence; read({path,outline:true}) declarations.
+write/edit workspace-only; external changes need separately authorized command. write(path,text) or {path,content,append:true}; after read edit or replace:true.
+edit(path,oldText,newText) or {path,edits:[{oldText,newText}]}; unique exact match; numbered windows. edit(view,text) or edit(view,old,new). edit(async()=>{...}) checkpoint: no bash; merge/rollback+rethrow.
+bash(command,{cwd?,timeoutMs?}) or {command,args}; nonzero throws. Outer timeout bounds foreground; bash inherits. Shell mutations flush edits.
+bash({command,background:true,pty?:true,timeoutMs?:1800000})→sessionId. bash({action:"list"}) or {sessionId,action:"poll"|"write"|"stop",cursor?,waitMs?,input?}→status/output/cursor/exitCode. PTY macOS/Linux; jobs end at shutdown.
+programs:[{code?,file?,data?}] inherit defaults; mergeData:true shallow. Fresh guests/commits; sequential failure stops, prior commits stay; parallel:true disjoint work.
+Promise.all ≤8 disjoint reads/mutations; same-file serial; bash/checkpoints barriers. Optional reads: Promise.allSettled retains successes. ONE call for known work.
 `;

package/src/shared/syntax-context.js

@@ -1,12 +1,26 @@
+import stringWidth from "string-width";
+
 /** Bounded source context for parse and syntax diagnostics. */
+const JS_LINES = /\r\n|[\n\r\u2028\u2029]/;
+
+const JSON_LINES = /\r\n|[\n\r]/;
+
+// Source columns are UTF-16 offsets; expand controls identically before the
+// source token and the caret. JSON strings can contain literal Unicode LS/PS.
+const displaySource = text => text.replaceAll("\t","    ").replaceAll("\u2028","\\u2028").replaceAll("\u2029","\\u2029");
 
-export function sourceContext(source, line, column) {
+export function sourceContext(source, line, column, lineBreaks = JS_LINES) {
   if (!Number.isInteger(line) || line < 1) return "";
-  const text = String(source).split("\n")[line - 1];
+  const text = String(source).split(lineBreaks)[line - 1];
 
   if (text === undefined) return "";
-  const shown = text.length > 160 ? text.slice(0, 160) : text;
-  const caret = Number.isInteger(column) ? " ".repeat(Math.min(column, shown.length)) + "^" : "";
+  const located = Number.isInteger(column) && column >= 0;
+  const position = located ? Math.min(column, text.length) : 0;
+  const start = Math.max(0, Math.min(position - 80, text.length - 160));
+  const end = Math.min(text.length, start + 160);
+  const prefix = start > 0 ? "…" : "";
+  const shown = prefix + displaySource(text.slice(start, end)) + (end < text.length ? "…" : "");
+  const caret = located ? " ".repeat(stringWidth(prefix + displaySource(text.slice(start, position)))) + "^" : "";
 
   return "\n  " + shown + (caret ? "\n  " + caret : "");
 }
@@ -24,11 +38,12 @@ export function parsePosition(message, source) {
   const offsetMatch = /at position (\d+)/.exec(String(message));
 
   if (!offsetMatch) return null;
+
   return offsetPosition(source, Number(offsetMatch[1]));
 }
 
 function offsetPosition(source, offset) {
-  const lines = String(source).slice(0, offset).split("\n");
+  const lines = String(source).slice(0, offset).split(JSON_LINES);
 
   return { line: lines.length, column: lines.at(-1).length };
 }
@@ -37,6 +52,7 @@ function offsetPosition(source, offset) {
 // offsets. JSON.parse remains the authority; cap extra work at 65,536 characters.
 // eslint-disable-next-line no-control-regex -- RFC 8259 excludes unescaped control characters from strings.
 const JSON_TOKEN = /("(?:[^"\\\u0000-\u001f]|\\(?:["\\/bfnrt]|u[\da-fA-F]{4}))*")|(-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?)|(true|false|null)|[{}[\]:,]/y;
+
 const JSON_NEXT = {
   end: { eof: [] },
   value: { string: [], number: [], literal: [], "{": ["object"], "[": ["array"] },
@@ -67,9 +83,12 @@ function invalidJsonOffset(source) {
   while (stack.length) {
     const token = jsonTokenAt(source, offset);
     let state = stack.pop();
+
     if (state === "array" && token.kind !== "]") { stack.push("arrayNext"); state = "value"; }
+
     if (state === "object" && token.kind !== "}") state = "key";
     const next = JSON_NEXT[state][token.kind];
+
     if (!next) return token.start;
     stack.push(...next);
     offset = token.end;
@@ -80,10 +99,12 @@ function invalidJsonOffset(source) {
 
 export function jsonErrorContext(message, source) {
   const native = parsePosition(message, source);
-  if (native) return sourceContext(source, native.line, native.column);
+
+  if (native) return sourceContext(source, native.line, native.column, JSON_LINES);
   const offset = invalidJsonOffset(source);
+
   if (offset === null) return "";
   const { line, column } = offsetPosition(source, offset);
 
-  return " (near line " + line + " column " + (column + 1) + ")" + sourceContext(source, line, column);
+  return " (near line " + line + " column " + (column + 1) + ")" + sourceContext(source, line, column, JSON_LINES);
 }