@camerontaylor/paseo-server 0.8.0-fork.1

package/dist/server/server/agent-history-search.js

@@ -0,0 +1,129 @@
+import { compareMatchScores, fuzzyPolicyForToken, matchRanges, scoreMatch, tokenizeQuery, } from "@camerontaylor/paseo-protocol/search/text-match";
+/** In tie-break order; the index into this list is a field's rank. */
+const SEARCH_FIELDS = ["workspace", "title", "branch", "project"];
+function searchableFields(candidate) {
+    const { agent, project } = candidate;
+    return [
+        project.workspaceName ?? "",
+        agent.title ?? "",
+        project.checkout.currentBranch ?? "",
+        project.projectName,
+    ];
+}
+function bestFieldMatch(token, fields) {
+    const fuzzy = fuzzyPolicyForToken(token);
+    let best = null;
+    for (let fieldRank = 0; fieldRank < fields.length; fieldRank += 1) {
+        const field = fields[fieldRank];
+        if (!field)
+            continue;
+        const score = scoreMatch(token, field, { fuzzy });
+        if (!score)
+            continue;
+        if (!best || compareMatchScores(score, best.score) < 0) {
+            best = { score, fieldRank, token };
+        }
+    }
+    return best;
+}
+/** Overlapping spans from different tokens would double-mark the same glyphs. */
+function mergeRanges(ranges) {
+    const sorted = [...ranges].sort((left, right) => left.start - right.start);
+    const merged = [];
+    for (const range of sorted) {
+        const last = merged.at(-1);
+        if (last && range.start <= last.start + last.length) {
+            last.length = Math.max(last.length, range.start + range.length - last.start);
+            continue;
+        }
+        merged.push({ ...range });
+    }
+    return merged;
+}
+/**
+ * One number so the wire can carry relevance and several hosts' pages can be
+ * merged by it. Tier dominates, then which field matched, then how deep into
+ * that field the match sat.
+ */
+function toSearchScore(matches) {
+    let total = 0;
+    for (const match of matches) {
+        total += match.score.tier * 1000 + match.fieldRank * 100 + Math.min(match.score.offset, 99);
+    }
+    return total;
+}
+/**
+ * Every token has to match something, so adding a word always narrows. Tokens
+ * may land on different fields — "stripe main" finds the Stripe workspace on
+ * the main branch.
+ */
+export function scoreAgentHistoryCandidate(query, candidate) {
+    const matches = matchAgentHistoryCandidate(query, candidate);
+    return matches ? toSearchScore(matches) : null;
+}
+function matchAgentHistoryCandidate(query, candidate) {
+    const tokens = tokenizeQuery(query);
+    if (tokens.length === 0)
+        return null;
+    const fields = searchableFields(candidate);
+    const matches = [];
+    for (const token of tokens) {
+        const match = bestFieldMatch(token, fields);
+        if (!match)
+            return null;
+        matches.push(match);
+    }
+    return matches;
+}
+/**
+ * Where the query landed in each field, for the rows that will actually be
+ * rendered. The ranker already knows this; sending it means the client never
+ * has to re-derive a second opinion that could disagree with the ranking it is
+ * explaining.
+ */
+export function describeAgentHistoryMatches(query, candidate) {
+    const matches = matchAgentHistoryCandidate(query, candidate);
+    if (!matches)
+        return [];
+    const fields = searchableFields(candidate);
+    const rangesByField = new Map();
+    for (const match of matches) {
+        const field = SEARCH_FIELDS[match.fieldRank];
+        const ranges = matchRanges(match.token, fields[match.fieldRank], match.score);
+        rangesByField.set(field, [...(rangesByField.get(field) ?? []), ...ranges]);
+    }
+    return [...rangesByField.entries()].map(([field, ranges]) => ({
+        field,
+        ranges: mergeRanges(ranges),
+    }));
+}
+/**
+ * Ranks the whole candidate set rather than a page of it. The daemon holds
+ * every persisted agent in memory already, so search is complete by
+ * construction and the client never has to warn that it only looked at what it
+ * had loaded.
+ *
+ * A searched response is one page: the best `limit` matches, and a flag saying
+ * more matched. There is no search cursor. Offsets into a ranking that is
+ * recomputed per request duplicate and skip rows as history mutates underneath
+ * them, and a keyset cursor would buy the ability to walk past result 200 of a
+ * relevance order — which is browsing, not searching. Narrowing the query is
+ * the answer, and the global top K is exactly recoverable from each host's own
+ * top K, which is what lets several hosts merge without a federated pager.
+ */
+export function rankAgentHistoryCandidates(query, candidates, compareTies) {
+    const ranked = [];
+    for (const candidate of candidates) {
+        const searchScore = scoreAgentHistoryCandidate(query, candidate);
+        if (searchScore === null)
+            continue;
+        ranked.push({ candidate, searchScore });
+    }
+    ranked.sort((left, right) => {
+        if (left.searchScore !== right.searchScore)
+            return left.searchScore - right.searchScore;
+        return compareTies(left.candidate, right.candidate);
+    });
+    return ranked;
+}
+//# sourceMappingURL=agent-history-search.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,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,122 @@
+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);
+            }
+        })();
+    };
+}
+const SELF_AUTHENTICATING_ROUTES = new Set(["/api/files/download", "/mcp/agents"]);
+function isBearerFreeRoute(path) {
+    return path === "/api/health" || SELF_AUTHENTICATING_ROUTES.has(path);
+}
+export function shouldBypassBearerAuth(method, path) {
+    if (method === "OPTIONS") {
+        return true;
+    }
+    return isBearerFreeRoute(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/authorization/index.d.ts

@@ -0,0 +1,18 @@
+import type { SessionInboundMessage, SessionOutboundMessage } from "../messages.js";
+import { DAEMON_PERMISSIONS, type DaemonPermission } from "@camerontaylor/paseo-protocol/messages";
+export { DAEMON_PERMISSIONS, type DaemonPermission };
+export declare function isDaemonPermission(value: string): value is DaemonPermission;
+export declare function parseDaemonPermissions(values: readonly string[]): DaemonPermission[];
+export declare const OWNER_PERMISSIONS: readonly DaemonPermission[];
+export declare class SessionAuthorization {
+    private permissions;
+    constructor(permissions: readonly DaemonPermission[]);
+    allowsInbound(message: SessionInboundMessage): boolean;
+    allowsOutbound(message: SessionOutboundMessage): boolean;
+    replacePermissions(permissions: readonly DaemonPermission[]): void;
+    listPermissions(): DaemonPermission[];
+    allowsPermission(permission: DaemonPermission): boolean;
+    private allows;
+}
+export declare function permissionsForLegacyHubScopes(scopes: readonly string[]): readonly DaemonPermission[];
+//# sourceMappingURL=index.d.ts.map

package/dist/server/server/authorization/index.js

@@ -0,0 +1,47 @@
+import { DAEMON_PERMISSIONS } from "@camerontaylor/paseo-protocol/messages";
+import { requiredPermissionForInbound, requiredPermissionForOutbound, } from "./operation-permissions.js";
+export { DAEMON_PERMISSIONS };
+const daemonPermissionSet = new Set(DAEMON_PERMISSIONS);
+export function isDaemonPermission(value) {
+    return daemonPermissionSet.has(value);
+}
+export function parseDaemonPermissions(values) {
+    const permissions = [...new Set(values)];
+    if (!permissions.every(isDaemonPermission))
+        throw new Error("Invalid daemon permission");
+    return permissions;
+}
+export const OWNER_PERMISSIONS = DAEMON_PERMISSIONS;
+export class SessionAuthorization {
+    constructor(permissions) {
+        this.permissions = new Set(permissions);
+    }
+    allowsInbound(message) {
+        return this.allows(requiredPermissionForInbound(message.type));
+    }
+    allowsOutbound(message) {
+        return this.allows(requiredPermissionForOutbound(message));
+    }
+    replacePermissions(permissions) {
+        this.permissions = new Set(permissions);
+    }
+    listPermissions() {
+        return [...this.permissions];
+    }
+    allowsPermission(permission) {
+        return this.permissions.has(permission);
+    }
+    allows(requirement) {
+        if (requirement === null)
+            return true;
+        if (typeof requirement === "string")
+            return this.permissions.has(requirement);
+        return requirement.some((permission) => this.permissions.has(permission));
+    }
+}
+const LEGACY_HUB_EXECUTION_SCOPE = "hub.execution.*";
+export function permissionsForLegacyHubScopes(scopes) {
+    // COMPAT(semanticHubPermissions): added in v0.7, remove after Hub enrollment uses permissions.
+    return scopes.includes(LEGACY_HUB_EXECUTION_SCOPE) ? ["hub.execute"] : [];
+}
+//# sourceMappingURL=index.js.map

package/dist/server/server/authorization/operation-permissions.d.ts

@@ -0,0 +1,8 @@
+import type { SessionInboundMessage, SessionOutboundMessage } from "../messages.js";
+import type { DaemonPermission } from "./index.js";
+type InboundOperation = SessionInboundMessage["type"];
+export type PermissionRequirement = DaemonPermission | readonly DaemonPermission[] | null;
+export declare function requiredPermissionForInbound(operation: InboundOperation): PermissionRequirement;
+export declare function requiredPermissionForOutbound(message: SessionOutboundMessage): PermissionRequirement;
+export {};
+//# sourceMappingURL=operation-permissions.d.ts.map