@pimote/pimote 0.1.1 → 0.2.0

package/server/dist/session-manager.js

@@ -1,6 +1,7 @@
 import { createAgentSessionRuntime, createAgentSessionServices, createAgentSessionFromServices, createEventBus, AuthStorage, ModelRegistry, getAgentDir, SessionManager as PiSessionManager, } from '@mariozechner/pi-coding-agent';
 import { EventBuffer } from './event-buffer.js';
 import { applyPanelMessage, getMergedPanelCards } from './panel-state.js';
+import { getGitBranch } from './git-branch.js';
 // ---- Slot-based helpers (operate on ManagedSlot) ----
 /** Send an event to the client connected to this slot. No-op if disconnected. */
 export function sendSlotEvent(slot, event) {
@@ -59,6 +60,7 @@ function createSessionState(session, eventBus, config, callbacks, slotRef, folde
         panelState: new Map(),
         panelListenerUnsubs: [],
         panelThrottleTimer: null,
+        treeNavigationInProgress: false,
     };
     // Subscribe to session events
     const unsubscribe = session.subscribe((event) => {
@@ -125,8 +127,11 @@ export class PimoteSessionManager {
     modelRegistry;
     sessions = new Map();
     idleCheckHandle = null;
+    gitBranchCheckHandle = null;
+    lastKnownGitBranchBySession = new Map();
     onStatusChange;
     onSessionClosed;
+    onGitBranchChange;
     constructor(config, pushNotificationService) {
         this.config = config;
         this.pushNotificationService = pushNotificationService;
@@ -137,6 +142,8 @@ export class PimoteSessionManager {
         const eventBusRef = { current: null };
         const sharedAuthStorage = this.authStorage;
         const sharedModelRegistry = this.modelRegistry;
+        const sessionManager = sessionFilePath ? PiSessionManager.open(sessionFilePath) : PiSessionManager.create(folderPath);
+        const effectiveFolderPath = sessionFilePath ? sessionManager.getCwd() : folderPath;
         const factory = async ({ cwd, agentDir, sessionManager, sessionStartEvent }) => {
             const eventBus = createEventBus();
             eventBusRef.current = eventBus;
@@ -154,9 +161,9 @@ export class PimoteSessionManager {
             };
         };
         const runtime = await createAgentSessionRuntime(factory, {
-            cwd: folderPath,
+            cwd: effectiveFolderPath,
             agentDir: getAgentDir(),
-            sessionManager: sessionFilePath ? PiSessionManager.open(sessionFilePath) : PiSessionManager.create(folderPath),
+            sessionManager,
         });
         const session = runtime.session;
         const sessionId = session.sessionId;
@@ -186,10 +193,10 @@ export class PimoteSessionManager {
             onStatusChange: (sid, fp) => this.onStatusChange?.(sid, fp),
             onAgentEnd: (sid, s) => this.handleAgentEnd(sid, s),
             sendEvent: (e) => sendSlotEvent(slot, e),
-        }, slotRef, folderPath);
+        }, slotRef, effectiveFolderPath);
         const slot = {
             runtime,
-            folderPath,
+            folderPath: effectiveFolderPath,
             eventBusRef,
             connection: null,
             sessionState,
@@ -199,6 +206,7 @@ export class PimoteSessionManager {
         };
         slotRef.slot = slot;
         this.sessions.set(sessionId, slot);
+        this.lastKnownGitBranchBySession.set(sessionId, getGitBranch(effectiveFolderPath));
         return sessionId;
     }
     handleAgentEnd(sessionId, slot) {
@@ -261,12 +269,16 @@ export class PimoteSessionManager {
         const folderPath = slot.folderPath;
         await slot.runtime.dispose();
         this.sessions.delete(sessionId);
+        this.lastKnownGitBranchBySession.delete(sessionId);
         this.onSessionClosed?.(sessionId, folderPath);
     }
     /** Re-key a slot in the session map after session replacement. */
     reKeySession(slot, oldId, newId) {
         this.sessions.delete(oldId);
         this.sessions.set(newId, slot);
+        const lastKnown = this.lastKnownGitBranchBySession.get(oldId) ?? null;
+        this.lastKnownGitBranchBySession.delete(oldId);
+        this.lastKnownGitBranchBySession.set(newId, lastKnown);
     }
     /** Rebuild a slot's SessionState after session replacement.
      *  Tears down the old state and creates a new one from the current runtime.session. */
@@ -289,6 +301,9 @@ export class PimoteSessionManager {
         this.stopIdleCheck();
         this.idleCheckHandle = setInterval(() => {
             for (const [sessionId, slot] of this.sessions) {
+                if (slot.sessionState.treeNavigationInProgress) {
+                    continue;
+                }
                 const clientId = slot.connection?.connectedClientId ?? null;
                 const hasConnectedClient = clientId !== null && (isClientConnected?.(clientId) ?? false);
                 if (!hasConnectedClient && Date.now() - slot.sessionState.lastActivity > idleTimeout) {
@@ -298,12 +313,28 @@ export class PimoteSessionManager {
                 }
             }
         }, 60_000);
+        this.gitBranchCheckHandle = setInterval(() => {
+            for (const [sessionId, slot] of this.sessions) {
+                if (!slot.connection?.connectedClientId)
+                    continue;
+                const next = getGitBranch(slot.folderPath);
+                const prev = this.lastKnownGitBranchBySession.get(sessionId) ?? null;
+                if (next !== prev) {
+                    this.lastKnownGitBranchBySession.set(sessionId, next);
+                    this.onGitBranchChange?.(sessionId, slot.folderPath);
+                }
+            }
+        }, 3000);
     }
     stopIdleCheck() {
         if (this.idleCheckHandle !== null) {
             clearInterval(this.idleCheckHandle);
             this.idleCheckHandle = null;
         }
+        if (this.gitBranchCheckHandle !== null) {
+            clearInterval(this.gitBranchCheckHandle);
+            this.gitBranchCheckHandle = null;
+        }
     }
     async dispose() {
         this.stopIdleCheck();

package/server/dist/ws-handler.js

@@ -1,9 +1,13 @@
-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';
 /** Parse data-URL encoded images into the shape the pi SDK expects. */
 function parseDataUrlImages(images) {
     if (!images || images.length === 0)
@@ -15,6 +19,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 +126,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;
@@ -131,7 +181,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 +250,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 +272,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 +405,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': {
@@ -495,7 +591,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 +637,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 +671,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 +738,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 +752,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 +807,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,6 +831,68 @@ 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.
@@ -935,6 +1108,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 +1140,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 +1150,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 +1207,7 @@ export class WsHandler {
             sessionName,
             firstMessage,
             messageCount,
+            gitBranch: slot ? getGitBranch(slot.folderPath) : null,
         };
         for (const [, handler] of clientRegistry) {
             handler.sendToClient(event);