@xfey/tutti 0.1.0

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

@@ -0,0 +1,441 @@
+import { ApprovalRequestIdSchema, ClarificationRoundRefSchema, ClarificationThreadRefSchema, IdempotencyKeySchema, IsoDateTimeStringSchema, ProjectIdSchema, RelayAccountRefSchema, RelayClientSessionIdSchema, RelayProjectRefSchema, RecoverySummaryIdSchema, TaskIdSchema, } from "@tutti/shared/schemas/domain";
+import { ActiveClarificationProjectionSchema, ActiveApprovalProjectionSchema, ExecutionStatusProjectionSchema, MessageWindowSchema, ProjectTimelineResponseSchema, ReadStateSummaryProjectionSchema, ScratchpadProjectionSchema, WorklistProjectionSchema, } from "@tutti/shared/schemas/api";
+import { ACCOUNT_AVATAR_COLORS } from "@tutti/shared/domain";
+import { HOST_MAINLINE_BRANCH } from "./constants.js";
+export const AccountAvatarProjectionSchema = {
+    oneOf: [
+        {
+            type: "object",
+            required: ["kind", "initials", "color"],
+            additionalProperties: false,
+            properties: {
+                kind: { type: "string", enum: ["initials"] },
+                initials: { type: "string", minLength: 1 },
+                color: { type: "string", enum: ACCOUNT_AVATAR_COLORS },
+            },
+        },
+        {
+            type: "object",
+            required: ["kind", "image_url", "initials", "color"],
+            additionalProperties: false,
+            properties: {
+                kind: { type: "string", enum: ["image"] },
+                image_url: { type: "string", minLength: 1 },
+                initials: { type: "string", minLength: 1 },
+                color: { type: "string", enum: ACCOUNT_AVATAR_COLORS },
+            },
+        },
+    ],
+};
+export const ProviderConfigProjectionSchema = {
+    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: IsoDateTimeStringSchema,
+            },
+        },
+        {
+            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: IsoDateTimeStringSchema,
+                invalid_reason_code: {
+                    type: "string",
+                    enum: [
+                        "provider_auth_invalid",
+                        "provider_quota_or_billing_required",
+                        "provider_rate_limited",
+                        "provider_model_unavailable",
+                        "provider_network_error",
+                        "unknown",
+                    ],
+                },
+            },
+        },
+    ],
+};
+const ProviderUsageBreakdownProjectionSchema = {
+    type: "object",
+    required: [
+        "input_tokens",
+        "cached_input_tokens",
+        "output_tokens",
+        "reasoning_output_tokens",
+        "total_tokens",
+        "event_count",
+    ],
+    additionalProperties: false,
+    properties: {
+        input_tokens: { type: "integer", minimum: 0 },
+        cached_input_tokens: { type: "integer", minimum: 0 },
+        output_tokens: { type: "integer", minimum: 0 },
+        reasoning_output_tokens: { type: "integer", minimum: 0 },
+        total_tokens: { type: "integer", minimum: 0 },
+        event_count: { type: "integer", minimum: 0 },
+    },
+};
+const ProviderUsageSourceSummaryProjectionSchema = {
+    type: "object",
+    required: [
+        "source",
+        "label",
+        "category",
+        "input_tokens",
+        "cached_input_tokens",
+        "output_tokens",
+        "reasoning_output_tokens",
+        "total_tokens",
+        "event_count",
+    ],
+    additionalProperties: false,
+    properties: {
+        source: { type: "string", minLength: 1 },
+        label: { type: "string", minLength: 1 },
+        category: {
+            type: "string",
+            enum: ["implementation", "planning", "context", "qna", "other"],
+        },
+        input_tokens: { type: "integer", minimum: 0 },
+        cached_input_tokens: { type: "integer", minimum: 0 },
+        output_tokens: { type: "integer", minimum: 0 },
+        reasoning_output_tokens: { type: "integer", minimum: 0 },
+        total_tokens: { type: "integer", minimum: 0 },
+        event_count: { type: "integer", minimum: 0 },
+    },
+};
+const ProviderUsageModelSummaryProjectionSchema = {
+    type: "object",
+    required: [
+        "model",
+        "input_tokens",
+        "cached_input_tokens",
+        "output_tokens",
+        "reasoning_output_tokens",
+        "total_tokens",
+        "event_count",
+    ],
+    additionalProperties: false,
+    properties: {
+        model: { type: "string", minLength: 1 },
+        input_tokens: { type: "integer", minimum: 0 },
+        cached_input_tokens: { type: "integer", minimum: 0 },
+        output_tokens: { type: "integer", minimum: 0 },
+        reasoning_output_tokens: { type: "integer", minimum: 0 },
+        total_tokens: { type: "integer", minimum: 0 },
+        event_count: { type: "integer", minimum: 0 },
+    },
+};
+export const ProviderUsageProjectionSchema = {
+    type: "object",
+    required: ["total_tokens", "totals", "by_source", "by_model", "recent_windows"],
+    additionalProperties: false,
+    properties: {
+        total_tokens: { type: "integer", minimum: 0 },
+        totals: ProviderUsageBreakdownProjectionSchema,
+        by_source: {
+            type: "array",
+            items: ProviderUsageSourceSummaryProjectionSchema,
+        },
+        by_model: {
+            type: "array",
+            items: ProviderUsageModelSummaryProjectionSchema,
+        },
+        recent_windows: {
+            type: "object",
+            required: ["today", "last_7_days", "last_30_days"],
+            additionalProperties: false,
+            properties: {
+                today: ProviderUsageBreakdownProjectionSchema,
+                last_7_days: ProviderUsageBreakdownProjectionSchema,
+                last_30_days: ProviderUsageBreakdownProjectionSchema,
+            },
+        },
+    },
+};
+export { ProjectTimelineResponseSchema };
+export const SessionResponseSchema = {
+    type: "object",
+    required: ["account", "membership", "client_session"],
+    additionalProperties: false,
+    properties: {
+        account: {
+            type: "object",
+            required: ["account_ref", "display_name", "avatar"],
+            additionalProperties: false,
+            properties: {
+                account_ref: RelayAccountRefSchema,
+                display_name: { type: "string", minLength: 1 },
+                avatar: AccountAvatarProjectionSchema,
+            },
+        },
+        membership: {
+            type: "object",
+            required: ["label", "joined_at"],
+            additionalProperties: false,
+            properties: {
+                label: { type: "string", enum: ["owner", "member"] },
+                relay_project_ref: RelayProjectRefSchema,
+                joined_at: IsoDateTimeStringSchema,
+            },
+        },
+        client_session: {
+            type: "object",
+            required: ["client_session_id", "transport", "connected_at"],
+            additionalProperties: false,
+            properties: {
+                client_session_id: RelayClientSessionIdSchema,
+                transport: { type: "string", enum: ["relay_tunnel"] },
+                connected_at: IsoDateTimeStringSchema,
+            },
+        },
+    },
+};
+export const WorkspaceResponseSchema = {
+    type: "object",
+    required: ["project", "server", "repo", "relay", "provider", "capabilities"],
+    additionalProperties: false,
+    properties: {
+        project: {
+            type: "object",
+            required: ["project_id", "display_name", "identity_source"],
+            additionalProperties: false,
+            properties: {
+                project_id: ProjectIdSchema,
+                display_name: { type: "string", minLength: 1 },
+                identity_source: { type: "string", enum: ["git_config"] },
+            },
+        },
+        server: {
+            type: "object",
+            required: ["version", "started_at", "mode"],
+            additionalProperties: false,
+            properties: {
+                version: { type: "string" },
+                started_at: IsoDateTimeStringSchema,
+                mode: { type: "string", enum: ["development", "production"] },
+            },
+        },
+        repo: {
+            type: "object",
+            required: ["mainline_branch", "mainline_timeline", "mainline_clean"],
+            additionalProperties: false,
+            properties: {
+                mainline_branch: { type: "string", enum: [HOST_MAINLINE_BRANCH] },
+                mainline_head: {
+                    type: "object",
+                    required: ["oid", "short_oid"],
+                    additionalProperties: false,
+                    properties: {
+                        oid: { type: "string", minLength: 1 },
+                        short_oid: { type: "string", minLength: 1 },
+                    },
+                },
+                mainline_timeline: {
+                    type: "object",
+                    required: ["entries"],
+                    additionalProperties: false,
+                    properties: {
+                        entries: {
+                            type: "array",
+                            items: {
+                                type: "object",
+                                required: ["oid", "committed_at"],
+                                additionalProperties: false,
+                                properties: {
+                                    oid: { type: "string", minLength: 1 },
+                                    committed_at: IsoDateTimeStringSchema,
+                                },
+                            },
+                        },
+                    },
+                },
+                mainline_clean: { type: "boolean" },
+            },
+        },
+        relay: {
+            type: "object",
+            required: ["status", "relay_url", "join_token_reusable"],
+            additionalProperties: false,
+            properties: {
+                status: { type: "string", enum: ["connected", "reconnecting", "unavailable"] },
+                relay_url: { type: "string", minLength: 1 },
+                join_url: { type: "string", minLength: 1 },
+                join_url_visibility: { type: "string", enum: ["visible_once", "not_recoverable"] },
+                join_token_expires_at: IsoDateTimeStringSchema,
+                join_token_reusable: { type: "boolean" },
+            },
+        },
+        provider: {
+            type: "object",
+            required: ["status"],
+            additionalProperties: false,
+            properties: {
+                status: { type: "string", enum: ["not_configured", "configured", "invalid"] },
+                provider: { type: "string", enum: ["openai"] },
+            },
+        },
+        capabilities: {
+            type: "object",
+            required: [
+                "sse",
+                "relay_join",
+                "repo_viewer",
+                "provider_config_query",
+                "browser_secret_write",
+                "task_auto_scheduler",
+                "task_run_now_scheduler",
+                "clarification",
+            ],
+            additionalProperties: false,
+            properties: {
+                sse: { type: "boolean" },
+                relay_join: { type: "boolean" },
+                repo_viewer: { type: "boolean" },
+                provider_config_query: { type: "boolean" },
+                browser_secret_write: { type: "boolean", enum: [false] },
+                task_auto_scheduler: { type: "boolean" },
+                task_run_now_scheduler: { type: "boolean" },
+                clarification: { type: "boolean" },
+            },
+        },
+    },
+};
+export const BootstrapResponseSchema = {
+    type: "object",
+    required: [
+        "generated_at",
+        "event_cursor",
+        "workspace",
+        "session",
+        "provider_config",
+        "snapshots",
+    ],
+    additionalProperties: false,
+    properties: {
+        generated_at: IsoDateTimeStringSchema,
+        event_cursor: { type: "string", minLength: 1 },
+        workspace: WorkspaceResponseSchema,
+        session: SessionResponseSchema,
+        provider_config: ProviderConfigProjectionSchema,
+        snapshots: {
+            type: "object",
+            additionalProperties: false,
+            properties: {
+                main_chat: MessageWindowSchema,
+                scratchpad: ScratchpadProjectionSchema,
+                worklist: WorklistProjectionSchema,
+                active_clarification: ActiveClarificationProjectionSchema,
+                active_approval: ActiveApprovalProjectionSchema,
+                execution_status: ExecutionStatusProjectionSchema,
+                read_state: ReadStateSummaryProjectionSchema,
+            },
+        },
+    },
+};
+export const SendMainChatMessageBodySchema = {
+    type: "object",
+    required: ["command_id", "issued_at", "payload"],
+    additionalProperties: false,
+    properties: {
+        command_id: IdempotencyKeySchema,
+        issued_at: IsoDateTimeStringSchema,
+        payload: {
+            type: "object",
+            required: ["body"],
+            additionalProperties: false,
+            properties: {
+                body: { type: "string" },
+            },
+        },
+    },
+};
+export const GetEventsRequestSchema = {
+    type: "object",
+    additionalProperties: false,
+    properties: {
+        after: { type: "string", minLength: 1 },
+    },
+};
+export const TaskParamsSchema = {
+    type: "object",
+    required: ["taskId"],
+    additionalProperties: false,
+    properties: {
+        taskId: TaskIdSchema,
+    },
+};
+export const RecoverySummaryParamsSchema = {
+    type: "object",
+    required: ["recoveryId"],
+    additionalProperties: false,
+    properties: {
+        recoveryId: RecoverySummaryIdSchema,
+    },
+};
+export const ApprovalRequestParamsSchema = {
+    type: "object",
+    required: ["approvalId"],
+    additionalProperties: false,
+    properties: {
+        approvalId: ApprovalRequestIdSchema,
+    },
+};
+export const ClarificationThreadParamsSchema = {
+    type: "object",
+    required: ["threadId"],
+    additionalProperties: false,
+    properties: {
+        threadId: ClarificationThreadRefSchema,
+    },
+};
+export const ClarificationRoundParamsSchema = {
+    type: "object",
+    required: ["roundId"],
+    additionalProperties: false,
+    properties: {
+        roundId: ClarificationRoundRefSchema,
+    },
+};
+export const OpenApiDocumentProjectionSchema = {
+    type: "object",
+    additionalProperties: true,
+};
+export const EventStreamResponseSchema = {
+    type: "string",
+    description: "Server-sent event stream containing WorkspaceSseEvent JSON payloads.",
+};
+export const BinaryAssetResponseSchema = {
+    type: "string",
+    contentEncoding: "base64",
+    description: "Binary viewer asset bytes. The concrete media type is selected per asset.",
+};
+//# sourceMappingURL=schemas.js.map

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

@@ -0,0 +1,10 @@
+import type { FastifyRequest } from "fastify";
+import type { Phase5ControlPlane } from "../../../../control-plane/index.js";
+import type { HostProjectStore } from "../../../../store/index.js";
+import type { HostProjectApiRouteOptions, HostSessionProjection } from "./types.js";
+export declare function requireHostProjectSession(request: FastifyRequest, options: HostProjectApiRouteOptions): HostSessionProjection;
+export declare function requireProjectStore(options: HostProjectApiRouteOptions): HostProjectStore;
+export declare function requireControlPlane(options: HostProjectApiRouteOptions): Phase5ControlPlane;
+export declare function requireWorkspaceRoot(options: HostProjectApiRouteOptions): string;
+export declare function requireViewerAssetCacheRoot(options: HostProjectApiRouteOptions): string;
+//# sourceMappingURL=session-requirements.d.ts.map

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

@@ -0,0 +1,60 @@
+import { requireRelaySessionContext, TRUSTED_RELAY_METADATA_REQUEST_HEADER, } from "../../../session/relay-session-context.js";
+import { HostProjectForbiddenError, HostProjectStoreUnavailableError } from "./errors.js";
+import { headerToString } from "./headers.js";
+function readTrustedMetadata(request, store) {
+    const requestId = headerToString(request.headers[TRUSTED_RELAY_METADATA_REQUEST_HEADER]);
+    if (requestId === undefined || requestId.trim() === "") {
+        return undefined;
+    }
+    return store.consume(requestId);
+}
+export function requireHostProjectSession(request, options) {
+    const context = requireRelaySessionContext(readTrustedMetadata(request, options.trustedMetadataStore));
+    const relayState = options.relay.getState();
+    if (relayState.relay_project_ref !== undefined &&
+        context.membership.relay_project_ref !== relayState.relay_project_ref) {
+        throw new HostProjectForbiddenError();
+    }
+    return {
+        account: {
+            account_ref: context.account_ref,
+            display_name: context.display_name,
+            avatar: context.avatar,
+        },
+        membership: {
+            label: context.membership.label,
+            relay_project_ref: context.membership.relay_project_ref,
+            joined_at: context.membership.joined_at,
+        },
+        client_session: {
+            client_session_id: context.client_session_id,
+            transport: "relay_tunnel",
+            connected_at: context.client_session_created_at,
+        },
+    };
+}
+export function requireProjectStore(options) {
+    if (options.store === undefined) {
+        throw new HostProjectStoreUnavailableError();
+    }
+    return options.store;
+}
+export function requireControlPlane(options) {
+    if (options.controlPlane === undefined) {
+        throw new HostProjectStoreUnavailableError();
+    }
+    return options.controlPlane;
+}
+export function requireWorkspaceRoot(options) {
+    if (options.workspaceOps === undefined) {
+        throw new HostProjectStoreUnavailableError();
+    }
+    return options.workspaceOps.workspaceRoot;
+}
+export function requireViewerAssetCacheRoot(options) {
+    if (options.workspaceOps === undefined) {
+        throw new HostProjectStoreUnavailableError();
+    }
+    return options.workspaceOps.viewerAssetCacheRoot;
+}
+//# sourceMappingURL=session-requirements.js.map

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

@@ -0,0 +1,7 @@
+import type { QueryInvalidationHint } from "@tutti/shared/schemas/api";
+import type { HostProjectApiRouteOptions } from "./types.js";
+export declare function skillsChangedInvalidates(): QueryInvalidationHint[];
+export declare function requireTuttiHome(options: HostProjectApiRouteOptions): string;
+export declare function withAsyncSkillServiceErrorMapping<T>(fn: () => Promise<T>): Promise<T>;
+export declare function withSkillServiceErrorMapping<T>(fn: () => T): T;
+//# sourceMappingURL=skills-helpers.d.ts.map

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

@@ -0,0 +1,48 @@
+import { SkillServiceError } from "../../../../skills/index.js";
+import { HostProjectBadRequestError, HostProjectNotFoundError, HostProjectStoreUnavailableError, HostProjectValidationError, } from "./errors.js";
+export function skillsChangedInvalidates() {
+    return [{ kind: "skills" }, { kind: "read_state" }, { kind: "bootstrap" }];
+}
+export function requireTuttiHome(options) {
+    if (options.tuttiHome === undefined) {
+        throw new HostProjectStoreUnavailableError();
+    }
+    return options.tuttiHome;
+}
+function toHostProjectSkillError(error) {
+    switch (error.code) {
+        case "invalid_skill_name":
+            return new HostProjectBadRequestError(error.message);
+        case "skill_not_found":
+            return new HostProjectNotFoundError(error.message);
+        case "invalid_zip":
+            return new HostProjectBadRequestError(error.message);
+        case "validation_failed":
+            return new HostProjectValidationError(error.message);
+        case "filesystem_error":
+            return new HostProjectStoreUnavailableError();
+    }
+}
+export async function withAsyncSkillServiceErrorMapping(fn) {
+    try {
+        return await fn();
+    }
+    catch (error) {
+        if (error instanceof SkillServiceError) {
+            throw toHostProjectSkillError(error);
+        }
+        throw error;
+    }
+}
+export function withSkillServiceErrorMapping(fn) {
+    try {
+        return fn();
+    }
+    catch (error) {
+        if (error instanceof SkillServiceError) {
+            throw toHostProjectSkillError(error);
+        }
+        throw error;
+    }
+}
+//# sourceMappingURL=skills-helpers.js.map

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