@pimote/pimote 0.1.1 → 0.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pimote/pimote",
-  "version": "0.1.1",
+  "version": "0.3.0",
   "description": "Web client and embedded server for pi with multi-session browser access, streaming, and extension UI support",
   "type": "module",
   "license": "MIT",
@@ -29,8 +29,10 @@
     "bin/pimote.js",
     "client/build/**",
     "server/dist/**/*.js",
+    "shared/dist/**/*.js",
+    "shared/dist/**/*.d.ts",
     "scripts/postinstall-patches.mjs",
-    "patches/@mariozechner+pi-coding-agent+0.65.0.patch",
+    "patches/@mariozechner+pi-coding-agent+0.67.6.patch",
     "README.md",
     "LICENSE"
   ],
@@ -38,13 +40,13 @@
     "node": ">=22.0.0"
   },
   "workspaces": [
-    "shared",
     "server",
     "client",
     "packages/panels"
   ],
   "scripts": {
-    "build": "npm run build --workspace=shared && npm run build --workspace=@pimote/server && npm run build --workspace=client",
+    "build": "npm run build:shared && npm run build --workspace=@pimote/server && npm run build --workspace=client",
+    "build:shared": "node --input-type=module -e \"import { rmSync } from 'node:fs'; rmSync('shared/dist', { recursive: true, force: true }); rmSync('shared/tsconfig.tsbuildinfo', { force: true });\" && tsc -b shared --force",
     "start": "node ./bin/pimote.js start",
     "format": "prettier --write .",
     "format:check": "prettier --check .",
@@ -73,7 +75,9 @@
   },
   "dependencies": {
     "@fontsource-variable/jetbrains-mono": "^5.2.8",
-    "@mariozechner/pi-coding-agent": "0.65.0",
+    "@mariozechner/pi-coding-agent": "0.67.6",
+    "@sinclair/typebox": "^0.34.49",
+    "@streamparser/json": "^0.0.22",
     "patch-package": "^8.0.1",
     "web-push": "^3.6.7",
     "ws": "^8.20.0"

package/patches/{@mariozechner+pi-coding-agent+0.65.0.patch → @mariozechner+pi-coding-agent+0.67.6.patch}

@@ -1,8 +1,8 @@
 diff --git a/node_modules/@mariozechner/pi-coding-agent/dist/core/agent-session-runtime.js b/node_modules/@mariozechner/pi-coding-agent/dist/core/agent-session-runtime.js
-index 9ab786e..6f89829 100644
+index fcb3466..20ee304 100644
 --- a/node_modules/@mariozechner/pi-coding-agent/dist/core/agent-session-runtime.js
 +++ b/node_modules/@mariozechner/pi-coding-agent/dist/core/agent-session-runtime.js
-@@ -74,9 +74,6 @@ export class AgentSessionRuntime {
+@@ -75,9 +75,6 @@ export class AgentSessionRuntime {
          this.session.dispose();
      }
      apply(result) {
@@ -12,9 +12,9 @@ index 9ab786e..6f89829 100644
          this._session = result.session;
          this._services = result.services;
          this._diagnostics = result.diagnostics;
-@@ -223,9 +220,6 @@ export class AgentSessionRuntime {
-  */
+@@ -227,9 +224,6 @@ export class AgentSessionRuntime {
  export async function createAgentSessionRuntime(createRuntime, options) {
+     assertSessionCwdExists(options.sessionManager, options.cwd);
      const result = await createRuntime(options);
 -    if (process.cwd() !== result.services.cwd) {
 -        process.chdir(result.services.cwd);

package/server/dist/auto-drain-on-abort.js

@@ -0,0 +1,49 @@
+// Auto-drain queued steering / follow-up messages after an aborted run.
+//
+// pi-agent-core's `runLoop` exits without polling the steering queue when
+// an abort signal fires mid-stream (see `agent-loop.js` — the
+// `stopReason === 'aborted'` branch returns immediately, before the
+// trailing `getSteeringMessages` poll). Any messages queued before / during
+// the abort would otherwise sit in the queue until something else calls
+// `agent.prompt()` or `agent.continue()`.
+//
+// In pimote this surfaces as silently-dropped user messages whenever a
+// queued steer races with an abort — most visibly during voice-mode
+// barge-in, but also for typed-mode users who queue a follow-up while the
+// agent is streaming and then hit the abort button.
+//
+// The fix is to call `agent.continue()` after the run settles: from the
+// pi-agent-core source, `continue()` explicitly drains the steering queue
+// (and falls back to follow-up if steering is empty) and replays the
+// drained messages as a fresh prompt.
+/**
+ * If `lastMessage` is the aborted-assistant synthetic that pi appends on
+ * abort and the session has queued messages, wait for the current run to
+ * settle and then drain the queue via `agent.continue()`.
+ *
+ * Idempotent: after `continue()` runs, the queue is empty so a re-entry
+ * (e.g. another agent_end) becomes a no-op. Errors from `continue()`
+ * (notably "Agent is already processing" when something else races us to
+ * a new prompt) are swallowed via `onError` — losing the auto-drain in
+ * that case is acceptable because the racing prompt itself will drain
+ * the queue inside `runLoop`'s initial `getSteeringMessages` poll.
+ */
+export async function autoDrainOnAbort(session, lastMessage, onError = (err) => console.warn('[pimote] auto-drain after abort failed', err)) {
+    if (!lastMessage || lastMessage.stopReason !== 'aborted') {
+        return;
+    }
+    try {
+        // The `agent_end` listener fires before `finishRun()` clears the
+        // run's `activeRun` reference. `waitForIdle()` resolves on the same
+        // promise that `finishRun` resolves, so awaiting it parks us until
+        // `agent.continue()` is safe to call without throwing
+        // "Agent is already processing".
+        await session.agent.waitForIdle();
+        if (session.pendingMessageCount === 0)
+            return;
+        await session.agent.continue();
+    }
+    catch (err) {
+        onError(err);
+    }
+}

package/server/dist/config.js

@@ -48,11 +48,32 @@ export async function loadConfig() {
         defaultProvider: typeof obj.defaultProvider === 'string' ? obj.defaultProvider : undefined,
         defaultModel: typeof obj.defaultModel === 'string' ? obj.defaultModel : undefined,
         defaultThinkingLevel: typeof obj.defaultThinkingLevel === 'string' ? obj.defaultThinkingLevel : undefined,
+        defaultInterpreterModel: parseModelRef(obj.defaultInterpreterModel),
+        defaultWorkerModel: parseModelRef(obj.defaultWorkerModel),
+        voice: parseVoiceConfig(obj.voice),
         vapidPublicKey: typeof obj.vapidPublicKey === 'string' ? obj.vapidPublicKey : undefined,
         vapidPrivateKey: typeof obj.vapidPrivateKey === 'string' ? obj.vapidPrivateKey : undefined,
         vapidEmail: typeof obj.vapidEmail === 'string' ? obj.vapidEmail : undefined,
     };
 }
+function parseModelRef(v) {
+    if (!v || typeof v !== 'object')
+        return undefined;
+    const o = v;
+    if (typeof o.provider !== 'string' || typeof o.modelId !== 'string')
+        return undefined;
+    return { provider: o.provider, modelId: o.modelId };
+}
+function parseVoiceConfig(v) {
+    if (!v || typeof v !== 'object')
+        return undefined;
+    const o = v;
+    return {
+        speechmuxBinary: typeof o.speechmuxBinary === 'string' ? o.speechmuxBinary : undefined,
+        speechmuxSignalUrl: typeof o.speechmuxSignalUrl === 'string' ? o.speechmuxSignalUrl : undefined,
+        speechmuxLlmWsUrl: typeof o.speechmuxLlmWsUrl === 'string' ? o.speechmuxLlmWsUrl : undefined,
+    };
+}
 export async function ensureVapidKeys(config) {
     if (config.vapidPublicKey && config.vapidPrivateKey) {
         return config;

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

@@ -1,3 +1,4 @@
+import { UI_BRIDGE_DISABLED_IN_VOICE_MODE } from '../../shared/dist/index.js';
 import { sendSlotEvent, waitForSlotUiResponse } from './session-manager.js';
 /**
  * Creates an ExtensionUIContext implementation that bridges pi extension UI calls
@@ -12,7 +13,11 @@ import { sendSlotEvent, waitForSlotUiResponse } from './session-manager.js';
  * 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) {
+export function createExtensionUIBridge(slot, pushNotificationService, options) {
+    const isVoice = () => options?.isVoiceModeActive?.() ?? false;
+    function voiceDisabledError() {
+        return new Error(UI_BRIDGE_DISABLED_IN_VOICE_MODE);
+    }
     function notifyInteraction(method, fields) {
         if (!pushNotificationService)
             return;
@@ -72,24 +77,32 @@ export function createExtensionUIBridge(slot, pushNotificationService) {
     const ui = {
         // ---- Dialog methods (send + wait for response) ----
         async select(title, options, opts) {
+            if (isVoice())
+                throw voiceDisabledError();
             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) {
+            if (isVoice())
+                throw voiceDisabledError();
             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) {
+            if (isVoice())
+                throw voiceDisabledError();
             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) {
+            if (isVoice())
+                throw voiceDisabledError();
             const requestId = crypto.randomUUID();
             const event = sendRequest(requestId, { method: 'editor', title, prefill });
             notifyInteraction('editor', { title });

package/server/dist/folder-index.js

@@ -7,9 +7,13 @@ 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;
+    _roots;
+    constructor(_roots) {
+        this._roots = _roots;
+    }
+    /** Returns the configured root directories. */
+    get roots() {
+        return this._roots;
     }
     /**
      * Scan all roots one level deep for project directories.
@@ -17,7 +21,7 @@ export class FolderIndex {
      */
     async scan() {
         const folders = [];
-        for (const root of this.roots) {
+        for (const root of this._roots) {
             let entries;
             try {
                 entries = await readdir(root);

package/server/dist/git-branch.js

@@ -0,0 +1,32 @@
+import { execFileSync } from 'node:child_process';
+/** Resolve the current git branch for a directory. Returns null if not a git repo or detached. */
+export function getGitBranch(cwd) {
+    // Guard against inherited Git env vars forcing resolution to another repo.
+    const env = { ...process.env };
+    delete env.GIT_DIR;
+    delete env.GIT_WORK_TREE;
+    const runGit = (args) => {
+        try {
+            const value = execFileSync('git', args, {
+                cwd,
+                env,
+                encoding: 'utf-8',
+                timeout: 2000,
+                stdio: ['ignore', 'pipe', 'ignore'],
+            }).trim();
+            return value || null;
+        }
+        catch {
+            return null;
+        }
+    };
+    // Best signal for the checked-out branch (works with linked worktrees).
+    const current = runGit(['branch', '--show-current']);
+    if (current)
+        return current;
+    // Fallback for older Git versions / unusual setups.
+    const abbrevRef = runGit(['rev-parse', '--abbrev-ref', 'HEAD']);
+    if (!abbrevRef || abbrevRef === 'HEAD')
+        return null;
+    return abbrevRef;
+}

package/server/dist/index.js

@@ -8,6 +8,7 @@ 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';
+import { buildVoiceOrchestrator } from './voice-orchestrator-boot.js';
 export async function main(options = {}) {
     let config = await loadConfig();
     config = await ensureVapidKeys(config);
@@ -23,7 +24,35 @@ export async function main(options = {}) {
     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);
+    // Build the voice orchestrator before createServer so each WsHandler can be
+    // handed a reference. The orchestrator needs a client-registry lookup, but
+    // the real registry is created inside createServer below — so we hand it a
+    // small forwarding shim whose backing map is swapped in after createServer
+    // returns (see review finding 6: previously a Proxy-over-Map).
+    const clientRegistryRef = { current: new Map() };
+    const voiceBoot = buildVoiceOrchestrator({
+        config,
+        sessionManager,
+        clientRegistry: {
+            get: (clientId) => clientRegistryRef.current.get(clientId),
+        },
+    });
+    const server = await createServer(config, sessionManager, folderIndex, pushNotificationService, sessionMetadataStore, voiceBoot.orchestrator);
+    clientRegistryRef.current = server.clientRegistry;
+    // Tear down orchestrator bookkeeping when a session is being closed (idle
+    // reap, explicit close). Emits call_ended{server_ended} to the owner.
+    sessionManager.onBeforeSessionClose = async (sessionId) => {
+        if (!voiceBoot.orchestrator.isCallActive(sessionId))
+            return;
+        const slot = sessionManager.getSlot(sessionId);
+        const ownerClientId = slot?.connection?.connectedClientId;
+        await voiceBoot.orchestrator.endCall({ sessionId, reason: 'server_ended' });
+        if (ownerClientId) {
+            const handler = server.clientRegistry.get(ownerClientId);
+            handler?.sendCallEndedEvent(sessionId, 'server_ended');
+        }
+    };
+    await voiceBoot.orchestrator.start();
     // Start idle session reaping with client connectivity check
     sessionManager.startIdleCheck(config.idleTimeout, (clientId) => server.clientRegistry.has(clientId));
     await server.start(port);
@@ -36,6 +65,7 @@ export async function main(options = {}) {
     // Graceful shutdown
     const shutdown = async () => {
         console.log('\n[pimote] Shutting down...');
+        await voiceBoot.shutdown();
         await sessionManager.dispose();
         await server.close();
         process.exit(0);

package/server/dist/message-mapper.js

@@ -6,6 +6,87 @@
 export function mapAgentMessages(messages) {
     return messages.map(mapAgentMessage);
 }
+/**
+ * Extract entry IDs from branch entries in the same order that
+ * buildSessionContext produces messages.  This mirrors the SDK's
+ * compaction/branch-summary logic so IDs can be zipped 1:1 with
+ * the mapped PimoteAgentMessage array.
+ */
+export function extractMessageEntryIds(branch) {
+    // Find the last compaction entry on the path
+    let compaction = null;
+    for (const entry of branch) {
+        if (entry.type === 'compaction')
+            compaction = entry;
+    }
+    const ids = [];
+    const appendId = (entry) => {
+        if (entry.type === 'message') {
+            ids.push(entry.id);
+        }
+        else if (entry.type === 'custom_message') {
+            ids.push(entry.id);
+        }
+        else if (entry.type === 'branch_summary' && entry.summary) {
+            ids.push(entry.id);
+        }
+    };
+    if (compaction) {
+        // Compaction summary message maps to the compaction entry
+        ids.push(compaction.id);
+        const compactionIdx = branch.findIndex((e) => e.type === 'compaction' && e.id === compaction.id);
+        // Kept messages before the compaction entry
+        let foundFirstKept = false;
+        for (let i = 0; i < compactionIdx; i++) {
+            if (branch[i].id === compaction.firstKeptEntryId)
+                foundFirstKept = true;
+            if (foundFirstKept)
+                appendId(branch[i]);
+        }
+        // Messages after the compaction entry
+        for (let i = compactionIdx + 1; i < branch.length; i++) {
+            appendId(branch[i]);
+        }
+    }
+    else {
+        for (const entry of branch) {
+            appendId(entry);
+        }
+    }
+    return ids;
+}
+/**
+ * True when the message is pi-agent-core's synthetic aborted placeholder
+ * (pushed into agent.state.messages on session.abort() but never persisted
+ * via message_end). Identifying these lets entryId alignment skip over them.
+ */
+export function isAbortedPlaceholderMessage(msg) {
+    if (msg.role !== 'assistant')
+        return false;
+    if (msg.aborted !== true)
+        return false;
+    return msg.content.every((c) => c.type === 'text' && !c.text);
+}
+/**
+ * Apply entry IDs from the session manager onto mapped messages.
+ *
+ * Subtle alignment: `messages` comes from `agent.state.messages`, which
+ * includes pi-agent-core's synthetic aborted placeholders (abort pushes an
+ * empty assistant into state but never persists an entry for it).
+ * `entryIds` comes from persisted session entries, which do NOT include
+ * those placeholders. We walk the messages and skip aborted placeholders
+ * so the persisted IDs land on the correct real messages.
+ */
+export function applyEntryIds(messages, entryIds) {
+    let idIdx = 0;
+    for (let i = 0; i < messages.length; i++) {
+        if (isAbortedPlaceholderMessage(messages[i]))
+            continue;
+        if (idIdx >= entryIds.length)
+            break;
+        messages[i].entryId = entryIds[idIdx++];
+    }
+}
 export function mapAgentMessage(msg) {
     const role = msg.role ?? 'unknown';
     const content = [];
@@ -46,13 +127,17 @@ export function mapAgentMessage(msg) {
         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) {
+    // Aborted assistant turns are a real signal in voice mode (every barge-in
+    // produces one via pi-agent-core's handleRunFailure) and shouldn't be
+    // confused with malformed messages. Log the empty-content warning only
+    // when it's NOT an expected aborted turn.
+    const aborted = role === 'assistant' && msg.stopReason === 'aborted';
+    if (content.length === 0 && !aborted) {
         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 };
+        return { role, content, entryId: msg.id, customType: msg.customType, display: msg.display ?? true };
     }
     // Handle tool result messages
     if (role === 'toolResult') {
@@ -72,9 +157,19 @@ export function mapAgentMessage(msg) {
                     toolCallId: msg.toolCallId,
                     toolName: msg.toolName,
                     result: resultContent.length > 0 ? resultContent[0].text : undefined,
+                    isError: msg.isError || undefined,
                 },
             ],
+            entryId: msg.id,
         };
     }
-    return { role, content };
+    // Note: msg.id is typically undefined for standard SDK messages (UserMessage,
+    // AssistantMessage, ToolResultMessage).  Entry IDs are applied separately via
+    // applyEntryIds() using the session manager's branch entries.
+    return {
+        role,
+        content,
+        ...(msg.id ? { entryId: msg.id } : {}),
+        ...(aborted ? { aborted: true } : {}),
+    };
 }

package/server/dist/server.js

@@ -79,7 +79,7 @@ async function serveFallback(res) {
         res.end(JSON.stringify({ error: 'not found' }));
     }
 }
-export async function createServer(config, sessionManager, folderIndex, pushNotificationService, sessionMetadataStore) {
+export async function createServer(config, sessionManager, folderIndex, pushNotificationService, sessionMetadataStore, voiceOrchestrator) {
     const clientVersion = await loadClientVersion();
     if (clientVersion) {
         console.log(`[pimote] Client build version: ${clientVersion}`);
@@ -121,6 +121,9 @@ export async function createServer(config, sessionManager, folderIndex, pushNoti
     sessionManager.onSessionClosed = (sessionId, folderPath) => {
         WsHandler.broadcastSidebarUpdate(sessionId, folderPath, sessionManager, clientRegistry);
     };
+    sessionManager.onGitBranchChange = (sessionId, folderPath) => {
+        WsHandler.broadcastSidebarUpdate(sessionId, folderPath, sessionManager, clientRegistry);
+    };
     const wss = new WebSocketServer({ noServer: true });
     const clientRegistry = new Map();
     httpServer.on('upgrade', (req, socket, head) => {
@@ -154,7 +157,7 @@ export async function createServer(config, sessionManager, folderIndex, pushNoti
         // The close handler skips cleanup when the registry already points to a
         // different handler, so this is the only place it runs.
         const existing = clientRegistry.get(clientId);
-        const handler = new WsHandler(sessionManager, folderIndex, ws, pushNotificationService, sessionMetadataStore, clientId, clientRegistry);
+        const handler = new WsHandler(sessionManager, folderIndex, ws, pushNotificationService, sessionMetadataStore, clientId, clientRegistry, voiceOrchestrator);
         clientRegistry.set(clientId, handler);
         if (existing) {
             existing.cleanup();