@hyperdrive.bot/paseo-server 0.2.6

package/dist/server/server/auth.d.ts

@@ -0,0 +1,38 @@
+import type { RequestHandler } from "express";
+export declare const DAEMON_PASSWORD_BCRYPT_COST = 12;
+export interface DaemonAuthConfig {
+    password?: string;
+}
+export interface BearerAuthRejectContext {
+    path: string;
+    method: string;
+    hasToken: boolean;
+}
+interface BearerValidationInput {
+    password: string | undefined;
+    token: string | null;
+}
+export declare function isBearerTokenValid(input: BearerValidationInput): boolean;
+export declare function isBearerTokenValidAsync(input: BearerValidationInput): Promise<boolean>;
+export declare function isBearerTokenValidSync(input: BearerValidationInput): boolean;
+export declare function hashDaemonPassword(password: string): string;
+export declare function extractHttpBearerToken(value: string | undefined): string | null;
+export declare function extractWsBearerProtocol(value: string | undefined): string | null;
+export declare function extractWsBearerToken(protocol: string | null): string | null;
+export declare function createRequireBearerMiddleware(auth: DaemonAuthConfig | undefined, onReject?: (context: BearerAuthRejectContext) => void): RequestHandler;
+export declare function shouldBypassBearerAuth(method: string, path: string): boolean;
+/**
+ * Authorizes a request to the Agent MCP endpoint (/mcp/agents), which is exempt
+ * from the global daemon-password middleware. Accepts either the per-daemon-run
+ * capability token the daemon injects into its own agents' configs and MCP
+ * client, or a valid daemon-password bearer (so existing password-authenticated
+ * callers keep working). When no daemon password is configured the endpoint is
+ * open, matching the global middleware's behavior.
+ */
+export declare function isAgentMcpRequestAuthorized(input: {
+    password: string | undefined;
+    capabilityToken: string | null;
+    authorizationHeader: string | undefined;
+}): Promise<boolean>;
+export {};
+//# sourceMappingURL=auth.d.ts.map

package/dist/server/server/auth.js

@@ -0,0 +1,143 @@
+import { compare, compareSync, hashSync } from "bcryptjs";
+import { timingSafeEqual } from "node:crypto";
+export const DAEMON_PASSWORD_BCRYPT_COST = 12;
+export function isBearerTokenValid(input) {
+    return isBearerTokenValidSync(input);
+}
+export async function isBearerTokenValidAsync(input) {
+    if (!input.password) {
+        return true;
+    }
+    if (input.token === null) {
+        return false;
+    }
+    return compare(input.token, input.password);
+}
+export function isBearerTokenValidSync(input) {
+    if (!input.password) {
+        return true;
+    }
+    if (input.token === null) {
+        return false;
+    }
+    return compareSync(input.token, input.password);
+}
+export function hashDaemonPassword(password) {
+    return hashSync(password, DAEMON_PASSWORD_BCRYPT_COST);
+}
+export function extractHttpBearerToken(value) {
+    if (!value) {
+        return null;
+    }
+    const [scheme, ...tokenParts] = value.trim().split(/\s+/);
+    if (scheme !== "Bearer" || tokenParts.length !== 1) {
+        return null;
+    }
+    return tokenParts[0] ?? null;
+}
+export function extractWsBearerProtocol(value) {
+    if (!value) {
+        return null;
+    }
+    for (const protocol of value.split(",")) {
+        const trimmed = protocol.trim();
+        const segments = trimmed.split(".");
+        if (segments[0] === "paseo" && segments[1] === "bearer" && segments.length >= 3) {
+            return trimmed;
+        }
+    }
+    return null;
+}
+export function extractWsBearerToken(protocol) {
+    if (!protocol) {
+        return null;
+    }
+    const segments = protocol.split(".");
+    if (segments[0] !== "paseo" || segments[1] !== "bearer" || segments.length < 3) {
+        return null;
+    }
+    return segments.slice(2).join(".");
+}
+export function createRequireBearerMiddleware(auth, onReject) {
+    const password = auth?.password;
+    return (req, res, next) => {
+        if (!password || shouldBypassBearerAuth(req.method, req.path)) {
+            next();
+            return;
+        }
+        void (async () => {
+            try {
+                const token = extractHttpBearerToken(req.header("authorization"));
+                if (!(await isBearerTokenValidAsync({ password, token }))) {
+                    onReject?.({
+                        path: req.path,
+                        method: req.method,
+                        hasToken: token !== null,
+                    });
+                    res.status(401).json({ error: "Unauthorized" });
+                    return;
+                }
+                next();
+            }
+            catch (error) {
+                next(error);
+            }
+        })();
+    };
+}
+// Routes that authenticate via their own capability and therefore must not be
+// gated a second time behind the daemon password.
+const BEARER_AUTH_BYPASS_PATHS = new Set([
+    // Unauthenticated liveness probe.
+    "/api/health",
+    // Guarded by a single-use download token (crypto-random UUID, 60s TTL,
+    // consumed on first use) that is only ever issued over the
+    // already-authenticated WebSocket. The token IS the capability for this
+    // route. Requiring the daemon password on top of it breaks browser and
+    // Electron downloads: those trigger the download via an anchor navigation,
+    // which cannot attach an `Authorization` header. The download endpoint still
+    // rejects requests without a valid token (400/403), so dropping the bearer
+    // here does not make the route unauthenticated.
+    "/api/files/download",
+    // The daemon injects its own agents' Paseo MCP connections at this endpoint
+    // (and connects its own per-client MCP client here). Those connections cannot
+    // carry the daemon password — it is only known in plaintext when set via env,
+    // never when set via the app — so the route authenticates them with a
+    // per-daemon-run capability token instead (see isAgentMcpRequestAuthorized).
+    // The token is injected only into local agent configs/sessions and never sent
+    // to remote clients, and the route still rejects callers presenting neither
+    // the token nor a valid daemon password, so dropping the global bearer here
+    // does not make the endpoint unauthenticated.
+    "/mcp/agents",
+]);
+export function shouldBypassBearerAuth(method, path) {
+    if (method === "OPTIONS") {
+        return true;
+    }
+    return BEARER_AUTH_BYPASS_PATHS.has(path);
+}
+/**
+ * Authorizes a request to the Agent MCP endpoint (/mcp/agents), which is exempt
+ * from the global daemon-password middleware. Accepts either the per-daemon-run
+ * capability token the daemon injects into its own agents' configs and MCP
+ * client, or a valid daemon-password bearer (so existing password-authenticated
+ * callers keep working). When no daemon password is configured the endpoint is
+ * open, matching the global middleware's behavior.
+ */
+export async function isAgentMcpRequestAuthorized(input) {
+    if (!input.password) {
+        return true;
+    }
+    const token = extractHttpBearerToken(input.authorizationHeader);
+    if (input.capabilityToken !== null && token !== null) {
+        // Constant-time compare; length-guard first because timingSafeEqual throws
+        // on differing buffer lengths.
+        const provided = Buffer.from(token);
+        const expected = Buffer.from(input.capabilityToken);
+        if (provided.length === expected.length && timingSafeEqual(provided, expected)) {
+            return true;
+        }
+    }
+    return isBearerTokenValidAsync({ password: input.password, token });
+}
+//# sourceMappingURL=auth.js.map

package/dist/server/server/auto-archive-on-merge/archive-if-safe.d.ts

@@ -0,0 +1,40 @@
+import type { Logger } from "pino";
+import type { AgentManager } from "../agent/agent-manager.js";
+import type { AgentStorage } from "../agent/agent-storage.js";
+import type { DaemonConfigStore } from "../daemon-config-store.js";
+import { archiveByScope, type ActiveWorkspaceRef, killTerminalsForWorkspace, resolveWorkspaceIdAtPath } from "../workspace-archive-service.js";
+import type { WorkspaceGitRuntimeSnapshot, WorkspaceGitServiceImpl } from "../workspace-git-service.js";
+import type { GitHubService } from "../../services/github-service.js";
+import type { TerminalManager } from "../../terminal/terminal-manager.js";
+import { isPaseoOwnedWorktreeCwd } from "../../utils/worktree.js";
+export interface AutoArchiveArchiveOptions {
+    paseoHome: string;
+    paseoWorktreesBaseRoot?: string;
+    daemonConfigStore: DaemonConfigStore;
+    workspaceGitService: WorkspaceGitServiceImpl;
+    github: GitHubService;
+    agentManager: AgentManager;
+    agentStorage: AgentStorage;
+    terminalManager: TerminalManager;
+    findWorkspaceIdForCwd: (cwd: string) => Promise<string | null>;
+    listActiveWorkspaces: () => Promise<ActiveWorkspaceRef[]>;
+    archiveWorkspaceRecord: (workspaceId: string) => Promise<void>;
+    markWorkspaceArchiving: (workspaceIds: Iterable<string>, archivingAt: string) => void;
+    clearWorkspaceArchiving: (workspaceIds: Iterable<string>) => void;
+    emitWorkspaceUpdatesForWorkspaceIds: (workspaceIds: Iterable<string>) => Promise<void>;
+}
+export interface ArchiveIfSafeDependencies {
+    archiveByScope: typeof archiveByScope;
+    resolveWorkspaceIdAtPath: typeof resolveWorkspaceIdAtPath;
+    isPaseoOwnedWorktreeCwd: typeof isPaseoOwnedWorktreeCwd;
+    killTerminalsForWorkspace: typeof killTerminalsForWorkspace;
+}
+export declare function archiveIfSafe(input: {
+    cwd: string;
+    pullRequest: WorkspaceGitRuntimeSnapshot["github"]["pullRequest"];
+    inFlight: Set<string>;
+    options: AutoArchiveArchiveOptions;
+    log: Logger;
+    deps?: ArchiveIfSafeDependencies;
+}): Promise<void>;
+//# sourceMappingURL=archive-if-safe.d.ts.map

package/dist/server/server/auto-archive-on-merge/archive-if-safe.js

@@ -0,0 +1,92 @@
+import { archiveByScope, killTerminalsForWorkspace, resolveWorkspaceIdAtPath, } from "../workspace-archive-service.js";
+import { isPaseoOwnedWorktreeCwd } from "../../utils/worktree.js";
+const defaultDependencies = {
+    archiveByScope,
+    resolveWorkspaceIdAtPath,
+    isPaseoOwnedWorktreeCwd,
+    killTerminalsForWorkspace,
+};
+export async function archiveIfSafe(input) {
+    const { cwd, pullRequest, inFlight, options, log } = input;
+    const deps = input.deps ?? defaultDependencies;
+    if (!pullRequest?.isMerged) {
+        return;
+    }
+    if (options.daemonConfigStore.get().autoArchiveAfterMerge !== true) {
+        return;
+    }
+    if (inFlight.has(cwd)) {
+        return;
+    }
+    inFlight.add(cwd);
+    try {
+        let snapshot;
+        try {
+            snapshot = await options.workspaceGitService.getSnapshot(cwd, {
+                reason: "auto-archive-on-merge",
+            });
+        }
+        catch (error) {
+            log.warn({ err: error, cwd }, "Failed to read snapshot for auto-archive; skipping");
+            return;
+        }
+        if (!snapshot) {
+            return;
+        }
+        if (snapshot.git.isDirty === true) {
+            return;
+        }
+        if (typeof snapshot.git.aheadOfOrigin === "number" && snapshot.git.aheadOfOrigin > 0) {
+            return;
+        }
+        const ownership = await deps.isPaseoOwnedWorktreeCwd(cwd, {
+            paseoHome: options.paseoHome,
+            worktreesRoot: options.paseoWorktreesBaseRoot,
+        });
+        if (!ownership.allowed) {
+            return;
+        }
+        try {
+            const workspaceId = await deps.resolveWorkspaceIdAtPath({
+                findWorkspaceIdForCwd: options.findWorkspaceIdForCwd,
+                listActiveWorkspaces: options.listActiveWorkspaces,
+            }, cwd);
+            if (!workspaceId) {
+                log.warn({ cwd }, "Auto-archive could not resolve a workspace for cwd; skipping");
+                return;
+            }
+            await deps.archiveByScope({
+                paseoHome: options.paseoHome,
+                paseoWorktreesBaseRoot: options.paseoWorktreesBaseRoot,
+                github: options.github,
+                workspaceGitService: options.workspaceGitService,
+                agentManager: options.agentManager,
+                agentStorage: options.agentStorage,
+                findWorkspaceIdForCwd: options.findWorkspaceIdForCwd,
+                listActiveWorkspaces: options.listActiveWorkspaces,
+                archiveWorkspaceRecord: options.archiveWorkspaceRecord,
+                emitWorkspaceUpdatesForWorkspaceIds: options.emitWorkspaceUpdatesForWorkspaceIds,
+                markWorkspaceArchiving: options.markWorkspaceArchiving,
+                clearWorkspaceArchiving: options.clearWorkspaceArchiving,
+                killTerminalsForWorkspace: (workspaceIdToKill) => deps.killTerminalsForWorkspace({
+                    terminalManager: options.terminalManager,
+                    sessionLogger: log,
+                }, workspaceIdToKill),
+                sessionLogger: log,
+            }, {
+                scope: { kind: "workspace", workspaceId },
+                repoRoot: ownership.repoRoot ?? null,
+                paseoWorktreesBaseRoot: options.paseoWorktreesBaseRoot,
+                requestId: "auto-archive-on-merge",
+            });
+            log.info({ cwd }, "Auto-archived worktree after PR merge");
+        }
+        catch (error) {
+            log.warn({ err: error, cwd }, "Auto-archive after merge failed");
+        }
+    }
+    finally {
+        inFlight.delete(cwd);
+    }
+}
+//# sourceMappingURL=archive-if-safe.js.map

package/dist/server/server/auto-archive-on-merge/index.d.ts

@@ -0,0 +1,8 @@
+import type { Logger } from "pino";
+import { type AutoArchiveArchiveOptions } from "./archive-if-safe.js";
+import type { WorkspaceGitSubscription } from "../workspace-git-service.js";
+export interface AutoArchiveOnMergeOptions extends AutoArchiveArchiveOptions {
+    logger: Logger;
+}
+export declare function setupAutoArchiveOnMerge(options: AutoArchiveOnMergeOptions): WorkspaceGitSubscription;
+//# sourceMappingURL=index.d.ts.map

package/dist/server/server/auto-archive-on-merge/index.js

@@ -0,0 +1,15 @@
+import { archiveIfSafe } from "./archive-if-safe.js";
+export function setupAutoArchiveOnMerge(options) {
+    const log = options.logger.child({ module: "auto-archive-on-merge" });
+    const inFlight = new Set();
+    return options.workspaceGitService.onSnapshotUpdated((snapshot) => {
+        void archiveIfSafe({
+            cwd: snapshot.cwd,
+            pullRequest: snapshot.github.pullRequest,
+            inFlight,
+            options,
+            log,
+        });
+    });
+}
+//# sourceMappingURL=index.js.map

package/dist/server/server/bootstrap.d.ts

@@ -0,0 +1,126 @@
+import express from "express";
+import type { Logger } from "pino";
+export type ListenTarget = {
+    type: "tcp";
+    host: string;
+    port: number;
+} | {
+    type: "socket";
+    path: string;
+} | {
+    type: "pipe";
+    path: string;
+};
+export declare function parseListenString(listen: string): ListenTarget;
+import type { OpenAiSpeechProviderConfig } from "./speech/providers/openai/config.js";
+import type { LocalSpeechProviderConfig } from "./speech/providers/local/config.js";
+import type { RequestedSpeechProviders } from "./speech/speech-types.js";
+import { AgentManager } from "./agent/agent-manager.js";
+import { AgentStorage } from "./agent/agent-storage.js";
+import { WorkflowManager } from "./workflow/workflow-manager.js";
+import { BrowserToolsBroker } from "./browser-tools/broker.js";
+import type { TerminalManager } from "../terminal/terminal-manager.js";
+import type { PushNotificationSender } from "./push/notifications.js";
+import type { AgentClient, AgentProvider } from "./agent/agent-sdk-types.js";
+import type { TerminalProfile } from "@hyperdrive.bot/paseo-protocol/messages";
+import type { AgentProviderRuntimeSettingsMap, ProviderOverride } from "./agent/provider-launch-config.js";
+import type { PersistedConfig } from "./persisted-config.js";
+import { type ServiceProxySubsystem } from "./service-proxy.js";
+import { WorkspaceScriptRuntimeStore } from "./workspace-script-runtime-store.js";
+import { type ManagedProcessRegistry } from "./managed-processes/managed-processes.js";
+import { type HostnamesConfig } from "./hostnames.js";
+import { type DaemonAuthConfig } from "./auth.js";
+export declare function createTerminalActivityRouteHandler(terminalManager: TerminalManager): express.RequestHandler;
+export type PaseoOpenAIConfig = OpenAiSpeechProviderConfig;
+export type PaseoLocalSpeechConfig = LocalSpeechProviderConfig;
+export interface PaseoSpeechSttLanguages {
+    dictation: string;
+    voice: string;
+}
+export interface PaseoSpeechConfig {
+    providers: RequestedSpeechProviders;
+    sttLanguages?: PaseoSpeechSttLanguages;
+    local?: PaseoLocalSpeechConfig;
+}
+export type DaemonLifecycleIntent = {
+    type: "shutdown";
+    clientId: string;
+    requestId: string;
+    reason: string;
+} | {
+    type: "restart";
+    clientId: string;
+    requestId: string;
+    reason: string;
+};
+export interface PaseoDaemonConfig {
+    listen: string;
+    paseoHome: string;
+    worktreesRoot?: string;
+    corsAllowedOrigins: string[];
+    allowedHosts?: HostnamesConfig;
+    hostnames?: HostnamesConfig;
+    trustedProxies?: true | string[];
+    mcpEnabled?: boolean;
+    mcpInjectIntoAgents?: boolean;
+    browserToolsEnabled?: boolean;
+    autoArchiveAfterMerge?: boolean;
+    enableTerminalAgentHooks?: boolean;
+    appendSystemPrompt?: string;
+    terminalProfiles?: TerminalProfile[];
+    staticDir: string;
+    mcpDebug: boolean;
+    isDev?: boolean;
+    agentClients: Partial<Record<AgentProvider, AgentClient>>;
+    agentStoragePath: string;
+    relayEnabled?: boolean;
+    relayEndpoint?: string;
+    relayPublicEndpoint?: string;
+    relayUseTls?: boolean;
+    relayPublicUseTls?: boolean;
+    serviceProxy?: {
+        publicBaseUrl: string | null;
+        standaloneListen: string | null;
+    };
+    webUi?: {
+        enabled: boolean;
+        distDir: string | null;
+    };
+    appBaseUrl?: string;
+    auth?: DaemonAuthConfig;
+    openai?: PaseoOpenAIConfig;
+    speech?: PaseoSpeechConfig;
+    voiceLlmProvider?: AgentProvider | null;
+    voiceLlmProviderExplicit?: boolean;
+    voiceLlmModel?: string | null;
+    dictationFinalTimeoutMs?: number;
+    downloadTokenTtlMs?: number;
+    agentProviderSettings?: AgentProviderRuntimeSettingsMap;
+    metadataGeneration?: {
+        providers?: Array<{
+            provider: string;
+            model?: string;
+            thinkingOptionId?: string;
+        }>;
+    };
+    providerOverrides?: Record<string, ProviderOverride>;
+    log?: PersistedConfig["log"];
+    onLifecycleIntent?: (intent: DaemonLifecycleIntent) => void;
+    pushNotificationSender?: PushNotificationSender;
+    managedProcesses?: ManagedProcessRegistry;
+}
+export interface PaseoDaemon {
+    config: PaseoDaemonConfig;
+    agentManager: AgentManager;
+    agentStorage: AgentStorage;
+    workflowManager: WorkflowManager;
+    terminalManager: TerminalManager;
+    serviceProxy: ServiceProxySubsystem;
+    scriptRuntimeStore: WorkspaceScriptRuntimeStore;
+    browserToolsBroker: BrowserToolsBroker;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    getListenTarget(): ListenTarget | null;
+}
+export declare function createPaseoDaemon(config: PaseoDaemonConfig, rootLogger: Logger): Promise<PaseoDaemon>;
+//# sourceMappingURL=bootstrap.d.ts.map