@ian-pascoe/pi-codemode 0.2.0 → 0.3.0

package/src/codemode-worker.ts

@@ -1,3 +1,4 @@
+import { CODEMODE_CONSOLE_METHODS, type CodeModeConsoleEntry } from "./codemode-console-output.ts";
 import {
   CODEMODE_WORKER_MESSAGE_LIMIT_BYTES,
   parseCodeModeWorkerRequest,
@@ -9,13 +10,27 @@ import {
 } from "./codemode-worker-protocol.ts";
 
 const CODEMODE_WORKER_READ_BUFFER_BYTES = 64 * 1024;
+const CODEMODE_CONSOLE_RESPONSE_RESERVE_BYTES = 512;
 
 type DenoByteReader = { read(buffer: Uint8Array): Promise<number | null> };
 type DenoByteWriter = { write(buffer: Uint8Array): Promise<number> };
+type DenoInspectOptions = {
+  readonly colors: false;
+  readonly getters: false;
+  readonly customInspect: false;
+};
 type CodeModeDenoNamespace = {
   readonly args: readonly string[];
   readonly stdin: DenoByteReader;
   readonly stdout: DenoByteWriter;
+  // oxlint-disable-next-line anti-slop/no-unknown-parameters -- SAFETY: Deno.inspect is the captured hostile-value formatter; coordinator tests cover getters, coercion hooks, custom inspectors, and Proxies.
+  readonly inspect: (value: unknown, options: DenoInspectOptions) => string;
+  readonly internal: symbol;
+  readonly [key: symbol]:
+    | {
+        readonly inspectArgs: (args: readonly unknown[], options: DenoInspectOptions) => string;
+      }
+    | undefined;
   readonly version: {
     readonly deno: string;
     readonly v8: string;
@@ -26,6 +41,11 @@ type CodeModeDenoNamespace = {
 declare const Deno: CodeModeDenoNamespace;
 
 const denoProcess = Deno;
+const denoInspect = denoProcess.inspect;
+const denoInternal = denoProcess[denoProcess.internal];
+if (denoInternal === undefined)
+  throw new Error("Pi CodeMode: Deno Console formatter is unavailable");
+const denoInspectArgs = denoInternal.inspectArgs;
 const arrayIsArray = Array.isArray;
 const arrayPrototype = Array.prototype;
 const blobConstructor = Blob;
@@ -43,6 +63,11 @@ const numberFrom = Number;
 const numberIsFinite = Number.isFinite;
 const numberIsSafeInteger = Number.isSafeInteger;
 const objectFreeze = Object.freeze;
+const SAFE_DENO_INSPECT_OPTIONS = objectFreeze({
+  colors: false,
+  getters: false,
+  customInspect: false,
+} as const);
 const objectPrototype = Object.prototype;
 const ownKeys = Reflect.ownKeys;
 const queueRuntimeMicrotask = queueMicrotask.bind(globalThis);
@@ -159,6 +184,9 @@ type ActiveWorkerCell = {
   readonly sessionId: string;
   readonly cellId: string;
   readonly pendingCalls: PendingGuestToolCall[];
+  readonly consoleEntries: CodeModeConsoleEntry[];
+  consoleBytes: number;
+  consoleOverflow: boolean;
   batchSequence: number;
   callSequence: number;
   batchScheduled: boolean;
@@ -206,6 +234,113 @@ function isReservedNotebookBindingName(name: string): boolean {
   return false;
 }
 
+// oxlint-disable-next-line anti-slop/no-unknown-parameters -- SAFETY: Cell Console calls accept arbitrary guest values; captured Deno.inspect disables getters and custom inspection, while coordinator hostile-value tests cover coercion hooks and Proxies.
+function inspectGuestConsoleValue(value: unknown): string {
+  try {
+    return denoInspect(value, SAFE_DENO_INSPECT_OPTIONS);
+  } catch {
+    return "[Uninspectable value]";
+  }
+}
+
+function formatGuestConsoleArguments(args: readonly unknown[]): string | undefined {
+  if (args.length === 0) return "";
+  const first = args[0];
+  const maximumTextLength =
+    CODEMODE_WORKER_MESSAGE_LIMIT_BYTES - CODEMODE_CONSOLE_RESPONSE_RESERVE_BYTES;
+  if (isGuestString(first) && first.length >= maximumTextLength) return undefined;
+  if (args.length === 1 && isGuestString(first)) return first;
+  if (isGuestString(first) && !first.includes("%")) {
+    let text = first;
+    for (let index = 1; index < args.length; index += 1) {
+      const value = args[index];
+      const rendered = isGuestString(value) ? value : inspectGuestConsoleValue(value);
+      if (text.length + rendered.length + 1 >= maximumTextLength) return undefined;
+      text += ` ${rendered}`;
+    }
+    return text;
+  }
+  if (!isGuestString(first)) {
+    let text = "";
+    for (let index = 0; index < args.length; index += 1) {
+      const value = args[index];
+      const rendered = isGuestString(value) ? value : inspectGuestConsoleValue(value);
+      const separatorLength = index === 0 ? 0 : 1;
+      if (text.length + rendered.length + separatorLength >= maximumTextLength) return undefined;
+      if (separatorLength > 0) text += " ";
+      text += rendered;
+    }
+    return text;
+  }
+
+  const safeArgs: unknown[] = [first];
+  for (let index = 1; index < args.length; index += 1) safeArgs[index] = args[index];
+  let format = "";
+  let argumentIndex = 1;
+  for (let index = 0; index < first.length; index += 1) {
+    const character = first[index];
+    if (character !== "%" || index + 1 >= first.length) {
+      format += character;
+      continue;
+    }
+    const token = first[index + 1];
+    if (token === "%") {
+      format += "%%";
+      index += 1;
+      continue;
+    }
+    if (
+      token !== "s" &&
+      token !== "d" &&
+      token !== "i" &&
+      token !== "f" &&
+      token !== "j" &&
+      token !== "o" &&
+      token !== "O" &&
+      token !== "c"
+    ) {
+      format += `%${token}`;
+      index += 1;
+      continue;
+    }
+    const value = safeArgs[argumentIndex];
+    if (value !== undefined || argumentIndex < safeArgs.length) {
+      if (isGuestReference(value)) {
+        const inspected = inspectGuestConsoleValue(value);
+        if (inspected.length >= maximumTextLength) return undefined;
+        safeArgs[argumentIndex] = inspected;
+        format += token === "c" ? "%c" : "%s";
+      } else {
+        format += `%${token}`;
+      }
+      argumentIndex += 1;
+    } else {
+      format += `%${token}`;
+    }
+    index += 1;
+  }
+  safeArgs[0] = format;
+  for (let index = argumentIndex; index < safeArgs.length; index += 1) {
+    const value = safeArgs[index];
+    if (isGuestReference(value)) {
+      const inspected = inspectGuestConsoleValue(value);
+      if (inspected.length >= maximumTextLength) return undefined;
+      safeArgs[index] = inspected;
+    }
+  }
+  let minimumFormattedBytes = 0;
+  for (const value of safeArgs) {
+    if (isGuestString(value)) minimumFormattedBytes += value.length;
+    if (
+      minimumFormattedBytes + CODEMODE_CONSOLE_RESPONSE_RESERVE_BYTES >=
+      CODEMODE_WORKER_MESSAGE_LIMIT_BYTES
+    ) {
+      return undefined;
+    }
+  }
+  return denoInspectArgs(safeArgs, SAFE_DENO_INSPECT_OPTIONS);
+}
+
 function assertNotebookBindingNameAvailable(name: string): void {
   if (isReservedNotebookBindingName(name)) {
     throw new typeErrorConstructor(`CodeMode Notebook Binding '${name}' is reserved`);
@@ -398,6 +533,35 @@ function utf8ByteLength(value: string): number {
   return encodeUtf8(value).byteLength;
 }
 
+function utf8JsonStringByteLength(value: string): number {
+  let bytes = 2;
+  for (let index = 0; index < value.length; index += 1) {
+    const codeUnit = value.charCodeAt(index);
+    if (codeUnit === 0x22 || codeUnit === 0x5c) bytes += 2;
+    else if (codeUnit <= 0x1f) {
+      bytes +=
+        codeUnit === 0x08 ||
+        codeUnit === 0x09 ||
+        codeUnit === 0x0a ||
+        codeUnit === 0x0c ||
+        codeUnit === 0x0d
+          ? 2
+          : 6;
+    } else if (codeUnit <= 0x7f) bytes += 1;
+    else if (codeUnit <= 0x7ff) bytes += 2;
+    else if (codeUnit >= 0xd800 && codeUnit <= 0xdbff) {
+      const lowSurrogate = value.charCodeAt(index + 1);
+      if (lowSurrogate >= 0xdc00 && lowSurrogate <= 0xdfff) {
+        bytes += 4;
+        index += 1;
+      } else bytes += 6;
+    } else if (codeUnit >= 0xdc00 && codeUnit <= 0xdfff) bytes += 6;
+    else bytes += 3;
+    if (bytes >= CODEMODE_WORKER_MESSAGE_LIMIT_BYTES) return bytes;
+  }
+  return bytes;
+}
+
 // oxlint-disable-next-line anti-slop/no-unknown-parameters -- SAFETY: This is arbitrary guest ingress; descriptor-only traversal avoids invoking accessors, coercion, and guest-mutated methods. Coordinator hostile JSON tests cover the boundary.
 function serializeGuestJson(value: unknown, allowUndefined: boolean): string | undefined {
   const seen: object[] = [];
@@ -715,6 +879,50 @@ defineProperty(globalThis, "tools", {
   value: tools,
   writable: false,
 });
+const guestConsole = createObject(null);
+for (const method of CODEMODE_CONSOLE_METHODS) {
+  defineProperty(guestConsole, method, {
+    configurable: false,
+    enumerable: true,
+    // oxlint-disable-next-line anti-slop/no-unknown-parameters -- SAFETY: Cell Console calls accept arbitrary guest values; formatGuestConsoleArguments safely inspects them before capture.
+    value: (...args: unknown[]): undefined => {
+      const cell = activeCell;
+      if (cell !== undefined && !cell.consoleOverflow) {
+        const text = formatGuestConsoleArguments(args);
+        if (text === undefined) {
+          cell.consoleEntries.length = 0;
+          cell.consoleOverflow = true;
+          return undefined;
+        }
+        const entryBytes = 19 + utf8JsonStringByteLength(method) + utf8JsonStringByteLength(text);
+        const nextConsoleBytes =
+          cell.consoleBytes + (cell.consoleEntries.length === 0 ? 0 : 1) + entryBytes;
+        if (
+          nextConsoleBytes + CODEMODE_CONSOLE_RESPONSE_RESERVE_BYTES >=
+          CODEMODE_WORKER_MESSAGE_LIMIT_BYTES
+        ) {
+          cell.consoleEntries.length = 0;
+          cell.consoleOverflow = true;
+          return undefined;
+        }
+        cell.consoleEntries[cell.consoleEntries.length] = {
+          method,
+          text,
+        };
+        cell.consoleBytes = nextConsoleBytes;
+      }
+      return undefined;
+    },
+    writable: false,
+  });
+}
+objectFreeze(guestConsole);
+defineProperty(globalThis, "console", {
+  configurable: false,
+  enumerable: false,
+  value: guestConsole,
+  writable: false,
+});
 
 function disableGuestGlobal(name: string, value?: Readonly<typeof safeDenoIdentity>): void {
   const descriptor = getOwnPropertyDescriptor(globalThis, name);
@@ -770,7 +978,6 @@ const safeDenoIdentity = objectFreeze({
 disableGuestGlobal("Deno", safeDenoIdentity);
 for (const unsafeGlobal of [
   "process",
-  "console",
   "alert",
   "confirm",
   "prompt",
@@ -889,42 +1096,97 @@ function scheduleCellFinish(cell: ActiveWorkerCell): void {
       return;
     }
     activeCell = undefined;
+    const consoleEntries = cell.consoleEntries.length === 0 ? undefined : [...cell.consoleEntries];
     let response: CodeModeWorkerResponse;
-    if (cell.mainFailed) {
-      const error = describeGuestError(cell.mainError);
-      const serializationFailure =
-        isGuestReference(cell.mainError) &&
-        (hasSerializationErrorInstance(cell.mainError) ||
-          internalToolErrorCode(cell.mainError) === "serialization");
+    if (cell.consoleOverflow) {
       response = {
         version: 1,
         type: "cell-error",
         sessionId: cell.sessionId,
         cellId: cell.cellId,
-        error: {
-          code: serializationFailure ? "serialization" : "script",
-          message: renderGuestError(error),
-        },
+        error: { code: "serialization", message: "CodeMode worker response exceeds 8 MiB" },
       };
-    } else {
-      try {
-        const resultJson = serializeGuestJson(cell.mainResult, true);
+    } else if (cell.mainFailed) {
+      const error = describeGuestError(cell.mainError);
+      const serializationFailure =
+        isGuestReference(cell.mainError) &&
+        (hasSerializationErrorInstance(cell.mainError) ||
+          internalToolErrorCode(cell.mainError) === "serialization");
+      const message = renderGuestError(error);
+      if (
+        consoleEntries !== undefined &&
+        cell.consoleBytes +
+          utf8JsonStringByteLength(message) +
+          CODEMODE_CONSOLE_RESPONSE_RESERVE_BYTES >=
+          CODEMODE_WORKER_MESSAGE_LIMIT_BYTES
+      ) {
+        response = {
+          version: 1,
+          type: "cell-error",
+          sessionId: cell.sessionId,
+          cellId: cell.cellId,
+          error: { code: "serialization", message: "CodeMode worker response exceeds 8 MiB" },
+        };
+      } else {
         const responseBase = {
           version: 1,
-          type: "cell-result",
+          type: "cell-error",
           sessionId: cell.sessionId,
           cellId: cell.cellId,
+          error: {
+            code: serializationFailure ? "serialization" : "script",
+            message,
+          },
         } as const;
-        response = resultJson === undefined ? responseBase : { ...responseBase, resultJson };
+        response =
+          consoleEntries === undefined
+            ? responseBase
+            : { ...responseBase, console: consoleEntries };
+      }
+    } else {
+      try {
+        const resultJson = serializeGuestJson(cell.mainResult, true);
+        if (
+          consoleEntries !== undefined &&
+          cell.consoleBytes +
+            (resultJson === undefined ? 0 : utf8JsonStringByteLength(resultJson)) +
+            CODEMODE_CONSOLE_RESPONSE_RESERVE_BYTES >=
+            CODEMODE_WORKER_MESSAGE_LIMIT_BYTES
+        ) {
+          response = {
+            version: 1,
+            type: "cell-error",
+            sessionId: cell.sessionId,
+            cellId: cell.cellId,
+            error: { code: "serialization", message: "CodeMode worker response exceeds 8 MiB" },
+          };
+        } else {
+          const responseBase = {
+            version: 1,
+            type: "cell-result",
+            sessionId: cell.sessionId,
+            cellId: cell.cellId,
+          } as const;
+          const resultResponse =
+            resultJson === undefined ? responseBase : { ...responseBase, resultJson };
+          response =
+            consoleEntries === undefined
+              ? resultResponse
+              : { ...resultResponse, console: consoleEntries };
+        }
       } catch (cause) {
         const error = describeGuestError(cause);
-        response = {
+        const responseBase = {
           version: 1,
           type: "cell-error",
           sessionId: cell.sessionId,
           cellId: cell.cellId,
           error: { code: "serialization", message: renderGuestError(error) },
-        };
+        } as const;
+        response =
+          consoleEntries === undefined
+            ? responseBase
+            : { ...responseBase, console: consoleEntries };
       }
     }
     void enqueueWorkerResponse(response);
@@ -939,6 +1201,9 @@ function startWorkerCell(
     sessionId: request.sessionId,
     cellId: request.cellId,
     pendingCalls: [],
+    consoleEntries: [],
+    consoleBytes: 2,
+    consoleOverflow: false,
     batchSequence: 0,
     callSequence: 0,
     batchScheduled: false,

package/src/pi-codemode-extension.ts

@@ -39,7 +39,7 @@ import {
 } from "./pi-tool-bridge.js";
 
 const CODEMODE_EXECUTE_DESCRIPTION =
-  "Execute a TypeScript Cell in a persistent isolated Deno CodeMode Session. Reuse a Session ID to retain Notebook Bindings; a new Session reclaims the least-recently-used idle Session at capacity. Use the read-only tools object for registered Pi tools.";
+  "Execute a TypeScript Cell in a persistent isolated Deno CodeMode Session. Reuse a Session ID to retain Notebook Bindings; a new Session reclaims the least-recently-used idle Session at capacity. Use the read-only tools object for registered Pi tools. Cells may call console.log, console.info, console.warn, console.error, and console.debug; captured output arrives only with terminal results.";
 
 type PiCodeModeGeneration = {
   readonly captured: CapturedPiAgentSession;
@@ -126,11 +126,11 @@ class PiCodeModeLifecycleController {
     this.pi.on("session_start", async (_event, context) => this.startSession(context));
     this.pi.on("before_agent_start", () => this.synchronizeCurrentGeneration());
     this.pi.on("tool_execution_end", () => this.synchronizeCurrentGeneration());
-    this.pi.on("session_shutdown", async (event) => this.shutdownSession(event.reason));
+    this.pi.on("session_shutdown", async () => this.shutdownSession());
   }
 
   private async startSession(context: ExtensionContext): Promise<void> {
-    await this.shutdownSession("replacement");
+    await this.shutdownSession();
     const capturedResult = capturePiAgentSession(this.pi);
     if (!capturedResult.ok) {
       this.notifyWarning(context, capturedResult.warning);
@@ -247,7 +247,7 @@ class PiCodeModeLifecycleController {
       } catch {
         // Observer cleanup is presentation-only; execution resources still require release.
       }
-      await coordinator.shutdown("startup failure");
+      await coordinator.shutdown();
       await sessionFiles.close();
       if (this.generation === generation) this.generation = undefined;
       this.notifyWarning(
@@ -389,12 +389,8 @@ class PiCodeModeLifecycleController {
       now: CODEMODE_SYSTEM_RUNTIME.now,
       signal: AbortSignal.any([batch.signal, terminationController.signal]),
       onTerminate: () => terminationController.abort(),
-    };
-    if (outerAssistantMessage !== undefined) {
-      Object.assign(bridgeOptions, { outerAssistantMessage });
-    }
-    if (batch.onUpdate !== undefined) {
-      Object.assign(bridgeOptions, {
+      ...(outerAssistantMessage !== undefined && { outerAssistantMessage }),
+      ...(batch.onUpdate !== undefined && {
         onUpdate: (_callId: string, update: AgentToolResult<unknown>) => {
           const outerUpdate: AgentToolResult<CodeModeResultDetails> = {
             content: update.content,
@@ -402,8 +398,8 @@ class PiCodeModeLifecycleController {
           };
           batch.onUpdate?.(outerUpdate);
         },
-      });
-    }
+      }),
+    };
     const bridged = await executePiToolBridgeBatch(bridgeCaptured, bridgeOptions);
     const bridgedResults = new Map<string, CodeModeNestedToolResult>(
       bridged.calls.map((outcome) => [
@@ -431,16 +427,16 @@ class PiCodeModeLifecycleController {
           "Pi CodeMode nested tool returned no result",
         ),
     );
-    const batchResult = { results, presentation: bridged.presentation };
-    if (bridged.usage !== undefined) Object.assign(batchResult, { usage: bridged.usage });
-    if (bridged.addedToolNames.length > 0) {
-      Object.assign(batchResult, { addedToolNames: bridged.addedToolNames });
-    }
-    if (bridged.terminate) Object.assign(batchResult, { terminate: true });
-    return batchResult;
+    return {
+      results,
+      presentation: bridged.presentation,
+      ...(bridged.usage !== undefined && { usage: bridged.usage }),
+      ...(bridged.addedToolNames.length > 0 && { addedToolNames: bridged.addedToolNames }),
+      ...(bridged.terminate && { terminate: true }),
+    };
   }
 
-  private async shutdownSession(reason: string): Promise<void> {
+  private async shutdownSession(): Promise<void> {
     const generation = this.generation;
     if (generation === undefined || !generation.active) return;
     generation.active = false;
@@ -450,7 +446,7 @@ class PiCodeModeLifecycleController {
       // Observer cleanup is presentation-only; execution resources still require release.
     }
     try {
-      await generation.coordinator.shutdown(reason);
+      await generation.coordinator.shutdown();
     } finally {
       try {
         await generation.sessionFiles.close();

package/src/pi-tool-bridge.ts

@@ -12,6 +12,7 @@ import {
   parseCodeModeJsonValue,
   type CodeModeJsonValue,
 } from "./codemode-tool-contract.js";
+import { addCodeModeUsage, boundedCodeModeElapsedMs } from "./codemode-session-coordinator.js";
 import type { CapturedPiAgentSession } from "./pi-agent-session-capture.js";
 
 const PI_TOOL_BRIDGE_RESULT_LIMIT_BYTES = 8 * 1024 * 1024;
@@ -505,36 +506,6 @@ function translatePiToolResult(
   };
 }
 
-function addUsage(left: Usage | undefined, right: Usage | undefined): Usage | undefined {
-  if (right === undefined) return left;
-  if (left === undefined) return right;
-  const reasoning =
-    left.reasoning === undefined && right.reasoning === undefined
-      ? undefined
-      : (left.reasoning ?? 0) + (right.reasoning ?? 0);
-  const cacheWrite1h =
-    left.cacheWrite1h === undefined && right.cacheWrite1h === undefined
-      ? undefined
-      : (left.cacheWrite1h ?? 0) + (right.cacheWrite1h ?? 0);
-  const combined: Usage = {
-    input: left.input + right.input,
-    output: left.output + right.output,
-    cacheRead: left.cacheRead + right.cacheRead,
-    cacheWrite: left.cacheWrite + right.cacheWrite,
-    totalTokens: left.totalTokens + right.totalTokens,
-    cost: {
-      input: left.cost.input + right.cost.input,
-      output: left.cost.output + right.cost.output,
-      cacheRead: left.cost.cacheRead + right.cost.cacheRead,
-      cacheWrite: left.cost.cacheWrite + right.cost.cacheWrite,
-      total: left.cost.total + right.cost.total,
-    },
-  };
-  if (cacheWrite1h !== undefined) combined.cacheWrite1h = cacheWrite1h;
-  if (reasoning !== undefined) combined.reasoning = reasoning;
-  return combined;
-}
-
 function terminatedPiToolCall(callId: string): FinalizedPiToolCall {
   return createBridgeFailure(
     callId,
@@ -553,12 +524,6 @@ function presentationOutcome(
     : "failed";
 }
 
-function elapsedMilliseconds(startedAt: number, finishedAt: number): number {
-  const elapsed = Math.round(finishedAt - startedAt);
-  if (!Number.isFinite(elapsed)) return 0;
-  return Math.min(Number.MAX_SAFE_INTEGER, Math.max(0, elapsed));
-}
-
 function timedFinalizedPiToolCall(
   call: PiToolBridgeCall,
   finalized: FinalizedPiToolCall,
@@ -569,7 +534,7 @@ function timedFinalizedPiToolCall(
     finalized,
     presentation: {
       callId: call.callId,
-      elapsedMs: elapsedMilliseconds(startedAt, now()),
+      elapsedMs: boundedCodeModeElapsedMs(startedAt, now()),
       name: call.name,
       outcome: presentationOutcome(finalized.outcome),
     },
@@ -590,7 +555,9 @@ function collectPiToolBridgeBatch(
   const addedToolNames: string[] = [];
   const seenToolNames = new Set<string>();
   for (const { finalized } of timedCalls) {
-    usage = addUsage(usage, finalized.usage);
+    if (finalized.usage !== undefined) {
+      usage = addCodeModeUsage(usage, finalized.usage);
+    }
     for (const toolName of finalized.addedToolNames) {
       if (seenToolNames.has(toolName)) continue;
       seenToolNames.add(toolName);