@xfey/tutti 0.1.0

package/dist/server-shell/http/routes/local-control.d.ts

@@ -0,0 +1,40 @@
+import type { FastifyInstance } from "fastify";
+import type { ProviderConfigProjection } from "@tutti/shared/schemas/api";
+export type HostLocalControlOptions = {
+    token: string;
+    getLaunchStatus?: () => HostLocalLaunchStatus;
+    project?: {
+        get: () => HostLocalProjectProjection;
+        update: (input: HostLocalProjectBody) => HostLocalProjectProjection;
+    };
+    providerConfig?: {
+        get: () => ProviderConfigProjection;
+        configure: (input: HostLocalProviderConfigBody) => Promise<ProviderConfigProjection>;
+    };
+    requestShutdown: () => void;
+};
+export type HostLocalLaunchStatus = {
+    relay?: {
+        relay_project_ref: string;
+        host_connection_ref: string;
+        join_url?: string;
+        join_url_visibility: "visible_once" | "not_recoverable";
+        join_token_expires_at?: string;
+        join_token_reusable?: boolean;
+        tunnel_url: string;
+        connected_at: string;
+    };
+};
+export type HostLocalProviderConfigBody = {
+    api_key: string;
+    base_url?: string;
+    default_model?: string;
+};
+export type HostLocalProjectProjection = {
+    display_name: string;
+};
+export type HostLocalProjectBody = {
+    display_name: string;
+};
+export declare function registerHostLocalControlRoutes(app: FastifyInstance, options: HostLocalControlOptions): void;
+//# sourceMappingURL=local-control.d.ts.map

package/dist/server-shell/http/routes/local-control.js

@@ -0,0 +1,260 @@
+import { timingSafeEqual } from "node:crypto";
+class HostLocalControlUnauthorizedError extends Error {
+    statusCode = 401;
+    code = "unauthorized";
+    constructor() {
+        super("Host local control token is invalid");
+        this.name = "HostLocalControlUnauthorizedError";
+    }
+}
+class HostLocalProviderConfigureUnavailableError extends Error {
+    statusCode = 404;
+    code = "not_found";
+    constructor() {
+        super("Host local provider configure route is unavailable");
+        this.name = "HostLocalProviderConfigureUnavailableError";
+    }
+}
+class HostLocalProjectUnavailableError extends Error {
+    statusCode = 404;
+    code = "not_found";
+    constructor() {
+        super("Host local project route is unavailable");
+        this.name = "HostLocalProjectUnavailableError";
+    }
+}
+class HostLocalProjectValidationError extends Error {
+    statusCode = 422;
+    code = "validation_failed";
+    constructor(message) {
+        super(message);
+        this.name = "HostLocalProjectValidationError";
+    }
+}
+const HostLocalShutdownResponseSchema = {
+    type: "object",
+    required: ["ok"],
+    additionalProperties: false,
+    properties: {
+        ok: { type: "boolean", enum: [true] },
+    },
+};
+const HostLocalProviderConfigBodySchema = {
+    type: "object",
+    required: ["api_key"],
+    additionalProperties: false,
+    properties: {
+        api_key: { type: "string", minLength: 1 },
+        base_url: { type: "string", minLength: 1 },
+        default_model: { type: "string", minLength: 1 },
+    },
+};
+const HostLocalProjectBodySchema = {
+    type: "object",
+    required: ["display_name"],
+    additionalProperties: false,
+    properties: {
+        display_name: { type: "string", minLength: 1, maxLength: 80 },
+    },
+};
+const HostLocalProjectResponseSchema = {
+    type: "object",
+    required: ["display_name"],
+    additionalProperties: false,
+    properties: {
+        display_name: { type: "string", minLength: 1, maxLength: 80 },
+    },
+};
+const HostLocalProviderConfigResponseSchema = {
+    oneOf: [
+        {
+            type: "object",
+            required: ["status"],
+            additionalProperties: false,
+            properties: {
+                status: { type: "string", enum: ["not_configured"] },
+            },
+        },
+        {
+            type: "object",
+            required: [
+                "status",
+                "provider",
+                "auth_kind",
+                "redacted_key",
+                "default_model",
+                "validated_at",
+            ],
+            additionalProperties: false,
+            properties: {
+                status: { type: "string", enum: ["configured"] },
+                provider: { type: "string", enum: ["openai"] },
+                auth_kind: { type: "string", enum: ["api_key"] },
+                redacted_key: { type: "string" },
+                default_model: { type: "string" },
+                validated_at: { type: "string" },
+            },
+        },
+        {
+            type: "object",
+            required: ["status"],
+            additionalProperties: false,
+            properties: {
+                status: { type: "string", enum: ["invalid"] },
+                provider: { type: "string", enum: ["openai"] },
+                auth_kind: { type: "string", enum: ["api_key"] },
+                redacted_key: { type: "string" },
+                default_model: { type: "string" },
+                validated_at: { type: "string" },
+                invalid_reason_code: { type: "string" },
+            },
+        },
+    ],
+};
+const HostLocalLaunchStatusResponseSchema = {
+    type: "object",
+    additionalProperties: false,
+    properties: {
+        relay: {
+            type: "object",
+            required: [
+                "relay_project_ref",
+                "host_connection_ref",
+                "join_url_visibility",
+                "tunnel_url",
+                "connected_at",
+            ],
+            additionalProperties: false,
+            properties: {
+                relay_project_ref: { type: "string" },
+                host_connection_ref: { type: "string" },
+                join_url: { type: "string" },
+                join_url_visibility: { type: "string", enum: ["visible_once", "not_recoverable"] },
+                join_token_expires_at: { type: "string" },
+                join_token_reusable: { type: "boolean" },
+                tunnel_url: { type: "string" },
+                connected_at: { type: "string" },
+            },
+        },
+    },
+};
+function headerToString(value) {
+    if (typeof value === "string" || value === undefined) {
+        return value;
+    }
+    return value[0];
+}
+function readBearerToken(authorization) {
+    const header = headerToString(authorization);
+    if (header === undefined) {
+        return null;
+    }
+    const match = /^Bearer\s+(.+)$/iu.exec(header.trim());
+    return match?.[1] ?? null;
+}
+function tokenEquals(actual, expected) {
+    if (actual === null || actual.length === 0 || expected.length === 0) {
+        return false;
+    }
+    const actualBuffer = Buffer.from(actual);
+    const expectedBuffer = Buffer.from(expected);
+    if (actualBuffer.length !== expectedBuffer.length) {
+        return false;
+    }
+    return timingSafeEqual(actualBuffer, expectedBuffer);
+}
+function normalizeProjectBody(input) {
+    const displayName = input.display_name.trim();
+    if (displayName.length === 0) {
+        throw new HostLocalProjectValidationError("Project display name is required");
+    }
+    if (displayName.length > 80) {
+        throw new HostLocalProjectValidationError("Project display name must be 80 characters or less");
+    }
+    return { display_name: displayName };
+}
+export function registerHostLocalControlRoutes(app, options) {
+    function requireLocalToken(authorization) {
+        const token = readBearerToken(authorization);
+        if (!tokenEquals(token, options.token)) {
+            throw new HostLocalControlUnauthorizedError();
+        }
+    }
+    app.get("/host-local/v1/launch-status", {
+        schema: {
+            response: {
+                200: HostLocalLaunchStatusResponseSchema,
+            },
+        },
+    }, (request) => {
+        requireLocalToken(request.headers.authorization);
+        return options.getLaunchStatus?.() ?? {};
+    });
+    app.get("/host-local/v1/provider/config", {
+        schema: {
+            response: {
+                200: HostLocalProviderConfigResponseSchema,
+            },
+        },
+    }, (request) => {
+        requireLocalToken(request.headers.authorization);
+        if (options.providerConfig === undefined) {
+            throw new HostLocalProviderConfigureUnavailableError();
+        }
+        return options.providerConfig.get();
+    });
+    app.post("/host-local/v1/provider/config", {
+        schema: {
+            body: HostLocalProviderConfigBodySchema,
+            response: {
+                200: HostLocalProviderConfigResponseSchema,
+            },
+        },
+    }, async (request) => {
+        requireLocalToken(request.headers.authorization);
+        if (options.providerConfig === undefined) {
+            throw new HostLocalProviderConfigureUnavailableError();
+        }
+        return await options.providerConfig.configure(request.body);
+    });
+    app.get("/host-local/v1/project", {
+        schema: {
+            response: {
+                200: HostLocalProjectResponseSchema,
+            },
+        },
+    }, (request) => {
+        requireLocalToken(request.headers.authorization);
+        if (options.project === undefined) {
+            throw new HostLocalProjectUnavailableError();
+        }
+        return options.project.get();
+    });
+    app.post("/host-local/v1/project", {
+        schema: {
+            body: HostLocalProjectBodySchema,
+            response: {
+                200: HostLocalProjectResponseSchema,
+            },
+        },
+    }, (request) => {
+        requireLocalToken(request.headers.authorization);
+        if (options.project === undefined) {
+            throw new HostLocalProjectUnavailableError();
+        }
+        return options.project.update(normalizeProjectBody(request.body));
+    });
+    app.post("/host-local/v1/shutdown", {
+        schema: {
+            response: {
+                202: HostLocalShutdownResponseSchema,
+            },
+        },
+    }, (request, reply) => {
+        requireLocalToken(request.headers.authorization);
+        setImmediate(options.requestShutdown);
+        void reply.code(202);
+        return { ok: true };
+    });
+}
+//# sourceMappingURL=local-control.js.map

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

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

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

@@ -0,0 +1,64 @@
+import { ActiveApprovalProjectionSchema, DecideApprovalBodySchema, DecideApprovalResponseSchema, } from "@tutti/shared/schemas/api";
+import { executeIdempotentCommand } from "../../../command-idempotency/index.js";
+import { HOST_PROJECT_API_BASE_PATH } from "./constants.js";
+import { approvalInvalidates } from "./invalidations.js";
+import { ApprovalRequestParamsSchema, } from "./schemas.js";
+import { requireHostProjectSession, requireProjectStore, } from "./session-requirements.js";
+function readActiveApproval(options) {
+    return options.approvalManager?.getActiveApproval() ?? { state: "none" };
+}
+export function registerApprovalRoutes(app, options) {
+    app.get(`${HOST_PROJECT_API_BASE_PATH}/approvals/active`, {
+        schema: {
+            response: {
+                200: ActiveApprovalProjectionSchema,
+            },
+        },
+    }, (request) => {
+        requireHostProjectSession(request, options);
+        return readActiveApproval(options);
+    });
+    app.post(`${HOST_PROJECT_API_BASE_PATH}/approvals/:approvalId/decide`, {
+        schema: {
+            params: ApprovalRequestParamsSchema,
+            body: DecideApprovalBodySchema,
+            response: {
+                200: DecideApprovalResponseSchema,
+            },
+        },
+    }, (request) => {
+        const session = requireHostProjectSession(request, options);
+        const store = requireProjectStore(options);
+        const execution = executeIdempotentCommand({
+            db: store.db,
+            command_id: request.body.command_id,
+            command_name: "approval.decide",
+            target_ref: request.params.approvalId,
+            payload: {
+                decision_id: request.body.payload.decision_id,
+            },
+            ...(options.now === undefined ? {} : { now: options.now }),
+            execute: () => options.approvalManager?.decide({
+                approvalId: request.params.approvalId,
+                payload: request.body.payload,
+                actor: {
+                    account_ref: session.account.account_ref,
+                    display_name: session.account.display_name,
+                },
+            }) ?? {
+                disposition: { kind: "stale_approval" },
+                result: { approval: { state: "none" } },
+            },
+        });
+        const response = {
+            command_id: execution.command_id,
+            disposition: execution.disposition,
+            invalidates: approvalInvalidates(),
+        };
+        if (execution.result !== undefined) {
+            response.result = execution.result;
+        }
+        return response;
+    });
+}
+//# sourceMappingURL=approval-routes.js.map

package/dist/server-shell/http/routes/project-api/artifacts-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 registerArtifactsRoutes(app: FastifyInstance, { options, workspaceEvents, }: {
+    options: HostProjectApiRouteOptions;
+    workspaceEvents: WorkspaceEventBus;
+}): void;
+//# sourceMappingURL=artifacts-routes.d.ts.map

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

@@ -0,0 +1,166 @@
+import { HeartbeatArtifactPreviewBodySchema, HeartbeatArtifactPreviewResponseSchema, GetArtifactsResponseSchema, StartArtifactPreviewBodySchema, StartArtifactPreviewResponseSchema, StopArtifactPreviewBodySchema, StopArtifactPreviewResponseSchema, } from "@tutti/shared/schemas/api";
+import { ARTIFACT_PREVIEW_CSP, ArtifactPreviewManager, readArtifactProjection, readArtifactStaticPreview, } from "../../../../artifacts/index.js";
+import { executeIdempotentCommand } from "../../../command-idempotency/index.js";
+import { HOST_PROJECT_API_BASE_PATH } from "./constants.js";
+import { requireHostProjectSession, requireProjectStore, requireWorkspaceRoot, } from "./session-requirements.js";
+function artifactInvalidates() {
+    return [{ kind: "artifacts" }];
+}
+export function registerArtifactsRoutes(app, { options, workspaceEvents, }) {
+    const artifactPreviewManager = new ArtifactPreviewManager({
+        ...(options.now === undefined ? {} : { now: options.now }),
+        onStatusChange: () => {
+            workspaceEvents.publish({
+                event_type: "query.invalidate",
+                payload: {
+                    reason: "bulk_state_change",
+                    message: "Artifacts changed.",
+                },
+                invalidates: artifactInvalidates(),
+            });
+        },
+    });
+    app.addHook("onClose", (_instance, done) => {
+        artifactPreviewManager.stopAll();
+        done();
+    });
+    app.get(`${HOST_PROJECT_API_BASE_PATH}/artifacts`, {
+        schema: {
+            response: {
+                200: GetArtifactsResponseSchema,
+            },
+        },
+    }, (request) => {
+        requireHostProjectSession(request, options);
+        return artifactPreviewManager.readProjection({
+            workspaceRoot: requireWorkspaceRoot(options),
+        });
+    });
+    app.get("/artifacts/preview/*", async (request, reply) => {
+        requireHostProjectSession(request, options);
+        const workspaceRoot = requireWorkspaceRoot(options);
+        const projection = readArtifactProjection({
+            workspaceRoot,
+            ...(options.now === undefined ? {} : { now: options.now }),
+        });
+        if (projection.artifact.status === "declared" && projection.artifact.artifact.kind === "server") {
+            const queryIndex = request.url.indexOf("?");
+            const preview = await artifactPreviewManager.fetchServerPreview({
+                workspaceRoot,
+                path: request.params["*"],
+                ...(queryIndex < 0 ? {} : { query: request.url.slice(queryIndex + 1) }),
+                headers: {
+                    ...(typeof request.headers.accept === "string"
+                        ? { accept: request.headers.accept }
+                        : {}),
+                    ...(typeof request.headers["accept-language"] === "string"
+                        ? { "accept-language": request.headers["accept-language"] }
+                        : {}),
+                },
+            });
+            for (const [key, value] of Object.entries(preview.headers)) {
+                void reply.header(key, value);
+            }
+            void reply
+                .code(preview.status_code)
+                .header("x-content-type-options", "nosniff")
+                .header("content-security-policy", ARTIFACT_PREVIEW_CSP)
+                .header("cache-control", preview.headers["cache-control"] ?? "no-store")
+                .send(preview.content);
+            return;
+        }
+        const preview = readArtifactStaticPreview({
+            workspaceRoot,
+            path: request.params["*"],
+            ...(options.now === undefined ? {} : { now: options.now }),
+        });
+        void reply
+            .header("content-type", preview.media_type)
+            .header("x-content-type-options", "nosniff")
+            .header("content-security-policy", ARTIFACT_PREVIEW_CSP)
+            .header("cache-control", "private, max-age=60")
+            .send(preview.content);
+    });
+    app.post(`${HOST_PROJECT_API_BASE_PATH}/artifacts/preview/start`, {
+        schema: {
+            body: StartArtifactPreviewBodySchema,
+            response: {
+                200: StartArtifactPreviewResponseSchema,
+            },
+        },
+    }, (request) => {
+        requireHostProjectSession(request, options);
+        const store = requireProjectStore(options);
+        const invalidates = artifactInvalidates();
+        const execution = executeIdempotentCommand({
+            db: store.db,
+            command_id: request.body.command_id,
+            command_name: "artifacts.preview.start",
+            target_ref: "artifacts:active",
+            payload: request.body.payload,
+            ...(options.now === undefined ? {} : { now: options.now }),
+            execute: () => artifactPreviewManager.start({ workspaceRoot: requireWorkspaceRoot(options) }),
+        });
+        return {
+            command_id: execution.command_id,
+            disposition: execution.disposition,
+            ...(execution.result === undefined ? {} : { result: execution.result }),
+            invalidates,
+        };
+    });
+    app.post(`${HOST_PROJECT_API_BASE_PATH}/artifacts/preview/heartbeat`, {
+        schema: {
+            body: HeartbeatArtifactPreviewBodySchema,
+            response: {
+                200: HeartbeatArtifactPreviewResponseSchema,
+            },
+        },
+    }, (request) => {
+        const session = requireHostProjectSession(request, options);
+        const store = requireProjectStore(options);
+        const invalidates = artifactInvalidates();
+        const execution = executeIdempotentCommand({
+            db: store.db,
+            command_id: request.body.command_id,
+            command_name: "artifacts.preview.heartbeat",
+            target_ref: `artifacts:active:${session.client_session.client_session_id}`,
+            payload: request.body.payload,
+            ...(options.now === undefined ? {} : { now: options.now }),
+            execute: () => artifactPreviewManager.heartbeat({ workspaceRoot: requireWorkspaceRoot(options) }),
+        });
+        return {
+            command_id: execution.command_id,
+            disposition: execution.disposition,
+            ...(execution.result === undefined ? {} : { result: execution.result }),
+            invalidates,
+        };
+    });
+    app.post(`${HOST_PROJECT_API_BASE_PATH}/artifacts/preview/stop`, {
+        schema: {
+            body: StopArtifactPreviewBodySchema,
+            response: {
+                200: StopArtifactPreviewResponseSchema,
+            },
+        },
+    }, (request) => {
+        requireHostProjectSession(request, options);
+        const store = requireProjectStore(options);
+        const invalidates = artifactInvalidates();
+        const execution = executeIdempotentCommand({
+            db: store.db,
+            command_id: request.body.command_id,
+            command_name: "artifacts.preview.stop",
+            target_ref: "artifacts:active",
+            payload: request.body.payload,
+            ...(options.now === undefined ? {} : { now: options.now }),
+            execute: () => artifactPreviewManager.stop({ workspaceRoot: requireWorkspaceRoot(options) }),
+        });
+        return {
+            command_id: execution.command_id,
+            disposition: execution.disposition,
+            ...(execution.result === undefined ? {} : { result: execution.result }),
+            invalidates,
+        };
+    });
+}
+//# sourceMappingURL=artifacts-routes.js.map

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

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