pi-sdk-web 0.1.0

package/dist/session.js

@@ -0,0 +1,52 @@
+var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
+    if (typeof path === "string" && /^\.\.?\//.test(path)) {
+        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
+            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
+        });
+    }
+    return path;
+};
+/**
+ * Session lookup helpers for the pi-web CLI.
+ *
+ * `pi-web r <name>` semantics match pii: match by session display name
+ * (session_info entry), and if several sessions share the name, pick the
+ * most recently modified one.
+ */
+import { join, dirname } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { SessionManager, } from "@earendil-works/pi-coding-agent";
+/** List all sessions, newest first. */
+export async function listSessions() {
+    return SessionManager.listAll();
+}
+/**
+ * Find a session by display name and open it.
+ * Throws with available names when no match is found.
+ */
+export async function findSessionByName(name) {
+    const all = await listSessions();
+    const hits = all
+        .filter((s) => s.name === name)
+        .sort((a, b) => b.modified.getTime() - a.modified.getTime());
+    if (hits.length === 0) {
+        const names = [...new Set(all.map((s) => s.name).filter(Boolean))].sort();
+        const available = names.length > 0 ? `\nAvailable names: ${names.join(", ")}` : "";
+        throw new Error(`No session named '${name}'${available}`);
+    }
+    const info = hits[0];
+    return { info, sessionManager: SessionManager.open(info.path) };
+}
+/** Build a resource loader including Pi's built-in extensions. */
+export async function loadBuiltinExtensions() {
+    try {
+        const entryUrl = import.meta.resolve("@earendil-works/pi-coding-agent");
+        const entryPath = fileURLToPath(entryUrl); // .../dist/index.js
+        const extPath = join(dirname(entryPath), "extensions", "index.js");
+        const mod = (await import(__rewriteRelativeImportExtension(pathToFileURL(extPath).href)));
+        return mod.builtInExtensions ?? [];
+    }
+    catch {
+        return [];
+    }
+}

package/dist/ui-context.js

@@ -0,0 +1,147 @@
+/**
+ * Identity theme: extensions call ui.theme.fg(...) / ui.theme.bg(...) to get
+ * ANSI-colored strings. The browser renders with CSS, so we return text
+ * unchanged (color codes are meaningless in the DOM). Keeps extensions from
+ * crashing on theme access; real colors can be added later.
+ */
+function createIdentityTheme() {
+    return new Proxy({}, {
+        get(_target, prop) {
+            // theme.name / theme.isDark etc. may be accessed as properties
+            if (prop === "name")
+                return "dark";
+            if (prop === "isDark")
+                return true;
+            // Everything else is a color function (fg/bg/...): return identity
+            return (text) => (typeof text === "string" ? text : "");
+        },
+    });
+}
+export class WebUIContext {
+    pending = new Map();
+    sink;
+    identityTheme = createIdentityTheme();
+    constructor(sink) {
+        this.sink = sink;
+    }
+    /** Handle a browser `extension_ui_response` message. */
+    respond(id, response) {
+        const pending = this.pending.get(id);
+        if (!pending)
+            return false;
+        this.pending.delete(id);
+        if (pending.timer)
+            clearTimeout(pending.timer);
+        if (response.cancelled) {
+            pending.resolve(undefined);
+        }
+        else if (response.confirmed !== undefined) {
+            pending.resolve(response.confirmed);
+        }
+        else {
+            pending.resolve(response.value);
+        }
+        return true;
+    }
+    createDialog(request, defaultValue, parse) {
+        const id = crypto.randomUUID();
+        return new Promise((resolve) => {
+            const timeoutMs = typeof request.timeout === "number" ? request.timeout : undefined;
+            const timer = timeoutMs
+                ? setTimeout(() => {
+                    this.pending.delete(id);
+                    resolve(defaultValue);
+                }, timeoutMs)
+                : undefined;
+            this.pending.set(id, {
+                resolve: (value) => resolve(parse(value)),
+                timer,
+            });
+            this.sink({ type: "extension_ui_request", id, ...request });
+        });
+    }
+    // ------------------------------------------------------------------
+    // Dialogs (browser resolves via extension_ui_response)
+    // ------------------------------------------------------------------
+    select(title, options, opts) {
+        return this.createDialog({ method: "select", title, options, timeout: opts?.timeout }, undefined, (v) => (typeof v === "string" ? v : undefined));
+    }
+    confirm(title, message, opts) {
+        return this.createDialog({ method: "confirm", title, message, timeout: opts?.timeout }, false, (v) => v === true);
+    }
+    input(title, placeholder, opts) {
+        return this.createDialog({ method: "input", title, placeholder, timeout: opts?.timeout }, undefined, (v) => (typeof v === "string" ? v : undefined));
+    }
+    editor(title, prefill) {
+        return this.createDialog({ method: "editor", title, prefill }, undefined, (v) => typeof v === "string" ? v : undefined);
+    }
+    // ------------------------------------------------------------------
+    // Fire-and-forget UI events (broadcast to browser)
+    // ------------------------------------------------------------------
+    notify(message, type) {
+        this.sink({ type: "extension_ui_request", id: crypto.randomUUID(), method: "notify", message, notifyType: type });
+    }
+    setStatus(key, text) {
+        this.sink({ type: "extension_ui_request", id: crypto.randomUUID(), method: "setStatus", statusKey: key, statusText: text });
+    }
+    setTitle(title) {
+        this.sink({ type: "extension_ui_request", id: crypto.randomUUID(), method: "setTitle", title });
+    }
+    setWidget(key, content, options) {
+        this.sink({
+            type: "extension_ui_request",
+            id: crypto.randomUUID(),
+            method: "setWidget",
+            widgetKey: key,
+            widgetLines: Array.isArray(content) ? content : undefined,
+            widgetPlacement: options?.placement,
+        });
+    }
+    // ------------------------------------------------------------------
+    // Terminal-specific features: no-op in web mode
+    // ------------------------------------------------------------------
+    onTerminalInput() {
+        return () => { };
+    }
+    setWorkingMessage() { }
+    setWorkingVisible() { }
+    setWorkingIndicator() { }
+    setHiddenThinkingLabel() { }
+    setFooter() { }
+    setHeader() { }
+    custom() {
+        return Promise.resolve(undefined);
+    }
+    pasteToEditor() { }
+    setEditorText() { }
+    getEditorText() {
+        return "";
+    }
+    addAutocompleteProvider() { }
+    setEditorComponent() { }
+    getEditorComponent() {
+        return undefined;
+    }
+    // ------------------------------------------------------------------
+    // Theme
+    // ------------------------------------------------------------------
+    get theme() {
+        return this.identityTheme;
+    }
+    getAllThemes() {
+        return [];
+    }
+    getTheme() {
+        return undefined;
+    }
+    setTheme() {
+        return { success: false, error: "Theme switching not supported in web mode" };
+    }
+    // ------------------------------------------------------------------
+    // Tool output expansion (web always shows expandable blocks)
+    // ------------------------------------------------------------------
+    getToolsExpanded() {
+        return false;
+    }
+    setToolsExpanded() { }
+}

package/dist/verify-sdk.js

@@ -0,0 +1,112 @@
+/**
+ * SDK link verification script (dev only).
+ *
+ * Proves that a third-party package can drive a full Pi AgentSession via the
+ * public SDK (@earendil-works/pi-coding-agent) without modifying Pi:
+ *   1. createAgentSession() -> AgentSession
+ *   2. bindExtensions() with a minimal no-op Web UI context
+ *   3. session.subscribe() -> event stream
+ *   4. session.prompt() -> LLM round-trip
+ *
+ * Run: npm run verify
+ */
+import { SessionManager, createAgentSession } from "@earendil-works/pi-coding-agent";
+// ---------------------------------------------------------------------------
+// Minimal no-op UI context: logs what extensions would show in the UI.
+// The real pi-sdk-web will map these to browser DOM (select/confirm/input/...).
+// Note: extensions call ui.theme.fg etc. - real WebUIContext must provide a
+// theme object (Pi exports initTheme/Theme utilities for this).
+// ---------------------------------------------------------------------------
+function createNoopUIContext() {
+    return {
+        select: async (title, options) => {
+            console.log(`[ui:select] ${title} ${JSON.stringify(options)}`);
+            return options[0];
+        },
+        confirm: async (title, message) => {
+            console.log(`[ui:confirm] ${title} ${message}`);
+            return true;
+        },
+        input: async (title, placeholder) => {
+            console.log(`[ui:input] ${title} ${placeholder ?? ""}`);
+            return undefined;
+        },
+        notify: (message, type) => {
+            console.log(`[ui:notify] ${type ?? "info"}: ${message}`);
+        },
+        onTerminalInput: () => () => { },
+        setStatus: (key, text) => {
+            if (text !== undefined)
+                console.log(`[ui:status] ${key}: ${text}`);
+        },
+        setWorkingMessage: () => { },
+        setWorkingVisible: () => { },
+        setWorkingIndicator: () => { },
+        setHiddenThinkingLabel: () => { },
+        setWidget: () => { },
+        setFooter: () => { },
+        setHeader: () => { },
+        setTitle: (title) => console.log(`[ui:title] ${title}`),
+        custom: async () => undefined,
+        pasteToEditor: () => { },
+        setEditorText: () => { },
+        getEditorText: () => "",
+        editor: async () => undefined,
+        addAutocompleteProvider: () => { },
+        setEditorComponent: () => { },
+        getEditorComponent: () => undefined,
+        get theme() {
+            return {};
+        },
+        getAllThemes: () => [],
+        getTheme: () => undefined,
+        setTheme: () => ({ success: true }),
+        getToolsExpanded: () => false,
+        setToolsExpanded: () => { },
+    };
+}
+async function main() {
+    console.log("=== pi-sdk-web SDK link verification ===");
+    // 1. Create an in-memory session (no disk writes) - proves SDK works
+    const sessionManager = SessionManager.inMemory();
+    console.log("[1] createAgentSession (in-memory)...");
+    const { session } = await createAgentSession({ sessionManager });
+    console.log(`    OK. model=${session.model?.provider}/${session.model?.id}`);
+    // 2. Bind extensions with no-op UI context
+    console.log("[2] bindExtensions (no-op UI context)...");
+    await session.bindExtensions({ uiContext: createNoopUIContext(), mode: "rpc" });
+    console.log("    OK.");
+    // 3. Subscribe to the event stream
+    const events = [];
+    let settled;
+    const settledPromise = new Promise((resolve) => {
+        settled = resolve;
+    });
+    session.subscribe((event) => {
+        const type = event.type;
+        if (!events.includes(type))
+            events.push(type);
+        console.log(`[event] ${type}`);
+        if (type === "agent_settled")
+            settled?.();
+    });
+    // 4. Prompt the model
+    console.log("[3] prompt: 'Reply with exactly: SDK-OK'...");
+    await session.prompt("Reply with exactly: SDK-OK");
+    const timeout = new Promise((resolve) => setTimeout(resolve, 120_000));
+    await Promise.race([settledPromise, timeout]);
+    console.log("\n=== Result ===");
+    console.log(`event types seen: ${events.join(", ")}`);
+    const ok = events.includes("message_start") && events.includes("message_end") && events.includes("agent_settled");
+    if (ok) {
+        console.log("✅ SDK LINK VERIFICATION PASSED");
+    }
+    else {
+        console.log("⚠️  Incomplete event flow - inspect output above");
+    }
+    process.exit(0);
+}
+main().catch((err) => {
+    console.error("❌ Verification failed:", err);
+    process.exit(1);
+});

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "pi-sdk-web",
+  "version": "0.1.0",
+  "description": "Browser Web access for Pi (AI coding agent) via the Pi SDK - standalone module, zero modification to Pi itself",
+  "type": "module",
+  "bin": {
+    "pi-web": "./dist/cli.js"
+  },
+  "files": [
+    "dist",
+    "static"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json && node -e \"require('node:fs').cpSync('../static', 'static', { recursive: true })\"",
+    "dev": "tsx src/cli.ts",
+    "verify": "tsx src/verify-sdk.ts",
+    "prepublishOnly": "npm run build"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "dependencies": {
+    "@earendil-works/pi-agent-core": "^0.84.2",
+    "@earendil-works/pi-coding-agent": "^0.84.2",
+    "ws": "^8.18.0"
+  },
+  "devDependencies": {
+    "@types/node": "^24.0.0",
+    "@types/ws": "^8.5.12",
+    "tsx": "^4.19.0",
+    "typescript": "^5.6.0"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/maxdai/pi-web.git"
+  },
+  "keywords": [
+    "pi",
+    "pi-coding-agent",
+    "browser",
+    "web-ui",
+    "agent",
+    "coding-agent"
+  ],
+  "author": "maxdai"
+}