@ian-pascoe/pi-codemode 0.2.0 → 0.3.0

package/src/codemode-tool-catalog.ts

@@ -95,10 +95,6 @@ function schemaRecord(value: CodeModeJsonValue | undefined): CodeModeJsonObject
   return value !== undefined && isCodeModeJsonObject(value) ? value : undefined;
 }
 
-function jsonLiteral(value: CodeModeJsonValue): string | undefined {
-  return JSON.stringify(value);
-}
-
 function quotedName(name: string): string {
   return JSON.stringify(name);
 }
@@ -139,9 +135,11 @@ function schemaType(
 
   const constant = record.const;
   if (Object.hasOwn(record, "const") && constant !== undefined) {
-    return jsonLiteral(constant) ?? "unknown";
+    return JSON.stringify(constant) ?? "unknown";
   }
-  const enumValues = Array.isArray(record.enum) ? record.enum.map(jsonLiteral) : undefined;
+  const enumValues = Array.isArray(record.enum)
+    ? record.enum.map((value) => JSON.stringify(value))
+    : undefined;
   if (
     enumValues !== undefined &&
     enumValues.length > 0 &&

package/src/codemode-tool-contract.ts

@@ -8,6 +8,11 @@ import type {
 import type { Usage } from "@earendil-works/pi-ai";
 import { type Static, Type } from "typebox";
 import { Value } from "typebox/value";
+import {
+  CODEMODE_CONSOLE_METHODS,
+  type CodeModeConsoleEntry,
+  type CodeModeConsoleMethod,
+} from "./codemode-console-output.js";
 
 const CODEMODE_TOOL_NAMES = {
   execute: "codemode_execute",
@@ -170,6 +175,15 @@ const CodeModeErrorCodeSchema = Type.Unsafe<CodeModeErrorCode>({
   type: "string",
   enum: [...CODEMODE_ERROR_CODES],
 });
+const CodeModeConsoleMethodSchema = Type.Unsafe<CodeModeConsoleMethod>({
+  type: "string",
+  enum: [...CODEMODE_CONSOLE_METHODS],
+});
+const CodeModeConsoleEntrySchema = Type.Object(
+  { method: CodeModeConsoleMethodSchema, text: Type.String() },
+  { additionalProperties: false },
+);
+const CodeModeConsoleOutputSchema = Type.Array(CodeModeConsoleEntrySchema, { minItems: 1 });
 
 /** Stable error retained by a failed CodeMode result. */
 export const CodeModeErrorSchema = Type.Object(
@@ -186,6 +200,7 @@ const CodeModeSuccessSchema = Type.Object(
     sessionId: SessionIdSchema,
     data: Type.Optional(CodeModeJsonValueSchema),
     reclaimedSessionId: Type.Optional(SessionIdSchema),
+    console: Type.Optional(CodeModeConsoleOutputSchema),
   },
   { additionalProperties: false },
 );
@@ -225,6 +240,7 @@ const CodeModeFailedSchema = Type.Object(
     result: Type.Literal("failed"),
     sessionId: SessionIdSchema,
     error: CodeModeErrorSchema,
+    console: Type.Optional(CodeModeConsoleOutputSchema),
   },
   { additionalProperties: false },
 );
@@ -245,6 +261,7 @@ const CodeModeSuccessDetailsSchema = Type.Object(
     sessionId: SessionIdSchema,
     data: Type.Optional(CodeModeJsonValueSchema),
     reclaimedSessionId: Type.Optional(SessionIdSchema),
+    console: Type.Optional(CodeModeConsoleOutputSchema),
     presentation: Type.Optional(CodeModePresentationSnapshotSchema),
   },
   { additionalProperties: false },
@@ -262,6 +279,7 @@ const CodeModeFailedDetailsSchema = Type.Object(
     result: Type.Literal("failed"),
     sessionId: SessionIdSchema,
     error: CodeModeErrorSchema,
+    console: Type.Optional(CodeModeConsoleOutputSchema),
     presentation: Type.Optional(CodeModePresentationSnapshotSchema),
   },
   { additionalProperties: false },
@@ -276,11 +294,19 @@ export const CodeModeResultDetailsSchema = Type.Union([
 /** Schema-derived details retained by one session-scoped CodeMode operation. */
 export type CodeModeResultDetails = Static<typeof CodeModeResultDetailsSchema>;
 
-/** A successful result with optional JSON data. */
-export function createCodeModeSuccess(sessionId: string, data?: CodeModeJsonValue): CodeModeResult {
-  return data === undefined
-    ? { result: "success", sessionId }
-    : { result: "success", sessionId, data };
+/** A success with optional data and non-empty Cell Console output; empty Console lists are omitted. */
+export function createCodeModeSuccess(
+  sessionId: string,
+  data?: CodeModeJsonValue,
+  consoleEntries?: readonly CodeModeConsoleEntry[],
+): CodeModeResult {
+  const result =
+    data === undefined
+      ? { result: "success" as const, sessionId }
+      : { result: "success" as const, sessionId, data };
+  return consoleEntries === undefined || consoleEntries.length === 0
+    ? result
+    : { ...result, console: [...consoleEntries] };
 }
 
 /** A polling result for a live Cell. */
@@ -288,13 +314,17 @@ export function createCodeModePending(sessionId: string): CodeModeResult {
   return { result: "pending", sessionId };
 }
 
-/** A stable expected failure result. */
+/** A stable expected failure with non-empty Cell Console output; empty Console lists are omitted. */
 export function createCodeModeFailure(
   sessionId: string,
   code: CodeModeErrorCode,
   message: string,
+  consoleEntries?: readonly CodeModeConsoleEntry[],
 ): CodeModeResult {
-  return { result: "failed", sessionId, error: { code, message } };
+  const result = { result: "failed" as const, sessionId, error: { code, message } };
+  return consoleEntries === undefined || consoleEntries.length === 0
+    ? result
+    : { ...result, console: [...consoleEntries] };
 }
 
 /** A bounded JSON compatibility parse that never invokes getters or `toJSON`. */

package/src/codemode-tool-rendering.ts

@@ -21,6 +21,7 @@ import {
 import { Type } from "typebox";
 import { Value } from "typebox/value";
 import { formatCodeModePresentationData } from "./codemode-presentation-output.js";
+import { formatCodeModeDuration } from "./codemode-session-coordinator.js";
 import {
   CodeModeCancelParametersSchema,
   CodeModeExecuteParametersSchema,
@@ -116,13 +117,6 @@ function shortCodeModeSessionId(sessionId: string): string {
 /** Resolves one Session ID to the shortest unambiguous CodeMode Transcript label. */
 export type CodeModeSessionPrefixFormatter = (sessionId: string) => string;
 
-function formatCodeModeDuration(elapsedMs: number): string {
-  if (elapsedMs < 1_000) return `${elapsedMs}ms`;
-  if (elapsedMs < 60_000) return `${(elapsedMs / 1_000).toFixed(1)}s`;
-  const seconds = Math.floor(elapsedMs / 1_000);
-  return `${Math.floor(seconds / 60)}m ${String(seconds % 60).padStart(2, "0")}s`;
-}
-
 function pluralizedCodeModeCount(count: number, noun: string): string {
   return `${count} ${noun}${count === 1 ? "" : "s"}`;
 }
@@ -252,6 +246,7 @@ function renderCodeModeSummary(
   formatSessionPrefix: CodeModeSessionPrefixFormatter,
 ): string {
   const presentation = details.presentation;
+  const consoleEntries = details.result === "pending" ? undefined : details.console;
   const state = codeModeCellState(toolName, details);
   const status =
     details.result === "failed" && details.error.code === "eviction"
@@ -279,6 +274,9 @@ function renderCodeModeSummary(
       : undefined,
     details.result === "failed" ? theme.fg("muted", details.error.code) : undefined,
     details.result === "failed" ? boundedCodeModePreview(details.error.message, 64) : undefined,
+    consoleEntries === undefined
+      ? undefined
+      : theme.fg("muted", pluralizedCodeModeCount(consoleEntries.length, "console call")),
     state !== "running" && presentation !== undefined && presentation.nested_tool_count > 0
       ? theme.fg("muted", pluralizedCodeModeCount(presentation.nested_tool_count, "tool"))
       : undefined,
@@ -414,6 +412,7 @@ export function renderCodeModeToolResult(
     return renderCodeModeFallback(result, options, theme, isError);
   }
   const details = result.details;
+  const consoleEntries = details.result === "pending" ? undefined : details.console;
   const summary = renderCodeModeSummary(details, toolName, theme, formatSessionPrefix);
   if (!options.expanded) {
     const hint = options.isPartial ? "" : `  ·  ${keyText("app.tools.expand")} to expand`;
@@ -462,6 +461,13 @@ export function renderCodeModeToolResult(
     }
   }
 
+  if (consoleEntries !== undefined) {
+    container.addChild(new Spacer(1));
+    container.addChild(new Text(theme.fg("muted", theme.bold("Console")), 0, 0));
+    const output = consoleEntries.map((entry) => `${entry.method}: ${entry.text}`).join("\n");
+    container.addChild(new Text(theme.fg("toolOutput", boundedCodeModeText(output, 2_000)), 0, 0));
+  }
+
   if (details.result === "success") {
     container.addChild(new Spacer(1));
     container.addChild(new Text(theme.fg("muted", theme.bold("Result")), 0, 0));

package/src/codemode-worker-protocol.ts

@@ -1,4 +1,5 @@
 import { Buffer } from "node:buffer";
+import { CODEMODE_CONSOLE_METHODS, type CodeModeConsoleEntry } from "./codemode-console-output.ts";
 
 /** Maximum UTF-8 bytes in one CodeMode worker protocol line, excluding its newline. */
 export const CODEMODE_WORKER_MESSAGE_LIMIT_BYTES = 8 * 1024 * 1024;
@@ -76,6 +77,7 @@ export type CodeModeWorkerResponse =
       readonly sessionId: string;
       readonly cellId: string;
       readonly resultJson?: string;
+      readonly console?: readonly CodeModeConsoleEntry[];
     }
   | {
       readonly version: 1;
@@ -83,6 +85,7 @@ export type CodeModeWorkerResponse =
       readonly sessionId: string;
       readonly cellId: string;
       readonly error: { readonly code: CodeModeWorkerCellErrorCode; readonly message: string };
+      readonly console?: readonly CodeModeConsoleEntry[];
     }
   | {
       readonly version: 1;
@@ -132,19 +135,61 @@ function hasString(values: readonly string[], candidate: string): boolean {
 function hasExactKeys(value: CodeModeProtocolObject, expected: readonly string[]): boolean {
   const keys = objectKeys(value);
   if (keys.length !== expected.length) return false;
-  for (let expectedIndex = 0; expectedIndex < expected.length; expectedIndex += 1) {
-    const expectedKey = expected[expectedIndex];
-    if (expectedKey === undefined) return false;
-    let found = false;
-    for (let keyIndex = 0; keyIndex < keys.length; keyIndex += 1) {
-      if (keys[keyIndex] === expectedKey) {
-        found = true;
-        break;
+  return expected.every((expectedKey) => expectedKey !== undefined && keys.includes(expectedKey));
+}
+
+function hasDuplicateJsonObjectKeys(message: string): boolean {
+  const objectKeysByDepth: (string[] | undefined)[] = [];
+  for (let index = 0; index < message.length; index += 1) {
+    const character = message[index];
+    if (character === "{") {
+      objectKeysByDepth.push([]);
+      continue;
+    }
+    if (character === "[") {
+      objectKeysByDepth.push(undefined);
+      continue;
+    }
+    if (character === "}" || character === "]") {
+      objectKeysByDepth.pop();
+      continue;
+    }
+    if (character !== '"') continue;
+
+    let endIndex = index + 1;
+    for (; endIndex < message.length; endIndex += 1) {
+      if (message[endIndex] === "\\") {
+        endIndex += 1;
+        continue;
       }
+      if (message[endIndex] === '"') break;
     }
-    if (!found) return false;
+    if (endIndex >= message.length) return false;
+    let nextIndex = endIndex + 1;
+    while (
+      message[nextIndex] === " " ||
+      message[nextIndex] === "\n" ||
+      message[nextIndex] === "\r" ||
+      message[nextIndex] === "\t"
+    ) {
+      nextIndex += 1;
+    }
+    const keys = objectKeysByDepth[objectKeysByDepth.length - 1];
+    if (message[nextIndex] === ":" && keys !== undefined) {
+      try {
+        // SAFETY: This slice is one syntactically bounded JSON string token; the string refinement below rejects every other JSON value.
+        const key = jsonParse(message.slice(index, endIndex + 1)) as CodeModeProtocolValue;
+        if (isString(key)) {
+          if (hasString(keys, key)) return true;
+          keys.push(key);
+        }
+      } catch {
+        return false;
+      }
+    }
+    index = endIndex;
   }
-  return true;
+  return false;
 }
 
 function parseProtocolJson(
@@ -158,6 +203,9 @@ function parseProtocolJson(
   if (Buffer.byteLength(message, "utf8") > CODEMODE_WORKER_MESSAGE_LIMIT_BYTES) {
     return { ok: false, message: `CodeMode worker ${subject} exceeds 8 MiB` };
   }
+  if (hasDuplicateJsonObjectKeys(message)) {
+    return { ok: false, message: `CodeMode worker ${subject} contains duplicate object keys` };
+  }
   try {
     // SAFETY: Successful JSON.parse output is exactly the recursive JSON representation modeled by CodeModeProtocolValue.
     return { ok: true, value: jsonParse(message) as CodeModeProtocolValue };
@@ -308,6 +356,30 @@ function parseWorkerError(
   return { code: value.code, message: value.message };
 }
 
+function parseConsoleOutput(
+  value: CodeModeProtocolSlot,
+): readonly CodeModeConsoleEntry[] | undefined {
+  if (!arrayIsArray(value) || value.length === 0) return undefined;
+  const entries: CodeModeConsoleEntry[] = [];
+  for (const candidate of value) {
+    if (
+      !isRecord(candidate) ||
+      !hasExactKeys(candidate, ["method", "text"]) ||
+      !isString(candidate.method) ||
+      !hasString(CODEMODE_CONSOLE_METHODS, candidate.method) ||
+      !isString(candidate.text)
+    ) {
+      return undefined;
+    }
+    entries.push({
+      // SAFETY: The literal-membership check above refines the protocol string to a supported Console method.
+      method: candidate.method as CodeModeConsoleEntry["method"],
+      text: candidate.text,
+    });
+  }
+  return entries;
+}
+
 function parseToolBatchResponse(
   decoded: CodeModeProtocolObject,
 ): CodeModeWorkerResponse | undefined {
@@ -401,43 +473,58 @@ export function parseCodeModeWorkerResponse(
   }
   if (
     decoded.type === "cell-result" &&
-    hasExactKeys(
-      decoded,
-      decoded.resultJson === undefined
-        ? ["cellId", "sessionId", "type", "version"]
-        : ["cellId", "resultJson", "sessionId", "type", "version"],
-    ) &&
     isNonEmptyString(decoded.cellId) &&
     (decoded.resultJson === undefined || isString(decoded.resultJson))
   ) {
+    const expectedKeys = ["cellId", "sessionId", "type", "version"];
+    if (decoded.resultJson !== undefined) expectedKeys.push("resultJson");
+    if (decoded.console !== undefined) expectedKeys.push("console");
+    if (!hasExactKeys(decoded, expectedKeys)) {
+      return { ok: false, message: "CodeMode worker response has an invalid protocol shape" };
+    }
+    const consoleEntries =
+      decoded.console === undefined ? undefined : parseConsoleOutput(decoded.console);
+    if (decoded.console !== undefined && consoleEntries === undefined) {
+      return { ok: false, message: "CodeMode worker response has an invalid protocol shape" };
+    }
     const value = {
       version: CODEMODE_WORKER_PROTOCOL_VERSION,
       type: "cell-result",
       sessionId: decoded.sessionId,
       cellId: decoded.cellId,
     } as const;
-    return decoded.resultJson === undefined
-      ? { ok: true, value }
-      : { ok: true, value: { ...value, resultJson: decoded.resultJson } };
+    const resultValue =
+      decoded.resultJson === undefined ? value : { ...value, resultJson: decoded.resultJson };
+    return consoleEntries === undefined
+      ? { ok: true, value: resultValue }
+      : { ok: true, value: { ...resultValue, console: consoleEntries } };
   }
-  if (
-    decoded.type === "cell-error" &&
-    hasExactKeys(decoded, ["cellId", "error", "sessionId", "type", "version"]) &&
-    isNonEmptyString(decoded.cellId)
-  ) {
+  if (decoded.type === "cell-error" && isNonEmptyString(decoded.cellId)) {
+    const expectedKeys = ["cellId", "error", "sessionId", "type", "version"];
+    if (decoded.console !== undefined) expectedKeys.push("console");
+    if (!hasExactKeys(decoded, expectedKeys)) {
+      return { ok: false, message: "CodeMode worker response has an invalid protocol shape" };
+    }
     const error = parseWorkerError(decoded.error);
-    if (error !== undefined && ["script", "serialization", "runtime"].includes(error.code)) {
+    const consoleEntries =
+      decoded.console === undefined ? undefined : parseConsoleOutput(decoded.console);
+    if (
+      error !== undefined &&
+      ["script", "serialization", "runtime"].includes(error.code) &&
+      (decoded.console === undefined || consoleEntries !== undefined)
+    ) {
       // SAFETY: The literal-membership check above refines the protocol string to the closed worker error code union.
       const code = error.code as CodeModeWorkerCellErrorCode;
+      const value = {
+        version: CODEMODE_WORKER_PROTOCOL_VERSION,
+        type: "cell-error",
+        sessionId: decoded.sessionId,
+        cellId: decoded.cellId,
+        error: { code, message: error.message },
+      } as const;
       return {
         ok: true,
-        value: {
-          version: CODEMODE_WORKER_PROTOCOL_VERSION,
-          type: "cell-error",
-          sessionId: decoded.sessionId,
-          cellId: decoded.cellId,
-          error: { code, message: error.message },
-        },
+        value: consoleEntries === undefined ? value : { ...value, console: consoleEntries },
       };
     }
   }
@@ -456,7 +543,28 @@ export function serializeCodeModeWorkerRequest(
 
 /** Serializes one worker response, replacing oversized Cell output with a bounded error. */
 export function serializeCodeModeWorkerResponse(response: CodeModeWorkerResponse): string {
-  const message = jsonStringify(response);
+  let message: string;
+  if (response.type === "cell-result" && response.console?.length === 0) {
+    const responseBase = {
+      version: response.version,
+      type: response.type,
+      sessionId: response.sessionId,
+      cellId: response.cellId,
+    } as const;
+    message = jsonStringify(
+      response.resultJson === undefined
+        ? responseBase
+        : { ...responseBase, resultJson: response.resultJson },
+    );
+  } else if (response.type === "cell-error" && response.console?.length === 0) {
+    message = jsonStringify({
+      version: response.version,
+      type: response.type,
+      sessionId: response.sessionId,
+      cellId: response.cellId,
+      error: response.error,
+    });
+  } else message = jsonStringify(response);
   if (Buffer.byteLength(message, "utf8") <= CODEMODE_WORKER_MESSAGE_LIMIT_BYTES) return message;
   if (
     response.type === "cell-result" ||