pi2web 0.2.0 → 0.2.1

package/dist/sdk-backend.js

@@ -1,6 +1,9 @@
-import { createAgentSession, SessionManager } from '@earendil-works/pi-coding-agent';
+import { createAgentSession, DefaultResourceLoader, getAgentDir, SessionManager } from '@earendil-works/pi-coding-agent';
 import { EventEmitter } from 'node:events';
 import { randomUUID } from 'node:crypto';
+import { createCollabExtension } from './collab/pi-extension.js';
+/** Older Pi builds resolved steer()/followUp() with undefined; treat anything but an explicit `handled` as queued. */
+const normalizeDisposition = (value) => value === 'handled' ? 'handled' : 'queued';
 /** Real in-process Pi SDK backend with session/model/extension controls exposed to remote clients. */
 export class SdkBackend {
     session;
@@ -14,9 +17,14 @@ export class SdkBackend {
         this.agentId = agentId;
         this.cwd = cwd;
     }
-    static async create(agentId, cwd, sessionFile) {
+    static async create(agentId, cwd, sessionFile, profile = 'default', collabBridge) {
         const sessionManager = sessionFile ? SessionManager.open(sessionFile) : SessionManager.create(cwd);
-        const { session, modelFallbackMessage } = await createAgentSession({ cwd, sessionManager });
+        // This factory is deliberately inline instead of auto-discovered: normal Pi and normal pi2web agents
+        // never load the collaboration tools or their collaboration-specific system guidance.
+        const resourceLoader = profile === 'collab' && collabBridge ? new DefaultResourceLoader({ cwd, agentDir: getAgentDir(), extensionFactories: [{ name: 'pi2web-collab', factory: createCollabExtension(agentId, collabBridge) }] }) : undefined;
+        if (resourceLoader)
+            await resourceLoader.reload();
+        const { session, modelFallbackMessage } = await createAgentSession({ cwd, sessionManager, resourceLoader });
         if (modelFallbackMessage && !session.state.model) {
             session.dispose();
             throw Object.assign(new Error(modelFallbackMessage), { code: 'PI_MODEL_UNAVAILABLE' });
@@ -25,23 +33,54 @@ export class SdkBackend {
         await session.bindExtensions({ uiContext: backend.extensionUi() });
         return backend;
     }
+    // Slash commands, skills and prompt templates are expanded by prompt() itself (expandPromptTemplates defaults to true),
+    // so `/name args` typed in the web composer behaves exactly like the Pi TUI.
     prompt(message) { return this.session.prompt(message); }
-    steer(message) { return this.session.steer(message); }
-    followUp(message) { return this.session.followUp(message); }
+    // Since pi 0.99 steer()/followUp() report whether the message reached the running turn (`handled`)
+    // or waits for it (`queued`); the web composer shows that difference instead of guessing.
+    async steer(message) { return normalizeDisposition(await this.session.steer(message)); }
+    async followUp(message) { return normalizeDisposition(await this.session.followUp(message)); }
+    async getQueue() { return { steering: [...this.session.getSteeringMessages()], followUp: [...this.session.getFollowUpMessages()] }; }
+    /** Drop queued steering and follow-up messages and hand them back so a client can restore them to its composer. */
+    async clearQueue() { const cleared = this.session.clearQueue(); return { steering: [...cleared.steering], followUp: [...cleared.followUp] }; }
     abort() { return this.session.abort(); }
     async getState() { return { agentId: this.agentId, sessionId: this.session.sessionId, sessionFile: this.session.sessionFile, sessionName: this.session.sessionName, cwd: this.cwd, status: this.disposed ? 'stopped' : this.session.isStreaming ? 'streaming' : 'idle' }; }
     async getMessages() { return [...this.session.state.messages]; }
     async getCapabilities() {
         const current = this.session.model;
-        const available = this.session.modelRegistry.getAvailable();
-        return { model: current ? this.modelInfo(current) : null, models: available.map(model => this.modelInfo(model)), thinkingLevel: this.session.thinkingLevel, thinkingLevels: this.session.getAvailableThinkingLevels(), supportsThinking: this.session.supportsThinking() };
+        // ModelRuntime.getAvailable() is async since 0.80.8 and may consult provider auth; the snapshot keeps
+        // an unauthenticated or offline call from blocking the capabilities endpoint.
+        const available = await this.session.modelRuntime.getAvailable().catch(() => this.session.modelRuntime.getAvailableSnapshot());
+        return { model: current ? this.modelInfo(current) : null, models: available.map((model) => this.modelInfo(model)), thinkingLevel: this.session.thinkingLevel, thinkingLevels: this.session.getAvailableThinkingLevels(), supportsThinking: this.session.supportsThinking() };
     }
+    /** Slash commands the composer can offer: file-based prompt templates and skills discovered for this cwd. */
+    async listCommands() {
+        const loader = this.session.resourceLoader;
+        const prompts = loader.getPrompts().prompts.map(prompt => ({ name: prompt.name, description: prompt.description, argumentHint: prompt.argumentHint, source: 'prompt' }));
+        const skills = loader.getSkills().skills.map(skill => ({ name: `skill:${skill.name}`, description: skill.description, source: 'skill' }));
+        return [...prompts, ...skills].sort((a, b) => a.name.localeCompare(b.name));
+    }
+    /** Run a command inside the Agent session so its output is recorded in the transcript (`!!` keeps it out of the model context). */
+    async runBash(command, excludeFromContext = false) {
+        const id = randomUUID();
+        this.events.emit('event', { type: 'bash_execution_start', id, command });
+        try {
+            const result = await this.session.executeBash(command, undefined, { excludeFromContext, id });
+            this.events.emit('event', { type: 'bash_execution_end', id, command, ...result });
+            return { id, ...result };
+        }
+        catch (error) {
+            this.events.emit('event', { type: 'bash_execution_end', id, command, isError: true, errorMessage: error instanceof Error ? error.message : String(error) });
+            throw error;
+        }
+    }
+    abortBash() { this.session.abortBash(); }
     async getSession() { return { ...await this.getSessionInfo(), leafId: this.session.sessionManager.getLeafId(), entries: this.session.sessionManager.getEntries(), tree: this.session.sessionManager.getTree(), userMessages: this.session.getUserMessagesForForking() }; }
     async getSessionInfo() { return { sessionId: this.session.sessionId, sessionFile: this.session.sessionFile, sessionName: this.session.sessionName, stats: this.session.getSessionStats(), contextUsage: this.session.getContextUsage() }; }
     compact(instructions) { return this.session.compact(instructions); }
-    async setModel(provider, modelId) { const model = this.session.modelRegistry.find(provider, modelId); if (!model)
+    async setModel(provider, modelId) { const model = this.session.modelRuntime.getModel(provider, modelId); if (!model)
         throw Object.assign(new Error('Model not found'), { code: 'MODEL_NOT_FOUND' }); await this.session.setModel(model); }
-    async setThinkingLevel(level) { if (!['off', 'minimal', 'low', 'medium', 'high', 'xhigh'].includes(level))
+    async setThinkingLevel(level) { if (level !== 'off' && !this.session.getAvailableThinkingLevels().includes(level))
         throw Object.assign(new Error('Invalid thinking level'), { code: 'INVALID_THINKING_LEVEL' }); this.session.setThinkingLevel(level); }
     async setSessionName(name) { const value = name.trim(); if (!value || value.length > 200)
         throw Object.assign(new Error('Session name must be 1-200 characters'), { code: 'INVALID_SESSION_NAME' }); this.session.setSessionName(value); }
@@ -56,17 +95,41 @@ export class SdkBackend {
             throw Object.assign(new Error('Session persistence is disabled'), { code: 'SESSION_NOT_PERSISTED' });
         sessionFile = SessionManager.create(this.cwd, this.session.sessionManager.getSessionDir(), { parentSession: current }).getSessionFile();
     } return { sessionFile, selectedText }; }
-    async extensionResponse(requestId, value) { const pending = this.pendingUi.get(requestId); if (!pending)
-        throw Object.assign(new Error('Extension UI request not found'), { code: 'EXTENSION_REQUEST_NOT_FOUND' }); clearTimeout(pending.timer); this.pendingUi.delete(requestId); pending.resolve(value); }
+    async extensionResponse(requestId, value) {
+        if (!this.resolveUiRequest(requestId, value))
+            throw Object.assign(new Error('Extension UI request not found'), { code: 'EXTENSION_REQUEST_NOT_FOUND' });
+    }
     subscribe(listener) { const fromSession = (event) => listener(event); const unsubscribe = this.session.subscribe(fromSession); this.events.on('event', listener); return () => { unsubscribe(); this.events.off('event', listener); }; }
-    async dispose() { if (this.disposed)
-        return; for (const [id, pending] of this.pendingUi) {
-        clearTimeout(pending.timer);
-        pending.resolve(undefined);
-        this.pendingUi.delete(id);
-    } await this.session.abort(); this.session.dispose(); this.disposed = true; }
+    async dispose() {
+        if (this.disposed)
+            return;
+        for (const requestId of this.pendingUi.keys())
+            this.resolveUiRequest(requestId, undefined);
+        await this.session.abort();
+        this.session.dispose();
+        this.disposed = true;
+    }
     modelInfo(model) { return { provider: model.provider, id: model.id, name: model.name, reasoning: !!model.reasoning, contextWindow: model.contextWindow, maxTokens: model.maxTokens }; }
-    request(kind, payload) { const requestId = randomUUID(); return new Promise(resolve => { const timer = setTimeout(() => { this.pendingUi.delete(requestId); resolve(undefined); }, 5 * 60_000); this.pendingUi.set(requestId, { resolve, timer }); this.events.emit('event', { type: 'extension_ui_request', requestId, kind, ...payload }); }); }
+    resolveUiRequest(requestId, value) {
+        const pending = this.pendingUi.get(requestId);
+        if (!pending)
+            return false;
+        clearTimeout(pending.timer);
+        this.pendingUi.delete(requestId);
+        // Publish before resuming the extension: every client sees the same order,
+        // including requests answered elsewhere, timed out, or closed during disposal.
+        this.events.emit('event', { type: 'extension_ui_response', requestId });
+        pending.resolve(value);
+        return true;
+    }
+    request(kind, payload) {
+        const requestId = randomUUID();
+        return new Promise(resolve => {
+            const timer = setTimeout(() => this.resolveUiRequest(requestId, undefined), 5 * 60_000);
+            this.pendingUi.set(requestId, { resolve, timer });
+            this.events.emit('event', { type: 'extension_ui_request', requestId, kind, ...payload });
+        });
+    }
     extensionUi() {
         return {
             select: async (title, options, opts) => await this.request('select', { title, options, opts }),
@@ -82,4 +145,4 @@ export class SdkBackend {
         };
     }
 }
-export const createSdkBackend = (agentId, cwd, sessionFile) => SdkBackend.create(agentId, cwd, sessionFile);
+export const createSdkBackend = (agentId, cwd, sessionFile, profile = 'default', collabBridge) => SdkBackend.create(agentId, cwd, sessionFile, profile, collabBridge);