@getpaseo/server 0.9.2 → 0.10.0

package/dist/server/server/bootstrap.js

@@ -141,6 +141,7 @@ import { terminateWithTreeKill } from "../utils/tree-kill.js";
 import { withTimeout } from "../utils/promise-timeout.js";
 import { isHostnameAllowed } from "./hostnames.js";
 import { createRequireBearerMiddleware, isAgentMcpRequestAuthorized, } from "./auth.js";
+import { deleteLocalCredential, writeLocalCredential } from "./local-credential.js";
 import { createWebUiMiddleware } from "./web-ui.js";
 import { WorkspaceAutoName } from "./workspace-auto-name.js";
 import { createGitMutationService } from "./session/git-mutation/git-mutation-service.js";
@@ -486,7 +487,9 @@ export async function createPaseoDaemon(config, rootLogger, dependencies = {}) {
     // static app files load without the daemon password while API/WebSocket calls
     // remain protected.
     mountWebUi(app, config, logger);
-    app.use(createRequireBearerMiddleware(config.auth, (context) => {
+    let localCredential = null;
+    const daemonAuth = { ...config.auth, localCredential: () => localCredential };
+    app.use(createRequireBearerMiddleware(daemonAuth, (context) => {
         logger.warn(context, "Rejected HTTP request with invalid daemon password");
     }));
     app.use(express.json());
@@ -1170,6 +1173,7 @@ export async function createPaseoDaemon(config, rootLogger, dependencies = {}) {
     const start = async () => {
         let mainStarted = false;
         try {
+            localCredential = await writeLocalCredential(config.paseoHome);
             if (serviceProxyListenTarget) {
                 const boundServiceProxyTarget = await serviceProxy.startStandalone({
                     listenTarget: serviceProxyListenTarget,
@@ -1241,7 +1245,7 @@ export async function createPaseoDaemon(config, rootLogger, dependencies = {}) {
                             daemonStatusRpc: dependencies.serverFeatureOverrides?.daemonStatusRpc,
                             relayConfig: dependencies.serverFeatureOverrides?.relayConfig,
                             startPaused: true,
-                        }, workspaceAutoName, config.auth, speechService, terminalManager, {
+                        }, workspaceAutoName, daemonAuth, speechService, terminalManager, {
                             finalTimeoutMs: config.dictationFinalTimeoutMs,
                         }, daemonVersion, (intent) => {
                             try {
@@ -1310,6 +1314,8 @@ export async function createPaseoDaemon(config, rootLogger, dependencies = {}) {
             scriptHealthMonitor.start();
         }
         catch (error) {
+            localCredential = null;
+            await deleteLocalCredential(config.paseoHome);
             unsubscribePluginProviders();
             await pluginRuntime.stopAllPlugins().catch(() => undefined);
             await serviceProxy.stopStandalone().catch(() => undefined);
@@ -1322,6 +1328,8 @@ export async function createPaseoDaemon(config, rootLogger, dependencies = {}) {
         }
     };
     const stop = async () => {
+        localCredential = null;
+        await deleteLocalCredential(config.paseoHome);
         // Stop tracking plugin provider registrations before anything tears plugins
         // down, so plugin shutdown cannot withdraw a provider from under an agent
         // that is still open. Plugins themselves are stopped once every session

package/dist/server/server/daemon-instance.d.ts

@@ -2,6 +2,7 @@ import { type PidLockInfo } from "./pid-lock.js";
 export { resolvePaseoHome } from "./paseo-home.js";
 export { ensurePrivateDirectory } from "./private-files.js";
 export { daemonLaunchEnvironment } from "./config-environment.js";
+export { readLocalCredentialForTarget } from "./local-credential.js";
 export { isSamePidLock as isSameDaemonInstance, type PidLockInfo as DaemonInstance, } from "./pid-lock.js";
 export declare class DaemonInstanceError extends Error {
     readonly code: string;

package/dist/server/server/daemon-instance.js

@@ -18,6 +18,7 @@ const killTree = (pid, signal) => new Promise((resolve, reject) => treeKill(pid,
 export { resolvePaseoHome } from "./paseo-home.js";
 export { ensurePrivateDirectory } from "./private-files.js";
 export { daemonLaunchEnvironment } from "./config-environment.js";
+export { readLocalCredentialForTarget } from "./local-credential.js";
 export { isSamePidLock as isSameDaemonInstance, } from "./pid-lock.js";
 export class DaemonInstanceError extends Error {
     constructor(code, message) {

package/dist/server/server/exports.d.ts

@@ -4,7 +4,7 @@ export { resolvePaseoHome } from "./paseo-home.js";
 export { getOrCreateServerId } from "./server-id.js";
 export { createRootLogger, type LogLevel, type LogFormat } from "./logger.js";
 export { loadPersistedConfig, savePersistedConfig, type PersistedConfig, } from "./persisted-config.js";
-export { hashDaemonPassword, isBearerTokenValid } from "./auth.js";
+export { hashDaemonPassword, isBearerTokenValidAsync } from "./auth.js";
 export { generateLocalPairingOffer, type LocalPairingOffer } from "./pairing-offer.js";
 export { ConnectionOfferSchema, decodeOfferFragmentPayload, parseConnectionOfferFromUrl, type ConnectionOffer, } from "@getpaseo/protocol/connection-offer";
 export { buildRelayWebSocketUrl } from "@getpaseo/protocol/daemon-endpoints";

package/dist/server/server/exports.js

@@ -5,7 +5,7 @@ export { resolvePaseoHome } from "./paseo-home.js";
 export { getOrCreateServerId } from "./server-id.js";
 export { createRootLogger } from "./logger.js";
 export { loadPersistedConfig, savePersistedConfig, } from "./persisted-config.js";
-export { hashDaemonPassword, isBearerTokenValid } from "./auth.js";
+export { hashDaemonPassword, isBearerTokenValidAsync } from "./auth.js";
 export { generateLocalPairingOffer } from "./pairing-offer.js";
 export { ConnectionOfferSchema, decodeOfferFragmentPayload, parseConnectionOfferFromUrl, } from "@getpaseo/protocol/connection-offer";
 export { buildRelayWebSocketUrl } from "@getpaseo/protocol/daemon-endpoints";

package/dist/server/server/local-credential.d.ts

@@ -0,0 +1,6 @@
+export declare function writeLocalCredential(home: string): Promise<string>;
+export declare function deleteLocalCredential(home: string): Promise<void>;
+export declare function readLocalCredential(home: string): string | null;
+export declare function matchesLocalCredential(expected: string, candidate: string): boolean;
+export declare function readLocalCredentialForTarget(home: string, target: string): string | null;
+//# sourceMappingURL=local-credential.d.ts.map

package/dist/server/server/local-credential.js

@@ -0,0 +1,82 @@
+import { randomBytes, randomUUID, timingSafeEqual } from "node:crypto";
+import { readFileSync } from "node:fs";
+import { chmod, rename, unlink, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { normalizeLoopbackToLocalhost, parseConnectionUri, } from "@getpaseo/protocol/daemon-endpoints";
+const FILE_NAME = "local-credential";
+export async function writeLocalCredential(home) {
+    const token = randomBytes(32).toString("base64url");
+    const temporary = join(home, `${FILE_NAME}.${randomUUID()}.tmp`);
+    try {
+        await writeFile(temporary, `${token}\n`, { mode: 0o600, flag: "wx" });
+        await chmod(temporary, 0o600);
+        await rename(temporary, join(home, FILE_NAME));
+        return token;
+    }
+    finally {
+        await unlink(temporary).catch((error) => {
+            if (error.code !== "ENOENT")
+                throw error;
+        });
+    }
+}
+export async function deleteLocalCredential(home) {
+    await unlink(join(home, FILE_NAME)).catch((error) => {
+        if (error.code !== "ENOENT")
+            throw error;
+    });
+}
+export function readLocalCredential(home) {
+    try {
+        const token = readFileSync(join(home, FILE_NAME), "utf8").trim();
+        return /^[A-Za-z0-9_-]{43}$/.test(token) ? token : null;
+    }
+    catch {
+        return null;
+    }
+}
+export function matchesLocalCredential(expected, candidate) {
+    const actual = Buffer.from(candidate);
+    const reference = Buffer.from(expected);
+    return actual.length === reference.length && timingSafeEqual(actual, reference);
+}
+function normalizeTarget(target) {
+    try {
+        const trimmed = target.trim();
+        if (trimmed.startsWith("tcp://")) {
+            const parsed = parseConnectionUri(trimmed);
+            const endpoint = parsed.isIpv6
+                ? `[${parsed.host}]:${parsed.port}`
+                : `${parsed.host}:${parsed.port}`;
+            return normalizeLoopbackToLocalhost(endpoint);
+        }
+        if (trimmed.startsWith("unix://") || trimmed.startsWith("pipe://"))
+            return trimmed;
+        if (trimmed.startsWith("/"))
+            return `unix://${trimmed}`;
+        if (trimmed.startsWith("\\\\.\\pipe\\"))
+            return `pipe://${trimmed}`;
+        if (/^\d+$/.test(trimmed))
+            return `localhost:${trimmed}`;
+        return normalizeLoopbackToLocalhost(trimmed);
+    }
+    catch {
+        return null;
+    }
+}
+export function readLocalCredentialForTarget(home, target) {
+    try {
+        const lock = JSON.parse(readFileSync(join(home, "paseo.pid"), "utf8"));
+        if (typeof lock.listen !== "string")
+            return null;
+        const selected = normalizeTarget(target);
+        const listening = normalizeTarget(lock.listen);
+        if (!selected || !listening || selected !== listening)
+            return null;
+        return readLocalCredential(home);
+    }
+    catch {
+        return null;
+    }
+}
+//# sourceMappingURL=local-credential.js.map

package/dist/server/server/session-admission-auth.d.ts

@@ -0,0 +1,16 @@
+import type { WSHelloMessage } from "@getpaseo/protocol/messages";
+import type { SessionAdmission } from "./websocket-server.js";
+export type AdmissionFailure = "password_required" | "incorrect_password";
+type AdmissionResolution = {
+    admission: SessionAdmission;
+} | {
+    rejection: AdmissionFailure;
+};
+export declare function resolveSessionAdmission(input: {
+    credential: WSHelloMessage["auth"];
+    passwordHash: string | undefined;
+    localCredential: string | null;
+    transport: "direct" | "relay";
+}): Promise<AdmissionResolution>;
+export {};
+//# sourceMappingURL=session-admission-auth.d.ts.map

package/dist/server/server/session-admission-auth.js

@@ -0,0 +1,26 @@
+import { compare } from "bcryptjs";
+import { OWNER_PERMISSIONS } from "./authorization/index.js";
+import { matchesLocalCredential } from "./local-credential.js";
+export async function resolveSessionAdmission(input) {
+    const { credential, passwordHash, localCredential, transport } = input;
+    if (!passwordHash) {
+        return { admission: { principalId: "owner", permissions: OWNER_PERMISSIONS } };
+    }
+    if (!credential) {
+        // COMPAT(relayPasswordOptional): added in v0.9.1, remove once release N mobile builds are live on App Store and Play.
+        if (transport === "relay") {
+            return { admission: { principalId: "owner", permissions: OWNER_PERMISSIONS } };
+        }
+        return { rejection: "password_required" };
+    }
+    if (credential.kind === "localCredential") {
+        if (localCredential && matchesLocalCredential(localCredential, credential.token)) {
+            return { admission: { principalId: "owner", permissions: OWNER_PERMISSIONS } };
+        }
+        return { rejection: "incorrect_password" };
+    }
+    return (await compare(credential.password, passwordHash))
+        ? { admission: { principalId: "owner", permissions: OWNER_PERMISSIONS } }
+        : { rejection: "incorrect_password" };
+}
+//# sourceMappingURL=session-admission-auth.js.map

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

@@ -91,6 +91,8 @@ export declare class VoiceAssistantWebSocketServer {
     private readonly workspaceAutoName;
     private readonly downloadTokenStore;
     private readonly paseoHome;
+    private readonly passwordHash;
+    private readonly credentialSource;
     private readonly worktreesRoot;
     private readonly daemonConfigStore;
     private readonly pushNotifications;
@@ -147,7 +149,7 @@ export declare class VoiceAssistantWebSocketServer {
     publishProjectUpdate(update: ProjectUpdate): void;
     publishSpeechReadiness(readiness: SpeechReadinessSnapshot | null): void;
     updateServerCapabilities(capabilities: ServerCapabilities | null | undefined): void;
-    attachExternalSocket(ws: WebSocketLike, metadata?: ExternalSocketMetadata, admission?: SessionAdmission, initialHello?: WSHelloMessage): Promise<void>;
+    attachExternalSocket(ws: WebSocketLike, metadata?: ExternalSocketMetadata, admission?: SessionAdmission | null, initialHello?: WSHelloMessage): Promise<void>;
     attachPluginSocket(pluginId: string, ws: WebSocketLike): Promise<{
         closed: Promise<void>;
     }>;
@@ -170,6 +172,9 @@ export declare class VoiceAssistantWebSocketServer {
     private createSocketSession;
     private clearPendingConnection;
     private handleHello;
+    private handleHelloSafely;
+    private admitPendingHello;
+    private rejectHello;
     private resumeSession;
     private buildServerInfoStatusPayload;
     private createServerInfoMessage;

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

@@ -19,7 +19,8 @@ import { createPushNotifications, } from "./push/index.js";
 import { computeNotificationPlan, isPushEligibleAttentionReason, } from "./agent-attention-policy.js";
 import { buildAgentAttentionNotificationPayload, findLatestPermissionRequest, } from "@getpaseo/protocol/agent-attention-notification";
 import { createGitHubService } from "../services/github-service.js";
-import { extractWsBearerProtocol, extractWsBearerToken, isBearerTokenValid, } from "./auth.js";
+import { extractHttpBearerToken, extractWsBearerProtocol, extractWsBearerToken, isBearerTokenValidAsync, } from "./auth.js";
+import { resolveSessionAdmission } from "./session-admission-auth.js";
 import { WebSocketRuntimeMetricsWindow, } from "./websocket/runtime-metrics.js";
 import { ProviderUsageService } from "../services/quota-fetcher/service.js";
 import { getProcessMemoryDiagnostics, getProcessUptimeSeconds } from "./process-diagnostics.js";
@@ -331,6 +332,7 @@ export class VoiceAssistantWebSocketServer {
             throw new MissingDaemonVersionError();
         }
         this.daemonVersion = daemonVersion.trim();
+        this.credentialSource = auth;
         this.daemonRuntimeConfig = daemonRuntimeConfig;
         this.browserToolsBroker = browserToolsBroker ?? null;
         this.hubRelationships = hubRelationships ?? null;
@@ -354,6 +356,7 @@ export class VoiceAssistantWebSocketServer {
         this.workspaceAutoName = workspaceAutoName;
         this.downloadTokenStore = downloadTokenStore;
         this.paseoHome = paseoHome;
+        this.passwordHash = auth?.password;
         this.worktreesRoot = daemonRuntimeConfig?.worktreesRoot;
         this.daemonConfigStore = daemonConfigStore;
         this.mcpBaseUrl = mcpBaseUrl;
@@ -523,19 +526,29 @@ export class VoiceAssistantWebSocketServer {
         }
     }
     async attachAuthenticatedSocket(ws, request, password) {
-        if (password) {
-            const requestMetadata = extractSocketRequestMetadata(request);
+        // Header validation is asynchronous. Buffer frames until the socket has a
+        // pending hello handler so an eager client cannot lose its first message.
+        ws.pause();
+        try {
+            // COMPAT(headerAuth): added in v0.9.1, remove after 2027-03-24.
             const protocol = extractWsBearerProtocol(request.headers["sec-websocket-protocol"]);
-            const token = extractWsBearerToken(protocol);
-            const isAuthorized = isBearerTokenValid({ password, token });
-            if (!isAuthorized) {
-                const reason = token === null ? "Password required" : "Incorrect password";
-                this.logger.warn({ ...requestMetadata, hasToken: token !== null }, "Rejected WebSocket connection with invalid daemon password");
-                ws.close(WS_CLOSE_DAEMON_AUTH_FAILED, reason);
-                return;
+            const token = extractHttpBearerToken(request.headers.authorization) ?? extractWsBearerToken(protocol);
+            const hasHeaderCredential = token !== null;
+            if (password && hasHeaderCredential) {
+                const requestMetadata = extractSocketRequestMetadata(request);
+                const isAuthorized = await isBearerTokenValidAsync({ password, token });
+                if (!isAuthorized) {
+                    const reason = "Incorrect password";
+                    this.logger.warn({ ...requestMetadata, hasToken: true }, "Rejected WebSocket connection with invalid daemon password");
+                    ws.close(WS_CLOSE_DAEMON_AUTH_FAILED, reason);
+                    return;
+                }
             }
+            await this.attachSocket(ws, request, undefined, false, hasHeaderCredential ? OWNER_SESSION_ADMISSION : null);
+        }
+        finally {
+            ws.resume();
         }
-        await this.attachSocket(ws, request);
     }
     broadcast(message) {
         if (message.type === "session") {
@@ -567,7 +580,7 @@ export class VoiceAssistantWebSocketServer {
         this.serverCapabilities = next;
         this.broadcastCapabilitiesUpdate();
     }
-    async attachExternalSocket(ws, metadata, admission = OWNER_SESSION_ADMISSION, initialHello) {
+    async attachExternalSocket(ws, metadata, admission = null, initialHello) {
         if (metadata?.transport === "relay") {
             this.incrementRuntimeCounter("relayExternalSocketAttached");
         }
@@ -584,7 +597,7 @@ export class VoiceAssistantWebSocketServer {
         this.pluginSocketIds.set(ws, pluginId);
         this.pluginSocketCleanup.set(ws, resolve);
         try {
-            await this.attachSocket(ws, undefined, undefined, true);
+            await this.attachSocket(ws, undefined, undefined, true, OWNER_SESSION_ADMISSION);
         }
         catch (error) {
             this.pluginSocketIds.delete(ws);
@@ -595,7 +608,7 @@ export class VoiceAssistantWebSocketServer {
     }
     updatePrincipalPermissions(principalId, permissions) {
         for (const pending of this.pendingConnections.values()) {
-            if (pending.admission.principalId === principalId) {
+            if (pending.admission?.principalId === principalId) {
                 pending.admission = { ...pending.admission, permissions };
             }
         }
@@ -818,7 +831,7 @@ export class VoiceAssistantWebSocketServer {
             this.sendBinaryToClient(ws, frame, false);
         }
     }
-    async attachSocket(ws, request, metadata, allowDuringStartup = false, admission = OWNER_SESSION_ADMISSION, initialHello) {
+    async attachSocket(ws, request, metadata, allowDuringStartup = false, admission = null, initialHello) {
         if (this.connectionLifecycle === "stopping" ||
             (this.connectionLifecycle === "starting" && !allowDuringStartup)) {
             try {
@@ -838,6 +851,7 @@ export class VoiceAssistantWebSocketServer {
             helloTimeout: null,
             identity,
             admission,
+            authenticating: false,
         };
         const timeout = setTimeout(() => {
             if (this.pendingConnections.get(ws) !== pending) {
@@ -862,9 +876,8 @@ export class VoiceAssistantWebSocketServer {
             ...toConnectionLogFields(identity),
             totalPendingConnections: this.pendingConnections.size,
         }, "Client connected; awaiting hello");
-        if (initialHello) {
-            this.handleHello({ ws, message: initialHello, pending });
-        }
+        if (initialHello)
+            await this.handleHelloSafely({ ws, message: initialHello, pending });
     }
     createSessionConnection(params) {
         const { ws, clientId, appVersion, clientCapabilities, connectionLogger, lifecycle, admission } = params;
@@ -1040,22 +1053,20 @@ export class VoiceAssistantWebSocketServer {
         this.pendingConnections.delete(ws);
         return pending;
     }
-    handleHello(params) {
+    async handleHello(params) {
         const { ws, message, pending } = params;
-        if (message.protocolVersion !== WS_PROTOCOL_VERSION) {
+        if (message.protocolVersion < 1) {
             this.clearPendingConnection(ws);
             pending.connectionLogger.warn({
                 receivedProtocolVersion: message.protocolVersion,
                 expectedProtocolVersion: WS_PROTOCOL_VERSION,
             }, "Rejected hello due to protocol version mismatch");
-            try {
-                ws.close(WS_CLOSE_INCOMPATIBLE_PROTOCOL, "Incompatible protocol version");
-            }
-            catch {
-                // ignore close errors
-            }
+            await this.rejectHello(ws, message, "incompatible_protocol");
             return;
         }
+        pending.authenticating = true;
+        if (!pending.admission && !(await this.admitPendingHello(ws, message, pending)))
+            return;
         const clientId = message.clientId.trim();
         if (clientId.length === 0) {
             this.clearPendingConnection(ws);
@@ -1078,11 +1089,14 @@ export class VoiceAssistantWebSocketServer {
             return;
         }
         this.clearPendingConnection(ws);
+        const admitted = pending.admission;
+        if (!admitted)
+            throw new Error("Admitted hello has no session admission");
         pending.identity.clientId = clientId;
         if (message.appVersion) {
             pending.identity.appVersion = message.appVersion;
         }
-        const sessionKey = sessionConnectionKey(pending.admission.principalId, clientId);
+        const sessionKey = sessionConnectionKey(admitted.principalId, clientId);
         const existing = pluginId ? undefined : this.externalSessionsByKey.get(sessionKey);
         if (existing) {
             this.resumeSession({ ws, message, pending, existing });
@@ -1097,7 +1111,7 @@ export class VoiceAssistantWebSocketServer {
             clientCapabilities: message.capabilities ?? null,
             connectionLogger,
             lifecycle: pluginId ? { kind: "ephemeral-plugin", pluginId } : { kind: "reconnectable" },
-            admission: pending.admission,
+            admission: admitted,
         });
         this.sessions.set(ws, connection);
         if (connection.lifecycle === "reconnectable") {
@@ -1111,6 +1125,83 @@ export class VoiceAssistantWebSocketServer {
             totalSessions: this.sessions.size,
         }, "Client connected via hello");
     }
+    handleHelloSafely(params) {
+        return this.handleHello(params).catch((error) => {
+            try {
+                this.handleRawMessageError({
+                    ws: params.ws,
+                    data: "",
+                    error,
+                    log: params.pending.connectionLogger,
+                });
+            }
+            catch {
+                // The error reporter must not turn a connection failure into a process failure.
+            }
+            finally {
+                try {
+                    params.ws.close(WS_CLOSE_INVALID_HELLO, "Invalid hello");
+                }
+                catch {
+                    // The transport may already be closed.
+                }
+            }
+        });
+    }
+    async admitPendingHello(ws, message, pending) {
+        if (pending.admission)
+            return true;
+        try {
+            const resolved = await resolveSessionAdmission({
+                credential: message.auth,
+                passwordHash: this.passwordHash,
+                localCredential: this.credentialSource?.localCredential?.() ?? null,
+                transport: pending.identity.transport === "relay" ? "relay" : "direct",
+            });
+            if (this.pendingConnections.get(ws) !== pending)
+                return false;
+            if ("rejection" in resolved) {
+                this.clearPendingConnection(ws);
+                await this.rejectHello(ws, message, resolved.rejection);
+                return false;
+            }
+            pending.admission = resolved.admission;
+            return true;
+        }
+        catch (error) {
+            pending.connectionLogger.error({ err: error }, "Failed to resolve hello credential");
+            if (this.pendingConnections.get(ws) === pending) {
+                this.clearPendingConnection(ws);
+                await this.rejectHello(ws, message, "incorrect_password");
+            }
+            return false;
+        }
+    }
+    async rejectHello(ws, hello, reason) {
+        // Older clients discard unknown frames, then use the close code and reason.
+        // They never send hello.auth, so avoid sending an unknown envelope to them.
+        if (hello.auth || hello.capabilities?.[CLIENT_CAPS.helloRejection] === true) {
+            try {
+                await ws.send(JSON.stringify({ type: "hello.rejected", reason, accepts: ["password"] }));
+            }
+            catch {
+                // The close reason remains the compatibility signal.
+            }
+        }
+        const closeReason = {
+            password_required: "Password required",
+            incorrect_password: "Incorrect password",
+            incompatible_protocol: "Incompatible protocol version",
+        }[reason];
+        try {
+            ws.close(reason === "incompatible_protocol"
+                ? WS_CLOSE_INCOMPATIBLE_PROTOCOL
+                : WS_CLOSE_DAEMON_AUTH_FAILED, closeReason);
+        }
+        catch {
+            // Ignore a transport that closed while the rejection was sent.
+        }
+    }
     resumeSession(params) {
         const { ws, message, pending, existing } = params;
         this.incrementRuntimeCounter("helloResumed");
@@ -1145,6 +1236,7 @@ export class VoiceAssistantWebSocketServer {
     buildServerInfoStatusPayload(session) {
         return {
             status: "server_info",
+            protocolVersion: WS_PROTOCOL_VERSION,
             serverId: this.serverId,
             hostname: getHostname(),
             version: this.daemonVersion,
@@ -1535,8 +1627,8 @@ export class VoiceAssistantWebSocketServer {
     }
     handlePendingConnectionMessage(params) {
         const { ws, message, pendingConnection } = params;
-        if (message.type === "hello") {
-            this.handleHello({
+        if (message.type === "hello" && !pendingConnection.authenticating) {
+            void this.handleHelloSafely({
                 ws,
                 message,
                 pending: pendingConnection,
@@ -1590,7 +1682,7 @@ export class VoiceAssistantWebSocketServer {
             }
             const message = parsedMessage.data;
             this.recordInboundMessageType(message.type);
-            if (message.type === "ping") {
+            if (message.type === "ping" && activeConnection) {
                 // A plugin socket is IPC to a child this daemon already supervises, not
                 // an abandonable application socket.
                 if (!this.pluginSocketIds.has(ws)) {
@@ -1599,9 +1691,6 @@ export class VoiceAssistantWebSocketServer {
                 this.sendToClient(ws, { type: "pong" });
                 return;
             }
-            if (message.type === "recording_state") {
-                return;
-            }
             if (pendingConnection) {
                 this.handlePendingConnectionMessage({
                     ws,
@@ -1610,6 +1699,9 @@ export class VoiceAssistantWebSocketServer {
                 });
                 return;
             }
+            if (message.type === "recording_state") {
+                return;
+            }
             if (!activeConnection) {
                 this.incrementRuntimeCounter("missingConnectionForMessage");
                 this.logger.error("No connection found for websocket");
@@ -1668,15 +1760,8 @@ export class VoiceAssistantWebSocketServer {
     handleRawMessageError(params) {
         const { ws, data, error, log } = params;
         const err = error instanceof Error ? error : new Error(String(error));
-        const { rawPayload, parsedPayload } = this.decodeRawMessagePayloadForError(data);
-        const trimmedRawPayload = typeof rawPayload === "string" && rawPayload.length > 2000
-            ? `${rawPayload.slice(0, 2000)}... (truncated)`
-            : rawPayload;
-        log.error({
-            err,
-            rawPayload: trimmedRawPayload,
-            parsedPayload,
-        }, "Failed to parse/handle message");
+        // Inbound frames can contain hello.auth.password or session secrets.
+        log.error({ errorName: err.name }, "Failed to parse/handle message");
         if (this.pendingConnections.has(ws)) {
             this.clearPendingConnection(ws);
             try {
@@ -1687,7 +1772,7 @@ export class VoiceAssistantWebSocketServer {
             }
             return;
         }
-        const requestInfo = extractRequestInfoFromUnknownWsInbound(parsedPayload);
+        const requestInfo = extractRequestInfoFromUnknownWsInbound(this.decodeRawMessagePayloadForError(data));
         this.sessions.get(ws)?.session.delivery.protocolFailure(ws, {
             ...requestInfo,
             error: `Invalid message: ${err.message}`,
@@ -1695,20 +1780,12 @@ export class VoiceAssistantWebSocketServer {
         });
     }
     decodeRawMessagePayloadForError(data) {
-        let rawPayload = null;
-        let parsedPayload = null;
         try {
-            const buffer = bufferFromWsData(data);
-            rawPayload = buffer.toString();
-            parsedPayload = JSON.parse(rawPayload);
+            return JSON.parse(bufferFromWsData(data).toString());
         }
-        catch (payloadError) {
-            rawPayload = rawPayload ?? "<unreadable>";
-            parsedPayload = parsedPayload ?? rawPayload;
-            const payloadErr = payloadError instanceof Error ? payloadError : new Error(String(payloadError));
-            this.logger.error({ err: payloadErr }, "Failed to decode raw payload");
+        catch {
+            return null;
         }
-        return { rawPayload, parsedPayload };
     }
     incrementRuntimeCounter(counter) {
         this.runtimeMetrics.incrementCounter(counter);

package/dist/server/web-ui/_expo/static/js/web/{desktop-attachment-bridge-f41bce08c3c4ac2de0652d20234d19e9.js → desktop-attachment-bridge-9da07adb97f5e0eb726f7762afee43f5.js}

@@ -1 +1 @@
-__d(function(g,r,i,a,m,e,d){"use strict";Object.defineProperty(e,'__esModule',{value:!0}),e.createDesktopAttachmentBridge=function(){const l=(0,s.createDesktopPreviewUrlResolver)({reader:(0,s.createDesktopFileReader)(),objectUrls:(0,s.createBrowserObjectUrlMinter)()});return{copyFile:t.copyDesktopAttachmentFile,writeBase64:t.writeDesktopAttachmentBase64,writeBytes:t.writeDesktopAttachmentBytes,deleteFile:t.deleteDesktopAttachmentFile,garbageCollect:t.garbageCollectDesktopAttachmentFiles,readFileBase64:s.readDesktopFileBase64,resolvePreviewUrl:t=>l.resolve(t),releasePreviewUrl:t=>l.release(t)}};var t=r(d[0]),s=r(d[1])},5079,[4431,4432]);
+__d(function(g,r,i,a,m,e,d){"use strict";Object.defineProperty(e,'__esModule',{value:!0}),e.createDesktopAttachmentBridge=function(){const l=(0,s.createDesktopPreviewUrlResolver)({reader:(0,s.createDesktopFileReader)(),objectUrls:(0,s.createBrowserObjectUrlMinter)()});return{copyFile:t.copyDesktopAttachmentFile,writeBase64:t.writeDesktopAttachmentBase64,writeBytes:t.writeDesktopAttachmentBytes,deleteFile:t.deleteDesktopAttachmentFile,garbageCollect:t.garbageCollectDesktopAttachmentFiles,readFileBase64:s.readDesktopFileBase64,resolvePreviewUrl:t=>l.resolve(t),releasePreviewUrl:t=>l.release(t)}};var t=r(d[0]),s=r(d[1])},5083,[4432,4433]);

package/dist/server/web-ui/_expo/static/js/web/{desktop-attachment-store-9e271e161480b0d1dd35e58616a37341.js → desktop-attachment-store-d5d3402a752965d3037191484127123b.js}

@@ -1 +1 @@
-__d(function(g,r,i,a,m,e,d){"use strict";Object.defineProperty(e,'__esModule',{value:!0}),e.createDesktopAttachmentStore=function(n){return{storageType:"desktop-file",async save(s){const o=s.id??(0,t.generateAttachmentId)(),l=s.fileName??null;if("file_uri"===s.source.kind)return await c(n,{id:o,uri:s.source.uri,mimeType:s.mimeType,fileName:l});if("data_url"===s.source.kind){const c=(0,t.parseDataUrl)(s.source.dataUrl),p=(0,t.normalizeMimeType)(s.mimeType??c.mimeType);return await y(n,{id:o,base64:c.base64,mimeType:p,fileName:l})}if("bytes"===s.source.kind){const c=(0,t.normalizeMimeType)(s.mimeType);return await p(n,{id:o,bytes:s.source.bytes,mimeType:c,fileName:l})}const f=(0,t.normalizeMimeType)(s.mimeType??s.source.blob.type),u=await(0,t.blobToBase64)(s.source.blob);return await y(n,{id:o,base64:u,mimeType:f,fileName:l})},encodeBase64:async({attachment:t})=>(f(t),await n.readFileBase64(t.storageKey)),resolvePreviewUrl:async({attachment:t})=>(f(t),await n.resolvePreviewUrl(t)),async releasePreviewUrl({attachment:t,url:s}){f(t),await n.releasePreviewUrl({url:s})},async delete({attachment:t}){f(t),await n.deleteFile({path:t.storageKey})},async garbageCollect({referencedIds:t}){await n.garbageCollect({referencedIds:Array.from(t)})}}};var t=r(d[0]);const n={"image/png":".png","image/jpeg":".jpg","image/jpg":".jpg","image/gif":".gif","image/webp":".webp","image/avif":".avif","image/heic":".heic","image/heif":".heif","image/tiff":".tiff","image/bmp":".bmp","image/svg+xml":".svg"};function s(t){const n=t.replace(/\\/g,"/").split("/"),s=n[n.length-1];return s&&s.length>0?s:null}function o(s){const o=(0,t.getFileExtensionFromName)(s.fileName);if(o)return o;const l=(0,t.getFileExtensionFromName)(s.sourcePath);return l||(n[s.mimeType]??".img")}function l(t){return{id:t.id,mimeType:t.mimeType,storageType:"desktop-file",storageKey:t.storagePath,fileName:t.fileName??null,byteSize:t.byteSize,createdAt:Date.now()}}async function c(n,c){const y=(0,t.fileUriToPath)(c.uri),p=c.fileName??s(y),f=(0,t.normalizeMimeType)(c.mimeType),u=o({fileName:p,sourcePath:y,mimeType:f}),T=await n.copyFile({attachmentId:c.id,sourcePath:y,extension:u});return l({id:c.id,mimeType:f,storagePath:T.path,byteSize:T.byteSize,fileName:p})}async function y(t,n){const s=o({fileName:n.fileName,mimeType:n.mimeType}),c=await t.writeBase64({attachmentId:n.id,base64:n.base64,extension:s});return l({id:n.id,mimeType:n.mimeType,storagePath:c.path,byteSize:c.byteSize,fileName:n.fileName})}async function p(t,n){const s=o({fileName:n.fileName,mimeType:n.mimeType}),c=await t.writeBytes({attachmentId:n.id,bytes:n.bytes,extension:s});return l({id:n.id,mimeType:n.mimeType,storagePath:c.path,byteSize:c.byteSize,fileName:n.fileName})}function f(t){if("desktop-file"!==t.storageType)throw new Error(`Unsupported desktop attachment storage type '${t.storageType}'.`)}},5078,[4425]);
+__d(function(g,r,i,a,m,e,d){"use strict";Object.defineProperty(e,'__esModule',{value:!0}),e.createDesktopAttachmentStore=function(n){return{storageType:"desktop-file",async save(s){const o=s.id??(0,t.generateAttachmentId)(),l=s.fileName??null;if("file_uri"===s.source.kind)return await c(n,{id:o,uri:s.source.uri,mimeType:s.mimeType,fileName:l});if("data_url"===s.source.kind){const c=(0,t.parseDataUrl)(s.source.dataUrl),p=(0,t.normalizeMimeType)(s.mimeType??c.mimeType);return await y(n,{id:o,base64:c.base64,mimeType:p,fileName:l})}if("bytes"===s.source.kind){const c=(0,t.normalizeMimeType)(s.mimeType);return await p(n,{id:o,bytes:s.source.bytes,mimeType:c,fileName:l})}const f=(0,t.normalizeMimeType)(s.mimeType??s.source.blob.type),u=await(0,t.blobToBase64)(s.source.blob);return await y(n,{id:o,base64:u,mimeType:f,fileName:l})},encodeBase64:async({attachment:t})=>(f(t),await n.readFileBase64(t.storageKey)),resolvePreviewUrl:async({attachment:t})=>(f(t),await n.resolvePreviewUrl(t)),async releasePreviewUrl({attachment:t,url:s}){f(t),await n.releasePreviewUrl({url:s})},async delete({attachment:t}){f(t),await n.deleteFile({path:t.storageKey})},async garbageCollect({referencedIds:t}){await n.garbageCollect({referencedIds:Array.from(t)})}}};var t=r(d[0]);const n={"image/png":".png","image/jpeg":".jpg","image/jpg":".jpg","image/gif":".gif","image/webp":".webp","image/avif":".avif","image/heic":".heic","image/heif":".heif","image/tiff":".tiff","image/bmp":".bmp","image/svg+xml":".svg"};function s(t){const n=t.replace(/\\/g,"/").split("/"),s=n[n.length-1];return s&&s.length>0?s:null}function o(s){const o=(0,t.getFileExtensionFromName)(s.fileName);if(o)return o;const l=(0,t.getFileExtensionFromName)(s.sourcePath);return l||(n[s.mimeType]??".img")}function l(t){return{id:t.id,mimeType:t.mimeType,storageType:"desktop-file",storageKey:t.storagePath,fileName:t.fileName??null,byteSize:t.byteSize,createdAt:Date.now()}}async function c(n,c){const y=(0,t.fileUriToPath)(c.uri),p=c.fileName??s(y),f=(0,t.normalizeMimeType)(c.mimeType),u=o({fileName:p,sourcePath:y,mimeType:f}),T=await n.copyFile({attachmentId:c.id,sourcePath:y,extension:u});return l({id:c.id,mimeType:f,storagePath:T.path,byteSize:T.byteSize,fileName:p})}async function y(t,n){const s=o({fileName:n.fileName,mimeType:n.mimeType}),c=await t.writeBase64({attachmentId:n.id,base64:n.base64,extension:s});return l({id:n.id,mimeType:n.mimeType,storagePath:c.path,byteSize:c.byteSize,fileName:n.fileName})}async function p(t,n){const s=o({fileName:n.fileName,mimeType:n.mimeType}),c=await t.writeBytes({attachmentId:n.id,bytes:n.bytes,extension:s});return l({id:n.id,mimeType:n.mimeType,storagePath:c.path,byteSize:c.byteSize,fileName:n.fileName})}function f(t){if("desktop-file"!==t.storageType)throw new Error(`Unsupported desktop attachment storage type '${t.storageType}'.`)}},5082,[4426]);