@pimote/pimote 0.1.0

package/server/dist/event-buffer.js

@@ -0,0 +1,223 @@
+import { mapAgentMessage } from './message-mapper.js';
+/**
+ * Event buffer for reconnect replay with coalescing.
+ *
+ * All events are forwarded live via sendLive(). For the replay buffer,
+ * streaming deltas (message_update, tool_execution_update) are coalesced
+ * into their corresponding start events rather than stored individually.
+ */
+export class EventBuffer {
+    capacity;
+    buffer;
+    head = 0; // index of oldest entry
+    tail = 0; // index of next write position
+    count = 0;
+    _cursor = 0;
+    constructor(capacity) {
+        this.capacity = capacity;
+        this.buffer = new Array(capacity);
+    }
+    get currentCursor() {
+        return this._cursor;
+    }
+    /**
+     * Process an SDK event: assign cursor, map to PimoteSessionEvent, forward live, and buffer (coalesced).
+     */
+    onEvent(sdkEvent, sessionId, sendLive, getLastMessage) {
+        this._cursor++;
+        const cursor = this._cursor;
+        const pimoteEvent = this.mapEvent(sdkEvent, sessionId, cursor, getLastMessage);
+        sendLive(pimoteEvent);
+        this.coalesceAndBuffer(pimoteEvent);
+    }
+    /**
+     * Replay buffered events from a given cursor position.
+     * Returns null if fromCursor is too old (full resync needed).
+     * Returns empty array if client is caught up.
+     */
+    replay(fromCursor) {
+        if (fromCursor >= this._cursor) {
+            return [];
+        }
+        if (this.count === 0) {
+            // Buffer is empty but cursor has advanced — can't replay
+            return fromCursor < this._cursor ? null : [];
+        }
+        const oldestEntry = this.buffer[this.head];
+        if (!oldestEntry) {
+            return null;
+        }
+        // If fromCursor is older than the oldest buffered cursor - 1,
+        // we can't guarantee complete replay
+        if (fromCursor < oldestEntry.cursor - 1) {
+            return null;
+        }
+        const events = [];
+        let idx = this.head;
+        for (let i = 0; i < this.count; i++) {
+            const entry = this.buffer[idx];
+            if (entry && entry.cursor > fromCursor) {
+                events.push(entry.event);
+            }
+            idx = (idx + 1) % this.capacity;
+        }
+        return events;
+    }
+    // ---- Private helpers ----
+    mapEvent(sdkEvent, sessionId, cursor, getLastMessage) {
+        const base = { sessionId, cursor, timestamp: new Date().toISOString() };
+        switch (sdkEvent.type) {
+            case 'agent_start':
+                return { ...base, type: 'agent_start' };
+            case 'agent_end':
+                return { ...base, type: 'agent_end', ...(sdkEvent.error ? { error: sdkEvent.error } : {}) };
+            case 'turn_start':
+                return { ...base, type: 'turn_start' };
+            case 'turn_end':
+                return { ...base, type: 'turn_end' };
+            case 'message_start':
+                return { ...base, type: 'message_start', role: sdkEvent.role ?? 'assistant' };
+            case 'message_update': {
+                const ame = sdkEvent.assistantMessageEvent;
+                const contentIndex = ame?.contentIndex ?? 0;
+                // Determine content type from the sub-event
+                let contentType = 'text';
+                if (ame?.type?.startsWith('thinking_')) {
+                    contentType = 'thinking';
+                }
+                else if (ame?.type?.startsWith('toolcall_')) {
+                    contentType = 'tool_call';
+                }
+                // Determine subtype from the sub-event suffix
+                let subtype = 'delta';
+                if (ame?.type?.endsWith('_start')) {
+                    subtype = 'start';
+                }
+                else if (ame?.type?.endsWith('_end')) {
+                    subtype = 'end';
+                }
+                const delta = ame?.delta ?? '';
+                const result = {
+                    ...base,
+                    type: 'message_update',
+                    contentIndex,
+                    subtype,
+                    content: {
+                        type: contentType,
+                        text: delta,
+                    },
+                };
+                // Extract tool call metadata on toolcall_start from the partial message
+                if (contentType === 'tool_call' && subtype === 'start' && ame?.partial?.content) {
+                    const block = ame.partial.content[contentIndex];
+                    if (block && block.type === 'toolCall') {
+                        result.toolCallId = block.id;
+                        result.toolName = block.name;
+                    }
+                }
+                return result;
+            }
+            case 'message_end': {
+                // Some providers (e.g. OpenAI) send message_end with empty content — the actual
+                // message is only available in session.messages. Use getLastMessage() fallback.
+                let message = sdkEvent.message;
+                if ((!message || !message.content || (Array.isArray(message.content) && message.content.length === 0)) && getLastMessage) {
+                    message = getLastMessage();
+                }
+                return {
+                    ...base,
+                    type: 'message_end',
+                    message: message ? mapAgentMessage(message) : { role: 'assistant', content: [] },
+                };
+            }
+            case 'tool_execution_start':
+                return {
+                    ...base,
+                    type: 'tool_execution_start',
+                    toolName: sdkEvent.toolName ?? '',
+                    toolCallId: sdkEvent.toolCallId ?? '',
+                    args: sdkEvent.args,
+                };
+            case 'tool_execution_update':
+                return {
+                    ...base,
+                    type: 'tool_execution_update',
+                    toolCallId: sdkEvent.toolCallId ?? '',
+                    content: typeof sdkEvent.partialResult === 'string' ? sdkEvent.partialResult : '',
+                };
+            case 'tool_execution_end':
+                return {
+                    ...base,
+                    type: 'tool_execution_end',
+                    toolCallId: sdkEvent.toolCallId ?? '',
+                    result: sdkEvent.result,
+                    isError: sdkEvent.isError || undefined,
+                };
+            case 'auto_compaction_start':
+                return {
+                    ...base,
+                    type: 'auto_compaction_start',
+                    reason: (sdkEvent.reason ?? 'threshold'),
+                };
+            case 'auto_compaction_end':
+                return {
+                    ...base,
+                    type: 'auto_compaction_end',
+                    result: sdkEvent.result,
+                    aborted: sdkEvent.aborted ?? false,
+                    willRetry: sdkEvent.willRetry ?? false,
+                    ...(sdkEvent.errorMessage ? { errorMessage: sdkEvent.errorMessage } : {}),
+                };
+            case 'auto_retry_start':
+                return {
+                    ...base,
+                    type: 'auto_retry_start',
+                    attempt: sdkEvent.attempt ?? 0,
+                    maxAttempts: sdkEvent.maxAttempts ?? 0,
+                    delayMs: sdkEvent.delayMs ?? 0,
+                    errorMessage: sdkEvent.errorMessage ?? '',
+                };
+            case 'auto_retry_end':
+                return {
+                    ...base,
+                    type: 'auto_retry_end',
+                    success: sdkEvent.success ?? false,
+                    attempt: sdkEvent.attempt ?? 0,
+                    ...(sdkEvent.finalError ? { finalError: sdkEvent.finalError } : {}),
+                };
+            case 'extension_error':
+                return {
+                    ...base,
+                    type: 'extension_error',
+                    error: sdkEvent.error ?? '',
+                    ...(sdkEvent.extensionName ? { extensionName: sdkEvent.extensionName } : {}),
+                };
+            default:
+                // Unknown event type — pass through as agent_start (shouldn't happen)
+                return { ...base, type: 'agent_start' };
+        }
+    }
+    coalesceAndBuffer(event) {
+        switch (event.type) {
+            case 'message_update':
+            case 'tool_execution_update':
+                // Streaming deltas are forwarded live but not stored in the replay buffer.
+                // Only start/end bookends are buffered — reconnect replays the finalized state.
+                break;
+            default:
+                this.pushToBuffer(event);
+                break;
+        }
+    }
+    pushToBuffer(event) {
+        this.buffer[this.tail] = { cursor: event.cursor, event };
+        this.tail = (this.tail + 1) % this.capacity;
+        if (this.count < this.capacity) {
+            this.count++;
+        }
+        else {
+            // Overflow: oldest entry dropped, advance head
+            this.head = (this.head + 1) % this.capacity;
+        }
+    }
+}

package/server/dist/extension-ui-bridge.js

@@ -0,0 +1,175 @@
+import { sendSlotEvent, waitForSlotUiResponse } from './session-manager.js';
+/**
+ * Creates an ExtensionUIContext implementation that bridges pi extension UI calls
+ * to WebSocket messages sent to the remote client.
+ *
+ * Dialog methods (select, confirm, input, editor) send a request event and wait
+ * for the client to respond. Fire-and-forget methods (notify, setStatus, etc.)
+ * send an event without waiting. TUI-only methods are no-ops.
+ *
+ * The bridge references the ManagedSlot directly — no closures over transient
+ * handler instances. When the handler changes (reconnect), the slot's connection
+ * is updated and the bridge automatically routes to the new connection.
+ * Pending UI promises survive reconnects and are replayed to the new client.
+ */
+export function createExtensionUIBridge(slot, pushNotificationService) {
+    function notifyInteraction(method, fields) {
+        if (!pushNotificationService)
+            return;
+        const projectName = slot.folderPath.split('/').pop() ?? 'Unknown';
+        pushNotificationService
+            .notify({
+            projectName,
+            folderPath: slot.folderPath,
+            sessionId: slot.sessionState.id,
+            sessionName: slot.session?.sessionName,
+            reason: 'interaction',
+            interaction: {
+                method,
+                title: fields.title,
+                options: fields.options,
+                message: fields.message,
+            },
+        })
+            .catch((err) => console.warn('[ExtensionUIBridge] Push notification error:', err.message ?? err));
+    }
+    function sendRequest(requestId, fields) {
+        const event = {
+            type: 'extension_ui_request',
+            sessionId: slot.sessionState.id,
+            requestId,
+            ...fields,
+        };
+        sendSlotEvent(slot, event);
+        return event;
+    }
+    async function dialogWithTimeout(requestId, requestEvent, opts, fallback) {
+        const responsePromise = waitForSlotUiResponse(slot, requestId, requestEvent);
+        const racers = [responsePromise];
+        if (opts?.timeout) {
+            racers.push(new Promise((resolve) => setTimeout(() => resolve(fallback), opts.timeout)));
+        }
+        if (opts?.signal) {
+            if (opts.signal.aborted) {
+                // Remove the pending entry we just created — no one will respond to it
+                slot.sessionState.pendingUiResponses.delete(requestId);
+                return fallback;
+            }
+            racers.push(new Promise((resolve) => {
+                opts.signal.addEventListener('abort', () => resolve(fallback), { once: true });
+            }));
+        }
+        if (racers.length === 1)
+            return responsePromise;
+        const result = await Promise.race(racers);
+        // If timeout or abort won the race, the pending entry is stale — the server
+        // has already moved on. Remove it so it won't be replayed on reconnect.
+        if (slot.sessionState.pendingUiResponses.has(requestId)) {
+            slot.sessionState.pendingUiResponses.delete(requestId);
+        }
+        return result;
+    }
+    const ui = {
+        // ---- Dialog methods (send + wait for response) ----
+        async select(title, options, opts) {
+            const requestId = crypto.randomUUID();
+            const event = sendRequest(requestId, { method: 'select', title, options });
+            notifyInteraction('select', { title, options });
+            return dialogWithTimeout(requestId, event, opts, undefined);
+        },
+        async confirm(title, message, opts) {
+            const requestId = crypto.randomUUID();
+            const event = sendRequest(requestId, { method: 'confirm', title, message });
+            notifyInteraction('confirm', { title, message });
+            return dialogWithTimeout(requestId, event, opts, false);
+        },
+        async input(title, placeholder, opts) {
+            const requestId = crypto.randomUUID();
+            const event = sendRequest(requestId, { method: 'input', title, placeholder });
+            notifyInteraction('input', { title });
+            return dialogWithTimeout(requestId, event, opts, undefined);
+        },
+        async editor(title, prefill) {
+            const requestId = crypto.randomUUID();
+            const event = sendRequest(requestId, { method: 'editor', title, prefill });
+            notifyInteraction('editor', { title });
+            return waitForSlotUiResponse(slot, requestId, event);
+        },
+        // ---- Fire-and-forget methods ----
+        notify(message, type) {
+            const requestId = crypto.randomUUID();
+            sendRequest(requestId, { method: 'notify', message, notifyType: type });
+        },
+        setStatus(key, text) {
+            const requestId = crypto.randomUUID();
+            sendRequest(requestId, { method: 'setStatus', key, text });
+        },
+        setWidget(key, content, options) {
+            if (Array.isArray(content) || content === undefined) {
+                const requestId = crypto.randomUUID();
+                sendRequest(requestId, {
+                    method: 'setWidget',
+                    key,
+                    lines: content,
+                    placement: options?.placement,
+                });
+            }
+            // If content is a function (TUI component factory), no-op — can't bridge to web
+        },
+        setTitle(title) {
+            const requestId = crypto.randomUUID();
+            sendRequest(requestId, { method: 'setTitle', title });
+        },
+        setEditorText(text) {
+            const requestId = crypto.randomUUID();
+            sendRequest(requestId, { method: 'setEditorText', text });
+        },
+        // ---- No-op methods (TUI-only, can't bridge to web) ----
+        custom() {
+            return Promise.resolve(undefined);
+        },
+        setWorkingMessage() {
+            // no-op
+        },
+        setHiddenThinkingLabel() {
+            // no-op
+        },
+        setFooter() {
+            // no-op
+        },
+        setHeader() {
+            // no-op
+        },
+        setEditorComponent() {
+            // no-op
+        },
+        onTerminalInput() {
+            return () => { };
+        },
+        getEditorText() {
+            return '';
+        },
+        pasteToEditor() {
+            // no-op
+        },
+        get theme() {
+            return null;
+        },
+        getAllThemes() {
+            return [];
+        },
+        getTheme() {
+            return undefined;
+        },
+        setTheme() {
+            return { success: false, error: 'UI not available' };
+        },
+        getToolsExpanded() {
+            return false;
+        },
+        setToolsExpanded() {
+            // no-op
+        },
+    };
+    return ui;
+}

package/server/dist/folder-index.js

@@ -0,0 +1,126 @@
+import { readdir, stat, unlink } from 'node:fs/promises';
+import { join, basename } from 'node:path';
+import { SessionManager } from '@mariozechner/pi-coding-agent';
+/** Project marker files/directories that identify a folder as a project. */
+const PROJECT_MARKERS = ['.git', 'package.json'];
+/**
+ * Scans configured root directories for project folders and lists their sessions.
+ */
+export class FolderIndex {
+    roots;
+    constructor(roots) {
+        this.roots = roots;
+    }
+    /**
+     * Scan all roots one level deep for project directories.
+     * A subdirectory is a "project" if it contains .git or package.json.
+     */
+    async scan() {
+        const folders = [];
+        for (const root of this.roots) {
+            let entries;
+            try {
+                entries = await readdir(root);
+            }
+            catch {
+                console.warn(`[FolderIndex] Root directory not accessible, skipping: ${root}`);
+                continue;
+            }
+            for (const entry of entries) {
+                const fullPath = join(root, entry);
+                try {
+                    const info = await stat(fullPath);
+                    if (!info.isDirectory())
+                        continue;
+                }
+                catch {
+                    continue;
+                }
+                const isProject = await this.hasProjectMarker(fullPath);
+                if (!isProject)
+                    continue;
+                folders.push({
+                    path: fullPath,
+                    name: basename(fullPath),
+                    activeSessionCount: 0, // Will be enriched by session pool later
+                    externalProcessCount: 0,
+                    activeStatus: null,
+                });
+            }
+        }
+        return folders;
+    }
+    /**
+     * List raw pi session records for a given folder path.
+     */
+    async listSessionRecords(folderPath) {
+        try {
+            return await SessionManager.list(folderPath);
+        }
+        catch (err) {
+            console.warn(`[FolderIndex] Failed to list sessions for ${folderPath}:`, err);
+            return [];
+        }
+    }
+    /**
+     * List sessions for a given folder path.
+     * Calls the pi SDK's SessionManager.list() and maps results to the shared SessionInfo type.
+     */
+    async listSessions(folderPath) {
+        const piSessions = await this.listSessionRecords(folderPath);
+        return piSessions.map((s) => ({
+            id: s.id,
+            name: s.name,
+            created: s.created.toISOString(),
+            modified: s.modified.toISOString(),
+            messageCount: s.messageCount,
+            firstMessage: s.firstMessage || undefined,
+        }));
+    }
+    /**
+     * Resolve a session ID to its file path within a folder.
+     * Returns undefined if the session is not found.
+     */
+    async resolveSessionPath(folderPath, sessionId) {
+        const piSessions = await this.listSessionRecords(folderPath);
+        const match = piSessions.find((s) => s.id === sessionId);
+        return match?.path;
+    }
+    /**
+     * Persist a new display name for a session on disk.
+     * Returns true if renamed, false if the session was not found.
+     */
+    async renameSession(folderPath, sessionId, name) {
+        const sessionPath = await this.resolveSessionPath(folderPath, sessionId);
+        if (!sessionPath)
+            return false;
+        SessionManager.open(sessionPath).appendSessionInfo(name);
+        return true;
+    }
+    /**
+     * Delete a session file from disk.
+     * Returns true if deleted, false if the session was not found.
+     */
+    async deleteSession(folderPath, sessionId) {
+        const sessionPath = await this.resolveSessionPath(folderPath, sessionId);
+        if (!sessionPath)
+            return false;
+        await unlink(sessionPath);
+        return true;
+    }
+    /**
+     * Check if a directory contains any project markers.
+     */
+    async hasProjectMarker(dirPath) {
+        for (const marker of PROJECT_MARKERS) {
+            try {
+                await stat(join(dirPath, marker));
+                return true;
+            }
+            catch {
+                // Marker doesn't exist, try next
+            }
+        }
+        return false;
+    }
+}

package/server/dist/index.js

@@ -0,0 +1,54 @@
+import { resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { loadConfig, ensureVapidKeys } from './config.js';
+import { createServer } from './server.js';
+import { PimoteSessionManager } from './session-manager.js';
+import { FolderIndex } from './folder-index.js';
+import { PushNotificationService } from './push-notification.js';
+import { FilePushSubscriptionStore, WebPushSender, migratePushSubscriptionStore } from './push-infrastructure.js';
+import { LEGACY_PIMOTE_PUSH_SUBSCRIPTIONS_PATH, PIMOTE_PUSH_SUBSCRIPTIONS_PATH, PIMOTE_SESSION_METADATA_PATH } from './paths.js';
+import { FileSessionMetadataStore } from './session-metadata.js';
+export async function main(options = {}) {
+    let config = await loadConfig();
+    config = await ensureVapidKeys(config);
+    // Allow explicit CLI override first, then PORT env var, then config
+    const port = options.portOverride ?? (process.env.PORT ? parseInt(process.env.PORT, 10) : config.port);
+    const folderIndex = new FolderIndex(config.roots);
+    // Initialize push notification service
+    await migratePushSubscriptionStore(LEGACY_PIMOTE_PUSH_SUBSCRIPTIONS_PATH, PIMOTE_PUSH_SUBSCRIPTIONS_PATH);
+    const pushStore = new FilePushSubscriptionStore(PIMOTE_PUSH_SUBSCRIPTIONS_PATH);
+    const pushSender = new WebPushSender(config.vapidPublicKey, config.vapidPrivateKey, config.vapidEmail || 'pimote@localhost');
+    const pushNotificationService = new PushNotificationService(pushSender, pushStore);
+    await pushNotificationService.initialize();
+    const sessionMetadataStore = new FileSessionMetadataStore(PIMOTE_SESSION_METADATA_PATH);
+    await sessionMetadataStore.initialize();
+    const sessionManager = new PimoteSessionManager(config, pushNotificationService);
+    const server = await createServer(config, sessionManager, folderIndex, pushNotificationService, sessionMetadataStore);
+    // Start idle session reaping with client connectivity check
+    sessionManager.startIdleCheck(config.idleTimeout, (clientId) => server.clientRegistry.has(clientId));
+    await server.start(port);
+    console.log(`[pimote] Server listening on http://localhost:${port}`);
+    console.log(`[pimote] WebSocket endpoint: ws://localhost:${port}/ws`);
+    console.log(`[pimote] Configured roots:`);
+    for (const root of config.roots) {
+        console.log(`  - ${root}`);
+    }
+    // Graceful shutdown
+    const shutdown = async () => {
+        console.log('\n[pimote] Shutting down...');
+        await sessionManager.dispose();
+        await server.close();
+        process.exit(0);
+    };
+    process.on('SIGINT', shutdown);
+    process.on('SIGTERM', shutdown);
+}
+function isDirectRun() {
+    return process.argv[1] != null && resolve(process.argv[1]) === fileURLToPath(import.meta.url);
+}
+if (isDirectRun()) {
+    main().catch((err) => {
+        console.error(err instanceof Error ? err.message : err);
+        process.exit(1);
+    });
+}

package/server/dist/message-mapper.js

@@ -0,0 +1,80 @@
+/**
+ * Convert raw pi SDK AgentMessage objects to PimoteAgentMessage format.
+ * Used both for bulk message retrieval (get_messages) and for live
+ * message_end events so the client always receives a consistent shape.
+ */
+export function mapAgentMessages(messages) {
+    return messages.map(mapAgentMessage);
+}
+export function mapAgentMessage(msg) {
+    const role = msg.role ?? 'unknown';
+    const content = [];
+    if (typeof msg.content === 'string') {
+        content.push({ type: 'text', text: msg.content });
+    }
+    else if (Array.isArray(msg.content)) {
+        for (const item of msg.content) {
+            switch (item.type) {
+                case 'text':
+                    content.push({ type: 'text', text: item.text ?? '' });
+                    break;
+                case 'thinking':
+                    content.push({ type: 'thinking', text: item.thinking ?? '' });
+                    break;
+                case 'toolCall':
+                    content.push({
+                        type: 'tool_call',
+                        toolCallId: item.id,
+                        toolName: item.name,
+                        args: item.arguments,
+                    });
+                    break;
+                case 'image':
+                    // Images in user messages — map as text placeholder
+                    content.push({ type: 'text', text: '[image]' });
+                    break;
+                default:
+                    // Unknown content type — pass through as text
+                    content.push({ type: 'text', text: item.text ?? JSON.stringify(item) });
+                    break;
+            }
+        }
+    }
+    else if (msg.content !== undefined && msg.content !== null) {
+        // Unexpected content type — log and convert to text
+        console.warn('[message-mapper] Unexpected content type:', typeof msg.content, 'role:', role);
+        console.warn('[message-mapper] Content value:', msg.content);
+        content.push({ type: 'text', text: `[Unexpected content type: ${typeof msg.content}]` });
+    }
+    // Log empty content for debugging
+    if (content.length === 0) {
+        console.warn('[message-mapper] Empty content array for message:', { role, content: msg.content });
+    }
+    // Handle custom messages — preserve customType and display flag for the client
+    if (role === 'custom') {
+        return { role, content, customType: msg.customType, display: msg.display ?? true };
+    }
+    // Handle tool result messages
+    if (role === 'toolResult') {
+        const resultContent = [];
+        if (Array.isArray(msg.content)) {
+            for (const item of msg.content) {
+                if (item.type === 'text') {
+                    resultContent.push({ type: 'text', text: item.text ?? '' });
+                }
+            }
+        }
+        return {
+            role,
+            content: [
+                {
+                    type: 'tool_result',
+                    toolCallId: msg.toolCallId,
+                    toolName: msg.toolName,
+                    result: resultContent.length > 0 ? resultContent[0].text : undefined,
+                },
+            ],
+        };
+    }
+    return { role, content };
+}

package/server/dist/panel-state.js

@@ -0,0 +1,28 @@
+/**
+ * Process a panel bus message and update the panel state map.
+ * - 'cards' messages replace the card list for that namespace.
+ * - 'clear' messages remove the namespace entirely.
+ */
+export function applyPanelMessage(panelState, message) {
+    if (message.type === 'cards') {
+        panelState.set(message.namespace, message.cards);
+    }
+    else if (message.type === 'clear') {
+        panelState.delete(message.namespace);
+    }
+}
+/**
+ * Merge all namespaces into a flat card list for sending to the client.
+ * Order: namespaces in insertion order, cards within each namespace in array order.
+ * Skips namespaces with empty card arrays.
+ * Card IDs are prefixed with the namespace to prevent collisions across extensions.
+ */
+export function getMergedPanelCards(panelState) {
+    const result = [];
+    for (const [namespace, cards] of panelState.entries()) {
+        for (const card of cards) {
+            result.push({ ...card, id: `${namespace}:${card.id}` });
+        }
+    }
+    return result;
+}