@xfey/tutti 0.1.0

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

@@ -0,0 +1,150 @@
+import { ActiveClarificationProjectionSchema, GetClarificationRoundMessagesRequestSchema, GetClarificationRoundResponseSchema, GetClarificationThreadResponseSchema, MessageWindowSchema, SendClarificationRoundMessageBodySchema, SendClarificationRoundMessageResponseSchema, SubmitClarificationRoundBodySchema, SubmitClarificationRoundResponseSchema, } from "@tutti/shared/schemas/api";
+import { readActiveClarificationProjection, readClarificationRoundMessagesWindow, readClarificationRoundProjection, readClarificationThreadResponse, } from "../../../../collaboration-state/index.js";
+import { executeIdempotentCommand } from "../../../command-idempotency/index.js";
+import { HOST_PROJECT_API_BASE_PATH } from "./constants.js";
+import { HostProjectNotFoundError } from "./errors.js";
+import { clarificationRoundInvalidates } from "./invalidations.js";
+import { requireValidMessageWindowRequest, requireValidRoundMessagePayload, } from "./payload-validation.js";
+import { ClarificationRoundParamsSchema, ClarificationThreadParamsSchema, } from "./schemas.js";
+import { requireControlPlane, requireHostProjectSession, requireProjectStore, } from "./session-requirements.js";
+export function registerClarificationRoutes(app, options) {
+    app.get(`${HOST_PROJECT_API_BASE_PATH}/clarifications/active`, {
+        schema: {
+            response: {
+                200: ActiveClarificationProjectionSchema,
+            },
+        },
+    }, (request) => {
+        requireHostProjectSession(request, options);
+        return readActiveClarificationProjection(requireProjectStore(options).db);
+    });
+    app.get(`${HOST_PROJECT_API_BASE_PATH}/clarifications/:threadId`, {
+        schema: {
+            params: ClarificationThreadParamsSchema,
+            response: {
+                200: GetClarificationThreadResponseSchema,
+            },
+        },
+    }, (request) => {
+        requireHostProjectSession(request, options);
+        const projection = readClarificationThreadResponse(requireProjectStore(options).db, request.params.threadId);
+        if (projection === null) {
+            throw new HostProjectNotFoundError("Clarification thread was not found");
+        }
+        return projection;
+    });
+    app.get(`${HOST_PROJECT_API_BASE_PATH}/clarifications/rounds/:roundId`, {
+        schema: {
+            params: ClarificationRoundParamsSchema,
+            response: {
+                200: GetClarificationRoundResponseSchema,
+            },
+        },
+    }, (request) => {
+        requireHostProjectSession(request, options);
+        const store = requireProjectStore(options);
+        const round = readClarificationRoundProjection(store.db, request.params.roundId);
+        if (round === null) {
+            throw new HostProjectNotFoundError("Clarification round was not found");
+        }
+        const thread = readClarificationThreadResponse(store.db, round.thread_id);
+        if (thread === null) {
+            throw new HostProjectNotFoundError("Clarification thread was not found");
+        }
+        return {
+            thread: thread.thread,
+            round,
+        };
+    });
+    app.get(`${HOST_PROJECT_API_BASE_PATH}/clarifications/rounds/:roundId/messages`, {
+        schema: {
+            params: ClarificationRoundParamsSchema,
+            querystring: GetClarificationRoundMessagesRequestSchema,
+            response: {
+                200: MessageWindowSchema,
+            },
+        },
+    }, (request) => {
+        requireHostProjectSession(request, options);
+        const window = readClarificationRoundMessagesWindow(requireProjectStore(options).db, request.params.roundId, requireValidMessageWindowRequest(request.query));
+        if (window === null) {
+            throw new HostProjectNotFoundError("Clarification round was not found");
+        }
+        return window;
+    });
+    app.post(`${HOST_PROJECT_API_BASE_PATH}/clarifications/rounds/:roundId/messages`, {
+        schema: {
+            params: ClarificationRoundParamsSchema,
+            body: SendClarificationRoundMessageBodySchema,
+            response: {
+                200: SendClarificationRoundMessageResponseSchema,
+            },
+        },
+    }, (request) => {
+        const session = requireHostProjectSession(request, options);
+        const store = requireProjectStore(options);
+        const controlPlane = requireControlPlane(options);
+        const payload = requireValidRoundMessagePayload(request.body.payload);
+        const execution = executeIdempotentCommand({
+            db: store.db,
+            command_id: request.body.command_id,
+            command_name: "clarification.message.create",
+            target_ref: request.params.roundId,
+            payload: {
+                body: payload.body,
+                author_ref: session.account.account_ref,
+            },
+            ...(options.now === undefined ? {} : { now: options.now }),
+            execute: () => controlPlane.sendClarificationRoundMessage(request.params.roundId, payload, {
+                account_ref: session.account.account_ref,
+                display_name: session.account.display_name,
+                avatar: session.account.avatar,
+            }),
+        });
+        const response = {
+            command_id: execution.command_id,
+            disposition: execution.disposition,
+            invalidates: clarificationRoundInvalidates(request.params.roundId),
+        };
+        if (execution.result !== undefined) {
+            response.result = execution.result;
+        }
+        const message = execution.result?.message;
+        if (!execution.replayed && message !== undefined) {
+            options.chatAssistant?.enqueue({ message });
+        }
+        return response;
+    });
+    app.post(`${HOST_PROJECT_API_BASE_PATH}/clarifications/rounds/:roundId/submit`, {
+        schema: {
+            params: ClarificationRoundParamsSchema,
+            body: SubmitClarificationRoundBodySchema,
+            response: {
+                200: SubmitClarificationRoundResponseSchema,
+            },
+        },
+    }, (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: "clarification.round.submit",
+            target_ref: request.params.roundId,
+            payload: request.body.payload,
+            ...(options.now === undefined ? {} : { now: options.now }),
+            execute: () => controlPlane.submitClarificationRound(request.params.roundId, request.body.payload, request.body.command_id),
+        });
+        const response = {
+            command_id: execution.command_id,
+            disposition: execution.disposition,
+            invalidates: clarificationRoundInvalidates(request.params.roundId),
+        };
+        if (execution.result !== undefined) {
+            response.result = execution.result;
+        }
+        return response;
+    });
+}
+//# sourceMappingURL=clarification-routes.js.map

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

@@ -0,0 +1,3 @@
+export declare const HOST_PROJECT_API_BASE_PATH: "/api/v1";
+export declare const HOST_MAINLINE_BRANCH: "tutti/mainline";
+//# sourceMappingURL=constants.d.ts.map

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

@@ -0,0 +1,3 @@
+export const HOST_PROJECT_API_BASE_PATH = "/api/v1";
+export const HOST_MAINLINE_BRANCH = "tutti/mainline";
+//# sourceMappingURL=constants.js.map

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

@@ -0,0 +1,26 @@
+export declare class HostProjectForbiddenError extends Error {
+    readonly statusCode = 403;
+    readonly code = "forbidden";
+    constructor();
+}
+export declare class HostProjectBadRequestError extends Error {
+    readonly statusCode = 400;
+    readonly code = "bad_request";
+    constructor(message: string);
+}
+export declare class HostProjectValidationError extends Error {
+    readonly statusCode = 422;
+    readonly code = "validation_failed";
+    constructor(message: string);
+}
+export declare class HostProjectStoreUnavailableError extends Error {
+    readonly statusCode = 503;
+    readonly code = "host_unavailable";
+    constructor();
+}
+export declare class HostProjectNotFoundError extends Error {
+    readonly statusCode = 404;
+    readonly code = "not_found";
+    constructor(message?: string);
+}
+//# sourceMappingURL=errors.d.ts.map

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

@@ -0,0 +1,41 @@
+export class HostProjectForbiddenError extends Error {
+    statusCode = 403;
+    code = "forbidden";
+    constructor() {
+        super("Relay session is not allowed for this host project");
+        this.name = "HostProjectForbiddenError";
+    }
+}
+export class HostProjectBadRequestError extends Error {
+    statusCode = 400;
+    code = "bad_request";
+    constructor(message) {
+        super(message);
+        this.name = "HostProjectBadRequestError";
+    }
+}
+export class HostProjectValidationError extends Error {
+    statusCode = 422;
+    code = "validation_failed";
+    constructor(message) {
+        super(message);
+        this.name = "HostProjectValidationError";
+    }
+}
+export class HostProjectStoreUnavailableError extends Error {
+    statusCode = 503;
+    code = "host_unavailable";
+    constructor() {
+        super("Host project store is unavailable");
+        this.name = "HostProjectStoreUnavailableError";
+    }
+}
+export class HostProjectNotFoundError extends Error {
+    statusCode = 404;
+    code = "not_found";
+    constructor(message = "Resource was not found") {
+        super(message);
+        this.name = "HostProjectNotFoundError";
+    }
+}
+//# sourceMappingURL=errors.js.map

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

@@ -0,0 +1,11 @@
+import type { FastifyReply, FastifyRequest } from "fastify";
+import type { WorkspaceEventBus } from "../../workspace-events.js";
+import type { GetEventsRequest } from "./schemas.js";
+export declare function openWorkspaceEventStream(options: {
+    request: FastifyRequest<{
+        Querystring: GetEventsRequest;
+    }>;
+    reply: FastifyReply;
+    events: WorkspaceEventBus;
+}): void;
+//# sourceMappingURL=events-stream.d.ts.map

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

@@ -0,0 +1,55 @@
+import { formatSseComment } from "../../sse.js";
+import { headerToString } from "./headers.js";
+const SSE_HEARTBEAT_INTERVAL_MS = 20_000;
+function readRequestedEventCursor(request) {
+    const lastEventId = headerToString(request.headers["last-event-id"]);
+    if (lastEventId !== undefined && lastEventId.trim() !== "") {
+        return lastEventId;
+    }
+    return request.query.after;
+}
+export function openWorkspaceEventStream(options) {
+    const requestedCursor = readRequestedEventCursor(options.request);
+    const replay = options.events.replayAfter(requestedCursor);
+    options.reply.hijack();
+    const raw = options.reply.raw;
+    raw.writeHead(200, {
+        "content-type": "text/event-stream; charset=utf-8",
+        "cache-control": "no-cache, no-transform",
+        connection: "keep-alive",
+        "x-accel-buffering": "no",
+    });
+    raw.write(`retry: ${options.events.retryAfterMs}\n\n`);
+    if (replay.status === "missed") {
+        raw.write(options.events.formatReplayMissFrame("SSE replay window was missed; refresh workspace state."));
+    }
+    for (const frame of replay.frames) {
+        raw.write(frame.frame);
+    }
+    raw.write(options.events.formatConnectionReadyFrame({
+        replay,
+        ...(requestedCursor === undefined ? {} : { requestedCursor }),
+    }));
+    const writeLiveFrame = (frame) => {
+        if (!raw.destroyed && !raw.writableEnded) {
+            raw.write(frame);
+        }
+    };
+    const unsubscribe = options.events.subscribe(writeLiveFrame);
+    const heartbeat = setInterval(() => {
+        writeLiveFrame(formatSseComment("ping"));
+    }, SSE_HEARTBEAT_INTERVAL_MS);
+    heartbeat.unref?.();
+    let closed = false;
+    const cleanup = () => {
+        if (closed) {
+            return;
+        }
+        closed = true;
+        clearInterval(heartbeat);
+        unsubscribe();
+    };
+    raw.on("close", cleanup);
+    raw.on("error", cleanup);
+}
+//# sourceMappingURL=events-stream.js.map

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

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

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

@@ -0,0 +1,92 @@
+import { CursorPageRequestSchema, ExecutionStatusProjectionSchema, GetRecoverySummariesRequestSchema, GetRecoverySummariesResponseSchema, GetRecoverySummaryResponseSchema, TaskDetailProjectionSchema, TaskProjectionSchema, TaskRunResultsPageSchema, } from "@tutti/shared/schemas/api";
+import { createIdleExecutionStatusProjection, readRecoverySummariesPage, readRecoverySummaryProjection, readTaskDetailProjection, readTaskProjection, readTaskRunResultsPage, } from "../../../../collaboration-state/index.js";
+import { HOST_PROJECT_API_BASE_PATH } from "./constants.js";
+import { HostProjectNotFoundError } from "./errors.js";
+import { RecoverySummaryParamsSchema, TaskParamsSchema, } from "./schemas.js";
+import { requireHostProjectSession, requireProjectStore, } from "./session-requirements.js";
+export function registerExecutionRoutes(app, options) {
+    app.get(`${HOST_PROJECT_API_BASE_PATH}/tasks/:taskId/detail`, {
+        schema: {
+            params: TaskParamsSchema,
+            response: {
+                200: TaskDetailProjectionSchema,
+            },
+        },
+    }, (request) => {
+        requireHostProjectSession(request, options);
+        const projection = readTaskDetailProjection(requireProjectStore(options).db, request.params.taskId);
+        if (projection === null) {
+            throw new HostProjectNotFoundError("Task was not found");
+        }
+        return projection;
+    });
+    app.get(`${HOST_PROJECT_API_BASE_PATH}/tasks/:taskId/run-results`, {
+        schema: {
+            params: TaskParamsSchema,
+            querystring: CursorPageRequestSchema,
+            response: {
+                200: TaskRunResultsPageSchema,
+            },
+        },
+    }, (request) => {
+        requireHostProjectSession(request, options);
+        const page = readTaskRunResultsPage(requireProjectStore(options).db, request.params.taskId, request.query);
+        if (page === null) {
+            throw new HostProjectNotFoundError("Task was not found");
+        }
+        return page;
+    });
+    app.get(`${HOST_PROJECT_API_BASE_PATH}/recovery-summaries`, {
+        schema: {
+            querystring: GetRecoverySummariesRequestSchema,
+            response: {
+                200: GetRecoverySummariesResponseSchema,
+            },
+        },
+    }, (request) => {
+        requireHostProjectSession(request, options);
+        return readRecoverySummariesPage(requireProjectStore(options).db, request.query);
+    });
+    app.get(`${HOST_PROJECT_API_BASE_PATH}/recovery-summaries/:recoveryId`, {
+        schema: {
+            params: RecoverySummaryParamsSchema,
+            response: {
+                200: GetRecoverySummaryResponseSchema,
+            },
+        },
+    }, (request) => {
+        requireHostProjectSession(request, options);
+        const recoverySummary = readRecoverySummaryProjection(requireProjectStore(options).db, request.params.recoveryId);
+        if (recoverySummary === null) {
+            throw new HostProjectNotFoundError("Recovery summary was not found");
+        }
+        return { recovery_summary: recoverySummary };
+    });
+    app.get(`${HOST_PROJECT_API_BASE_PATH}/tasks/:taskId`, {
+        schema: {
+            params: TaskParamsSchema,
+            response: {
+                200: TaskProjectionSchema,
+            },
+        },
+    }, (request) => {
+        requireHostProjectSession(request, options);
+        const task = readTaskProjection(requireProjectStore(options).db, request.params.taskId);
+        if (task === null) {
+            throw new HostProjectNotFoundError("Task was not found");
+        }
+        return task;
+    });
+    app.get(`${HOST_PROJECT_API_BASE_PATH}/execution-status`, {
+        schema: {
+            response: {
+                200: ExecutionStatusProjectionSchema,
+            },
+        },
+    }, (request) => {
+        requireHostProjectSession(request, options);
+        return (options.controlPlane?.getExecutionStatus() ??
+            createIdleExecutionStatusProjection(options.now));
+    });
+}
+//# sourceMappingURL=execution-routes.js.map

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

@@ -0,0 +1,2 @@
+export declare function headerToString(value: string | readonly string[] | undefined): string | undefined;
+//# sourceMappingURL=headers.d.ts.map

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

@@ -0,0 +1,7 @@
+export function headerToString(value) {
+    if (typeof value === "string" || value === undefined) {
+        return value;
+    }
+    return value[0];
+}
+//# sourceMappingURL=headers.js.map

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

@@ -0,0 +1,10 @@
+import type { ClarificationRoundRef } from "@tutti/shared/ids";
+import type { QueryInvalidationHint, RunSchedulerNowDisposition } from "@tutti/shared/schemas/api";
+export declare function mainChatMessageInvalidates(): QueryInvalidationHint[];
+export declare function worklistSubmitInvalidates(): QueryInvalidationHint[];
+export declare function schedulerRunNowInvalidates(disposition: RunSchedulerNowDisposition): QueryInvalidationHint[];
+export declare function clarificationRoundInvalidates(roundId: ClarificationRoundRef): QueryInvalidationHint[];
+export declare function approvalInvalidates(): QueryInvalidationHint[];
+export declare function readStateInvalidates(): QueryInvalidationHint[];
+export declare function projectDisplayNameInvalidates(): QueryInvalidationHint[];
+//# sourceMappingURL=invalidations.d.ts.map

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

@@ -0,0 +1,57 @@
+export function mainChatMessageInvalidates() {
+    return [
+        { kind: "messages", scope: "main_chat" },
+        { kind: "read_state" },
+        { kind: "bootstrap" },
+    ];
+}
+export function worklistSubmitInvalidates() {
+    return [
+        { kind: "worklist" },
+        { kind: "scratchpad" },
+        { kind: "execution_status" },
+        { kind: "messages", scope: "main_chat" },
+        { kind: "clarification" },
+        { kind: "viewer" },
+        { kind: "workspace" },
+        { kind: "read_state" },
+        { kind: "bootstrap" },
+    ];
+}
+export function schedulerRunNowInvalidates(disposition) {
+    const base = [
+        { kind: "worklist" },
+        { kind: "execution_status" },
+        { kind: "read_state" },
+        { kind: "bootstrap" },
+    ];
+    if (disposition.kind !== "scheduled") {
+        return base;
+    }
+    return [
+        ...base,
+        { kind: "task", task_id: disposition.task_id },
+        { kind: "task_detail", task_id: disposition.task_id },
+        { kind: "task_run_results", task_id: disposition.task_id },
+    ];
+}
+export function clarificationRoundInvalidates(roundId) {
+    return [
+        { kind: "clarification", round_id: roundId },
+        { kind: "messages", scope: "clarification_round", round_id: roundId },
+        { kind: "messages", scope: "main_chat" },
+        { kind: "execution_status" },
+        { kind: "read_state" },
+        { kind: "bootstrap" },
+    ];
+}
+export function approvalInvalidates() {
+    return [{ kind: "approval" }, { kind: "execution_status" }, { kind: "bootstrap" }];
+}
+export function readStateInvalidates() {
+    return [{ kind: "read_state" }, { kind: "bootstrap" }];
+}
+export function projectDisplayNameInvalidates() {
+    return [{ kind: "workspace" }, { kind: "bootstrap" }];
+}
+//# sourceMappingURL=invalidations.js.map

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

@@ -0,0 +1,8 @@
+import type { FastifyInstance } from "fastify";
+import type { WorkspaceEventBus } from "../../workspace-events.js";
+import type { HostProjectApiRouteOptions } from "./types.js";
+export declare function registerMessagesRoutes(app: FastifyInstance, { options, workspaceEvents, }: {
+    options: HostProjectApiRouteOptions;
+    workspaceEvents: WorkspaceEventBus;
+}): void;
+//# sourceMappingURL=messages-routes.d.ts.map

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

@@ -0,0 +1,80 @@
+import { GetMessagesRequestSchema, MessageWindowSchema, SendMainChatMessageBodySchema, SendMainChatMessageResponseSchema, } from "@tutti/shared/schemas/api";
+import { createMainChatMessage, readMainChatMessageWindow, } from "../../../../collaboration-state/index.js";
+import { executeIdempotentCommand } from "../../../command-idempotency/index.js";
+import { HOST_PROJECT_API_BASE_PATH } from "./constants.js";
+import { mainChatMessageInvalidates } from "./invalidations.js";
+import { requireValidMessageWindowRequest, requireValidSendMainChatPayload, } from "./payload-validation.js";
+import { requireHostProjectSession, requireProjectStore, } from "./session-requirements.js";
+export function registerMessagesRoutes(app, { options, workspaceEvents, }) {
+    app.get(`${HOST_PROJECT_API_BASE_PATH}/messages`, {
+        schema: {
+            querystring: GetMessagesRequestSchema,
+            response: {
+                200: MessageWindowSchema,
+            },
+        },
+    }, (request) => {
+        requireHostProjectSession(request, options);
+        const store = requireProjectStore(options);
+        return readMainChatMessageWindow(store.db, requireValidMessageWindowRequest(request.query));
+    });
+    app.post(`${HOST_PROJECT_API_BASE_PATH}/messages`, {
+        schema: {
+            body: SendMainChatMessageBodySchema,
+            response: {
+                200: SendMainChatMessageResponseSchema,
+            },
+        },
+    }, (request) => {
+        const session = requireHostProjectSession(request, options);
+        const store = requireProjectStore(options);
+        const payload = requireValidSendMainChatPayload(request.body.payload);
+        const execution = executeIdempotentCommand({
+            db: store.db,
+            command_id: request.body.command_id,
+            command_name: "messages.create",
+            target_ref: "main_chat",
+            payload: {
+                body: payload.body,
+                author_ref: session.account.account_ref,
+            },
+            ...(options.now === undefined ? {} : { now: options.now }),
+            execute: (tx) => ({
+                disposition: { kind: "created" },
+                result: {
+                    message: createMainChatMessage(tx, {
+                        body: payload.body,
+                        author: {
+                            kind: "human",
+                            ref: session.account.account_ref,
+                            display_name: session.account.display_name,
+                            avatar: session.account.avatar,
+                        },
+                        ...(options.now === undefined ? {} : { now: options.now }),
+                    }),
+                },
+            }),
+        });
+        const response = {
+            command_id: execution.command_id,
+            disposition: execution.disposition,
+            invalidates: mainChatMessageInvalidates(),
+        };
+        if (execution.result !== undefined) {
+            response.result = execution.result;
+        }
+        if (!execution.replayed && execution.result !== undefined) {
+            workspaceEvents.publish({
+                event_type: "message.created",
+                payload: {
+                    message: execution.result.message,
+                },
+                invalidates: mainChatMessageInvalidates(),
+            });
+            options.controlPlane?.notifyScratchpadSourceChanged();
+            options.chatAssistant?.enqueue({ message: execution.result.message });
+        }
+        return response;
+    });
+}
+//# sourceMappingURL=messages-routes.js.map