pi2web 0.2.0 → 0.2.6

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,38 @@ export class SdkBackend {
         this.agentId = agentId;
         this.cwd = cwd;
     }
-    static async create(agentId, cwd, sessionFile) {
+    static async create(agentId, cwd, sessionFile, profile = 'default', collabBridge, options = {}) {
         const sessionManager = sessionFile ? SessionManager.open(sessionFile) : SessionManager.create(cwd);
-        const { session, modelFallbackMessage } = await createAgentSession({ cwd, sessionManager });
+        const { template, piDefaultPrompt } = options;
+        // 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 extensionFactories = profile === 'collab' && collabBridge
+            ? [{ name: 'pi2web-collab', factory: createCollabExtension(agentId, collabBridge) }]
+            : [];
+        // A template behaves like Pi's own prompt files: `replace` stands in for SYSTEM.md, `append` follows
+        // APPEND_SYSTEM.md. `piDefaultPrompt` ignores both files to show what Pi itself would send.
+        const systemPromptOverride = piDefaultPrompt
+            ? () => undefined
+            : template?.mode === 'replace'
+                ? () => template.systemPrompt
+                : undefined;
+        const appendSystemPromptOverride = piDefaultPrompt
+            ? () => []
+            : template?.mode === 'append'
+                ? (base) => [...base, template.systemPrompt]
+                : undefined;
+        const resourceLoader = extensionFactories.length || systemPromptOverride || appendSystemPromptOverride
+            ? new DefaultResourceLoader({
+                cwd,
+                agentDir: getAgentDir(),
+                extensionFactories,
+                systemPromptOverride,
+                appendSystemPromptOverride
+            })
+            : 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,61 +57,268 @@ export class SdkBackend {
         await session.bindExtensions({ uiContext: backend.extensionUi() });
         return backend;
     }
-    prompt(message) { return this.session.prompt(message); }
-    steer(message) { return this.session.steer(message); }
-    followUp(message) { return this.session.followUp(message); }
-    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]; }
+    // 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);
+    }
+    // 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'
+        };
+    }
+    timeline() {
+        const manager = this.session.sessionManager;
+        return {
+            sessionId: this.session.sessionId,
+            leafId: manager.getLeafId(),
+            entries: () => manager.getBranch()
+        };
+    }
+    /** The effective system prompt Pi will send next, plus the prompt files that contributed to it. */
+    async getSystemPrompt() {
+        const loader = this.session.resourceLoader;
+        return {
+            systemPrompt: this.session.systemPrompt,
+            systemFile: loader.getSystemPromptSource()?.path,
+            appendFiles: loader.getAppendSystemPromptSources().map(source => source.path),
+            contextFiles: loader.getAgentsFiles().agentsFiles.map(file => file.path)
+        };
+    }
     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() };
-    }
-    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)
-        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))
-        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); }
-    navigate(entryId) { return this.session.navigateTree(entryId); }
-    async fork(entryId) { const entry = this.session.sessionManager.getEntry(entryId); if (!entry || entry.type !== 'message' || entry.message?.role !== 'user')
-        throw Object.assign(new Error('A user message entry is required'), { code: 'SESSION_ENTRY_NOT_FOUND' }); const content = entry.message.content; const selectedText = typeof content === 'string' ? content : Array.isArray(content) ? content.filter((part) => part.type === 'text').map((part) => part.text).join('\n') : ''; let sessionFile; if (entry.parentId) {
-        sessionFile = this.session.sessionManager.createBranchedSession(entry.parentId);
-    }
-    else {
-        const current = this.session.sessionFile;
-        if (!current)
-            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); }
-    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) {
+        // 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.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 (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);
+    }
+    navigate(entryId) {
+        return this.session.navigateTree(entryId);
+    }
+    async fork(entryId) {
+        const entry = this.session.sessionManager.getEntry(entryId);
+        if (!entry || entry.type !== 'message' || entry.message?.role !== 'user')
+            throw Object.assign(new Error('A user message entry is required'), { code: 'SESSION_ENTRY_NOT_FOUND' });
+        const content = entry.message.content;
+        const selectedText = typeof content === 'string'
+            ? content
+            : Array.isArray(content)
+                ? content
+                    .filter((part) => part.type === 'text')
+                    .map((part) => part.text)
+                    .join('\n')
+                : '';
+        let sessionFile;
+        if (entry.parentId) {
+            sessionFile = this.session.sessionManager.createBranchedSession(entry.parentId);
+        }
+        else {
+            const current = this.session.sessionFile;
+            if (!current)
+                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) {
+        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 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
+        };
+    }
+    resolveUiRequest(requestId, value) {
+        const pending = this.pendingUi.get(requestId);
+        if (!pending)
+            return false;
         clearTimeout(pending.timer);
-        pending.resolve(undefined);
-        this.pendingUi.delete(id);
-    } 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 }); }); }
+        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 }),
+            select: async (title, options, opts) => (await this.request('select', { title, options, opts })),
             confirm: async (title, message, opts) => Boolean(await this.request('confirm', { title, message, opts })),
-            input: async (title, placeholder, opts) => await this.request('input', { title, placeholder, opts }),
-            editor: async (title, prefill) => await this.request('editor', { title, prefill }),
+            input: async (title, placeholder, opts) => (await this.request('input', { title, placeholder, opts })),
+            editor: async (title, prefill) => (await this.request('editor', { title, prefill })),
             notify: (message, type) => this.events.emit('event', { type: 'extension_ui_notify', message, notificationType: type ?? 'info' }),
             setStatus: (key, text) => this.events.emit('event', { type: 'extension_ui_status', key, text }),
-            setWidget: (key, content, options) => this.events.emit('event', { type: 'extension_ui_widget', key, content: Array.isArray(content) ? content : undefined, options }),
+            setWidget: (key, content, options) => this.events.emit('event', {
+                type: 'extension_ui_widget',
+                key,
+                content: Array.isArray(content) ? content : undefined,
+                options
+            }),
             setTitle: (title) => this.events.emit('event', { type: 'extension_ui_title', title }),
-            setWorkingMessage: (message) => this.events.emit('event', { type: 'extension_ui_working_message', message }), setWorkingVisible: () => { }, setWorkingIndicator: () => { }, setHiddenThinkingLabel: () => { },
-            onTerminalInput: () => () => { }, setFooter: () => { }, setHeader: () => { }, pasteToEditor: () => { }, setEditorText: () => { }, getEditorText: () => '', addAutocompleteProvider: () => { }, setEditorComponent: () => { }, custom: async () => { throw Object.assign(new Error('Custom extension components are unsupported'), { code: 'EXTENSION_CUSTOM_UI_UNSUPPORTED' }); }
+            setWorkingMessage: (message) => this.events.emit('event', { type: 'extension_ui_working_message', message }),
+            setWorkingVisible: () => { },
+            setWorkingIndicator: () => { },
+            setHiddenThinkingLabel: () => { },
+            onTerminalInput: () => () => { },
+            setFooter: () => { },
+            setHeader: () => { },
+            pasteToEditor: () => { },
+            setEditorText: () => { },
+            getEditorText: () => '',
+            addAutocompleteProvider: () => { },
+            setEditorComponent: () => { },
+            custom: async () => {
+                throw Object.assign(new Error('Custom extension components are unsupported'), {
+                    code: 'EXTENSION_CUSTOM_UI_UNSUPPORTED'
+                });
+            }
         };
     }
 }
-export const createSdkBackend = (agentId, cwd, sessionFile) => SdkBackend.create(agentId, cwd, sessionFile);
+export const createSdkBackend = (agentId, cwd, sessionFile, profile = 'default', collabBridge, options = {}) => SdkBackend.create(agentId, cwd, sessionFile, profile, collabBridge, options);