@getpaseo/server 0.1.91-beta.1 → 0.1.91

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/server/utils/directory-suggestions.js

@@ -12,8 +12,11 @@ const NO_SEGMENT_INDEX = Number.MAX_SAFE_INTEGER;
 const NO_MATCH_OFFSET = Number.MAX_SAFE_INTEGER;
 const NO_FUZZY_SCORE = Number.MAX_SAFE_INTEGER;
 const NO_WORKSPACE_MATCH_TIER = 5;
-const WORKSPACE_IGNORED_DIRECTORY_NAMES = new Set([
+const IGNORED_SUGGESTION_DIRECTORY_NAMES = new Set([
     "node_modules",
+    "venv",
+    "env",
+    "virtualenv",
     "dist",
     "build",
     "target",
@@ -589,7 +592,9 @@ async function listChildDirectories(input) {
         return cached.entries;
     }
     const dirents = await readdir(input.directory, { withFileTypes: true }).catch(() => []);
-    const candidates = dirents.filter((dirent) => !isHiddenDirectoryName(dirent.name) && (dirent.isDirectory() || dirent.isSymbolicLink()));
+    const candidates = dirents.filter((dirent) => !isHiddenDirectoryName(dirent.name) &&
+        !isIgnoredSuggestionDirectoryName(dirent.name) &&
+        (dirent.isDirectory() || dirent.isSymbolicLink()));
     const resolved = await Promise.all(candidates.map(async (dirent) => {
         const candidatePath = path.join(input.directory, dirent.name);
         const absolutePath = await resolveDirectoryCandidate({
@@ -613,7 +618,7 @@ async function listWorkspaceChildEntries(input) {
         return cached.entries;
     }
     const dirents = await readdir(input.directory, { withFileTypes: true }).catch(() => []);
-    const candidates = dirents.filter((dirent) => !isHiddenDirectoryName(dirent.name) && !isIgnoredWorkspaceDirectoryName(dirent.name));
+    const candidates = dirents.filter((dirent) => !isHiddenDirectoryName(dirent.name) && !isIgnoredSuggestionDirectoryName(dirent.name));
     const resolved = await Promise.all(candidates.map(async (dirent) => {
         const candidatePath = path.join(input.directory, dirent.name);
         const entry = await resolveWorkspaceCandidate({
@@ -682,8 +687,8 @@ async function resolveWorkspaceCandidate(input) {
 function isHiddenDirectoryName(name) {
     return name.startsWith(".");
 }
-function isIgnoredWorkspaceDirectoryName(name) {
-    return WORKSPACE_IGNORED_DIRECTORY_NAMES.has(name);
+function isIgnoredSuggestionDirectoryName(name) {
+    return IGNORED_SUGGESTION_DIRECTORY_NAMES.has(name);
 }
 function setDirectoryListCache(cacheKey, entry) {
     directoryListCache.set(cacheKey, entry);

package/dist/server/utils/worktree.d.ts

@@ -128,6 +128,10 @@ export declare class UnknownBranchError extends Error {
         cwd: string;
     });
 }
+export declare class InvalidGitBranchNameError extends Error {
+    readonly branchName: string;
+    constructor(branchName: string);
+}
 export type ReadPaseoConfigResult = {
     ok: true;
     config: PaseoConfig | null;

package/dist/server/utils/worktree.js

@@ -55,6 +55,13 @@ export class UnknownBranchError extends Error {
         this.cwd = params.cwd;
     }
 }
+export class InvalidGitBranchNameError extends Error {
+    constructor(branchName) {
+        super(`Invalid branch name: Git rejected ref name '${branchName}'`);
+        this.name = "InvalidGitBranchNameError";
+        this.branchName = branchName;
+    }
+}
 export function readPaseoConfig(repoRoot) {
     try {
         const json = readPaseoConfigJson(repoRoot);
@@ -898,7 +905,7 @@ async function resolveWorktreeSourcePlan({ cwd, source, desiredSlug, }) {
             };
         }
         case "checkout-branch": {
-            validateWorktreeBranchName(source.branchName);
+            await validateExistingWorktreeBranchName(cwd, source.branchName);
             if (!(await localBranchExists(cwd, source.branchName))) {
                 try {
                     await runGitCommand(["fetch", "origin", `${source.branchName}:${source.branchName}`], {
@@ -921,7 +928,7 @@ async function resolveWorktreeSourcePlan({ cwd, source, desiredSlug, }) {
         }
         case "checkout-github-pr": {
             const localBranchCandidate = source.localBranchName ?? source.headRef;
-            validateWorktreeBranchName(localBranchCandidate);
+            await validateExistingWorktreeBranchName(cwd, localBranchCandidate);
             const localBranchName = await resolveUniqueLocalBranchName(cwd, localBranchCandidate);
             const normalizedBaseRefName = normalizeRequiredBaseBranch(source.baseRefName);
             await runGitCommand([
@@ -966,6 +973,16 @@ function validateWorktreeBranchName(branchName) {
         throw new Error(`Invalid branch name: ${validation.error}`);
     }
 }
+async function validateExistingWorktreeBranchName(cwd, branchName) {
+    const result = await runGitCommand(["check-ref-format", "--branch", branchName], {
+        cwd,
+        timeout: 30000,
+        acceptExitCodes: [0, 1, 128],
+    });
+    if (result.exitCode !== 0) {
+        throw new InvalidGitBranchNameError(branchName);
+    }
+}
 function normalizeRequiredBaseBranch(baseBranch) {
     const normalizedBaseBranch = normalizeBaseRefName(baseBranch);
     if (!normalizedBaseBranch) {

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;
@@ -169,6 +169,7 @@ function normalizeAgentProviders(value) {
 }
 export const PersistedConfigSchema = z
     .object({
+    $schema: z.string().optional(),
     // v1 schema marker
     version: z.literal(1).optional(),
     // v1 config layout

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@getpaseo/server",
-  "version": "0.1.91-beta.1",
+  "version": "0.1.91",
   "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.1",
-    "@getpaseo/highlight": "0.1.91-beta.1",
-    "@getpaseo/protocol": "0.1.91-beta.1",
-    "@getpaseo/relay": "0.1.91-beta.1",
+    "@getpaseo/client": "0.1.91",
+    "@getpaseo/highlight": "0.1.91",
+    "@getpaseo/protocol": "0.1.91",
+    "@getpaseo/relay": "0.1.91",
     "@isaacs/ttlcache": "^2.1.4",
     "@modelcontextprotocol/sdk": "^1.20.1",
     "@opencode-ai/sdk": "1.14.46",