@hyperdrive.bot/fleet-server 0.3.99

package/dist/server/server/agent/wait-for-agent-tracker.js

@@ -0,0 +1,53 @@
+/**
+ * Tracks long-running wait_for_agent tool calls so they can be cancelled
+ * explicitly (e.g., when a voice barge-in aborts the current turn).
+ */
+export class WaitForAgentTracker {
+    constructor(logger) {
+        this.waiters = new Map();
+        this.logger = logger.child({ module: "agent", component: "wait-for-agent-tracker" });
+    }
+    register(agentId, cancel) {
+        if (!this.waiters.has(agentId)) {
+            this.waiters.set(agentId, new Set());
+        }
+        const waitersForAgent = this.waiters.get(agentId);
+        waitersForAgent.add(cancel);
+        return () => {
+            const current = this.waiters.get(agentId);
+            if (!current) {
+                return;
+            }
+            current.delete(cancel);
+            if (current.size === 0) {
+                this.waiters.delete(agentId);
+            }
+        };
+    }
+    cancel(agentId, reason) {
+        const waitersForAgent = this.waiters.get(agentId);
+        if (!waitersForAgent || waitersForAgent.size === 0) {
+            return false;
+        }
+        this.waiters.delete(agentId);
+        for (const cancel of waitersForAgent) {
+            try {
+                cancel(reason);
+            }
+            catch (error) {
+                this.logger.warn({ err: error, agentId }, "Cancel callback failed");
+            }
+        }
+        return true;
+    }
+    cancelAll(reason) {
+        let cancelled = 0;
+        for (const agentId of Array.from(this.waiters.keys())) {
+            if (this.cancel(agentId, reason)) {
+                cancelled += 1;
+            }
+        }
+        return cancelled;
+    }
+}
+//# sourceMappingURL=wait-for-agent-tracker.js.map

package/dist/server/server/agent-attention-policy.d.ts

@@ -0,0 +1,29 @@
+import type { AgentAttentionReason } from "@hyperdrive.bot/fleet-protocol/agent-attention-notification";
+export declare const PRESENCE_THRESHOLD_MS = 180000;
+export interface ClientPresenceState {
+    appVisible: boolean;
+    lastActivityAtMs: number | null;
+    focusedAgentId: string | null;
+    focusedTerminalId: string | null;
+}
+export type AttentionFocusTarget = {
+    kind: "agent";
+    id: string;
+} | {
+    kind: "terminal";
+    id: string;
+};
+export interface NotificationPlan {
+    inAppRecipientIndex: number | null;
+    shouldPush: boolean;
+}
+interface ComputeNotificationPlanInput {
+    allStates: ClientPresenceState[];
+    focusTarget: AttentionFocusTarget | null;
+    pushEligible: boolean;
+    nowMs: number;
+}
+export declare function computeNotificationPlan({ allStates, focusTarget, pushEligible, nowMs, }: ComputeNotificationPlanInput): NotificationPlan;
+export declare function isPushEligibleAttentionReason(reason: AgentAttentionReason): boolean;
+export {};
+//# sourceMappingURL=agent-attention-policy.d.ts.map

package/dist/server/server/agent-attention-policy.js

@@ -0,0 +1,36 @@
+export const PRESENCE_THRESHOLD_MS = 180000;
+function isFocusedOnTarget(state, target) {
+    if (target === null) {
+        return false;
+    }
+    if (target.kind === "agent") {
+        return state.focusedAgentId === target.id;
+    }
+    return state.focusedTerminalId === target.id;
+}
+export function computeNotificationPlan({ allStates, focusTarget, pushEligible, nowMs, }) {
+    let mostRecentPresentIndex = null;
+    let mostRecentPresentAtMs = Number.NEGATIVE_INFINITY;
+    for (const [clientIndex, state] of allStates.entries()) {
+        const clampedActivityAtMs = state.lastActivityAtMs === null ? null : Math.min(state.lastActivityAtMs, nowMs);
+        const isPresent = clampedActivityAtMs !== null && nowMs - clampedActivityAtMs <= PRESENCE_THRESHOLD_MS;
+        if (!isPresent) {
+            continue;
+        }
+        if (state.appVisible && isFocusedOnTarget(state, focusTarget)) {
+            return { inAppRecipientIndex: null, shouldPush: false };
+        }
+        if (clampedActivityAtMs > mostRecentPresentAtMs) {
+            mostRecentPresentIndex = clientIndex;
+            mostRecentPresentAtMs = clampedActivityAtMs;
+        }
+    }
+    if (mostRecentPresentIndex !== null) {
+        return { inAppRecipientIndex: mostRecentPresentIndex, shouldPush: false };
+    }
+    return { inAppRecipientIndex: null, shouldPush: pushEligible };
+}
+export function isPushEligibleAttentionReason(reason) {
+    return reason !== "error";
+}
+//# sourceMappingURL=agent-attention-policy.js.map

package/dist/server/server/atomic-file.d.ts

@@ -0,0 +1,3 @@
+export declare function writeFileAtomic(filePath: string, data: string | NodeJS.ArrayBufferView): Promise<void>;
+export declare function writeJsonFileAtomic(filePath: string, value: unknown): Promise<void>;
+//# sourceMappingURL=atomic-file.d.ts.map

package/dist/server/server/atomic-file.js

@@ -0,0 +1,19 @@
+import { randomUUID } from "node:crypto";
+import { promises as fs } from "node:fs";
+import path from "node:path";
+export async function writeFileAtomic(filePath, data) {
+    await fs.mkdir(path.dirname(filePath), { recursive: true });
+    const tempPath = path.join(path.dirname(filePath), `.${path.basename(filePath)}.${process.pid}.${Date.now()}.${randomUUID()}.tmp`);
+    try {
+        await fs.writeFile(tempPath, data, "utf8");
+        await fs.rename(tempPath, filePath);
+    }
+    catch (error) {
+        await fs.rm(tempPath, { force: true });
+        throw error;
+    }
+}
+export async function writeJsonFileAtomic(filePath, value) {
+    await writeFileAtomic(filePath, JSON.stringify(value, null, 2));
+}
+//# sourceMappingURL=atomic-file.js.map

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

@@ -0,0 +1,68 @@
+import type { RequestHandler } from "express";
+import { type TenantAuthConfig, type TenantIdentity } from "./tenant-token-verifier.js";
+export declare const DAEMON_PASSWORD_BCRYPT_COST = 12;
+export interface DaemonAuthConfig {
+    password?: string;
+    /**
+     * Multi-tenant builds authenticate the user against the tenant's Cognito pool
+     * in the client. When this is set the daemon verifies that same token itself,
+     * so reaching the port is no longer sufficient to drive the daemon.
+     */
+    tenant?: TenantAuthConfig;
+}
+export interface DaemonAuthOutcome {
+    ok: boolean;
+    /** Human-readable rejection, surfaced to the client as the WS close reason. */
+    reason?: string;
+    method?: "password" | "tenant";
+    identity?: TenantIdentity;
+}
+export interface DaemonAuthenticator {
+    /** False when the daemon is deliberately unauthenticated (no password, no tenant). */
+    readonly isConfigured: boolean;
+    authenticate(token: string | null): Promise<DaemonAuthOutcome>;
+}
+export declare function isDaemonAuthConfigured(auth: DaemonAuthConfig | undefined): boolean;
+/**
+ * Single entry point for daemon credential checks. Accepts EITHER the shared
+ * daemon password or a valid tenant Cognito token, so an operator can turn on
+ * tenant auth without breaking CLI callers that still use the password.
+ *
+ * Fails CLOSED: once either credential is configured, an unverifiable token is a
+ * rejection. A JWKS fetch failure surfaces as a failed verification, never as a
+ * skipped check.
+ */
+export declare function createDaemonAuthenticator(auth: DaemonAuthConfig | undefined): DaemonAuthenticator;
+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,207 @@
+import { compare, compareSync, hashSync } from "bcryptjs";
+import { timingSafeEqual } from "node:crypto";
+import { createTenantTokenVerifier, } from "./tenant-token-verifier.js";
+export const DAEMON_PASSWORD_BCRYPT_COST = 12;
+export function isDaemonAuthConfigured(auth) {
+    return Boolean(auth?.password ?? auth?.tenant);
+}
+/** A JWT is three base64url segments; anything else cannot be a Cognito token. */
+function looksLikeJwt(token) {
+    return token.split(".").length === 3;
+}
+/**
+ * Single entry point for daemon credential checks. Accepts EITHER the shared
+ * daemon password or a valid tenant Cognito token, so an operator can turn on
+ * tenant auth without breaking CLI callers that still use the password.
+ *
+ * Fails CLOSED: once either credential is configured, an unverifiable token is a
+ * rejection. A JWKS fetch failure surfaces as a failed verification, never as a
+ * skipped check.
+ */
+export function createDaemonAuthenticator(auth) {
+    let verifier = null;
+    const tenant = auth?.tenant;
+    const getVerifier = () => {
+        if (!tenant) {
+            return null;
+        }
+        verifier ?? (verifier = createTenantTokenVerifier(tenant));
+        return verifier;
+    };
+    const password = auth?.password;
+    const configured = isDaemonAuthConfigured(auth);
+    return {
+        isConfigured: configured,
+        async authenticate(token) {
+            if (!configured) {
+                return { ok: true };
+            }
+            if (token === null) {
+                return { ok: false, reason: "Password required" };
+            }
+            // Try the tenant token first when the credential is JWT-shaped: a bcrypt
+            // compare against a JWT is pure waste, and it runs on every connection.
+            const tenantFirst = Boolean(tenant) && looksLikeJwt(token);
+            if (tenantFirst) {
+                const result = await getVerifier()?.verify(token);
+                if (result?.ok) {
+                    return { ok: true, method: "tenant", identity: result.identity };
+                }
+                if (!password) {
+                    return { ok: false, reason: `Tenant token rejected: ${result?.reason ?? "unknown"}` };
+                }
+            }
+            if (password && (await isBearerTokenValidAsync({ password, token }))) {
+                return { ok: true, method: "password" };
+            }
+            if (!tenantFirst && tenant) {
+                const result = await getVerifier()?.verify(token);
+                if (result?.ok) {
+                    return { ok: true, method: "tenant", identity: result.identity };
+                }
+                return { ok: false, reason: `Tenant token rejected: ${result?.reason ?? "unknown"}` };
+            }
+            return { ok: false, reason: "Incorrect password" };
+        },
+    };
+}
+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 authenticator = createDaemonAuthenticator(auth);
+    return (req, res, next) => {
+        if (!authenticator.isConfigured || shouldBypassBearerAuth(req.method, req.path)) {
+            next();
+            return;
+        }
+        void (async () => {
+            try {
+                const token = extractHttpBearerToken(req.header("authorization"));
+                if (!(await authenticator.authenticate(token)).ok) {
+                    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