@getpaseo/server 0.1.91-beta.2 → 0.1.92

package/dist/server/server/session.js

@@ -8,6 +8,7 @@ import { CLIENT_CAPS } from "@getpaseo/protocol/client-capabilities";
 import { serializeAgentStreamEvent, } from "./messages.js";
 import { TerminalSessionController } from "../terminal/terminal-session-controller.js";
 import { encodeFileTransferFrame, FileTransferOpcode, } from "@getpaseo/protocol/binary-frames/index";
+import { FileUploadStore } from "./file-upload/index.js";
 import { CursorError } from "./pagination/cursor.js";
 import { SortablePager } from "./pagination/sortable-pager.js";
 import { TTSManager } from "./agent/tts-manager.js";
@@ -327,6 +328,7 @@ export class Session {
         this.onLifecycleIntent = onLifecycleIntent ?? null;
         this.downloadTokenStore = downloadTokenStore;
         this.pushTokenStore = pushTokenStore;
+        this.fileUploads = new FileUploadStore({ paseoHome });
         this.paseoHome = paseoHome;
         this.worktreesRoot = worktreesRoot;
         this.sessionLogger = logger.child({
@@ -1322,6 +1324,9 @@ export class Session {
                 return this.handleProjectIconRequest(msg);
             case "file_download_token_request":
                 return this.handleFileDownloadTokenRequest(msg);
+            case "file.upload.request":
+                this.handleFileUploadRequest(msg);
+                return undefined;
             default:
                 return undefined;
         }
@@ -1419,8 +1424,12 @@ export class Session {
     resetPeakInflight() {
         this.peakInflightRequests = this.inflightRequests;
     }
-    handleBinaryFrame(frame) {
-        this.terminalController.handleBinaryFrame(frame);
+    async handleBinaryFrame(binaryFrame) {
+        if (binaryFrame.kind === "file_transfer") {
+            await this.handleFileTransferFrame(binaryFrame.frame);
+            return;
+        }
+        this.terminalController.handleBinaryFrame(binaryFrame.frame);
     }
     async handleRestartServerRequest(requestId, reason) {
         const payload = {
@@ -2260,7 +2269,6 @@ export class Session {
                 logger: this.sessionLogger,
             });
             await this.registerWorkspaceForImportedAgent(snapshot.cwd);
-            await this.forwardAgentUpdate(snapshot);
             const agentPayload = await this.buildAgentPayload(snapshot);
             this.emit({
                 type: "status",
@@ -4395,6 +4403,15 @@ export class Session {
             });
         }
     }
+    handleFileUploadRequest(request) {
+        this.fileUploads.beginUpload(request);
+    }
+    async handleFileTransferFrame(frame) {
+        const response = await this.fileUploads.receiveFrame(frame);
+        if (response) {
+            this.emit(response);
+        }
+    }
     /**
      * Handle project icon request for a given cwd
      */

package/dist/server/server/speech/providers/local/runtime.js

@@ -67,6 +67,7 @@ export async function initializeLocalSpeechServices(params) {
     });
     const workerClient = localConfig
         ? new LocalSpeechWorkerClient({
+            logger,
             config: {
                 modelsDir: localConfig.modelsDir,
                 voiceSttModel: localModels.voiceLocalSttModel,

package/dist/server/server/speech/providers/local/worker-client.d.ts

@@ -1,4 +1,5 @@
 import { EventEmitter } from "node:events";
+import { Readable } from "node:stream";
 import type pino from "pino";
 import type { SpeechStreamResult, SpeechToTextProvider, StreamingTranscriptionSession, TextToSpeechProvider } from "../../speech-provider.js";
 import type { TurnDetectionProvider, TurnDetectionSession } from "../../turn-detection-provider.js";
@@ -6,20 +7,24 @@ import type { LocalSpeechSessionKind, LocalSpeechTranscriptionResult, LocalSpeec
 interface LocalSpeechWorkerProcess {
     connected: boolean;
     killed: boolean;
+    pid?: number;
+    stderr?: Readable | null;
     send(message: LocalSpeechWorkerRequest, callback: (error: Error | null) => void): boolean;
     disconnect(): void;
     kill(): boolean;
     on(event: "message", listener: (message: LocalSpeechWorkerToParentMessage) => void): this;
-    on(event: "exit", listener: (code: number | null, signal: NodeJS.Signals | null) => void): this;
+    on(event: "close", listener: (code: number | null, signal: NodeJS.Signals | null) => void): this;
 }
 interface LocalSpeechWorkerClientOptions {
     config: LocalSpeechWorkerConfig;
+    logger: pino.Logger;
     requestTimeoutMs?: number;
     idleTtlMs?: number;
     forkWorker?: () => LocalSpeechWorkerProcess;
 }
 export declare class LocalSpeechWorkerClient {
     private readonly config;
+    private readonly logger;
     private readonly requestTimeoutMs;
     private readonly idleTtlMs;
     private readonly forkWorker;
@@ -27,8 +32,12 @@ export declare class LocalSpeechWorkerClient {
     private readonly activeSessionIds;
     private readonly sessionEmitters;
     private worker;
+    private workerPid;
+    private stderrTail;
+    private stderrLineBuffer;
     private inFlightRequests;
     private idleTimer;
+    private readonly intentionalWorkerCloses;
     constructor(options: LocalSpeechWorkerClientOptions);
     synthesizeSpeech(text: string): Promise<SpeechStreamResult>;
     transcribeVoice(audio: Buffer, format: string): Promise<LocalSpeechTranscriptionResult>;
@@ -45,10 +54,14 @@ export declare class LocalSpeechWorkerClient {
     shutdown(): void;
     private sendRequest;
     private ensureWorker;
+    private handleWorkerStderr;
     private handleWorkerMessage;
     private handleWorkerExit;
+    private describePendingRequests;
+    private getStderrTail;
     private rejectAllPending;
     private emitSessionError;
+    private emitErrorIfObserved;
     private scheduleIdleShutdownIfReady;
     private clearIdleTimer;
 }

package/dist/server/server/speech/providers/local/worker-client.js

@@ -8,6 +8,8 @@ import { bufferToWorkerBytes, workerBytesToBuffer } from "./worker-bytes.js";
 const DEFAULT_REQUEST_TIMEOUT_MS = 30000;
 const DEFAULT_IDLE_TTL_MS = 5 * 60 * 1000;
 const DEFAULT_LOCAL_SAMPLE_RATE = 16000;
+const STDERR_TAIL_MAX_CHARS = 8000;
+const USER_ERROR_STDERR_MAX_CHARS = 1000;
 function resolveWorkerUrl() {
     const currentUrl = import.meta.url;
     if (currentUrl.endsWith(".ts")) {
@@ -38,21 +40,81 @@ function forkLocalSpeechWorker() {
         env,
         execArgv: resolveWorkerExecArgv(),
         serialization: "advanced",
-        stdio: ["ignore", "ignore", "inherit", "ipc"],
+        stdio: ["ignore", "ignore", "pipe", "ipc"],
     });
 }
 function isResponse(message) {
     return message.type === "response";
 }
+function truncateStart(value, maxChars) {
+    if (value.length <= maxChars) {
+        return value;
+    }
+    return value.slice(value.length - maxChars);
+}
+function summarizeWorkerRequest(message) {
+    switch (message.type) {
+        case "session.create":
+            return { kind: message.kind, sessionId: message.sessionId };
+        case "session.append":
+            return { sessionId: message.sessionId, audioBytes: message.audio.byteLength };
+        case "session.commit":
+        case "session.clear":
+        case "session.flush":
+        case "session.reset":
+        case "session.close":
+            return { sessionId: message.sessionId };
+        case "stt.transcribe":
+            return {
+                model: message.model,
+                audioBytes: message.audio.byteLength,
+                format: message.format,
+            };
+        case "tts.synthesize":
+            return { textLength: message.text.length };
+    }
+}
+function formatExitStatus(code, signal) {
+    const parts = [];
+    if (code !== null) {
+        parts.push(`code ${code}`);
+    }
+    if (signal) {
+        parts.push(`signal ${signal}`);
+    }
+    return parts.length > 0 ? parts.join(", ") : "unknown exit status";
+}
+function formatPendingRequestForMessage(request) {
+    const type = typeof request.type === "string" ? request.type : "unknown request";
+    const kind = typeof request.kind === "string" ? ` (${request.kind})` : "";
+    return `${type}${kind}`;
+}
+function buildWorkerExitMessage(params) {
+    const pending = params.pendingRequests.length > 0
+        ? ` while handling ${params.pendingRequests
+            .slice(0, 3)
+            .map(formatPendingRequestForMessage)
+            .join(", ")}`
+        : "";
+    const stderr = params.stderrTail
+        ? ` Last stderr: ${truncateStart(params.stderrTail, USER_ERROR_STDERR_MAX_CHARS)}`
+        : " Check daemon.log and macOS DiagnosticReports for Paseo Voice crash details.";
+    return `Local speech worker exited (${formatExitStatus(params.code, params.signal)})${pending}.${stderr}`;
+}
 export class LocalSpeechWorkerClient {
     constructor(options) {
         this.pendingRequests = new Map();
         this.activeSessionIds = new Set();
         this.sessionEmitters = new Map();
         this.worker = null;
+        this.workerPid = null;
+        this.stderrTail = "";
+        this.stderrLineBuffer = "";
         this.inFlightRequests = 0;
         this.idleTimer = null;
+        this.intentionalWorkerCloses = new WeakSet();
         this.config = options.config;
+        this.logger = options.logger.child({ component: "local-speech-worker-client" });
         this.requestTimeoutMs = options.requestTimeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS;
         this.idleTtlMs = options.idleTtlMs ?? DEFAULT_IDLE_TTL_MS;
         this.forkWorker = options.forkWorker ?? forkLocalSpeechWorker;
@@ -141,7 +203,9 @@ export class LocalSpeechWorkerClient {
         this.sessionEmitters.clear();
         const worker = this.worker;
         this.worker = null;
+        this.workerPid = null;
         if (worker && !worker.killed) {
+            this.intentionalWorkerCloses.add(worker);
             try {
                 worker.disconnect();
             }
@@ -160,6 +224,7 @@ export class LocalSpeechWorkerClient {
         const worker = this.ensureWorker();
         const requestId = randomUUID();
         const message = { ...input, requestId };
+        const requestSummary = summarizeWorkerRequest(message);
         this.inFlightRequests++;
         this.clearIdleTimer();
         return new Promise((resolve, reject) => {
@@ -173,6 +238,9 @@ export class LocalSpeechWorkerClient {
                 resolve: (value) => resolve(value),
                 reject,
                 timeout,
+                type: message.type,
+                summary: requestSummary,
+                startedAt: Date.now(),
             });
             worker.send(message, (error) => {
                 if (!error) {
@@ -196,10 +264,35 @@ export class LocalSpeechWorkerClient {
         }
         const worker = this.forkWorker();
         this.worker = worker;
+        this.workerPid = worker.pid ?? null;
+        this.stderrTail = "";
+        this.stderrLineBuffer = "";
+        this.logger.info({
+            workerPid: this.workerPid,
+            modelsDir: this.config.modelsDir,
+            voiceSttModel: this.config.voiceSttModel,
+            dictationSttModel: this.config.dictationSttModel,
+            voiceTtsModel: this.config.voiceTtsModel,
+        }, "Local speech worker spawned");
+        worker.stderr?.on("data", (chunk) => this.handleWorkerStderr(chunk));
         worker.on("message", (message) => this.handleWorkerMessage(message));
-        worker.on("exit", () => this.handleWorkerExit());
+        worker.on("close", (code, signal) => this.handleWorkerExit(worker, code, signal));
         return worker;
     }
+    handleWorkerStderr(chunk) {
+        const text = Buffer.isBuffer(chunk) ? chunk.toString("utf8") : chunk;
+        this.stderrTail = truncateStart(this.stderrTail + text, STDERR_TAIL_MAX_CHARS);
+        this.stderrLineBuffer += text;
+        const lines = this.stderrLineBuffer.split(/\r?\n/);
+        this.stderrLineBuffer = lines.pop() ?? "";
+        for (const line of lines) {
+            const trimmed = line.trim();
+            if (!trimmed) {
+                continue;
+            }
+            this.logger.warn({ workerPid: this.workerPid, stderr: trimmed }, "Local speech worker stderr");
+        }
+    }
     handleWorkerMessage(message) {
         if (isResponse(message)) {
             const pending = this.pendingRequests.get(message.requestId);
@@ -240,19 +333,81 @@ export class LocalSpeechWorkerClient {
                 return;
         }
     }
-    handleWorkerExit() {
-        this.worker = null;
+    handleWorkerExit(worker, code, signal) {
+        const wasCurrentWorker = this.worker === worker;
+        const wasIntentionalClose = this.intentionalWorkerCloses.has(worker);
+        this.intentionalWorkerCloses.delete(worker);
+        const workerPid = worker.pid ?? (wasCurrentWorker ? this.workerPid : null);
+        const pendingRequests = this.describePendingRequests();
+        const activeSessionCount = this.activeSessionIds.size;
+        const stderrTail = this.getStderrTail();
+        if (wasIntentionalClose) {
+            this.logger.info({
+                workerPid,
+                code,
+                signal,
+                pendingRequests,
+                activeSessionCount,
+                stderrTail: stderrTail || null,
+            }, "Local speech worker closed after shutdown");
+            if (wasCurrentWorker) {
+                this.worker = null;
+                this.workerPid = null;
+            }
+            return;
+        }
+        if (!wasCurrentWorker) {
+            this.logger.warn({
+                workerPid,
+                code,
+                signal,
+                pendingRequests,
+                activeSessionCount,
+                stderrTail: stderrTail || null,
+            }, "Stale local speech worker closed");
+            return;
+        }
+        const error = new Error(buildWorkerExitMessage({
+            code,
+            signal,
+            pendingRequests,
+            stderrTail,
+        }));
+        this.logger.error({
+            err: error,
+            workerPid,
+            code,
+            signal,
+            pendingRequests,
+            activeSessionCount,
+            stderrTail: stderrTail || null,
+        }, "Local speech worker exited");
+        if (wasCurrentWorker) {
+            this.worker = null;
+            this.workerPid = null;
+        }
         this.clearIdleTimer();
-        this.rejectAllPending(new Error("Local speech worker exited"));
+        this.rejectAllPending(error);
         for (const [sessionId, emitter] of this.sessionEmitters) {
             if (this.activeSessionIds.has(sessionId)) {
-                emitter.emit("error", new Error("Local speech worker exited"));
+                this.emitErrorIfObserved(sessionId, emitter, error, workerPid);
             }
         }
         this.activeSessionIds.clear();
         this.sessionEmitters.clear();
         this.inFlightRequests = 0;
     }
+    describePendingRequests() {
+        const now = Date.now();
+        return Array.from(this.pendingRequests.entries()).map(([requestId, request]) => Object.assign({
+            requestId,
+            type: request.type,
+            ageMs: Math.max(0, now - request.startedAt),
+        }, request.summary));
+    }
+    getStderrTail() {
+        return truncateStart(this.stderrTail.trim(), STDERR_TAIL_MAX_CHARS);
+    }
     rejectAllPending(error) {
         for (const [requestId, pending] of this.pendingRequests) {
             clearTimeout(pending.timeout);
@@ -265,7 +420,14 @@ export class LocalSpeechWorkerClient {
         if (!emitter) {
             return;
         }
-        emitter.emit("error", error instanceof Error ? error : new Error(String(error)));
+        this.emitErrorIfObserved(sessionId, emitter, error instanceof Error ? error : new Error(String(error)));
+    }
+    emitErrorIfObserved(sessionId, emitter, error, workerPid = this.workerPid) {
+        if (emitter.listenerCount("error") > 0) {
+            emitter.emit("error", error);
+            return;
+        }
+        this.logger.warn({ err: error, workerPid, sessionId }, "Local speech worker session error had no listener");
     }
     scheduleIdleShutdownIfReady() {
         if (!this.worker || this.inFlightRequests > 0 || this.activeSessionIds.size > 0) {

package/dist/server/server/websocket-server.d.ts

@@ -51,6 +51,7 @@ export declare class VoiceAssistantWebSocketServer {
     private readonly pendingConnections;
     private readonly sessions;
     private readonly externalSessionsByKey;
+    private readonly socketMessageQueues;
     private readonly serverId;
     private readonly daemonVersion;
     private readonly daemonRuntimeConfig;
@@ -129,6 +130,7 @@ export declare class VoiceAssistantWebSocketServer {
     private broadcastCapabilitiesUpdate;
     private broadcastDaemonConfigChanged;
     private bindSocketHandlers;
+    private enqueueRawMessage;
     resolveVoiceSpeakHandler(callerAgentId: string): VoiceSpeakHandler | null;
     resolveVoiceCallerContext(callerAgentId: string): VoiceCallerContext | null;
     private detachSocket;

package/dist/server/server/websocket-server.js

@@ -2,7 +2,7 @@ import { WebSocketServer } from "ws";
 import { basename, join } from "path";
 import { hostname as getHostname } from "node:os";
 import { WSInboundMessageSchema, wrapSessionMessage, } from "./messages.js";
-import { asUint8Array, decodeTerminalStreamFrame } from "@getpaseo/protocol/binary-frames/index";
+import { asUint8Array, decodeBinaryFrame } from "@getpaseo/protocol/binary-frames/index";
 import { isHostnameAllowed } from "./hostnames.js";
 import { Session } from "./session.js";
 import { buildWorkspaceGitMetadataFromSnapshot } from "./workspace-git-metadata.js";
@@ -206,6 +206,7 @@ export class VoiceAssistantWebSocketServer {
         this.pendingConnections = new Map();
         this.sessions = new Map();
         this.externalSessionsByKey = new Map();
+        this.socketMessageQueues = new Map();
         this.voiceSpeakHandlers = new Map();
         this.voiceCallerContexts = new Map();
         this.workspaceSetupSnapshots = new Map();
@@ -756,7 +757,7 @@ export class VoiceAssistantWebSocketServer {
     bindSocketHandlers(ws) {
         ws.on("message", (...args) => {
             const data = args[0];
-            void this.handleRawMessage(ws, data);
+            this.enqueueRawMessage(ws, data);
         });
         ws.on("close", async (...args) => {
             const code = args[0];
@@ -776,6 +777,18 @@ export class VoiceAssistantWebSocketServer {
             await this.detachSocket(ws, { error: err });
         });
     }
+    enqueueRawMessage(ws, data) {
+        const previous = this.socketMessageQueues.get(ws) ?? Promise.resolve();
+        const next = previous.then(() => this.handleRawMessage(ws, data), () => this.handleRawMessage(ws, data));
+        this.socketMessageQueues.set(ws, next);
+        void next
+            .catch(() => undefined)
+            .finally(() => {
+            if (this.socketMessageQueues.get(ws) === next) {
+                this.socketMessageQueues.delete(ws);
+            }
+        });
+    }
     resolveVoiceSpeakHandler(callerAgentId) {
         return this.voiceSpeakHandlers.get(callerAgentId) ?? null;
     }
@@ -897,14 +910,14 @@ export class VoiceAssistantWebSocketServer {
             },
         }));
     }
-    maybeHandleBinaryFrame(params) {
+    async maybeHandleBinaryFrame(params) {
         const { ws, buffer, activeConnection, log } = params;
         const asBytes = asUint8Array(buffer);
         if (!asBytes) {
             return false;
         }
-        const frame = decodeTerminalStreamFrame(asBytes);
-        if (!frame) {
+        const decodedFrame = decodeBinaryFrame(asBytes);
+        if (!decodedFrame) {
             return false;
         }
         if (!activeConnection) {
@@ -919,7 +932,7 @@ export class VoiceAssistantWebSocketServer {
             }
             return true;
         }
-        activeConnection.session.handleBinaryFrame(frame);
+        await activeConnection.session.handleBinaryFrame(decodedFrame);
         return true;
     }
     handlePendingConnectionMessage(params) {
@@ -950,7 +963,7 @@ export class VoiceAssistantWebSocketServer {
         const log = activeConnection?.connectionLogger ?? pendingConnection?.connectionLogger ?? this.logger;
         try {
             const buffer = bufferFromWsData(data);
-            const binaryHandled = this.maybeHandleBinaryFrame({
+            const binaryHandled = await this.maybeHandleBinaryFrame({
                 ws,
                 buffer,
                 activeConnection,

package/dist/server/server/workspace-registry.d.ts

@@ -16,8 +16,8 @@ declare const PersistedProjectRecordSchema: z.ZodObject<{
     archivedAt: string | null;
     kind: "git" | "non_git";
     projectId: string;
-    rootPath: string;
     displayName: string;
+    rootPath: string;
     customName: string | null;
 }, {
     createdAt: string;
@@ -25,8 +25,8 @@ declare const PersistedProjectRecordSchema: z.ZodObject<{
     archivedAt: string | null;
     kind: "git" | "non_git";
     projectId: string;
-    rootPath: string;
     displayName: string;
+    rootPath: string;
     customName?: string | null | undefined;
 }>;
 declare const PersistedWorkspaceRecordSchema: z.ZodObject<{
@@ -44,7 +44,7 @@ declare const PersistedWorkspaceRecordSchema: z.ZodObject<{
     createdAt: string;
     updatedAt: string;
     archivedAt: string | null;
-    kind: "worktree" | "local_checkout" | "directory";
+    kind: "local_checkout" | "worktree" | "directory";
     projectId: string;
     displayName: string;
 }, {
@@ -53,7 +53,7 @@ declare const PersistedWorkspaceRecordSchema: z.ZodObject<{
     createdAt: string;
     updatedAt: string;
     archivedAt: string | null;
-    kind: "worktree" | "local_checkout" | "directory";
+    kind: "local_checkout" | "worktree" | "directory";
     projectId: string;
     displayName: string;
 }>;

package/dist/src/server/persisted-config.js

@@ -129,7 +129,7 @@ const AgentMetadataGenerationSchema = z
     providers: z.array(StructuredGenerationProviderConfigSchema).optional(),
 })
     .strict();
-const BUILTIN_PROVIDER_IDS = ["claude", "codex", "copilot", "opencode", "pi"];
+const BUILTIN_PROVIDER_IDS = ["claude", "codex", "copilot", "opencode", "pi", "omp"];
 function isLegacyProviderEntry(value) {
     if (!value || typeof value !== "object" || Array.isArray(value)) {
         return false;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@getpaseo/server",
-  "version": "0.1.91-beta.2",
+  "version": "0.1.92",
   "description": "Paseo backend server",
   "files": [
     "dist/server",
@@ -59,10 +59,10 @@
   "dependencies": {
     "@agentclientprotocol/sdk": "^0.17.1",
     "@anthropic-ai/claude-agent-sdk": "^0.2.133",
-    "@getpaseo/client": "0.1.91-beta.2",
-    "@getpaseo/highlight": "0.1.91-beta.2",
-    "@getpaseo/protocol": "0.1.91-beta.2",
-    "@getpaseo/relay": "0.1.91-beta.2",
+    "@getpaseo/client": "0.1.92",
+    "@getpaseo/highlight": "0.1.92",
+    "@getpaseo/protocol": "0.1.92",
+    "@getpaseo/relay": "0.1.92",
     "@isaacs/ttlcache": "^2.1.4",
     "@modelcontextprotocol/sdk": "^1.20.1",
     "@opencode-ai/sdk": "1.14.46",