@xfey/tutti 0.1.0

package/dist/server-shell/http/routes/project-api/viewer-projections.js

@@ -0,0 +1,102 @@
+import { projectDocKeyForPath } from "../../../../project-docs/context.js";
+import { VIEWER_HARD_READ_LIMIT_BYTES, } from "../../../../workspace-ops/index.js";
+import { HostProjectBadRequestError } from "./errors.js";
+const DEFAULT_VIEWER_LIMIT = 200;
+const MAX_VIEWER_LIMIT = 1000;
+export function viewerPageLimit(limit) {
+    return limit ?? DEFAULT_VIEWER_LIMIT;
+}
+function cursorOffset(cursor) {
+    if (cursor === undefined) {
+        return 0;
+    }
+    const match = /^offset:(\d+)$/u.exec(cursor);
+    if (match === null) {
+        throw new HostProjectBadRequestError("Viewer cursor is invalid");
+    }
+    return Number(match[1]);
+}
+export function paginateViewerItems(items, request) {
+    const limit = viewerPageLimit(request.limit);
+    if (!Number.isInteger(limit) || limit < 1 || limit > MAX_VIEWER_LIMIT) {
+        throw new HostProjectBadRequestError("Viewer limit must be an integer from 1 to 1000");
+    }
+    const offset = cursorOffset(request.cursor);
+    const pageItems = items.slice(offset, offset + limit);
+    const nextOffset = offset + pageItems.length;
+    const hasMore = nextOffset < items.length;
+    return {
+        items: pageItems,
+        page: {
+            ...(hasMore ? { next_cursor: `offset:${nextOffset}` } : {}),
+            has_more: hasMore,
+            limit,
+        },
+    };
+}
+function textReadForTreeEntry(entry) {
+    if (entry.kind === "directory") {
+        return { can_read: false, blocked_reason: "directory" };
+    }
+    if (entry.kind === "symlink") {
+        return { can_read: false, blocked_reason: "symlink" };
+    }
+    if (entry.kind === "submodule") {
+        return { can_read: false, blocked_reason: "submodule" };
+    }
+    if (entry.size_bytes !== undefined && entry.size_bytes > VIEWER_HARD_READ_LIMIT_BYTES) {
+        return { can_read: false, blocked_reason: "too_large" };
+    }
+    return { can_read: true };
+}
+export function toViewerTreeEntryProjection(entry) {
+    const projection = {
+        path: entry.path,
+        name: entry.name,
+        kind: entry.kind,
+        depth: entry.depth,
+        text_read: textReadForTreeEntry(entry),
+    };
+    if (entry.parent_path !== undefined) {
+        projection.parent_path = entry.parent_path;
+    }
+    if (entry.size_bytes !== undefined) {
+        projection.size_bytes = entry.size_bytes;
+    }
+    if (entry.blob_oid !== undefined) {
+        projection.blob_oid = entry.blob_oid;
+    }
+    if (entry.extension !== undefined) {
+        projection.extension = entry.extension;
+    }
+    if (entry.language_hint !== undefined) {
+        projection.language_hint = entry.language_hint;
+    }
+    if (entry.has_children !== undefined) {
+        projection.has_children = entry.has_children;
+    }
+    const docKey = projectDocKeyForPath(entry.path);
+    if (docKey !== undefined) {
+        projection.project_doc_key = docKey;
+    }
+    return projection;
+}
+export function toViewerFileProjection(file) {
+    const projection = {
+        path: file.path,
+        name: file.name,
+        kind: "file",
+        size_bytes: file.size_bytes,
+    };
+    if (file.blob_oid !== undefined) {
+        projection.blob_oid = file.blob_oid;
+    }
+    if (file.extension !== undefined) {
+        projection.extension = file.extension;
+    }
+    if (file.language_hint !== undefined) {
+        projection.language_hint = file.language_hint;
+    }
+    return projection;
+}
+//# sourceMappingURL=viewer-projections.js.map

package/dist/server-shell/http/routes/project-api/viewer-routes.d.ts

@@ -0,0 +1,4 @@
+import type { FastifyInstance } from "fastify";
+import type { HostProjectApiRouteOptions } from "./types.js";
+export declare function registerViewerRoutes(app: FastifyInstance, options: HostProjectApiRouteOptions): void;
+//# sourceMappingURL=viewer-routes.d.ts.map

package/dist/server-shell/http/routes/project-api/viewer-routes.js

@@ -0,0 +1,100 @@
+import { GetViewerAssetRequestSchema, GetViewerFileRequestSchema, GetViewerFileResponseSchema, GetViewerTreeRequestSchema, GetViewerTreeResponseSchema, } from "@tutti/shared/schemas/api";
+import { readViewerAsset, readViewerFile, readViewerTree, } from "../../../../workspace-ops/index.js";
+import { HOST_PROJECT_API_BASE_PATH } from "./constants.js";
+import { requireHostProjectSession, requireViewerAssetCacheRoot, requireWorkspaceRoot, } from "./session-requirements.js";
+import { paginateViewerItems, toViewerFileProjection, toViewerTreeEntryProjection, } from "./viewer-projections.js";
+const ASSET_CACHE_CONTROL = "private, max-age=31536000, immutable";
+function assetEtag(asset) {
+    const variantKey = asset.variant === "original"
+        ? "original"
+        : `${asset.variant}:${asset.cache_version ?? "unknown"}`;
+    return `"${asset.file.blob_oid}:${variantKey}"`;
+}
+function requestMatchesEtag(value, etag) {
+    if (value === undefined) {
+        return false;
+    }
+    const values = Array.isArray(value) ? value : [value];
+    return values.some((entry) => entry
+        .split(",")
+        .map((part) => part.trim())
+        .some((part) => part === "*" || part === etag));
+}
+export function registerViewerRoutes(app, options) {
+    app.get(`${HOST_PROJECT_API_BASE_PATH}/viewer/tree`, {
+        schema: {
+            querystring: GetViewerTreeRequestSchema,
+            response: {
+                200: GetViewerTreeResponseSchema,
+            },
+        },
+    }, (request) => {
+        requireHostProjectSession(request, options);
+        const tree = readViewerTree({
+            workspaceRoot: requireWorkspaceRoot(options),
+            ...(request.query.path === undefined ? {} : { path: request.query.path }),
+            ...(request.query.depth === undefined ? {} : { depth: request.query.depth }),
+            ...(options.now === undefined ? {} : { now: options.now }),
+        });
+        const page = paginateViewerItems(tree.items.map((entry) => toViewerTreeEntryProjection(entry)), request.query);
+        return {
+            snapshot: tree.snapshot,
+            root: toViewerTreeEntryProjection(tree.root),
+            items: page.items,
+            page: page.page,
+        };
+    });
+    app.get(`${HOST_PROJECT_API_BASE_PATH}/viewer/files`, {
+        schema: {
+            querystring: GetViewerFileRequestSchema,
+            response: {
+                200: GetViewerFileResponseSchema,
+            },
+        },
+    }, (request) => {
+        requireHostProjectSession(request, options);
+        const file = readViewerFile({
+            workspaceRoot: requireWorkspaceRoot(options),
+            path: request.query.path,
+            ...(request.query.max_bytes === undefined ? {} : { maxBytes: request.query.max_bytes }),
+            ...(options.now === undefined ? {} : { now: options.now }),
+        });
+        return {
+            snapshot: file.snapshot,
+            file: toViewerFileProjection(file.file),
+            content: file.content,
+        };
+    });
+    app.get(`${HOST_PROJECT_API_BASE_PATH}/viewer/assets`, {
+        schema: {
+            querystring: GetViewerAssetRequestSchema,
+        },
+    }, async (request, reply) => {
+        requireHostProjectSession(request, options);
+        const asset = await readViewerAsset({
+            workspaceRoot: requireWorkspaceRoot(options),
+            assetCacheRoot: requireViewerAssetCacheRoot(options),
+            path: request.query.path,
+            variant: request.query.variant,
+            version: request.query.v,
+            ...(options.now === undefined ? {} : { now: options.now }),
+        });
+        const etag = assetEtag(asset);
+        if (requestMatchesEtag(request.headers["if-none-match"], etag)) {
+            void reply
+                .code(304)
+                .header("etag", etag)
+                .header("cache-control", ASSET_CACHE_CONTROL)
+                .header("x-content-type-options", "nosniff")
+                .send();
+            return;
+        }
+        void reply
+            .header("content-type", asset.media_type)
+            .header("etag", etag)
+            .header("cache-control", ASSET_CACHE_CONTROL)
+            .header("x-content-type-options", "nosniff")
+            .send(asset.content);
+    });
+}
+//# sourceMappingURL=viewer-routes.js.map

package/dist/server-shell/http/routes/project-api/workflow-routes.d.ts

@@ -0,0 +1,4 @@
+import type { FastifyInstance } from "fastify";
+import type { HostProjectApiRouteOptions } from "./types.js";
+export declare function registerWorkflowRoutes(app: FastifyInstance, options: HostProjectApiRouteOptions): void;
+//# sourceMappingURL=workflow-routes.d.ts.map

package/dist/server-shell/http/routes/project-api/workflow-routes.js

@@ -0,0 +1,85 @@
+import { RunSchedulerNowBodySchema, RunSchedulerNowResponseSchema, ScratchpadProjectionSchema, SubmitWorklistBodySchema, SubmitWorklistResponseSchema, WorklistProjectionSchema, } from "@tutti/shared/schemas/api";
+import { readScratchpadProjection, readWorklistProjection, } from "../../../../collaboration-state/index.js";
+import { executeIdempotentCommand } from "../../../command-idempotency/index.js";
+import { HOST_PROJECT_API_BASE_PATH } from "./constants.js";
+import { schedulerRunNowInvalidates, worklistSubmitInvalidates, } from "./invalidations.js";
+import { requireControlPlane, requireHostProjectSession, requireProjectStore, } from "./session-requirements.js";
+export function registerWorkflowRoutes(app, options) {
+    app.get(`${HOST_PROJECT_API_BASE_PATH}/scratchpad`, {
+        schema: {
+            response: {
+                200: ScratchpadProjectionSchema,
+            },
+        },
+    }, (request) => {
+        requireHostProjectSession(request, options);
+        return readScratchpadProjection(requireProjectStore(options).db);
+    });
+    app.get(`${HOST_PROJECT_API_BASE_PATH}/worklist`, {
+        schema: {
+            response: {
+                200: WorklistProjectionSchema,
+            },
+        },
+    }, (request) => {
+        requireHostProjectSession(request, options);
+        return readWorklistProjection(requireProjectStore(options).db);
+    });
+    app.post(`${HOST_PROJECT_API_BASE_PATH}/worklist/submit`, {
+        schema: {
+            body: SubmitWorklistBodySchema,
+            response: {
+                200: SubmitWorklistResponseSchema,
+            },
+        },
+    }, (request) => {
+        requireHostProjectSession(request, options);
+        const store = requireProjectStore(options);
+        const controlPlane = requireControlPlane(options);
+        const execution = executeIdempotentCommand({
+            db: store.db,
+            command_id: request.body.command_id,
+            command_name: "worklist.submit",
+            target_ref: "scratchpad:current",
+            payload: request.body.payload,
+            ...(options.now === undefined ? {} : { now: options.now }),
+            execute: () => controlPlane.startTaskCompile(request.body.payload),
+        });
+        const response = {
+            command_id: execution.command_id,
+            disposition: execution.disposition,
+            invalidates: worklistSubmitInvalidates(),
+        };
+        if (execution.result !== undefined) {
+            response.result = execution.result;
+        }
+        return response;
+    });
+    app.post(`${HOST_PROJECT_API_BASE_PATH}/scheduler/run-now`, {
+        schema: {
+            body: RunSchedulerNowBodySchema,
+            response: {
+                200: RunSchedulerNowResponseSchema,
+            },
+        },
+    }, (request) => {
+        requireHostProjectSession(request, options);
+        const store = requireProjectStore(options);
+        const controlPlane = requireControlPlane(options);
+        const execution = executeIdempotentCommand({
+            db: store.db,
+            command_id: request.body.command_id,
+            command_name: "scheduler.run_now",
+            target_ref: "worklist",
+            payload: request.body.payload,
+            ...(options.now === undefined ? {} : { now: options.now }),
+            execute: () => controlPlane.runSchedulerNow(request.body.payload),
+        });
+        return {
+            command_id: execution.command_id,
+            disposition: execution.disposition,
+            invalidates: schedulerRunNowInvalidates(execution.disposition),
+        };
+    });
+}
+//# sourceMappingURL=workflow-routes.js.map

package/dist/server-shell/http/routes/project-api/workspace-projections.d.ts

@@ -0,0 +1,5 @@
+import type { HostProjectApiRouteOptions, HostSessionProjection, HostWorkspaceProjection, HostWorkspaceRelayState } from "./types.js";
+export declare function buildWorkspaceProjection(options: HostProjectApiRouteOptions, relayState?: HostWorkspaceRelayState, now?: Date): HostWorkspaceProjection;
+export declare function resolveWorkspaceProjection(options: HostProjectApiRouteOptions): Promise<HostWorkspaceProjection>;
+export declare function buildBootstrapSnapshots(options: HostProjectApiRouteOptions, eventsNow: () => Date, session: HostSessionProjection): Record<string, unknown>;
+//# sourceMappingURL=workspace-projections.d.ts.map

package/dist/server-shell/http/routes/project-api/workspace-projections.js

@@ -0,0 +1,103 @@
+import { createIdleExecutionStatusProjection, readActiveClarificationProjection, readMainChatMessageWindow, readReadStateSummary, readScratchpadProjection, readWorklistProjection, } from "../../../../collaboration-state/index.js";
+import { HOST_MAINLINE_BRANCH } from "./constants.js";
+function defaultCapabilities(overrides) {
+    return {
+        sse: overrides?.sse ?? true,
+        relay_join: overrides?.relay_join ?? true,
+        repo_viewer: overrides?.repo_viewer ?? false,
+        provider_config_query: overrides?.provider_config_query ?? true,
+        browser_secret_write: false,
+        task_auto_scheduler: overrides?.task_auto_scheduler ?? false,
+        task_run_now_scheduler: overrides?.task_run_now_scheduler ?? true,
+        clarification: overrides?.clarification ?? false,
+    };
+}
+function providerSummary(providerConfig) {
+    if (!("provider" in providerConfig) || providerConfig.provider === undefined) {
+        return { status: providerConfig.status };
+    }
+    return {
+        status: providerConfig.status,
+        provider: providerConfig.provider,
+    };
+}
+const JOIN_URL_REFRESH_GRACE_MS = 5 * 60 * 1000;
+function isFreshVisibleJoinUrl(relayState, now) {
+    if (relayState.join_url === undefined || relayState.join_url_visibility !== "visible_once") {
+        return false;
+    }
+    if (relayState.join_token_expires_at === undefined) {
+        return true;
+    }
+    const expiresAt = new Date(relayState.join_token_expires_at).getTime();
+    if (!Number.isFinite(expiresAt)) {
+        return false;
+    }
+    return expiresAt - now.getTime() > JOIN_URL_REFRESH_GRACE_MS;
+}
+function workspaceRelayProjection(relayState, now) {
+    const projection = {
+        status: relayState.status,
+        relay_url: relayState.relay_url,
+        join_token_reusable: relayState.join_token_reusable,
+    };
+    const visibleJoinUrl = isFreshVisibleJoinUrl(relayState, now) ? relayState.join_url : undefined;
+    if (visibleJoinUrl !== undefined) {
+        projection.join_url = visibleJoinUrl;
+    }
+    if (relayState.join_url_visibility !== undefined) {
+        projection.join_url_visibility = relayState.join_url_visibility;
+    }
+    if (relayState.join_token_expires_at !== undefined) {
+        projection.join_token_expires_at = relayState.join_token_expires_at;
+    }
+    return projection;
+}
+export function buildWorkspaceProjection(options, relayState = options.relay.getState(), now = options.now?.() ?? new Date()) {
+    const providerConfig = options.getProviderConfig?.() ?? { status: "not_configured" };
+    return {
+        project: options.project,
+        server: options.server,
+        repo: options.getRepo?.() ?? {
+            mainline_branch: HOST_MAINLINE_BRANCH,
+            mainline_timeline: { entries: [] },
+            mainline_clean: false,
+        },
+        relay: workspaceRelayProjection(relayState, now),
+        provider: providerSummary(providerConfig),
+        capabilities: defaultCapabilities(options.capabilities),
+    };
+}
+export async function resolveWorkspaceProjection(options) {
+    const now = options.now?.() ?? new Date();
+    const relayState = options.relay.getState();
+    if (relayState.status !== "connected" || isFreshVisibleJoinUrl(relayState, now)) {
+        return buildWorkspaceProjection(options, relayState, now);
+    }
+    try {
+        const refreshedRelayState = await options.relay.refreshJoinUrl?.();
+        return buildWorkspaceProjection(options, refreshedRelayState ?? relayState, now);
+    }
+    catch {
+        return buildWorkspaceProjection(options, relayState, now);
+    }
+}
+export function buildBootstrapSnapshots(options, eventsNow, session) {
+    if (options.store === undefined) {
+        return {};
+    }
+    return {
+        main_chat: readMainChatMessageWindow(options.store.db),
+        scratchpad: readScratchpadProjection(options.store.db),
+        worklist: readWorklistProjection(options.store.db),
+        active_clarification: readActiveClarificationProjection(options.store.db),
+        active_approval: options.approvalManager?.getActiveApproval() ?? { state: "none" },
+        execution_status: options.controlPlane?.getExecutionStatus() ?? createIdleExecutionStatusProjection(eventsNow),
+        read_state: readReadStateSummary(options.store.db, {
+            account_ref: session.account.account_ref,
+            session_created_at: session.client_session.connected_at,
+            now: eventsNow,
+        }),
+    };
+}
+//# sourceMappingURL=workspace-projections.js.map

package/dist/server-shell/http/routes/project-api.d.ts

@@ -0,0 +1,8 @@
+import type { FastifyInstance } from "fastify";
+import type { HostProjectApiRouteOptions } from "./project-api/types.js";
+export { HOST_PROJECT_API_BASE_PATH, HOST_MAINLINE_BRANCH } from "./project-api/constants.js";
+export { HOST_PROJECT_OPENAPI_ROUTES, buildHostProjectOpenApiDocument, } from "./project-api/openapi.js";
+export { readHostRepoProjection } from "./project-api/repo-projection.js";
+export type { HostProjectApiCapabilities, HostProjectApiRouteOptions, HostProviderConfigProjection, HostRepoProjection, HostSessionProjection, HostWorkspaceProjection, HostWorkspaceRelayState, } from "./project-api/types.js";
+export declare function registerHostProjectApiRoutes(app: FastifyInstance, options: HostProjectApiRouteOptions): void;
+//# sourceMappingURL=project-api.d.ts.map

package/dist/server-shell/http/routes/project-api.js

@@ -0,0 +1,34 @@
+import { WorkspaceEventBus } from "../workspace-events.js";
+import { registerApprovalRoutes } from "./project-api/approval-routes.js";
+import { registerArtifactsRoutes } from "./project-api/artifacts-routes.js";
+import { registerClarificationRoutes } from "./project-api/clarification-routes.js";
+import { registerExecutionRoutes } from "./project-api/execution-routes.js";
+import { registerMessagesRoutes } from "./project-api/messages-routes.js";
+import { registerProjectDocsRoutes } from "./project-api/project-docs-routes.js";
+import { registerProjectTimelineRoutes } from "./project-api/project-timeline-routes.js";
+import { registerReadStateRoutes } from "./project-api/read-state-routes.js";
+import { registerReferenceFilesRoutes } from "./project-api/reference-files-routes.js";
+import { registerSkillRoutes } from "./project-api/skills-routes.js";
+import { registerSystemRoutes } from "./project-api/system-routes.js";
+import { registerViewerRoutes } from "./project-api/viewer-routes.js";
+import { registerWorkflowRoutes } from "./project-api/workflow-routes.js";
+export { HOST_PROJECT_API_BASE_PATH, HOST_MAINLINE_BRANCH } from "./project-api/constants.js";
+export { HOST_PROJECT_OPENAPI_ROUTES, buildHostProjectOpenApiDocument, } from "./project-api/openapi.js";
+export { readHostRepoProjection } from "./project-api/repo-projection.js";
+export function registerHostProjectApiRoutes(app, options) {
+    const workspaceEvents = options.events ?? new WorkspaceEventBus(options.now === undefined ? {} : { now: options.now });
+    registerSystemRoutes(app, { options, workspaceEvents });
+    registerProjectTimelineRoutes(app, options);
+    registerProjectDocsRoutes(app, { options, workspaceEvents });
+    registerViewerRoutes(app, options);
+    registerReferenceFilesRoutes(app, { options, workspaceEvents });
+    registerSkillRoutes(app, { options, workspaceEvents });
+    registerArtifactsRoutes(app, { options, workspaceEvents });
+    registerMessagesRoutes(app, { options, workspaceEvents });
+    registerWorkflowRoutes(app, options);
+    registerReadStateRoutes(app, { options, workspaceEvents });
+    registerClarificationRoutes(app, options);
+    registerApprovalRoutes(app, options);
+    registerExecutionRoutes(app, options);
+}
+//# sourceMappingURL=project-api.js.map

package/dist/server-shell/http/sse-replay-buffer.d.ts

@@ -0,0 +1,54 @@
+import { type WorkspaceSseEvent } from "./sse.js";
+export type StoredWorkspaceSseFrame = {
+    event_id: string;
+    occurred_at: string;
+    frame: string;
+    stored_at_ms: number;
+};
+export type SseReplayResult = {
+    status: "not_requested";
+    frames: [];
+    replayed_event_count: 0;
+} | {
+    status: "replayed";
+    frames: StoredWorkspaceSseFrame[];
+    replayed_event_count: number;
+} | {
+    status: "missed";
+    frames: [];
+    replayed_event_count: 0;
+    reason: "empty_buffer" | "cursor_not_found";
+};
+export type SseReplaySuccessResult = Extract<SseReplayResult, {
+    status: "replayed";
+}>;
+export type WorkspaceSseReplayBufferOptions = {
+    policy?: WorkspaceSseReplayWindowPolicy;
+    now?: () => Date;
+};
+export type WorkspaceSseReplayWindowPolicy = {
+    retention_seconds: number;
+    max_events: number;
+};
+export declare class WorkspaceSseReplayBuffer {
+    private readonly frames;
+    private readonly now;
+    readonly policy: WorkspaceSseReplayWindowPolicy;
+    constructor(options?: WorkspaceSseReplayBufferOptions);
+    get size(): number;
+    currentEventCursor(): string | null;
+    append<TPayload>(event: WorkspaceSseEvent<TPayload>): StoredWorkspaceSseFrame;
+    replayAfter(cursor: string | null | undefined): SseReplayResult;
+    replayAll(): SseReplaySuccessResult;
+    clear(): void;
+    private trim;
+}
+export declare class WorkspaceSseReplayBufferRegistry {
+    private readonly buffers;
+    private readonly options;
+    constructor(options?: WorkspaceSseReplayBufferOptions);
+    get(workspaceKey: string): WorkspaceSseReplayBuffer;
+    delete(workspaceKey: string): boolean;
+    clear(): void;
+}
+//# sourceMappingURL=sse-replay-buffer.d.ts.map

package/dist/server-shell/http/sse-replay-buffer.js

@@ -0,0 +1,110 @@
+import { DEFAULT_SSE_REPLAY_WINDOW_POLICY } from "@tutti/shared/schemas/api";
+import { formatWorkspaceSseEvent, toSingleSseLine } from "./sse.js";
+export class WorkspaceSseReplayBuffer {
+    frames = [];
+    now;
+    policy;
+    constructor(options = {}) {
+        this.policy = options.policy ?? DEFAULT_SSE_REPLAY_WINDOW_POLICY;
+        this.now = options.now ?? (() => new Date());
+    }
+    get size() {
+        this.trim();
+        return this.frames.length;
+    }
+    currentEventCursor() {
+        this.trim();
+        return this.frames.at(-1)?.event_id ?? null;
+    }
+    append(event) {
+        if (event.event_type === "connection.ready") {
+            throw new Error("connection.ready is connection-local and must not enter replay buffer");
+        }
+        const storedFrame = {
+            event_id: toSingleSseLine(event.event_id),
+            occurred_at: event.occurred_at,
+            frame: formatWorkspaceSseEvent(event),
+            stored_at_ms: this.now().getTime(),
+        };
+        this.frames.push(storedFrame);
+        this.trim();
+        return storedFrame;
+    }
+    replayAfter(cursor) {
+        this.trim();
+        if (cursor === null || cursor === undefined || cursor.trim() === "") {
+            return {
+                status: "not_requested",
+                frames: [],
+                replayed_event_count: 0,
+            };
+        }
+        if (this.frames.length === 0) {
+            return {
+                status: "missed",
+                frames: [],
+                replayed_event_count: 0,
+                reason: "empty_buffer",
+            };
+        }
+        const normalizedCursor = toSingleSseLine(cursor);
+        const cursorIndex = this.frames.findIndex((frame) => frame.event_id === normalizedCursor);
+        if (cursorIndex === -1) {
+            return {
+                status: "missed",
+                frames: [],
+                replayed_event_count: 0,
+                reason: "cursor_not_found",
+            };
+        }
+        const frames = this.frames.slice(cursorIndex + 1);
+        return {
+            status: "replayed",
+            frames,
+            replayed_event_count: frames.length,
+        };
+    }
+    replayAll() {
+        this.trim();
+        return {
+            status: "replayed",
+            frames: [...this.frames],
+            replayed_event_count: this.frames.length,
+        };
+    }
+    clear() {
+        this.frames.length = 0;
+    }
+    trim() {
+        const retentionFloorMs = this.now().getTime() - this.policy.retention_seconds * 1000;
+        while (this.frames.length > 0 && (this.frames[0]?.stored_at_ms ?? 0) < retentionFloorMs) {
+            this.frames.shift();
+        }
+        while (this.frames.length > this.policy.max_events) {
+            this.frames.shift();
+        }
+    }
+}
+export class WorkspaceSseReplayBufferRegistry {
+    buffers = new Map();
+    options;
+    constructor(options = {}) {
+        this.options = options;
+    }
+    get(workspaceKey) {
+        const existing = this.buffers.get(workspaceKey);
+        if (existing !== undefined) {
+            return existing;
+        }
+        const buffer = new WorkspaceSseReplayBuffer(this.options);
+        this.buffers.set(workspaceKey, buffer);
+        return buffer;
+    }
+    delete(workspaceKey) {
+        return this.buffers.delete(workspaceKey);
+    }
+    clear() {
+        this.buffers.clear();
+    }
+}
+//# sourceMappingURL=sse-replay-buffer.js.map

package/dist/server-shell/http/sse.d.ts

@@ -0,0 +1,12 @@
+import type { QueryInvalidationHint, WorkspaceSseEventType } from "@tutti/shared/schemas/api";
+export type WorkspaceSseEvent<TPayload> = {
+    event_id: string;
+    event_type: WorkspaceSseEventType;
+    occurred_at: string;
+    payload: TPayload;
+    invalidates?: QueryInvalidationHint[];
+};
+export declare function toSingleSseLine(value: string): string;
+export declare function formatWorkspaceSseEvent<TPayload>(event: WorkspaceSseEvent<TPayload>): string;
+export declare function formatSseComment(comment: string): string;
+//# sourceMappingURL=sse.d.ts.map

package/dist/server-shell/http/sse.js

@@ -0,0 +1,22 @@
+import { redactText, redactValue } from "@tutti/shared/utils";
+export function toSingleSseLine(value) {
+    return redactText(value).replace(/[\r\n]+/gu, " ");
+}
+export function formatWorkspaceSseEvent(event) {
+    const redactedEvent = redactValue(event);
+    const data = JSON.stringify(redactedEvent);
+    if (data === undefined) {
+        throw new Error("SSE event data must be JSON serializable");
+    }
+    return [
+        `id: ${toSingleSseLine(event.event_id)}`,
+        `event: ${toSingleSseLine(event.event_type)}`,
+        `data: ${data}`,
+        "",
+        "",
+    ].join("\n");
+}
+export function formatSseComment(comment) {
+    return `: ${toSingleSseLine(comment)}\n\n`;
+}
+//# sourceMappingURL=sse.js.map

package/dist/server-shell/http/static-web.d.ts

@@ -0,0 +1,6 @@
+import type { FastifyInstance } from "fastify";
+export type HostWebStaticOptions = {
+    root: string;
+};
+export declare function registerHostWebStaticRoutes(app: FastifyInstance, options: HostWebStaticOptions): void;
+//# sourceMappingURL=static-web.d.ts.map