@tt-a1i/openpi 0.3.1 → 0.5.0

package/bin/openpi.js

@@ -0,0 +1,145 @@
+#!/usr/bin/env node
+
+import { resolve } from "node:path";
+import { createJiti } from "jiti";
+
+function printHelp() {
+  console.log(`OpenPI Web Workbench
+
+Usage:
+  openpi web [workspace]
+  openpi [workspace]          Alias for openpi web [workspace]
+
+Options:
+  --port <number>              Bind a specific loopback port (development)
+  --no-open                    Do not open a browser (development)
+
+Starts an isolated local Web runtime. Browser conversations and session changes
+never enter an interactive terminal Pi session.`);
+}
+
+const args = process.argv.slice(2);
+if (args.includes("--help") || args.includes("-h")) {
+  printHelp();
+  process.exit(0);
+}
+const command = args[0] === "web" ? args.slice(1) : args;
+const noOpen = command.includes("--no-open");
+const noWorkspace = command.includes("--no-workspace");
+const portIndex = command.indexOf("--port");
+const portText = portIndex >= 0 ? command[portIndex + 1] : undefined;
+const workspaceArgs = [];
+for (let index = 0; index < command.length; index++) {
+  const value = command[index];
+  if (value === "--no-open") continue;
+  if (value === "--no-workspace") continue;
+  if (value === "--port") {
+    index++;
+    continue;
+  }
+  workspaceArgs.push(value);
+}
+const configuredPort = portText ?? process.env.OPENPI_WEB_PORT;
+const port = configuredPort === undefined ? undefined : Number(configuredPort);
+if (portIndex >= 0 && (!portText || portText.startsWith("--"))) {
+  console.error("--port requires a value");
+  process.exit(1);
+}
+if (port !== undefined && (!Number.isInteger(port) || port < 0 || port > 65535)) {
+  console.error("--port must be an integer between 0 and 65535");
+  process.exit(1);
+}
+if (workspaceArgs.length > 1) {
+  console.error("Usage: openpi web [workspace]");
+  process.exit(1);
+}
+if (noWorkspace && workspaceArgs.length > 0) {
+  console.error("--no-workspace cannot be combined with a workspace");
+  process.exit(1);
+}
+
+let host;
+let runtime;
+let stopping;
+const stop = () => {
+  stopping ??= host?.stop() ?? runtime?.dispose() ?? Promise.resolve();
+  return stopping;
+};
+
+try {
+  const jiti = createJiti(import.meta.url);
+  const [browserModule, hostModule, runtimeModule, statusModule, traceModule] =
+    await Promise.all([
+      jiti.import("../web/host/browser-launcher.ts"),
+      jiti.import("../web/host/web-host.ts"),
+      jiti.import("../web/runtime/pi-runtime.ts"),
+      jiti.import("../web/host/terminal-status.ts"),
+      jiti.import("../web/trace.ts"),
+    ]);
+  const { openBrowser } = browserModule;
+  const { WebHost } = hostModule;
+  const { PiWebRuntime } = runtimeModule;
+  const { formatWebReadyScreen } = statusModule;
+  const { traceWeb } = traceModule;
+  runtime = noWorkspace
+    ? await PiWebRuntime.createWithoutWorkspace()
+    : await PiWebRuntime.create(resolve(workspaceArgs[0] ?? process.cwd()));
+  host = new WebHost({
+    runtime,
+    ...(port === undefined ? {} : { port }),
+    ...(process.env.OPENPI_WEB_TOKEN
+      ? { token: process.env.OPENPI_WEB_TOKEN }
+      : {}),
+    ...(process.env.OPENPI_WEB_ALLOWED_ORIGIN
+      ? { allowedOrigins: [process.env.OPENPI_WEB_ALLOWED_ORIGIN] }
+      : {}),
+  });
+  await host.start();
+  traceWeb("web_started", {
+    ...(runtime.workspaceSelected === true ? { cwd: runtime.cwd } : {}),
+    origin: host.origin,
+  });
+  const opened = noOpen ? false : await openBrowser(host.url);
+  if (noWorkspace) {
+    console.log(
+      formatWebReadyScreen({
+        origin: host.origin,
+        url: host.url,
+        opened,
+      }),
+    );
+  } else {
+    console.log(`OpenPI Web Workbench is running at ${host.origin}`);
+    if (!opened) console.log(`Open this URL in a browser: ${host.url}`);
+  }
+
+  for (const signal of ["SIGINT", "SIGTERM"]) {
+    process.once(signal, () => {
+      void stop().then(
+        () => process.exit(0),
+        (error) => {
+          console.error(
+            `Failed to stop OpenPI Web Workbench: ${error instanceof Error ? error.message : String(error)}`,
+          );
+          process.exit(1);
+        },
+      );
+    });
+  }
+} catch (error) {
+  let cleanupError;
+  try {
+    await stop();
+  } catch (caught) {
+    cleanupError = caught;
+  }
+  console.error(
+    `Failed to start OpenPI Web Workbench: ${error instanceof Error ? error.message : String(error)}`,
+  );
+  if (cleanupError) {
+    console.error(
+      `Failed to clean up OpenPI Web Workbench: ${cleanupError instanceof Error ? cleanupError.message : String(cleanupError)}`,
+    );
+  }
+  process.exit(1);
+}

package/extensions/ask-user/index.ts

@@ -15,36 +15,37 @@ import type {
 import {
   Editor,
   type EditorTheme,
+  type Focusable,
   Key,
   matchesKey,
   Text,
   truncateToWidth,
-  type Focusable,
   wrapTextWithAnsi,
 } from "@earendil-works/pi-tui";
 import { Cause, Effect, Exit } from "effect";
-import { Type, type Static } from "typebox";
-import { sanitizeTerminalText } from "../shared/terminal-text.ts";
+import { type Static, Type } from "typebox";
 import {
   PLAN_MODE_CHANNEL,
   type PlanModeState,
 } from "../shared/plan-mode-state.ts";
+import { hintLine } from "../shared/screen-chrome.ts";
 import {
   OPENPI_SETUP_EPISODE_CHANNEL,
   type OpenPiSetupEpisodeState,
 } from "../shared/setup-episode-state.ts";
+import { sanitizeTerminalText } from "../shared/terminal-text.ts";
 import {
   OPENPI_TOOL_SURFACE,
   patchOwnedTools,
 } from "../shared/tool-surface.ts";
 import { createHumanHandoffToolDefinition } from "./handoff.ts";
 import {
-  BRACKETED_PASTE_END,
-  BRACKETED_PASTE_START,
-  MAX_ANSWER_DRAFT_UTF8_BYTES,
   answerDraftByteLength,
   answerDraftFits,
+  BRACKETED_PASTE_END,
+  BRACKETED_PASTE_START,
   longerThanAnswerDraftLimit,
+  MAX_ANSWER_DRAFT_UTF8_BYTES,
   prospectiveAnswerDraftFits,
   sanitizeAnswerDraftEditorInput,
 } from "./limits.ts";
@@ -63,7 +64,7 @@ const MAX_OPTIONS = 5;
 /** Preview lines rendered before the tail is summarized. */
 const PREVIEW_MAX_LINES = 20;
 
-export { MAX_ANSWER_DRAFT_UTF8_BYTES, answerDraftFits } from "./limits.ts";
+export { answerDraftFits, MAX_ANSWER_DRAFT_UTF8_BYTES } from "./limits.ts";
 
 const OptionSchema = Type.Object({
   label: Type.String({
@@ -949,9 +950,15 @@ export default function askUser(pi: ExtensionAPI) {
               );
               lines.push("");
               add(
-                theme.fg(
-                  "dim",
-                  ` ↑↓ choose • 1-${params.questions.length} edit answer • Enter open/submit • Esc dismiss`,
+                hintLine(
+                  theme,
+                  [
+                    ["↑↓", "choose"],
+                    [`1-${params.questions.length}`, "edit answer"],
+                    ["enter", "open/submit"],
+                    ["esc", "dismiss"],
+                  ],
+                  width,
                 ),
               );
               add(theme.fg("accent", "─".repeat(width)));
@@ -1043,11 +1050,20 @@ export default function askUser(pi: ExtensionAPI) {
 
             lines.push("");
             add(
-              theme.fg(
-                "dim",
+              hintLine(
+                theme,
                 editMode
-                  ? " Enter save answer • Esc keep draft and return"
-                  : ` ↑↓ or 1-${currentOptions.length} select • Tab add notes • Enter save draft answer • Esc dismiss`,
+                  ? [
+                      ["enter", "save answer"],
+                      ["esc", "keep draft and return"],
+                    ]
+                  : [
+                      [`↑↓ or 1-${currentOptions.length}`, "select"],
+                      ["tab", "add notes"],
+                      ["enter", "save draft answer"],
+                      ["esc", "dismiss"],
+                    ],
+                width,
               ),
             );
             add(theme.fg("accent", "─".repeat(width)));

package/extensions/background-terminals/index.ts

@@ -32,6 +32,10 @@ import {
   OPENPI_TOOL_SURFACE,
   patchOwnedTools,
 } from "../shared/tool-surface.ts";
+import {
+  projectBackgroundTerminalCapability,
+  registerWebCapability,
+} from "../shared/web-observer-registry.ts";
 import type { TerminalSnapshot } from "./src/domain.ts";
 import {
   MAX_RUNNING,
@@ -95,6 +99,8 @@ interface WatchToolDetails {
 export default function (pi: ExtensionAPI) {
   let runtime: TerminalRuntime | undefined;
   let managerPromise: Promise<TerminalManagerShape> | undefined;
+  let managerForHooks: TerminalManagerShape | undefined;
+  let unregisterWebCapability: (() => void) | undefined;
   let sessionContext: ExtensionContext | undefined;
   let ui: ExtensionUIContext | undefined;
   let unsubStatus: (() => void) | undefined;
@@ -115,9 +121,21 @@ export default function (pi: ExtensionAPI) {
 
   /** Resolve the manager service once per runtime and wire the extension hooks. */
   const getManager = () => {
+    const scope = sessionContext?.sessionManager;
     managerPromise ??= getRuntime()
       .runPromise(TerminalManager)
       .then((manager) => {
+        managerForHooks = manager;
+        unregisterWebCapability?.();
+        unregisterWebCapability =
+          scope && sessionContext?.sessionManager === scope
+            ? registerWebCapability(scope, {
+                kind: "background-terminals",
+                snapshot: () =>
+                  projectBackgroundTerminalCapability(manager.view.list()),
+                subscribe: (listener) => manager.view.subscribe(listener),
+              })
+            : undefined;
         manager.view.setOnSettled(onSettled);
         unsubStatus?.();
         unsubStatus = manager.view.subscribe(() => updateWidget(manager));
@@ -214,6 +232,7 @@ export default function (pi: ExtensionAPI) {
         // costing a turn.
         resultDeliveryOptions(wake),
       );
+      for (const snap of snaps) managerForHooks?.view.releaseResult(snap.id);
       return true;
     } catch (error) {
       // Session may be shutting down, but retain the snapshot so any later
@@ -253,6 +272,7 @@ export default function (pi: ExtensionAPI) {
       stdout: { ...snap.stdout },
       stderr: { ...snap.stderr },
     });
+    managerForHooks?.view.retainResult(snap.id);
     // Pending settlements remain retractable while busy, so bg_status/bg_kill
     // can consume them before they are committed to context. bg_start applies
     // backpressure across running + pending + reserved work, keeping this map
@@ -310,7 +330,10 @@ export default function (pi: ExtensionAPI) {
     ui = undefined;
     const closing = runtime;
     runtime = undefined;
+    unregisterWebCapability?.();
+    unregisterWebCapability = undefined;
     managerPromise = undefined;
+    managerForHooks = undefined;
     await closing?.dispose();
   });
 
@@ -423,12 +446,16 @@ export default function (pi: ExtensionAPI) {
         );
       }
 
+      const text = buildStatusResult(snap);
       // This status is returning the settlement itself; a pending automatic
       // follow-up for the same settle would be a duplicate.
-      if (snap.status !== "running") resultDelivery.consume([snap.id]);
+      if (snap.status !== "running") {
+        resultDelivery.consume([snap.id]);
+        manager.view.releaseResult(snap.id);
+      }
 
       return {
-        content: [{ type: "text", text: buildStatusResult(snap) }],
+        content: [{ type: "text", text }],
         details: {
           id: snap.id,
           status: snap.status,
@@ -510,6 +537,7 @@ export default function (pi: ExtensionAPI) {
       // via the killInterest consumed flag). Remove any deferred automatic
       // delivery now that this tool returns the final state itself.
       resultDelivery.consume(ids);
+      for (const id of ids) manager.view.releaseResult(id);
 
       return {
         content: [{ type: "text", text: buildKillReport(report) }],

package/extensions/background-terminals/src/domain.ts

@@ -23,6 +23,8 @@ export type TerminalStatus =
 export interface OutputView {
   /** Decoded, possibly head-trimmed text (bounded by the in-memory cap). */
   readonly text: string;
+  /** Stateful, bounded projection safe for model-facing output. */
+  readonly modelSafeText: string;
   /** True total bytes ever received on this stream. */
   readonly totalBytes: number;
   /** Bytes dropped from the head of the in-memory view (0 = complete). */