@xfey/tutti 0.1.0

package/dist/server-shell/http/static-web.js

@@ -0,0 +1,52 @@
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import fastifyStatic from "@fastify/static";
+const BLOCKED_SPA_FALLBACK_PREFIXES = [
+    "/api/",
+    "/health",
+    "/host-local/",
+    "/assets/",
+];
+function requestPath(request) {
+    const queryIndex = request.url.indexOf("?");
+    return queryIndex === -1 ? request.url : request.url.slice(0, queryIndex);
+}
+function shouldServeSpaFallback(path) {
+    return !BLOCKED_SPA_FALLBACK_PREFIXES.some((prefix) => path === prefix || path.startsWith(prefix));
+}
+function sendIndex(reply, indexHtml) {
+    void reply
+        .header("content-type", "text/html; charset=utf-8")
+        .header("cache-control", "no-cache")
+        .send(indexHtml);
+}
+export function registerHostWebStaticRoutes(app, options) {
+    const indexPath = join(options.root, "index.html");
+    const assetsRoot = join(options.root, "assets");
+    if (!existsSync(indexPath)) {
+        throw new Error(`Web static index was not found at ${indexPath}`);
+    }
+    if (!existsSync(assetsRoot)) {
+        throw new Error(`Web static assets directory was not found at ${assetsRoot}`);
+    }
+    const indexHtml = readFileSync(indexPath, "utf8");
+    void app.register(fastifyStatic, {
+        root: assetsRoot,
+        prefix: "/assets/",
+        decorateReply: false,
+    });
+    app.get("/*", (request, reply) => {
+        if (!shouldServeSpaFallback(requestPath(request))) {
+            void reply.status(404).send({
+                error: {
+                    code: "not_found",
+                    message: "Route was not found",
+                    retryable: false,
+                },
+            });
+            return;
+        }
+        sendIndex(reply, indexHtml);
+    });
+}
+//# sourceMappingURL=static-web.js.map

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

@@ -0,0 +1,13 @@
+import type { ApiErrorResponse } from "@tutti/shared/schemas/api";
+import type { FastifyInstance } from "fastify";
+export type RouteValidationIssue = {
+    path: string;
+    message: string;
+    keyword?: string;
+    params?: unknown;
+};
+export declare function normalizeValidationIssues(validation: unknown): RouteValidationIssue[];
+export declare function toValidationErrorResponse(error: unknown): ApiErrorResponse;
+export declare function toApiErrorResponse(error: unknown): ApiErrorResponse;
+export declare function registerApiErrorHandler(app: FastifyInstance): void;
+//# sourceMappingURL=validation.d.ts.map

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

@@ -0,0 +1,136 @@
+import { redactText, redactValue } from "@tutti/shared/utils";
+const API_ERROR_CODES = new Set([
+    "bad_request",
+    "unauthorized",
+    "forbidden",
+    "not_found",
+    "conflict",
+    "validation_failed",
+    "provider_not_configured",
+    "provider_auth_invalid",
+    "provider_quota_or_billing_required",
+    "provider_rate_limited",
+    "provider_model_unavailable",
+    "provider_network_error",
+    "relay_session_invalid",
+    "command_replay_mismatch",
+    "repo_snapshot_unavailable",
+    "host_unavailable",
+    "internal_error",
+]);
+function isApiErrorCode(value) {
+    return API_ERROR_CODES.has(value);
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function stringField(record, key) {
+    const value = record[key];
+    return typeof value === "string" ? redactText(value) : undefined;
+}
+function getErrorMessage(error) {
+    if (isRecord(error) && typeof error.message === "string") {
+        return redactText(error.message);
+    }
+    return "Unknown error";
+}
+function getValidationArray(error) {
+    if (!isRecord(error) || !Array.isArray(error.validation)) {
+        return undefined;
+    }
+    return error.validation.map((entry) => entry);
+}
+export function normalizeValidationIssues(validation) {
+    if (!Array.isArray(validation)) {
+        return [];
+    }
+    return validation.map((entry) => {
+        if (!isRecord(entry)) {
+            return {
+                path: "",
+                message: "Invalid request",
+            };
+        }
+        const issue = {
+            path: stringField(entry, "instancePath") ?? stringField(entry, "dataPath") ?? "",
+            message: stringField(entry, "message") ?? "Invalid request",
+        };
+        const keyword = stringField(entry, "keyword");
+        if (keyword !== undefined) {
+            issue.keyword = keyword;
+        }
+        if (entry.params !== undefined) {
+            issue.params = redactValue(entry.params);
+        }
+        return issue;
+    });
+}
+export function toValidationErrorResponse(error) {
+    const validation = getValidationArray(error);
+    return {
+        error: {
+            code: "bad_request",
+            message: "Request shape is invalid",
+            retryable: false,
+            details: {
+                message: getErrorMessage(error),
+                issues: normalizeValidationIssues(validation),
+            },
+        },
+    };
+}
+function apiErrorCodeForStatus(statusCode) {
+    if (statusCode === 401) {
+        return "unauthorized";
+    }
+    if (statusCode === 403) {
+        return "forbidden";
+    }
+    if (statusCode === 404) {
+        return "not_found";
+    }
+    if (statusCode === 409) {
+        return "conflict";
+    }
+    if (statusCode === 422) {
+        return "validation_failed";
+    }
+    return "internal_error";
+}
+function apiErrorCodeFromError(error, statusCode) {
+    if (isRecord(error) && typeof error.code === "string" && isApiErrorCode(error.code)) {
+        return error.code;
+    }
+    return apiErrorCodeForStatus(statusCode);
+}
+function statusCodeFromError(error) {
+    const statusCode = isRecord(error) ? error.statusCode : undefined;
+    if (typeof statusCode !== "number" || statusCode < 400 || statusCode > 599) {
+        return 500;
+    }
+    return statusCode;
+}
+export function toApiErrorResponse(error) {
+    const statusCode = statusCodeFromError(error);
+    return {
+        error: {
+            code: apiErrorCodeFromError(error, statusCode),
+            message: statusCode >= 500 ? "Internal server error" : getErrorMessage(error),
+            retryable: statusCode >= 500,
+        },
+    };
+}
+export function registerApiErrorHandler(app) {
+    app.setErrorHandler((error, request, reply) => {
+        if (getValidationArray(error) !== undefined) {
+            void reply.status(400).send(toValidationErrorResponse(error));
+            return;
+        }
+        const statusCode = statusCodeFromError(error);
+        if (statusCode >= 500) {
+            request.log.error({ err: error }, "Unhandled host request error");
+        }
+        void reply.status(statusCode).send(toApiErrorResponse(error));
+    });
+}
+//# sourceMappingURL=validation.js.map

package/dist/server-shell/http/workspace-events.d.ts

@@ -0,0 +1,38 @@
+import { type QueryInvalidationHint, type WorkspaceSseEventType } from "@tutti/shared/schemas/api";
+import { type SseReplayResult, type WorkspaceSseReplayWindowPolicy } from "./sse-replay-buffer.js";
+import { type WorkspaceSseEvent } from "./sse.js";
+export type WorkspaceSseSubscriber = (frame: string) => void;
+export type WorkspaceEventBusOptions = {
+    now?: () => Date;
+    initialCursor?: string;
+    retryAfterMs?: number;
+    replayWindowPolicy?: WorkspaceSseReplayWindowPolicy;
+    createEventId?: () => string;
+};
+export type PublishWorkspaceEventInput<TPayload> = {
+    event_type: Exclude<WorkspaceSseEventType, "connection.ready">;
+    payload: TPayload;
+    invalidates?: QueryInvalidationHint[];
+};
+export type ConnectionReadyFrameOptions = {
+    requestedCursor?: string;
+    replay: SseReplayResult;
+};
+export declare class WorkspaceEventBus {
+    readonly replayWindowPolicy: WorkspaceSseReplayWindowPolicy;
+    readonly retryAfterMs: number;
+    private readonly replayBuffer;
+    private readonly subscribers;
+    private readonly now;
+    private readonly initialCursor;
+    private readonly createEventId;
+    private nextEventSequence;
+    constructor(options?: WorkspaceEventBusOptions);
+    currentEventCursor(): string;
+    replayAfter(cursor: string | null | undefined): SseReplayResult;
+    subscribe(subscriber: WorkspaceSseSubscriber): () => void;
+    publish<TPayload>(input: PublishWorkspaceEventInput<TPayload>): WorkspaceSseEvent<TPayload>;
+    formatConnectionReadyFrame(options: ConnectionReadyFrameOptions): string;
+    formatReplayMissFrame(message?: string): string;
+}
+//# sourceMappingURL=workspace-events.d.ts.map

package/dist/server-shell/http/workspace-events.js

@@ -0,0 +1,98 @@
+import { DEFAULT_SSE_REPLAY_WINDOW_POLICY, } from "@tutti/shared/schemas/api";
+import { WorkspaceSseReplayBuffer, } from "./sse-replay-buffer.js";
+import { formatWorkspaceSseEvent, toSingleSseLine } from "./sse.js";
+const DEFAULT_RETRY_AFTER_MS = 3000;
+export class WorkspaceEventBus {
+    replayWindowPolicy;
+    retryAfterMs;
+    replayBuffer;
+    subscribers = new Set();
+    now;
+    initialCursor;
+    createEventId;
+    nextEventSequence = 0;
+    constructor(options = {}) {
+        this.now = options.now ?? (() => new Date());
+        this.initialCursor = options.initialCursor ?? "workspace_sse_cursor_0";
+        this.retryAfterMs = options.retryAfterMs ?? DEFAULT_RETRY_AFTER_MS;
+        this.replayWindowPolicy = options.replayWindowPolicy ?? DEFAULT_SSE_REPLAY_WINDOW_POLICY;
+        this.replayBuffer = new WorkspaceSseReplayBuffer({
+            policy: this.replayWindowPolicy,
+            now: this.now,
+        });
+        this.createEventId =
+            options.createEventId ??
+                (() => {
+                    this.nextEventSequence += 1;
+                    return `workspace_sse_${this.nextEventSequence}`;
+                });
+    }
+    currentEventCursor() {
+        return this.replayBuffer.currentEventCursor() ?? this.initialCursor;
+    }
+    replayAfter(cursor) {
+        if (cursor === null || cursor === undefined || cursor.trim() === "") {
+            return this.replayBuffer.replayAfter(cursor);
+        }
+        if (toSingleSseLine(cursor) === this.initialCursor) {
+            return this.replayBuffer.replayAll();
+        }
+        return this.replayBuffer.replayAfter(cursor);
+    }
+    subscribe(subscriber) {
+        this.subscribers.add(subscriber);
+        return () => {
+            this.subscribers.delete(subscriber);
+        };
+    }
+    publish(input) {
+        const event = {
+            event_id: this.createEventId(),
+            event_type: input.event_type,
+            occurred_at: this.now().toISOString(),
+            payload: input.payload,
+            ...(input.invalidates === undefined ? {} : { invalidates: input.invalidates }),
+        };
+        const stored = this.replayBuffer.append(event);
+        for (const subscriber of this.subscribers) {
+            subscriber(stored.frame);
+        }
+        return event;
+    }
+    formatConnectionReadyFrame(options) {
+        const replay = {
+            status: options.replay.status,
+            replayed_event_count: options.replay.replayed_event_count,
+            ...(options.requestedCursor === undefined
+                ? {}
+                : { requested_cursor: options.requestedCursor }),
+        };
+        const payload = {
+            server_time: this.now().toISOString(),
+            current_event_cursor: this.currentEventCursor(),
+            replay,
+            retry_after_ms: this.retryAfterMs,
+            replay_window: DEFAULT_SSE_REPLAY_WINDOW_POLICY,
+        };
+        return formatWorkspaceSseEvent({
+            event_id: this.currentEventCursor(),
+            event_type: "connection.ready",
+            occurred_at: payload.server_time,
+            payload,
+        });
+    }
+    formatReplayMissFrame(message) {
+        const payload = {
+            reason: "replay_missed",
+            ...(message === undefined ? {} : { message }),
+        };
+        return formatWorkspaceSseEvent({
+            event_id: this.currentEventCursor(),
+            event_type: "query.invalidate",
+            occurred_at: this.now().toISOString(),
+            payload,
+            invalidates: [{ kind: "all" }],
+        });
+    }
+}
+//# sourceMappingURL=workspace-events.js.map

package/dist/server-shell/session/relay-session-context.d.ts

@@ -0,0 +1,25 @@
+import { type RelaySessionContext } from "@tutti/shared/schemas/internal";
+export declare const RELAY_SESSION_CONTEXT_METADATA_KEY = "relay_session_context";
+export declare const TRUSTED_RELAY_METADATA_REQUEST_HEADER = "x-tutti-internal-relay-metadata-id";
+export type RelaySessionContextReadResult = {
+    kind: "present";
+    context: RelaySessionContext;
+} | {
+    kind: "missing";
+} | {
+    kind: "invalid";
+};
+export declare class RelaySessionInvalidError extends Error {
+    readonly statusCode = 401;
+    readonly code = "relay_session_invalid";
+    constructor(message?: string);
+}
+export declare class TrustedRelaySessionMetadataStore {
+    #private;
+    stage(metadata: unknown): string;
+    consume(requestId: string): unknown;
+}
+export declare function createTrustedRelaySessionMetadataStore(): TrustedRelaySessionMetadataStore;
+export declare function readRelaySessionContext(metadata: unknown): RelaySessionContextReadResult;
+export declare function requireRelaySessionContext(metadata: unknown): RelaySessionContext;
+//# sourceMappingURL=relay-session-context.d.ts.map

package/dist/server-shell/session/relay-session-context.js

@@ -0,0 +1,49 @@
+import { randomUUID } from "node:crypto";
+import { parseRelaySessionContext } from "@tutti/shared/schemas/internal";
+export const RELAY_SESSION_CONTEXT_METADATA_KEY = "relay_session_context";
+export const TRUSTED_RELAY_METADATA_REQUEST_HEADER = "x-tutti-internal-relay-metadata-id";
+export class RelaySessionInvalidError extends Error {
+    statusCode = 401;
+    code = "relay_session_invalid";
+    constructor(message = "Relay session context is missing or invalid") {
+        super(message);
+        this.name = "RelaySessionInvalidError";
+    }
+}
+export class TrustedRelaySessionMetadataStore {
+    #entries = new Map();
+    stage(metadata) {
+        const requestId = randomUUID();
+        this.#entries.set(requestId, metadata);
+        return requestId;
+    }
+    consume(requestId) {
+        const metadata = this.#entries.get(requestId);
+        this.#entries.delete(requestId);
+        return metadata;
+    }
+}
+export function createTrustedRelaySessionMetadataStore() {
+    return new TrustedRelaySessionMetadataStore();
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+export function readRelaySessionContext(metadata) {
+    if (!isRecord(metadata) || !(RELAY_SESSION_CONTEXT_METADATA_KEY in metadata)) {
+        return { kind: "missing" };
+    }
+    const context = parseRelaySessionContext(metadata[RELAY_SESSION_CONTEXT_METADATA_KEY]);
+    if (context === null) {
+        return { kind: "invalid" };
+    }
+    return { kind: "present", context };
+}
+export function requireRelaySessionContext(metadata) {
+    const result = readRelaySessionContext(metadata);
+    if (result.kind !== "present") {
+        throw new RelaySessionInvalidError();
+    }
+    return result.context;
+}
+//# sourceMappingURL=relay-session-context.js.map

package/dist/server-shell/smoke/e2e-client.d.ts

@@ -0,0 +1,59 @@
+import { type HostProjectApiClient, type LoginPayload, type LoginResponse, type OpenProjectResponse, type RelayApiClient, type TuttiApiFetch, type AcceptJoinResponse, type JoinEntryProjection, type TuttiApiResponse } from "@tutti/api-client";
+import type { RelayProjectRef } from "@tutti/shared/ids";
+export type E2ESmokeLogSink = (line: string) => void;
+export type E2ESmokeClientOptions = {
+    relayBaseUrl: string;
+    origin?: string;
+    fetch?: TuttiApiFetch;
+    now?: () => Date;
+    log?: E2ESmokeLogSink;
+};
+export type E2ESmokeSession = {
+    relayBaseUrl: string;
+    origin: string;
+    relay: RelayApiClient;
+    cookieJar: E2ESmokeCookieJar;
+    fetch: TuttiApiFetch;
+    now: () => Date;
+    log?: E2ESmokeLogSink;
+    hostForProject: (relayProjectRef: RelayProjectRef) => HostProjectApiClient;
+};
+export type LoginJoinAndOpenWorkspaceInput = {
+    joinToken: string;
+    login?: Partial<LoginPayload>;
+};
+export type LoginJoinAndOpenWorkspaceResult = {
+    joinEntry: JoinEntryProjection;
+    login: LoginResponse;
+    acceptJoin: AcceptJoinResponse;
+    openProject: OpenProjectResponse;
+    relayProjectRef: RelayProjectRef;
+    host: HostProjectApiClient;
+};
+export type E2ESmokePollOptions<TValue> = {
+    label: string;
+    read: () => Promise<TValue>;
+    predicate: (value: TValue) => boolean;
+    timeoutMs?: number;
+    intervalMs?: number;
+    log?: E2ESmokeLogSink;
+    now?: () => Date;
+    sleep?: (ms: number) => Promise<void>;
+    describe?: (value: TValue) => Record<string, unknown>;
+};
+export declare class E2ESmokeFlowError extends Error {
+    readonly code: "missing_fetch" | "join_entry_invalid" | "join_accept_missing_project" | "project_open_failed" | "poll_timeout";
+    readonly details: Record<string, unknown>;
+    constructor(code: "missing_fetch" | "join_entry_invalid" | "join_accept_missing_project" | "project_open_failed" | "poll_timeout", message: string, details?: Record<string, unknown>);
+}
+export declare class E2ESmokeCookieJar {
+    private readonly cookies;
+    getCookieHeader(): string | undefined;
+    storeFromResponse(response: TuttiApiResponse): void;
+    private storeSetCookieHeader;
+}
+export declare function createE2ESmokeSession(options: E2ESmokeClientOptions): E2ESmokeSession;
+export declare function loginRelaySmokeAccount(session: E2ESmokeSession, input?: Partial<LoginPayload>): Promise<LoginResponse>;
+export declare function loginJoinAndOpenWorkspace(session: E2ESmokeSession, input: LoginJoinAndOpenWorkspaceInput): Promise<LoginJoinAndOpenWorkspaceResult>;
+export declare function pollE2ESmoke<TValue>(options: E2ESmokePollOptions<TValue>): Promise<TValue>;
+//# sourceMappingURL=e2e-client.d.ts.map