pi-supernova 0.5.0 → 0.7.0

package/src/output/format.js

@@ -1,20 +1,20 @@
 import { isString, isObject } from "../shared/decode.js";
 
-export function truncateChars(text, maxChars, label = "value") {
-  const normalized = isString(text) ? text : String(text ?? "");
+function normalizeText(text) {
+  return isString(text) ? text : String(text ?? "");
+}
+
+function charLimit(maxChars, length) {
   const numericLimit = Number(maxChars);
-  const limit = Number.isFinite(numericLimit) ? Math.max(0, Math.floor(numericLimit)) : numericLimit === Infinity ? normalized.length : 0;
 
-  if (normalized.length <= limit) return { text: normalized, truncated: false };
+  return Number.isFinite(numericLimit) ? Math.max(0, Math.floor(numericLimit)) : numericLimit === Infinity ? length : 0;
+}
 
-  if (limit <= 100) {
-    return {
-      text: normalized.slice(0, headEnd(normalized, limit)),
-      truncated: true,
-      originalChars: normalized.length,
-    };
-  }
+function truncatedSlice(text, end) {
+  return { text: text.slice(0, headEnd(text, end)), truncated: true, originalChars: text.length };
+}
 
+function truncateHeadTail(normalized, limit, label) {
   let head = headEnd(normalized, Math.floor(limit * 0.7));
   let tail = 0;
   let marker = "";
@@ -23,7 +23,7 @@ export function truncateChars(text, maxChars, label = "value") {
     const omitted = normalized.length - head - tail;
     marker = "\n…[" + label + " truncated " + omitted + " chars]…\n";
 
-    if (marker.length > limit) return { text: normalized.slice(0, headEnd(normalized, limit)), truncated: true, originalChars: normalized.length };
+    if (marker.length > limit) return truncatedSlice(normalized, limit);
     const budget = limit - marker.length;
     const nextHead = headEnd(normalized, Math.min(head, budget));
     const nextTail = normalized.length - tailStartIndex(normalized, Math.max(0, budget - nextHead));
@@ -36,6 +36,17 @@ export function truncateChars(text, maxChars, label = "value") {
   return { text: normalized.slice(0, head) + marker + normalized.slice(normalized.length - tail), truncated: true, originalChars: normalized.length };
 }
 
+export function truncateChars(text, maxChars, label = "value") {
+  const normalized = normalizeText(text);
+  const limit = charLimit(maxChars, normalized.length);
+
+  if (normalized.length <= limit) return { text: normalized, truncated: false };
+
+  if (limit <= 100) return truncatedSlice(normalized, limit);
+
+  return truncateHeadTail(normalized, limit, label);
+}
+
 // Lone surrogates in a tool result make the message invalid UTF-8 at the API
 // boundary, so a cut must never split a surrogate pair.
 function headEnd(text, end) {
@@ -90,35 +101,35 @@ export function formatBoundedStringArray(values, budget) {
   return out;
 }
 
-/** Lossless framing for source arrays, not string escaping or source compression. */
-export function formatReturn(value) {
-  if (isString(value)) return value;
+function formatRawStringArray(value) {
+  if (!(Array.isArray(value) && value.length && hasWellFormedStrings(value) && value.some(text => text.includes("\n")))) return null;
+  const raw = "strings[" + value.length + "]\n" + value.map((text, i) => "[" + i + "] " + text.length + " UTF-16 units\n" + text + "\n").join("");
+  const escapedSize = value.reduce((sum, text) => sum + JSON.stringify(text).length, value.length + 1);
 
-  if (Array.isArray(value) && value.length && hasWellFormedStrings(value) && value.some(text => text.includes("\n"))) {
-    const raw = "strings[" + value.length + "]\n" + value.map((text, i) => "[" + i + "] " + text.length + " UTF-16 units\n" + text + "\n").join("");
-    const escapedSize = value.reduce((sum, text) => sum + JSON.stringify(text).length, value.length + 1);
-
-    if (raw.length < escapedSize) return raw;
-  }
+  return raw.length < escapedSize ? raw : null;
+}
 
-  const escaped = formatValue(value);
-  const strings = [];
+function shouldFrameRaw(input) {
+  return isString(input) && input.includes("\n") && !hasUnpairedSurrogate(input) && JSON.stringify(input).length - input.length > 64;
+}
 
-  const visit = input => {
-    if (isString(input) && input.includes("\n") && !hasUnpairedSurrogate(input) && JSON.stringify(input).length - input.length > 64) {
-      const index = strings.push(input) - 1;
+function visitRawStrings(input, strings) {
+  if (shouldFrameRaw(input)) {
+    const index = strings.push(input) - 1;
 
-      return { [RAW_TEXT]: "raw[" + index + "]" };
-    }
+    return { [RAW_TEXT]: "raw[" + index + "]" };
+  }
 
-    if (Array.isArray(input)) return input.map(visit);
+  if (Array.isArray(input)) return input.map(child => visitRawStrings(child, strings));
 
-    if (isObject(input)) return Object.fromEntries(Object.entries(input).map(([key, child]) => [key, visit(child)]));
+  if (isObject(input)) return Object.fromEntries(Object.entries(input).map(([key, child]) => [key, visitRawStrings(child, strings)]));
 
-    return input;
-  };
+  return input;
+}
 
-  const referencedValue = visit(value);
+function framedReturn(value, escaped) {
+  const strings = [];
+  const referencedValue = visitRawStrings(value, strings);
 
   if (!strings.length) return escaped;
   // Keep every key, value, duplicate string and byte. References are unquoted
@@ -128,6 +139,16 @@ export function formatReturn(value) {
   return framed.length < escaped.length ? framed : escaped;
 }
 
+/** Lossless framing for source arrays, not string escaping or source compression. */
+export function formatReturn(value) {
+  if (isString(value)) return value;
+  const rawArray = formatRawStringArray(value);
+
+  if (rawArray !== null) return rawArray;
+
+  return framedReturn(value, formatValue(value));
+}
+
 const RAW_TEXT = Symbol("raw text reference");
 
 const IDENT_KEY = /^[A-Za-z_$][\w$]*$/;
@@ -143,7 +164,8 @@ function formatPrimitive(value) {
 
   if (Number.isNaN(value) || value === Infinity || value === -Infinity) return String(value);
 
-  return JSON.stringify(value) ?? String(value);
+  try { return JSON.stringify(value) ?? String(value); }
+  catch { return String(value); }
 }
 
 /**
@@ -168,28 +190,24 @@ function formatFlatWithin(value, limit) {
     return true;
   };
 
-  return walkFlat(value, push) ? parts.join("") : null;
+  return walkFlat(value, push, new Set()) ? parts.join("") : null;
 }
 
-function walkFlat(value, push) {
-  if (value?.[RAW_TEXT] !== undefined) return push(value[RAW_TEXT]);
-
-  if (!isObject(value) && !Array.isArray(value)) return push(formatPrimitive(value));
-
-  if (Array.isArray(value)) {
-    if (value.length === 0) return push("[]");
-
-    if (!push("[")) return false;
+function walkFlatArray(value, push, seen) {
+  if (value.length === 0) return push("[]");
 
-    for (let i = 0; i < value.length; i++) {
-      if (i && !push(",")) return false;
+  if (!push("[")) return false;
 
-      if (!walkFlat(value[i] === undefined ? null : value[i], push)) return false;
-    }
+  for (let i = 0; i < value.length; i++) {
+    if (i && !push(",")) return false;
 
-    return push("]");
+    if (!walkFlat(value[i] === undefined ? null : value[i], push, seen)) return false;
   }
 
+  return push("]");
+}
+
+function walkFlatObject(value, push, seen) {
   const keys = Object.keys(value).filter((key) => value[key] !== undefined);
 
   if (keys.length === 0) return push("{}");
@@ -197,36 +215,67 @@ function walkFlat(value, push) {
   for (let i = 0; i < keys.length; i++) {
     if (!push((i ? "," : "{") + formatKey(keys[i]) + ":")) return false;
 
-    if (!walkFlat(value[keys[i]], push)) return false;
+    if (!walkFlat(value[keys[i]], push, seen)) return false;
   }
 
   return push("}");
 }
 
+function walkFlat(value, push, seen) {
+  if (value?.[RAW_TEXT] !== undefined) return push(value[RAW_TEXT]);
+
+  if (!isObject(value) && !Array.isArray(value)) return push(formatPrimitive(value));
+
+  if (seen.has(value)) return push("[Circular]");
+  seen.add(value);
+
+  try {
+    return Array.isArray(value) ? walkFlatArray(value, push, seen) : walkFlatObject(value, push, seen);
+  } finally {
+    seen.delete(value);
+  }
+}
+
+function definedKeys(value) {
+  return Object.keys(value).filter((key) => value[key] !== undefined);
+}
+
+function formatArray(value, indent, width, seen) {
+  if (value.length === 0) return "[]";
+  const pad = indent + " ";
+
+  return "[\n" + value.map((item) => pad + formatValue(item === undefined ? null : item, pad, width, seen)).join(",\n") + "\n" + indent + "]";
+}
+
+function formatObject(value, indent, width, seen) {
+  const keys = definedKeys(value);
+
+  if (keys.length === 0) return "{}";
+  const pad = indent + " ";
+
+  return "{\n" + keys.map((key) => pad + formatKey(key) + ":" + formatValue(value[key], pad, width, seen)).join(",\n") + "\n" + indent + "}";
+}
+
 /**
  * Compact JS-literal rendering for the model: containers that fit in FORMAT_WIDTH
  * stay on one line with no separator whitespace, identifier keys are unquoted,
  * indent is one space. Whitespace is what costs tokens: this measures ~43% fewer
  * than JSON.stringify(value, null, 2) on typical shaped returns (gpt-tokenizer).
  */
-export function formatValue(value, indent = "", width = FORMAT_WIDTH) {
+export function formatValue(value, indent = "", width = FORMAT_WIDTH, seen = new Set()) {
   if (value?.[RAW_TEXT] !== undefined) return value[RAW_TEXT];
 
   if (!isObject(value) && !Array.isArray(value)) return formatPrimitive(value);
-  const flat = formatFlatWithin(value, width - indent.length);
+  if (seen.has(value)) return "[Circular]";
+  seen.add(value);
 
-  if (flat !== null) return flat;
-  const pad = indent + " ";
+  try {
+    const flat = formatFlatWithin(value, width - indent.length);
 
-  if (Array.isArray(value)) {
-    if (value.length === 0) return "[]";
+    if (flat !== null) return flat;
 
-    return "[\n" + value.map((item) => pad + formatValue(item === undefined ? null : item, pad, width)).join(",\n") + "\n" + indent + "]";
+    return Array.isArray(value) ? formatArray(value, indent, width, seen) : formatObject(value, indent, width, seen);
+  } finally {
+    seen.delete(value);
   }
-
-  const keys = Object.keys(value).filter((key) => value[key] !== undefined);
-
-  if (keys.length === 0) return "{}";
-
-  return "{\n" + keys.map((key) => pad + formatKey(key) + ":" + formatValue(value[key], pad, width)).join(",\n") + "\n" + indent + "}";
 }

package/src/runtime/guest-deny-imports.js

@@ -0,0 +1,34 @@
+/** Custom loader: guest programs cannot import host I/O modules. */
+import { isString } from "../shared/decode.js";
+
+const DENY = new Set([
+  "fs", "node:fs", "fs/promises", "node:fs/promises",
+  "child_process", "node:child_process",
+  "module", "node:module",
+  "worker_threads", "node:worker_threads",
+  "net", "node:net", "http", "node:http", "https", "node:https",
+  "os", "node:os", "vm", "node:vm",
+  "dgram", "node:dgram", "cluster", "node:cluster",
+  "inspector", "node:inspector", "sqlite", "node:sqlite",
+]);
+
+export function guestImportMessage(specifier) {
+  return "guest cannot import " + specifier + "; use read, edit, write, or bash";
+}
+
+export function isDeniedGuestImport(specifier) {
+  if (!isString(specifier)) return false;
+  const key = specifier.replace(/^node:/, "");
+
+  return DENY.has(specifier) || DENY.has("node:" + key) || DENY.has(key);
+}
+
+export async function resolve(specifier, context, nextResolve) {
+  if (isDeniedGuestImport(specifier)) {
+    const error = new Error(guestImportMessage(specifier));
+    error.code = "ERR_GUEST_IMPORT";
+    throw error;
+  }
+
+  return nextResolve(specifier, context);
+}