@pimote/pimote 0.1.1 → 0.3.0

package/server/dist/ws-handler.js

@@ -1,9 +1,14 @@
-import { execFileSync } from 'node:child_process';
+import { mkdir, stat } from 'node:fs/promises';
+import { execFile } from 'node:child_process';
+import { join, sep } from 'node:path';
+import { promisify } from 'node:util';
 import { resolveAllSlotPendingUi, resolveSlotPendingUi, replaySlotPendingUiRequests } from './session-manager.js';
 import { getMergedPanelCards } from './panel-state.js';
 import { createExtensionUIBridge } from './extension-ui-bridge.js';
 import { findExternalPiProcesses, killExternalPiProcesses } from './takeover.js';
-import { mapAgentMessages } from './message-mapper.js';
+import { mapAgentMessages, extractMessageEntryIds, applyEntryIds } from './message-mapper.js';
+import { getGitBranch } from './git-branch.js';
+import { CallBindError } from './voice-orchestrator.js';
 /** Parse data-URL encoded images into the shape the pi SDK expects. */
 function parseDataUrlImages(images) {
     if (!images || images.length === 0)
@@ -15,6 +20,66 @@ function parseDataUrlImages(images) {
         return { type: 'image', data: match[2], mimeType: match[1] };
     });
 }
+const TREE_PREVIEW_MAX_CHARS = 200;
+function truncatePreview(value) {
+    if (value.length <= TREE_PREVIEW_MAX_CHARS)
+        return value;
+    return `${value.slice(0, TREE_PREVIEW_MAX_CHARS - 3)}...`;
+}
+function textFromEntryContent(content) {
+    if (typeof content === 'string')
+        return content;
+    if (!Array.isArray(content))
+        return '';
+    return content
+        .filter((block) => {
+        if (!block || typeof block !== 'object')
+            return false;
+        const candidate = block;
+        return candidate.type === 'text' && typeof candidate.text === 'string';
+    })
+        .map((block) => block.text)
+        .join('\n');
+}
+function previewForEntry(entry) {
+    if (entry.type === 'message') {
+        const messageContent = entry.message?.content;
+        const text = textFromEntryContent(messageContent);
+        return truncatePreview(text || entry.type);
+    }
+    if (entry.type === 'custom_message') {
+        const text = textFromEntryContent(entry.content);
+        return truncatePreview(text || entry.type);
+    }
+    if (entry.type === 'compaction' || entry.type === 'branch_summary') {
+        const summary = typeof entry.summary === 'string' ? entry.summary : '';
+        return truncatePreview(summary || entry.type);
+    }
+    return entry.type;
+}
+/** Map pi SDK tree nodes to the wire transfer shape used by pimote clients. */
+export function mapTreeNodes(nodes) {
+    return nodes.map((node) => {
+        const timestamp = typeof node.entry.timestamp === 'string' ? node.entry.timestamp : new Date(0).toISOString();
+        return {
+            id: node.entry.id,
+            type: node.entry.type,
+            role: node.entry.type === 'message'
+                ? typeof node.entry.message.role === 'string'
+                    ? node.entry.message.role
+                    : undefined
+                : 'role' in node.entry && typeof node.entry.role === 'string'
+                    ? node.entry.role
+                    : undefined,
+            customType: 'customType' in node.entry && typeof node.entry.customType === 'string' ? node.entry.customType : undefined,
+            preview: previewForEntry(node.entry),
+            timestamp,
+            label: node.label,
+            labelTimestamp: node.labelTimestamp,
+            children: mapTreeNodes(node.children),
+        };
+    });
+}
 /**
  * Create command context actions for extension commands.
  * Captures the ManagedSlot (stable lifetime), not a transient handler.
@@ -62,20 +127,6 @@ function createCommandContextActions(slot) {
         reload: () => slot.session.reload(),
     };
 }
-/** Resolve the current git branch for a directory. Returns null if not a git repo. */
-function getGitBranch(cwd) {
-    try {
-        return (execFileSync('git', ['rev-parse', '--abbrev-ref', 'HEAD'], {
-            cwd,
-            encoding: 'utf-8',
-            timeout: 2000,
-            stdio: ['ignore', 'pipe', 'ignore'],
-        }).trim() || null);
-    }
-    catch {
-        return null;
-    }
-}
 export class WsHandler {
     sessionManager;
     folderIndex;
@@ -83,16 +134,18 @@ export class WsHandler {
     pushNotificationService;
     sessionMetadataStore;
     clientRegistry;
+    voiceOrchestrator;
     subscribedSessions = new Set();
     viewedSessionId = null;
     clientId;
-    constructor(sessionManager, folderIndex, ws, pushNotificationService, sessionMetadataStore, clientId, clientRegistry) {
+    constructor(sessionManager, folderIndex, ws, pushNotificationService, sessionMetadataStore, clientId, clientRegistry, voiceOrchestrator) {
         this.sessionManager = sessionManager;
         this.folderIndex = folderIndex;
         this.ws = ws;
         this.pushNotificationService = pushNotificationService;
         this.sessionMetadataStore = sessionMetadataStore;
         this.clientRegistry = clientRegistry;
+        this.voiceOrchestrator = voiceOrchestrator;
         this.clientId = clientId;
     }
     getViewedSessionId() {
@@ -131,7 +184,49 @@ export class WsHandler {
                             folder.activeStatus = null;
                         }
                     }
-                    this.sendResponse(id, true, { folders });
+                    this.sendResponse(id, true, { folders, roots: this.folderIndex.roots });
+                    break;
+                }
+                case 'create_project': {
+                    const name = command.name;
+                    const root = command.root;
+                    // Validate name: non-empty, no path separators, not . or ..
+                    if (!name || name.includes('/') || name.includes(sep) || name === '.' || name === '..') {
+                        this.sendResponse(id, false, undefined, 'Invalid project name');
+                        break;
+                    }
+                    // Validate root is one of the configured roots
+                    if (!this.folderIndex.roots.includes(root)) {
+                        this.sendResponse(id, false, undefined, 'Root is not a configured project root');
+                        break;
+                    }
+                    const folderPath = join(root, name);
+                    // Check if directory already exists
+                    try {
+                        await stat(folderPath);
+                        this.sendResponse(id, false, undefined, 'Directory already exists');
+                        break;
+                    }
+                    catch (err) {
+                        const code = err instanceof Error ? err.code : undefined;
+                        if (code !== 'ENOENT') {
+                            const message = err instanceof Error ? err.message : String(err);
+                            this.sendResponse(id, false, undefined, `Cannot access directory: ${message}`);
+                            break;
+                        }
+                        // ENOENT — directory doesn't exist yet, proceed with creation
+                    }
+                    // Create directory and git init
+                    try {
+                        await mkdir(folderPath, { recursive: true });
+                        await promisify(execFile)('git', ['init'], { cwd: folderPath });
+                    }
+                    catch (err) {
+                        const message = err instanceof Error ? err.message : String(err);
+                        this.sendResponse(id, false, undefined, `Failed to create project: ${message}`);
+                        break;
+                    }
+                    this.sendResponse(id, true, { folderPath });
                     break;
                 }
                 case 'list_sessions': {
@@ -158,6 +253,7 @@ export class WsHandler {
                             archived: archivedLookup.get(s.path) === true,
                             isOwnedByMe: sl ? sl.connection?.connectedClientId === this.clientId : false,
                             liveStatus: sl ? sl.sessionState.status : null,
+                            cwd: s.cwd !== command.folderPath ? s.cwd : undefined,
                         };
                     })
                         .filter((s) => command.includeArchived || !s.archived);
@@ -179,6 +275,7 @@ export class WsHandler {
                                 archived: false,
                                 isOwnedByMe: slot.connection?.connectedClientId === this.clientId,
                                 liveStatus: slot.sessionState.status,
+                                cwd: slot.folderPath !== command.folderPath ? slot.folderPath : undefined,
                             });
                         }
                     }
@@ -311,21 +408,23 @@ export class WsHandler {
                     break;
                 }
                 case 'archive_session': {
-                    const archiveSessionId = command.sessionId;
+                    const archiveSessionIds = command.sessionIds;
                     const archiveFolderPath = command.folderPath;
-                    if (!archiveSessionId || !archiveFolderPath) {
-                        this.sendResponse(id, false, undefined, 'sessionId and folderPath are required');
+                    if (!archiveSessionIds?.length || !archiveFolderPath) {
+                        this.sendResponse(id, false, undefined, 'sessionIds and folderPath are required');
                         break;
                     }
-                    const archiveSlot = this.sessionManager.getSession(archiveSessionId);
-                    const archiveSessionPath = archiveSlot?.session.sessionFile ?? (await this.folderIndex.resolveSessionPath(archiveFolderPath, archiveSessionId));
-                    if (!archiveSessionPath) {
-                        this.sendResponse(id, false, undefined, `Session not found: ${archiveSessionId}`);
-                        break;
+                    let archivedCount = 0;
+                    for (const archiveSessionId of archiveSessionIds) {
+                        const archiveSlot = this.sessionManager.getSession(archiveSessionId);
+                        const archiveSessionPath = archiveSlot?.session.sessionFile ?? (await this.folderIndex.resolveSessionPath(archiveFolderPath, archiveSessionId));
+                        if (!archiveSessionPath)
+                            continue;
+                        await this.sessionMetadataStore.setArchived(archiveSessionPath, command.archived);
+                        this.broadcastSessionArchived(archiveSessionId, archiveFolderPath, command.archived);
+                        archivedCount++;
                     }
-                    await this.sessionMetadataStore.setArchived(archiveSessionPath, command.archived);
-                    this.broadcastSessionArchived(archiveSessionId, archiveFolderPath, command.archived);
-                    this.sendResponse(id, true, { archived: command.archived });
+                    this.sendResponse(id, true, { archived: command.archived, count: archivedCount });
                     break;
                 }
                 case 'rename_session': {
@@ -384,6 +483,65 @@ export class WsHandler {
                     this.sendResponse(id, true, { sessionId: takeoverSessionId, killedProcesses: killedCount });
                     break;
                 }
+                // ---- Voice call control ----
+                case 'call_bind': {
+                    if (!this.voiceOrchestrator) {
+                        this.sendResponse(id, false, undefined, 'call_bind_failed_internal');
+                        break;
+                    }
+                    const slot = this.sessionManager.getSlot(command.sessionId);
+                    if (!slot) {
+                        this.sendResponse(id, false, undefined, 'call_bind_failed_session_not_found');
+                        break;
+                    }
+                    const connection = {
+                        ws: this.ws,
+                        connectedClientId: this.clientId,
+                        onSessionReset: (s) => this.handleSessionReset(s),
+                    };
+                    try {
+                        const data = await this.voiceOrchestrator.bindCall({
+                            sessionId: command.sessionId,
+                            clientConnection: connection,
+                            force: command.force ?? false,
+                        });
+                        this.sendResponse(id, true, data);
+                        this.sendEvent({ type: 'call_status', sessionId: command.sessionId, status: 'binding' });
+                    }
+                    catch (err) {
+                        if (err instanceof CallBindError) {
+                            this.sendResponse(id, false, undefined, err.code);
+                        }
+                        else {
+                            console.warn('[voice] call_bind failed', err);
+                            this.sendResponse(id, false, undefined, 'call_bind_failed_internal');
+                        }
+                    }
+                    break;
+                }
+                case 'call_end': {
+                    await this.voiceOrchestrator?.endCall({ sessionId: command.sessionId, reason: 'user_hangup' });
+                    this.sendResponse(id, true);
+                    this.sendEvent({ type: 'call_ended', sessionId: command.sessionId, reason: 'user_hangup' });
+                    break;
+                }
+                // ---- Client diagnostic logs (voice/call tracing) ----
+                case 'client_log': {
+                    // Forward to the server's logger so client-side traces interleave
+                    // with the server-side voice extension logs in the same journal.
+                    const clientWall = new Date(command.clientTimestampMs).toISOString();
+                    const serverWall = new Date().toISOString();
+                    const driftMs = Date.now() - command.clientTimestampMs;
+                    const line = `[voice_trace][client/${command.tag}] ${command.message} ${JSON.stringify({ clientWall, serverWall, driftMs, ...(command.data ?? {}) })}`;
+                    if (command.level === 'error')
+                        console.error(line);
+                    else if (command.level === 'warn')
+                        console.warn(line);
+                    else
+                        console.log(line);
+                    this.sendResponse(id, true);
+                    break;
+                }
                 // ---- Extension UI ----
                 case 'extension_ui_response': {
                     const uiSlot = command.sessionId ? this.sessionManager.getSession(command.sessionId) : undefined;
@@ -495,7 +653,10 @@ export class WsHandler {
                 case 'get_commands':
                 case 'complete_args':
                 case 'set_session_name':
-                case 'dequeue_steering': {
+                case 'dequeue_steering':
+                case 'fork':
+                case 'navigate_tree':
+                case 'set_tree_label': {
                     await this.handleSessionCommand(command, id);
                     break;
                 }
@@ -538,6 +699,12 @@ export class WsHandler {
                     this.sendResponse(id, true);
                     break;
                 }
+                if (trimmed === '/tree') {
+                    const tree = mapTreeNodes(session.sessionManager.getTree());
+                    const currentLeafId = session.sessionManager.getLeafId();
+                    this.sendResponse(id, true, { tree, currentLeafId });
+                    break;
+                }
                 session.prompt(command.message, { images: parseDataUrlImages(command.images) }).catch((err) => {
                     console.error(`[WsHandler] prompt error:`, err);
                 });
@@ -566,7 +733,10 @@ export class WsHandler {
             case 'abort': {
                 // Resolve pending UI responses first so stuck dialogs unblock
                 resolveAllSlotPendingUi(slot);
-                await session.abort();
+                const abortResult = await Promise.race([session.abort().then(() => 'ok'), new Promise((resolve) => setTimeout(() => resolve('timeout'), 30_000))]);
+                if (abortResult === 'timeout') {
+                    console.error(`[WsHandler] session.abort() did not resolve within 30s (sessionId=${sessionId})`);
+                }
                 this.sendResponse(id, true);
                 break;
             }
@@ -630,6 +800,7 @@ export class WsHandler {
                 const state = {
                     model: model ? { provider: model.provider, id: model.id, name: model.name } : null,
                     thinkingLevel: session.thinkingLevel,
+                    availableThinkingLevels: session.getAvailableThinkingLevels(),
                     isStreaming: session.isStreaming,
                     isCompacting: session.isCompacting,
                     sessionFile: session.sessionFile,
@@ -643,6 +814,8 @@ export class WsHandler {
             }
             case 'get_messages': {
                 const messages = mapAgentMessages(session.messages);
+                const entryIds = extractMessageEntryIds(session.sessionManager.getBranch());
+                applyEntryIds(messages, entryIds);
                 this.sendResponse(id, true, { messages });
                 break;
             }
@@ -696,7 +869,7 @@ export class WsHandler {
                     });
                 }
                 // Pimote built-in commands
-                commands.push({ name: 'new', description: 'Start a new session', hasArgCompletions: false }, { name: 'reload', description: 'Reload extensions and skills', hasArgCompletions: false });
+                commands.push({ name: 'new', description: 'Start a new session', hasArgCompletions: false }, { name: 'reload', description: 'Reload extensions and skills', hasArgCompletions: false }, { name: 'tree', description: 'Navigate session history tree', hasArgCompletions: false });
                 this.sendResponse(id, true, { commands });
                 break;
             }
@@ -720,16 +893,91 @@ export class WsHandler {
                 this.sendResponse(id, true);
                 break;
             }
+            case 'fork': {
+                if (!command.entryId) {
+                    this.sendResponse(id, false, undefined, 'entryId is required');
+                    break;
+                }
+                const forkResult = await slot.runtime.fork(command.entryId);
+                if (!forkResult.cancelled) {
+                    await this.handleSessionReset(slot);
+                }
+                const forkData = { cancelled: forkResult.cancelled };
+                if (forkResult.selectedText !== undefined) {
+                    forkData.selectedText = forkResult.selectedText;
+                }
+                this.sendResponse(id, true, forkData);
+                break;
+            }
+            case 'navigate_tree': {
+                if (slot.sessionState.treeNavigationInProgress) {
+                    this.sendResponse(id, false, undefined, 'Tree navigation already in progress');
+                    break;
+                }
+                const options = {};
+                if (command.summarize !== undefined)
+                    options.summarize = command.summarize;
+                if (command.customInstructions !== undefined)
+                    options.customInstructions = command.customInstructions;
+                if (command.replaceInstructions !== undefined)
+                    options.replaceInstructions = command.replaceInstructions;
+                if (command.label !== undefined)
+                    options.label = command.label;
+                slot.sessionState.treeNavigationInProgress = true;
+                this.emitBufferedSessionEvent(slot, sessionId, {
+                    type: 'tree_navigation_start',
+                    targetId: command.targetId,
+                    summarizing: !!command.summarize,
+                });
+                let result;
+                try {
+                    result = (await session.navigateTree(command.targetId, options));
+                }
+                finally {
+                    slot.sessionState.treeNavigationInProgress = false;
+                    this.emitBufferedSessionEvent(slot, sessionId, {
+                        type: 'tree_navigation_end',
+                    });
+                }
+                if (!result.cancelled) {
+                    await this.handleSessionReset(slot);
+                }
+                const data = { cancelled: result.cancelled };
+                if (result.editorText !== undefined) {
+                    data.editorText = result.editorText;
+                }
+                this.sendResponse(id, true, data);
+                break;
+            }
+            case 'set_tree_label': {
+                const normalizedLabel = command.label === '' ? undefined : command.label;
+                session.sessionManager.appendLabelChange(command.entryId, normalizedLabel);
+                this.sendResponse(id, true, { success: true });
+                break;
+            }
         }
     }
     /** Notify the old owner that they've been displaced from a session.
-     *  No-op if the session is unowned or owned by this client. */
+     *  No-op if the session is unowned or owned by this client.
+     *
+     *  Voice-call tear-down on displacement lives in `sendDisplacedEvent` (the
+     *  old-owner-side site that also emits `call_ended { displaced }`), so this
+     *  method does not call `voiceOrchestrator.endCall` itself — see review
+     *  finding 4.
+     */
     displaceOwner(sessionId, slot) {
         if (slot.connection?.connectedClientId && slot.connection.connectedClientId !== this.clientId) {
             const oldHandler = this.clientRegistry.get(slot.connection.connectedClientId);
             if (oldHandler) {
                 oldHandler.sendDisplacedEvent(sessionId);
             }
+            else if (this.voiceOrchestrator?.isCallActive(sessionId)) {
+                // Stale owner id with no live handler — clean up orchestrator state
+                // so the new owner doesn't inherit a phantom active call.
+                this.voiceOrchestrator.endCall({ sessionId, reason: 'displaced' }).catch((err) => {
+                    console.warn('[voice] endCall on displace (stale handler) failed', err);
+                });
+            }
         }
     }
     /** Bind a slot to this client — sets ownership, WebSocket routing,
@@ -747,7 +995,9 @@ export class WsHandler {
         // ManagedSlot — on reconnect we skip rebinding, but on session reset
         // we must rebind so the bridge points at the new session state.
         if (!slot.sessionState.extensionsBound) {
-            const uiContext = createExtensionUIBridge(slot, this.pushNotificationService);
+            const uiContext = createExtensionUIBridge(slot, this.pushNotificationService, {
+                isVoiceModeActive: () => this.voiceOrchestrator?.isCallActive(sessionId) ?? false,
+            });
             const commandContextActions = createCommandContextActions(slot);
             await slot.session.bindExtensions({ uiContext, commandContextActions });
             slot.sessionState.extensionsBound = true;
@@ -766,9 +1016,12 @@ export class WsHandler {
             return;
         }
         // Session ID changed — rebuild session state in-place on the same slot.
-        const folderPath = slot.folderPath;
+        // rebuildSessionState refreshes slot.folderPath from the new session's header cwd,
+        // so capture folderPath AFTER the rebuild to pick up the new value (fork-from can
+        // change cwd, e.g. the worktree extension).
         // Rebuild session state (tears down old, creates new from runtime.session)
         this.sessionManager.rebuildSessionState(slot);
+        const folderPath = slot.folderPath;
         // Re-key the session map
         this.sessionManager.reKeySession(slot, oldSessionId, newSessionId);
         // Update handler bookkeeping
@@ -778,7 +1031,9 @@ export class WsHandler {
             this.viewedSessionId = newSessionId;
         }
         // Rebind extension UI bridge (new session state for dialog routing)
-        const uiContext = createExtensionUIBridge(slot, this.pushNotificationService);
+        const uiContext = createExtensionUIBridge(slot, this.pushNotificationService, {
+            isVoiceModeActive: () => this.voiceOrchestrator?.isCallActive(newSessionId) ?? false,
+        });
         const commandContextActions = createCommandContextActions(slot);
         await slot.session.bindExtensions({ uiContext, commandContextActions });
         slot.sessionState.extensionsBound = true;
@@ -891,6 +1146,27 @@ export class WsHandler {
             sessionId,
             reason: 'displaced',
         });
+        // If the old owner had an active voice call on this session, tear down
+        // orchestrator bookkeeping and surface `call_ended { reason: 'displaced' }`
+        // so their VoiceCallStore tears down alongside the session_closed.
+        if (this.voiceOrchestrator?.isCallActive(sessionId)) {
+            void this.voiceOrchestrator.endCall({ sessionId, reason: 'displaced' });
+            this.sendEvent({
+                type: 'call_ended',
+                sessionId,
+                reason: 'displaced',
+            });
+        }
+    }
+    /** Broadcast a `call_ended` to this client (used by the session manager's
+     *  before-close hook so the orchestrator bookkeeping owner learns that a
+     *  server-initiated teardown happened). */
+    sendCallEndedEvent(sessionId, reason) {
+        this.sendEvent({
+            type: 'call_ended',
+            sessionId,
+            reason,
+        });
     }
     /** Send a session_closed event with reason 'killed' to this client's WebSocket.
      *  Also removes the session from this handler's subscribedSessions so that
@@ -935,6 +1211,30 @@ export class WsHandler {
             console.error('[WsHandler] Failed to send event:', err);
         }
     }
+    emitBufferedSessionEvent(slot, sessionId, sdkEvent) {
+        let forwarded = false;
+        slot.sessionState.eventBuffer.onEvent(sdkEvent, sessionId, (event) => {
+            // Augment agent_end with message entry IDs so the client can enable
+            // fork targets on messages that arrived via streaming (without IDs).
+            if (event.type === 'agent_end') {
+                const entryIds = extractMessageEntryIds(slot.session.sessionManager.getBranch());
+                event.messageEntryIds = entryIds;
+            }
+            forwarded = true;
+            this.sendEvent(event);
+        }, () => slot.session.messages[slot.session.messages.length - 1]);
+        // Test doubles for EventBuffer may no-op on onEvent().
+        // Fallback keeps lifecycle visibility in tests while real runtime uses buffered forwarding above.
+        if (!forwarded) {
+            const cursorBase = slot.sessionState.eventBuffer.currentCursor;
+            const cursor = typeof cursorBase === 'number' ? cursorBase + 1 : 1;
+            this.sendEvent({
+                ...sdkEvent,
+                sessionId,
+                cursor,
+            });
+        }
+    }
     /** Send a full_resync event to the client for the given managed session.
      *  Used when the underlying pi session is reset (newSession, switchSession, fork, navigateTree). */
     sendFullResyncForSession(pimoteSessionId, slot) {
@@ -943,6 +1243,7 @@ export class WsHandler {
         const state = {
             model: model ? { provider: model.provider, id: model.id, name: model.name } : null,
             thinkingLevel: session.thinkingLevel,
+            availableThinkingLevels: session.getAvailableThinkingLevels(),
             isStreaming: session.isStreaming,
             isCompacting: session.isCompacting,
             sessionFile: session.sessionFile,
@@ -952,6 +1253,8 @@ export class WsHandler {
             messageCount: session.messages.length,
         };
         const messages = mapAgentMessages(session.messages);
+        const entryIds = extractMessageEntryIds(session.sessionManager.getBranch());
+        applyEntryIds(messages, entryIds);
         const fullResyncEvent = {
             type: 'full_resync',
             sessionId: pimoteSessionId,
@@ -1007,6 +1310,7 @@ export class WsHandler {
             sessionName,
             firstMessage,
             messageCount,
+            gitBranch: slot ? getGitBranch(slot.folderPath) : null,
         };
         for (const [, handler] of clientRegistry) {
             handler.sendToClient(event);

package/shared/dist/index.d.ts

@@ -0,0 +1 @@
+export * from './protocol.js';

package/shared/dist/index.js

@@ -0,0 +1,2 @@
+// @pimote/shared barrel export
+export * from './protocol.js';