pi-sdk-web 0.2.4 → 0.3.0

package/dist/cli.js

@@ -7,7 +7,7 @@
  *   pi-web list                       List all sessions (name, id, cwd), newest first
  *   pi-web help                       Show this help
  */
-import { SettingsManager, createAgentSessionFromServices, createAgentSessionServices, getAgentDir, resolveModelScopeWithDiagnostics, } from "@earendil-works/pi-coding-agent";
+import { SettingsManager, createAgentSessionFromServices, createAgentSessionRuntime, createAgentSessionServices, getAgentDir, resolveModelScopeWithDiagnostics, } from "@earendil-works/pi-coding-agent";
 import { findSessionByName, listSessions, loadBuiltinExtensions } from "./session.js";
 import { PiWebServer } from "./server.js";
 const DEFAULT_PORT = 4080;
@@ -56,21 +56,38 @@ async function cmdResume(name, port) {
     // the same modelRuntime used below, so scopedModels resolution sees them.
     const agentDir = getAgentDir();
     const settingsManager = SettingsManager.create(sessionManager.getCwd(), agentDir);
-    const services = await createAgentSessionServices({
+    // Runtime factory: re-invoked by AgentSessionRuntime whenever the session is
+    // replaced (e.g. /resume switches to another session with a different cwd).
+    const createRuntime = async ({ cwd, agentDir: dir, sessionManager: sm, sessionStartEvent }) => {
+        const settings = SettingsManager.create(cwd, dir);
+        const services = await createAgentSessionServices({
+            cwd,
+            agentDir: dir,
+            settingsManager: settings,
+            resourceLoaderOptions: { extensionFactories: await loadBuiltinExtensions() },
+        });
+        // Resolve enabledModels (settings) into scopedModels, matching Pi's CLI
+        const enabledModels = settings.getEnabledModels();
+        const scopedModels = enabledModels && enabledModels.length > 0
+            ? (await resolveModelScopeWithDiagnostics(enabledModels, services.modelRuntime, {
+                signal: AbortSignal.timeout(15_000),
+            })).scopedModels
+            : [];
+        const created = await createAgentSessionFromServices({
+            services,
+            sessionManager: sm,
+            sessionStartEvent,
+            scopedModels,
+        });
+        return { ...created, services, diagnostics: [] };
+    };
+    const runtime = await createAgentSessionRuntime(createRuntime, {
         cwd: sessionManager.getCwd(),
         agentDir,
-        settingsManager,
-        resourceLoaderOptions: { extensionFactories: await loadBuiltinExtensions() },
+        sessionManager,
     });
-    // Resolve enabledModels (settings) into scopedModels, matching Pi's CLI
-    const enabledModels = settingsManager.getEnabledModels();
-    const scopedModels = enabledModels && enabledModels.length > 0
-        ? (await resolveModelScopeWithDiagnostics(enabledModels, services.modelRuntime, {
-            signal: AbortSignal.timeout(15_000),
-        })).scopedModels
-        : [];
-    const { session } = await createAgentSessionFromServices({ services, sessionManager, scopedModels });
-    const server = new PiWebServer(session, { port });
+    const { session } = runtime;
+    const server = new PiWebServer(runtime, { port });
     await server.start();
     console.log(`server at http://127.0.0.1:${port}/ (session: ${info.name ?? info.id})`);
     let shuttingDown = false;
@@ -86,7 +103,7 @@ async function cmdResume(name, port) {
             // ignore teardown errors - we still need to exit
         }
         try {
-            session.dispose();
+            runtime.dispose();
         }
         catch {
             // ignore

package/dist/server.js

@@ -16,6 +16,7 @@ import { dirname, join, resolve, sep } from "node:path";
 import { fileURLToPath } from "node:url";
 import { ModelRegistry, VERSION, } from "@earendil-works/pi-coding-agent";
 import { WebSocket, WebSocketServer } from "ws";
+import { listSessions } from "./session.js";
 import { WebUIContext } from "./ui-context.js";
 const DEFAULT_PORT = 4080;
 // Static frontend: prefer the in-package copy (built by `npm run build` for
@@ -62,7 +63,7 @@ const MIME = {
     ".ico": "image/x-icon",
 };
 export class PiWebServer {
-    session;
+    runtime;
     port;
     staticDir;
     uiContext;
@@ -70,8 +71,12 @@ export class PiWebServer {
     wsServer = null;
     clients = new Set();
     unsubscribe = null;
-    constructor(session, options = {}) {
-        this.session = session;
+    /** Current session (may change on /resume session switching). */
+    get session() {
+        return this.runtime.session;
+    }
+    constructor(runtime, options = {}) {
+        this.runtime = runtime;
         this.port = options.port ?? DEFAULT_PORT;
         this.staticDir = options.staticDir ?? STATIC_DIR;
         this.uiContext = new WebUIContext((obj) => this.broadcast(obj));
@@ -80,13 +85,10 @@ export class PiWebServer {
     // Lifecycle
     // ------------------------------------------------------------------
     async start() {
-        // Bind extensions with the web UI context (replaces the TUI/RPC context)
-        await this.session.bindExtensions({
-            uiContext: this.uiContext,
-            // "rpc" is the closest ExtensionMode: dialog-capable UI (hasUI=true),
-            // but not terminal-only UI
-            mode: "rpc",
-        });
+        // Rebind hook: invoked by the runtime whenever the session is replaced
+        // (/resume switches to another session).
+        this.runtime.setRebindSession(() => this.bindCurrentSession(true));
+        await this.bindCurrentSession(false);
         this.httpServer = createServer((req, res) => this.handleHttp(req, res));
         // Some components (ws internals, MCP-style extensions) accumulate 'close'
         // listeners on the server; raise the limit to avoid MaxListenersExceededWarning
@@ -98,13 +100,46 @@ export class PiWebServer {
             this.httpServer.once("error", reject);
             this.httpServer.listen(this.port, "127.0.0.1", () => resolvePromise());
         });
-        // Forward session events to all browser clients
-        this.unsubscribe = this.session.subscribe((event) => {
+    }
+    /**
+     * Bind extensions + subscribe events for the current session, and sync the
+     * process cwd. On session replacement (`afterSwitch`), also tell browsers to
+     * reload their view (new state + history) and switch the process cwd.
+     */
+    async bindCurrentSession(afterSwitch) {
+        const session = this.runtime.session;
+        // Unsubscribe from the previous session first (also avoids stale events
+        // during teardown/dispose of the old session).
+        this.unsubscribe?.();
+        this.unsubscribe = null;
+        await session.bindExtensions({
+            uiContext: this.uiContext,
+            // "rpc" is the closest ExtensionMode: dialog-capable UI (hasUI=true),
+            // but not terminal-only UI
+            mode: "rpc",
+        });
+        this.unsubscribe = session.subscribe((event) => {
             this.broadcast(event);
             if (STATS_REFRESH_EVENTS.has(event.type)) {
                 this.broadcastStats();
             }
         });
+        if (afterSwitch) {
+            // Align process cwd with the resumed session (same as startup chdir)
+            const cwd = session.sessionManager.getCwd();
+            if (cwd) {
+                try {
+                    process.chdir(cwd);
+                }
+                catch {
+                    console.error(`Session cwd not found (${cwd}), keeping current directory`);
+                }
+            }
+            // Stale extension dialogs/status from the previous session are dropped
+            this.uiContext.clearSessionState();
+            this.broadcastState();
+            this.broadcastHistory();
+        }
     }
     async stop() {
         this.unsubscribe?.();
@@ -172,6 +207,10 @@ export class PiWebServer {
             // state unavailable - skip
         }
     }
+    /** Broadcast the current session's history (used after session switching). */
+    broadcastHistory() {
+        this.broadcast({ type: "history", data: this.buildHistory() });
+    }
     // ------------------------------------------------------------------
     // HTTP: static files
     // ------------------------------------------------------------------
@@ -491,12 +530,54 @@ export class PiWebServer {
                 // Read-only session info (TUI /session equivalent)
                 this.broadcastSessionInfo();
                 break;
+            case "get_sessions": {
+                // All sessions except the current one (for /resume)
+                const currentFile = this.session.sessionFile;
+                const all = await listSessions();
+                this.broadcast({
+                    type: "sessions",
+                    data: all
+                        .filter((s) => s.path !== currentFile)
+                        .map((s) => ({ name: s.name ?? "", id: s.id, cwd: s.cwd, path: s.path })),
+                });
+                break;
+            }
+            case "resume": {
+                const path = typeof data.path === "string" && data.path ? data.path : "";
+                if (!path)
+                    throw new Error("Missing 'path'");
+                await this.resumeSession(path);
+                break;
+            }
             default:
                 throw new Error(`Unsupported command: ${cmdType}`);
         }
     }
-    /** TUI /session equivalent: show session info as a modal (read-only). */
-    broadcastSessionInfo() {
+    /**
+     * Resume (switch to) another session file. The runtime tears down the current
+     * session, creates the new one and invokes our rebind callback, which rebinds
+     * extensions, resubscribes, switches cwd and broadcasts state/history.
+     */
+    async resumeSession(path) {
+        // Unsubscribe from the current session before teardown so stale events from
+        // the old session are not broadcast during disposal.
+        this.unsubscribe?.();
+        this.unsubscribe = null;
+        try {
+            const result = await this.runtime.switchSession(path);
+            if (result.cancelled)
+                return;
+        }
+        catch (err) {
+            // Rebind hook already ran on failure? No: on error the old session may be
+            // gone - resubscribe defensively to keep the server usable.
+            await this.bindCurrentSession(false);
+            throw err;
+        }
+        // On success the rebind hook (bindCurrentSession(true)) already ran inside
+        // switchSession; nothing more to do here.
+    }
+    /** TUI /session equivalent: show session info as a modal (read-only). */ broadcastSessionInfo() {
         try {
             const stats = this.session.getSessionStats();
             const sm = this.session.sessionManager;

package/dist/static/app.js

@@ -9,6 +9,7 @@ const BUILTIN_COMMANDS = [
   { name: 'reload', description: 'Reload session resources and extensions', builtin: true, action: 'reload' },
   { name: 'export', description: 'Export session to HTML (or .jsonl)', builtin: true, action: 'export' },
   { name: 'session', description: 'Show session information', builtin: true, action: 'session' },
+  { name: 'resume', description: 'Switch to another session', builtin: true, action: 'resume' },
   { name: 'name', description: 'Set session display name', builtin: true, action: 'name' },
   { name: 'login', description: 'Configure provider authentication (not supported in web)', builtin: true, unsupported: true },
   { name: 'logout', description: 'Remove provider authentication (not supported in web)', builtin: true, unsupported: true },
@@ -165,6 +166,9 @@ class PiWebClient {
       case 'scoped_models':
         this.handleScopedModels(data.data);
         break;
+      case 'sessions':
+        this.handleSessions(data.data);
+        break;
       case 'error':
         this.appendError(data.error);
         break;
@@ -590,6 +594,19 @@ class PiWebClient {
     this.toolTimers.clear();
     this.toolEls.clear();
     this.streaming = { active: false, el: null, role: 'assistant' };
+    // Drop stale UI state from the previous session (on /resume reload)
+    const widgets = document.getElementById('widgets');
+    if (widgets) {
+      widgets.innerHTML = '';
+      widgets.style.display = 'none';
+    }
+    this.extStatus = {};
+    const extStatusEl = document.getElementById('ext-status');
+    if (extStatusEl) extStatusEl.style.display = 'none';
+    const pendingEl = document.getElementById('pending');
+    if (pendingEl) pendingEl.style.display = 'none';
+    const statusEl = document.getElementById('status');
+    if (statusEl) statusEl.style.display = 'none';
   }
 
   // ------------------------------------------------------------------
@@ -1205,6 +1222,8 @@ class PiWebClient {
       this.send({ type: 'export', path: path });
     } else if (cmd.action === 'session') {
       this.send({ type: 'session' });
+    } else if (cmd.action === 'resume') {
+      this.openResumePicker();
     } else if (cmd.action === 'name') {
       const newName = window.prompt('Set session display name:', '');
       if (newName && newName.trim()) {
@@ -1531,6 +1550,31 @@ class PiWebClient {
     });
   }
 
+  // ------------------------------------------------------------------
+  // Resume picker (switch to another session)
+  // ------------------------------------------------------------------
+
+  openResumePicker() {
+    this.openModal('Resume Session', 'resume');
+    this.modalList.innerHTML = '<div class="modal-message">Loading sessions...</div>';
+    this.send({ type: 'get_sessions' });
+  }
+
+  handleSessions(data) {
+    if (this.modalMode !== 'resume') return;
+    const sessions = data || [];
+    if (sessions.length === 0) {
+      this.modalList.innerHTML = '<div class="modal-message">No other sessions available</div>';
+      return;
+    }
+    this.renderModalItems(
+      sessions.map((s) => ({ name: s.name || s.id, desc: s.cwd, value: s.path })),
+      (item) => {
+        this.send({ type: 'resume', path: item.value });
+      },
+    );
+  }
+
   // ------------------------------------------------------------------
   // Scoped models picker (multi-select: models available for cycling)
   // ------------------------------------------------------------------

package/dist/ui-context.js

@@ -30,6 +30,16 @@ export class WebUIContext {
     getStatusSnapshot() {
         return Object.fromEntries(this.statusMap);
     }
+    /** Drop state tied to the previous session (dialogs + status snapshots). */
+    clearSessionState() {
+        for (const pending of this.pending.values()) {
+            if (pending.timer)
+                clearTimeout(pending.timer);
+            pending.resolve(undefined);
+        }
+        this.pending.clear();
+        this.statusMap.clear();
+    }
     /** Handle a browser `extension_ui_response` message. */
     respond(id, response) {
         const pending = this.pending.get(id);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-sdk-web",
-  "version": "0.2.4",
+  "version": "0.3.0",
   "description": "Browser Web access for Pi (AI coding agent) via the Pi SDK - standalone module, zero modification to Pi itself",
   "type": "module",
   "bin": {