@hyperdrive.bot/paseo-server 0.2.6

package/dist/server/server/agent/agent-timeline-store-types.d.ts

@@ -0,0 +1,50 @@
+import type { AgentTimelineItem } from "./agent-sdk-types.js";
+export interface AgentTimelineRow {
+    seq: number;
+    timestamp: string;
+    item: AgentTimelineItem;
+}
+export interface AgentTimelineCursor {
+    epoch: string;
+    seq: number;
+}
+export type AgentTimelineFetchDirection = "tail" | "before" | "after";
+export interface AgentTimelineFetchOptions {
+    direction?: AgentTimelineFetchDirection;
+    cursor?: AgentTimelineCursor;
+    /**
+     * Number of canonical rows to return.
+     * - undefined: store default
+     * - 0: all rows in the selected window
+     */
+    limit?: number;
+}
+export interface AgentTimelineWindow {
+    minSeq: number;
+    maxSeq: number;
+    nextSeq: number;
+}
+export interface AgentTimelineFetchResult {
+    epoch: string;
+    direction: AgentTimelineFetchDirection;
+    reset: boolean;
+    staleCursor: boolean;
+    gap: boolean;
+    window: AgentTimelineWindow;
+    hasOlder: boolean;
+    hasNewer: boolean;
+    rows: AgentTimelineRow[];
+}
+export interface AgentTimelineStore {
+    appendCommitted(agentId: string, item: AgentTimelineItem, options?: {
+        timestamp?: string;
+    }): Promise<AgentTimelineRow>;
+    fetchCommitted(agentId: string, options?: AgentTimelineFetchOptions): Promise<AgentTimelineFetchResult>;
+    getLatestCommittedSeq(agentId: string): Promise<number>;
+    getCommittedRows(agentId: string): Promise<AgentTimelineRow[]>;
+    getLastItem(agentId: string): Promise<AgentTimelineItem | null>;
+    getLastAssistantMessage(agentId: string): Promise<string | null>;
+    deleteAgent(agentId: string): Promise<void>;
+    bulkInsert(agentId: string, rows: readonly AgentTimelineRow[]): Promise<void>;
+}
+//# sourceMappingURL=agent-timeline-store-types.d.ts.map

package/dist/server/server/agent/agent-timeline-store-types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=agent-timeline-store-types.js.map

package/dist/server/server/agent/agent-timeline-store.d.ts

@@ -0,0 +1,27 @@
+import type { AgentTimelineItem } from "./agent-sdk-types.js";
+import type { AgentTimelineFetchOptions, AgentTimelineFetchResult, AgentTimelineRow } from "./agent-timeline-store-types.js";
+export interface SeedAgentTimelineOptions {
+    items?: readonly AgentTimelineItem[];
+    rows?: readonly AgentTimelineRow[];
+    epoch?: string;
+    nextSeq?: number;
+    timestamp?: string;
+}
+export declare class InMemoryAgentTimelineStore {
+    private readonly states;
+    has(agentId: string): boolean;
+    initialize(agentId: string, options?: SeedAgentTimelineOptions): void;
+    delete(agentId: string): void;
+    getItems(agentId: string): AgentTimelineItem[];
+    getRows(agentId: string): AgentTimelineRow[];
+    getEpoch(agentId: string): string;
+    fetch(agentId: string, options?: AgentTimelineFetchOptions): AgentTimelineFetchResult;
+    append(agentId: string, item: AgentTimelineItem, options?: {
+        timestamp?: string;
+    }): AgentTimelineRow;
+    getLastItem(agentId: string): AgentTimelineItem | null;
+    getLastAssistantMessage(agentId: string): string | null;
+    private requireState;
+    private buildRowsFromItems;
+}
+//# sourceMappingURL=agent-timeline-store.d.ts.map

package/dist/server/server/agent/agent-timeline-store.js

@@ -0,0 +1,230 @@
+import { randomUUID } from "node:crypto";
+const DEFAULT_TIMELINE_FETCH_LIMIT = 200;
+function cloneRow(row) {
+    return { ...row };
+}
+function fetchTail(ctx) {
+    const { state, direction, limit, selectAll, minSeq, window } = ctx;
+    const selected = selectAll || limit >= state.rows.length
+        ? state.rows
+        : state.rows.slice(state.rows.length - limit);
+    return {
+        epoch: state.epoch,
+        direction,
+        reset: false,
+        staleCursor: false,
+        gap: false,
+        window,
+        hasOlder: selected.length > 0 && selected[0].seq > minSeq,
+        hasNewer: false,
+        rows: selected.map(cloneRow),
+    };
+}
+function fetchAfter(ctx) {
+    const { state, direction, limit, selectAll, cursor, minSeq, maxSeq, window } = ctx;
+    const baseSeq = cursor?.seq ?? 0;
+    const startIdx = state.rows.findIndex((row) => row.seq > baseSeq);
+    if (startIdx < 0) {
+        return {
+            epoch: state.epoch,
+            direction,
+            reset: false,
+            staleCursor: false,
+            gap: false,
+            window,
+            hasOlder: baseSeq >= minSeq,
+            hasNewer: false,
+            rows: [],
+        };
+    }
+    const selected = selectAll
+        ? state.rows.slice(startIdx)
+        : state.rows.slice(startIdx, startIdx + limit);
+    const lastSelected = selected[selected.length - 1];
+    return {
+        epoch: state.epoch,
+        direction,
+        reset: false,
+        staleCursor: false,
+        gap: false,
+        window,
+        hasOlder: selected[0].seq > minSeq,
+        hasNewer: lastSelected !== null && lastSelected !== undefined && lastSelected.seq < maxSeq,
+        rows: selected.map(cloneRow),
+    };
+}
+function fetchBefore(ctx) {
+    const { state, direction, limit, selectAll, cursor, minSeq, window } = ctx;
+    const beforeSeq = cursor?.seq ?? state.nextSeq;
+    const endExclusive = state.rows.findIndex((row) => row.seq >= beforeSeq);
+    const boundedRows = endExclusive < 0 ? state.rows : state.rows.slice(0, endExclusive);
+    const selected = selectAll || limit >= boundedRows.length
+        ? boundedRows
+        : boundedRows.slice(boundedRows.length - limit);
+    return {
+        epoch: state.epoch,
+        direction,
+        reset: false,
+        staleCursor: false,
+        gap: false,
+        window,
+        hasOlder: selected.length > 0 && selected[0].seq > minSeq,
+        hasNewer: endExclusive >= 0,
+        rows: selected.map(cloneRow),
+    };
+}
+function fetchReset(ctx, flags) {
+    const { state, direction, limit, selectAll, minSeq, window } = ctx;
+    const rows = selectAll || limit >= state.rows.length
+        ? state.rows.map(cloneRow)
+        : state.rows.slice(state.rows.length - limit).map(cloneRow);
+    return {
+        epoch: state.epoch,
+        direction,
+        reset: true,
+        staleCursor: flags.staleCursor,
+        gap: flags.gap,
+        window,
+        hasOlder: rows.length > 0 && rows[0].seq > minSeq,
+        hasNewer: false,
+        rows,
+    };
+}
+export class InMemoryAgentTimelineStore {
+    constructor() {
+        this.states = new Map();
+    }
+    has(agentId) {
+        return this.states.has(agentId);
+    }
+    initialize(agentId, options) {
+        const timestamp = options?.timestamp ?? new Date().toISOString();
+        const rows = options?.rows?.length
+            ? options.rows.map(cloneRow)
+            : this.buildRowsFromItems(options?.items ?? [], options?.nextSeq ?? 1, timestamp);
+        const nextSeq = options?.nextSeq ?? (rows.length ? rows[rows.length - 1].seq + 1 : 1);
+        this.states.set(agentId, {
+            epoch: options?.epoch ?? randomUUID(),
+            rows,
+            nextSeq,
+        });
+    }
+    delete(agentId) {
+        this.states.delete(agentId);
+    }
+    getItems(agentId) {
+        return this.requireState(agentId).rows.map((row) => row.item);
+    }
+    getRows(agentId) {
+        return this.requireState(agentId).rows.map(cloneRow);
+    }
+    getEpoch(agentId) {
+        return this.requireState(agentId).epoch;
+    }
+    fetch(agentId, options) {
+        const state = this.requireState(agentId);
+        const direction = options?.direction ?? "tail";
+        const requestedLimit = options?.limit;
+        const limit = requestedLimit === undefined
+            ? DEFAULT_TIMELINE_FETCH_LIMIT
+            : Math.max(0, Math.floor(requestedLimit));
+        const cursor = options?.cursor;
+        const minSeq = state.rows.length ? state.rows[0].seq : 0;
+        const maxSeq = state.rows.length ? state.rows[state.rows.length - 1].seq : 0;
+        const selectAll = limit === 0;
+        const window = {
+            minSeq,
+            maxSeq,
+            nextSeq: state.nextSeq,
+        };
+        const ctx = {
+            state,
+            direction,
+            limit,
+            selectAll,
+            cursor,
+            minSeq,
+            maxSeq,
+            window,
+        };
+        if (cursor && typeof cursor.epoch === "string" && cursor.epoch !== state.epoch) {
+            return fetchReset(ctx, { staleCursor: true, gap: false });
+        }
+        if (direction === "after" && cursor && state.rows.length > 0 && cursor.seq < minSeq - 1) {
+            return fetchReset(ctx, { staleCursor: false, gap: true });
+        }
+        if (state.rows.length === 0) {
+            return {
+                epoch: state.epoch,
+                direction,
+                reset: false,
+                staleCursor: false,
+                gap: false,
+                window,
+                hasOlder: false,
+                hasNewer: false,
+                rows: [],
+            };
+        }
+        if (direction === "tail") {
+            return fetchTail(ctx);
+        }
+        if (direction === "after") {
+            return fetchAfter(ctx);
+        }
+        return fetchBefore(ctx);
+    }
+    append(agentId, item, options) {
+        const state = this.requireState(agentId);
+        const row = {
+            seq: state.nextSeq,
+            timestamp: options?.timestamp ?? new Date().toISOString(),
+            item,
+        };
+        state.nextSeq += 1;
+        state.rows.push(row);
+        return cloneRow(row);
+    }
+    getLastItem(agentId) {
+        const state = this.requireState(agentId);
+        return state.rows[state.rows.length - 1]?.item ?? null;
+    }
+    getLastAssistantMessage(agentId) {
+        const rows = this.requireState(agentId).rows;
+        const chunks = [];
+        for (let i = rows.length - 1; i >= 0; i -= 1) {
+            const item = rows[i].item;
+            if (item.type !== "assistant_message") {
+                if (chunks.length > 0) {
+                    break;
+                }
+                continue;
+            }
+            chunks.push(item.text);
+        }
+        if (chunks.length === 0) {
+            return null;
+        }
+        return chunks.toReversed().join("");
+    }
+    requireState(agentId) {
+        const state = this.states.get(agentId);
+        if (!state) {
+            throw new Error(`Unknown agent '${agentId}'`);
+        }
+        return state;
+    }
+    buildRowsFromItems(items, startSeq, timestamp) {
+        let nextSeq = startSeq;
+        return items.map((item) => {
+            const row = {
+                seq: nextSeq,
+                timestamp,
+                item,
+            };
+            nextSeq += 1;
+            return row;
+        });
+    }
+}
+//# sourceMappingURL=agent-timeline-store.js.map

package/dist/server/server/agent/audio-utils.d.ts

@@ -0,0 +1,3 @@
+export declare function inferAudioExtension(format: string | undefined): string;
+export declare function sanitizeForFilename(segment: string | undefined, fallback: string): string;
+//# sourceMappingURL=audio-utils.d.ts.map

package/dist/server/server/agent/audio-utils.js

@@ -0,0 +1,19 @@
+const AUDIO_EXTENSIONS = [
+    { match: (format) => format.includes("webm"), ext: "webm" },
+    { match: (format) => format.includes("ogg"), ext: "ogg" },
+    { match: (format) => format.includes("mp3"), ext: "mp3" },
+    { match: (format) => format.includes("wav"), ext: "wav" },
+    { match: (format) => format.includes("m4a") || format.includes("aac"), ext: "m4a" },
+    { match: (format) => format.includes("mp4"), ext: "mp4" },
+    { match: (format) => format.includes("flac"), ext: "flac" },
+];
+export function inferAudioExtension(format) {
+    const normalized = (format || "webm").toLowerCase();
+    const candidate = AUDIO_EXTENSIONS.find((entry) => entry.match(normalized));
+    return candidate?.ext ?? "webm";
+}
+export function sanitizeForFilename(segment, fallback) {
+    const value = segment && segment.length > 0 ? segment : fallback;
+    return value.replace(/[^a-zA-Z0-9-_]/g, "_").slice(0, 64);
+}
+//# sourceMappingURL=audio-utils.js.map

package/dist/server/server/agent/create-agent/create.d.ts

@@ -0,0 +1,83 @@
+import type { Logger } from "pino";
+import type { TerminalManager } from "../../../terminal/terminal-manager.js";
+import type { AgentWorktreeSetupContinuation, CreatePaseoWorktreeWorkflowFn } from "../../worktree-session.js";
+import type { AgentAttachment, FirstAgentContext, GitSetupOptions } from "../../messages.js";
+import type { AgentManager, ManagedAgent } from "../agent-manager.js";
+import type { AgentSessionConfig } from "../agent-sdk-types.js";
+import type { AgentStorage } from "../agent-storage.js";
+import type { ProviderSnapshotManager } from "../provider-snapshot-manager.js";
+export interface CreateAgentSessionWorktreeResult {
+    sessionConfig: AgentSessionConfig;
+    setupContinuation?: AgentWorktreeSetupContinuation;
+    createdWorkspaceId?: string;
+}
+interface CreateAgentCommandDependencies {
+    agentManager: AgentManager;
+    agentStorage: AgentStorage;
+    logger: Logger;
+    paseoHome?: string;
+    worktreesRoot?: string;
+    terminalManager?: TerminalManager | null;
+    providerSnapshotManager: ProviderSnapshotManager;
+    createPaseoWorktree?: CreatePaseoWorktreeWorkflowFn;
+    ensureWorkspaceForCreate?: (cwd: string, firstAgentContext?: FirstAgentContext) => Promise<string>;
+}
+export interface CreateAgentFromSessionInput {
+    kind: "session";
+    config: AgentSessionConfig;
+    workspaceId?: string;
+    worktreeName?: string;
+    initialPrompt?: string;
+    clientMessageId?: string;
+    outputSchema?: Record<string, unknown>;
+    images?: Array<{
+        data: string;
+        mimeType: string;
+    }>;
+    attachments?: AgentAttachment[];
+    git?: GitSetupOptions;
+    labels: Record<string, string>;
+    env?: Record<string, string>;
+    provisionalTitle: string | null;
+    firstAgentContext: FirstAgentContext;
+    buildSessionConfig: (config: AgentSessionConfig, gitOptions?: GitSetupOptions, legacyWorktreeName?: string, firstAgentContext?: FirstAgentContext) => Promise<CreateAgentSessionWorktreeResult>;
+}
+export interface CreateAgentFromMcpInput {
+    kind: "mcp";
+    provider: string;
+    title: string;
+    initialPrompt: string;
+    cwd?: string;
+    workspaceId?: string;
+    thinking?: string;
+    features?: Record<string, unknown>;
+    labels?: Record<string, string>;
+    mode?: string;
+    background: boolean;
+    notifyOnFinish: boolean;
+    detached?: boolean;
+    callerAgentId?: string;
+    callerContext?: {
+        lockedCwd?: string;
+        allowCustomCwd?: boolean;
+        childAgentDefaultLabels?: Record<string, string>;
+    } | null;
+    worktree?: {
+        worktreeName?: string;
+        branchName?: string;
+        baseBranch?: string;
+        refName?: string;
+        action?: "branch-off" | "checkout";
+        githubPrNumber?: number;
+    };
+}
+export type CreateAgentCommandInput = CreateAgentFromSessionInput | CreateAgentFromMcpInput;
+export interface CreateAgentCommandResult {
+    snapshot: ManagedAgent;
+    liveSnapshot: ManagedAgent;
+    background: boolean;
+    initialPromptStarted: boolean;
+}
+export declare function createAgentCommand(dependencies: CreateAgentCommandDependencies, input: CreateAgentCommandInput): Promise<CreateAgentCommandResult>;
+export {};
+//# sourceMappingURL=create.d.ts.map