@xfey/tutti 0.1.0

package/node_modules/@tutti/relay-client/dist/host-control.js

@@ -0,0 +1,284 @@
+import { createIdempotencyKey, } from "@tutti/shared/ids";
+export class RelayHostControlClientError extends Error {
+    code;
+    retryable;
+    statusCode;
+    relayErrorCode;
+    constructor(code, message, retryable, statusCode, relayErrorCode) {
+        super(message);
+        this.code = code;
+        this.retryable = retryable;
+        this.statusCode = statusCode;
+        this.relayErrorCode = relayErrorCode;
+        this.name = "RelayHostControlClientError";
+    }
+}
+const DEFAULT_TIMEOUT_MS = 5_000;
+function registrationUrl(relayUrl) {
+    return new URL("/host-control/v1/host-connections", relayUrl);
+}
+function joinTokenUrl(relayUrl) {
+    return new URL("/host-control/v1/join-token", relayUrl);
+}
+function uploadResolveUrl(relayUrl) {
+    return new URL("/host-control/v1/uploads/resolve", relayUrl);
+}
+function uploadCompleteUrl(relayUrl) {
+    return new URL("/host-control/v1/uploads/complete", relayUrl);
+}
+function createRegisterPayload(options) {
+    const capabilities = options.capabilities ?? {};
+    const payload = {
+        project_identity: {
+            source: "git_config",
+            project_id: options.projectId,
+        },
+        host_auth: {
+            kind: "host_registration_secret_v1",
+            secret: options.hostRegistrationSecret,
+        },
+        display_name: options.displayName,
+        host: {
+            server_version: options.serverVersion,
+            host_project_api_base_path: "/api/v1",
+            capabilities: {
+                sse: capabilities.sse ?? true,
+                provider_config_query: capabilities.provider_config_query ?? true,
+                browser_secret_write: false,
+                repo_viewer: capabilities.repo_viewer ?? false,
+            },
+        },
+    };
+    if (options.joinToken !== undefined) {
+        payload.join_token = {
+            mode: options.joinToken.mode,
+            ...(options.joinToken.ttlSeconds === undefined
+                ? {}
+                : { ttl_seconds: options.joinToken.ttlSeconds }),
+        };
+    }
+    return payload;
+}
+function createRefreshJoinTokenPayload(options) {
+    const payload = {
+        project_identity: {
+            source: "git_config",
+            project_id: options.projectId,
+        },
+        host_auth: {
+            kind: "host_registration_secret_v1",
+            secret: options.hostRegistrationSecret,
+        },
+        relay_project_ref: options.relayProjectRef,
+        host_connection_ref: options.hostConnectionRef,
+    };
+    if (options.joinToken !== undefined) {
+        payload.join_token = {
+            mode: options.joinToken.mode,
+            ...(options.joinToken.ttlSeconds === undefined
+                ? {}
+                : { ttl_seconds: options.joinToken.ttlSeconds }),
+        };
+    }
+    return payload;
+}
+function createResolveRelayUploadPayload(options) {
+    return {
+        project_identity: {
+            source: "git_config",
+            project_id: options.projectId,
+        },
+        host_auth: {
+            kind: "host_registration_secret_v1",
+            secret: options.hostRegistrationSecret,
+        },
+        relay_project_ref: options.relayProjectRef,
+        host_connection_ref: options.hostConnectionRef,
+        upload_id: options.uploadId,
+    };
+}
+function createCompleteRelayUploadPayload(options) {
+    return {
+        ...createResolveRelayUploadPayload(options),
+        status: options.status,
+    };
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function stringField(record, key) {
+    const value = record[key];
+    return typeof value === "string" ? value : undefined;
+}
+function relayErrorCodeFromBody(value) {
+    if (!isRecord(value) || !isRecord(value.error)) {
+        return undefined;
+    }
+    return stringField(value.error, "code");
+}
+async function fetchWithTimeout(fetchImpl, url, init, timeoutMs) {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => {
+        controller.abort();
+    }, timeoutMs);
+    try {
+        return await fetchImpl(url, {
+            ...init,
+            signal: controller.signal,
+        });
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}
+function assertRegistrationResponse(value) {
+    if (!isRecord(value) || !isRecord(value.disposition)) {
+        throw new RelayHostControlClientError("relay_registration_failed", "Relay host registration response is invalid", false);
+    }
+    const dispositionKind = stringField(value.disposition, "kind");
+    if (dispositionKind !== "registered" && dispositionKind !== "interrupted") {
+        throw new RelayHostControlClientError("relay_registration_failed", "Relay host registration disposition is invalid", false);
+    }
+    return value;
+}
+function assertRefreshJoinTokenResponse(value) {
+    if (!isRecord(value) || !isRecord(value.join_token)) {
+        throw new RelayHostControlClientError("relay_registration_failed", "Relay join token refresh response is invalid", false);
+    }
+    return value;
+}
+function assertResolveRelayUploadResponse(value) {
+    if (!isRecord(value) || !isRecord(value.upload) || !isRecord(value.get)) {
+        throw new RelayHostControlClientError("relay_registration_failed", "Relay upload resolve response is invalid", false);
+    }
+    return value;
+}
+function assertCompleteRelayUploadResponse(value) {
+    if (!isRecord(value) || !isRecord(value.upload)) {
+        throw new RelayHostControlClientError("relay_registration_failed", "Relay upload complete response is invalid", false);
+    }
+    return value;
+}
+export async function registerRelayHostConnection(options) {
+    const fetchImpl = options.fetch ?? fetch;
+    const commandId = options.commandId ?? createIdempotencyKey();
+    const issuedAt = options.issuedAt ?? new Date();
+    const response = await (async () => {
+        try {
+            return await fetchWithTimeout(fetchImpl, registrationUrl(options.relayUrl), {
+                method: "POST",
+                headers: {
+                    accept: "application/json",
+                    "content-type": "application/json",
+                },
+                body: JSON.stringify({
+                    command_id: commandId,
+                    issued_at: issuedAt.toISOString(),
+                    payload: createRegisterPayload(options),
+                }),
+            }, options.timeoutMs ?? DEFAULT_TIMEOUT_MS);
+        }
+        catch {
+            throw new RelayHostControlClientError("relay_unavailable", `Cannot reach Relay at ${options.relayUrl}`, true);
+        }
+    })();
+    if (!response.ok) {
+        let relayErrorCode;
+        try {
+            relayErrorCode = relayErrorCodeFromBody(await response.json());
+        }
+        catch {
+            relayErrorCode = undefined;
+        }
+        throw new RelayHostControlClientError(response.status >= 500 ? "relay_unavailable" : "relay_registration_failed", `Relay host registration failed with HTTP ${response.status}`, response.status >= 500, response.status, relayErrorCode);
+    }
+    return assertRegistrationResponse(await response.json());
+}
+export async function refreshRelayJoinToken(options) {
+    const fetchImpl = options.fetch ?? fetch;
+    const response = await (async () => {
+        try {
+            return await fetchWithTimeout(fetchImpl, joinTokenUrl(options.relayUrl), {
+                method: "POST",
+                headers: {
+                    accept: "application/json",
+                    "content-type": "application/json",
+                },
+                body: JSON.stringify(createRefreshJoinTokenPayload(options)),
+            }, options.timeoutMs ?? DEFAULT_TIMEOUT_MS);
+        }
+        catch {
+            throw new RelayHostControlClientError("relay_unavailable", `Cannot reach Relay at ${options.relayUrl}`, true);
+        }
+    })();
+    if (!response.ok) {
+        let relayErrorCode;
+        try {
+            relayErrorCode = relayErrorCodeFromBody(await response.json());
+        }
+        catch {
+            relayErrorCode = undefined;
+        }
+        throw new RelayHostControlClientError(response.status >= 500 ? "relay_unavailable" : "relay_registration_failed", `Relay join token refresh failed with HTTP ${response.status}`, response.status >= 500, response.status, relayErrorCode);
+    }
+    return assertRefreshJoinTokenResponse(await response.json());
+}
+export async function resolveRelayUpload(options) {
+    const fetchImpl = options.fetch ?? fetch;
+    const response = await (async () => {
+        try {
+            return await fetchWithTimeout(fetchImpl, uploadResolveUrl(options.relayUrl), {
+                method: "POST",
+                headers: {
+                    accept: "application/json",
+                    "content-type": "application/json",
+                },
+                body: JSON.stringify(createResolveRelayUploadPayload(options)),
+            }, options.timeoutMs ?? DEFAULT_TIMEOUT_MS);
+        }
+        catch {
+            throw new RelayHostControlClientError("relay_unavailable", `Cannot reach Relay at ${options.relayUrl}`, true);
+        }
+    })();
+    if (!response.ok) {
+        let relayErrorCode;
+        try {
+            relayErrorCode = relayErrorCodeFromBody(await response.json());
+        }
+        catch {
+            relayErrorCode = undefined;
+        }
+        throw new RelayHostControlClientError(response.status >= 500 ? "relay_unavailable" : "relay_registration_failed", `Relay upload resolve failed with HTTP ${response.status}`, response.status >= 500, response.status, relayErrorCode);
+    }
+    return assertResolveRelayUploadResponse(await response.json());
+}
+export async function completeRelayUpload(options) {
+    const fetchImpl = options.fetch ?? fetch;
+    const response = await (async () => {
+        try {
+            return await fetchWithTimeout(fetchImpl, uploadCompleteUrl(options.relayUrl), {
+                method: "POST",
+                headers: {
+                    accept: "application/json",
+                    "content-type": "application/json",
+                },
+                body: JSON.stringify(createCompleteRelayUploadPayload(options)),
+            }, options.timeoutMs ?? DEFAULT_TIMEOUT_MS);
+        }
+        catch {
+            throw new RelayHostControlClientError("relay_unavailable", `Cannot reach Relay at ${options.relayUrl}`, true);
+        }
+    })();
+    if (!response.ok) {
+        let relayErrorCode;
+        try {
+            relayErrorCode = relayErrorCodeFromBody(await response.json());
+        }
+        catch {
+            relayErrorCode = undefined;
+        }
+        throw new RelayHostControlClientError(response.status >= 500 ? "relay_unavailable" : "relay_registration_failed", `Relay upload complete failed with HTTP ${response.status}`, response.status >= 500, response.status, relayErrorCode);
+    }
+    return assertCompleteRelayUploadResponse(await response.json());
+}
+//# sourceMappingURL=host-control.js.map

package/node_modules/@tutti/relay-client/dist/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./host-control.js";
+export * from "./tunnel.js";
+//# sourceMappingURL=index.d.ts.map

package/node_modules/@tutti/relay-client/dist/index.js

@@ -0,0 +1,3 @@
+export * from "./host-control.js";
+export * from "./tunnel.js";
+//# sourceMappingURL=index.js.map

package/node_modules/@tutti/relay-client/dist/tunnel-frames.d.ts

@@ -0,0 +1,8 @@
+import type { RelayHostTunnelRequest, RelayHostTunnelResponse, RelayHostTunnelWebSocketLike } from "./tunnel-types.js";
+export declare function parseHostRequestFrame(data: unknown, expectedKind: "host_request" | "host_stream_request"): RelayHostTunnelRequest | null;
+export declare function parseHostStreamCancelFrame(data: unknown): string | null;
+export declare function internalErrorResponse(requestId: string): RelayHostTunnelResponse;
+export declare function sendResponse(socket: RelayHostTunnelWebSocketLike, requestId: string, response: RelayHostTunnelResponse): void;
+export declare function sendFrame(socket: RelayHostTunnelWebSocketLike, frame: Record<string, unknown>): void;
+export declare function chunkToBase64(chunk: Buffer | Uint8Array | string): string;
+//# sourceMappingURL=tunnel-frames.d.ts.map

package/node_modules/@tutti/relay-client/dist/tunnel-frames.js

@@ -0,0 +1,124 @@
+import { parseRelaySessionContext } from "@tutti/shared/schemas/internal";
+function bufferFromWsMessage(data) {
+    if (typeof data === "string") {
+        return Buffer.from(data, "utf8");
+    }
+    if (Buffer.isBuffer(data)) {
+        return data;
+    }
+    if (data instanceof ArrayBuffer) {
+        return Buffer.from(data);
+    }
+    if (Array.isArray(data)) {
+        return Buffer.concat(data.map((entry) => bufferFromWsMessage(entry)));
+    }
+    return Buffer.from(String(data), "utf8");
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function parseTunnelHeaders(value) {
+    if (!isRecord(value)) {
+        return null;
+    }
+    const headers = {};
+    for (const [key, entry] of Object.entries(value)) {
+        if (typeof entry === "string") {
+            headers[key] = entry;
+            continue;
+        }
+        if (Array.isArray(entry) && entry.every((item) => typeof item === "string")) {
+            headers[key] = entry;
+            continue;
+        }
+        return null;
+    }
+    return headers;
+}
+export function parseHostRequestFrame(data, expectedKind) {
+    let value;
+    try {
+        value = JSON.parse(bufferFromWsMessage(data).toString("utf8"));
+    }
+    catch {
+        return null;
+    }
+    if (!isRecord(value) || value.kind !== expectedKind) {
+        return null;
+    }
+    const headers = parseTunnelHeaders(value.headers);
+    const metadata = isRecord(value.metadata) ? value.metadata : null;
+    const relaySessionContext = metadata === null ? null : parseRelaySessionContext(metadata.relay_session_context);
+    if (typeof value.request_id !== "string" ||
+        typeof value.method !== "string" ||
+        typeof value.path !== "string" ||
+        headers === null ||
+        relaySessionContext === null ||
+        (value.body_base64 !== undefined && typeof value.body_base64 !== "string")) {
+        return null;
+    }
+    const request = {
+        request_id: value.request_id,
+        method: value.method,
+        path: value.path,
+        headers,
+        metadata: {
+            relay_session_context: relaySessionContext,
+        },
+    };
+    if (value.body_base64 !== undefined) {
+        request.body_base64 = value.body_base64;
+    }
+    return request;
+}
+export function parseHostStreamCancelFrame(data) {
+    let value;
+    try {
+        value = JSON.parse(bufferFromWsMessage(data).toString("utf8"));
+    }
+    catch {
+        return null;
+    }
+    if (!isRecord(value) ||
+        value.kind !== "host_stream_cancel" ||
+        typeof value.request_id !== "string") {
+        return null;
+    }
+    return value.request_id;
+}
+function encodeJsonBody(value) {
+    return Buffer.from(JSON.stringify(value), "utf8").toString("base64");
+}
+export function internalErrorResponse(requestId) {
+    return {
+        request_id: requestId,
+        status_code: 500,
+        headers: {
+            "content-type": "application/json; charset=utf-8",
+        },
+        body_base64: encodeJsonBody({
+            error: {
+                code: "internal_error",
+                message: "Internal server error",
+                retryable: true,
+            },
+        }),
+    };
+}
+export function sendResponse(socket, requestId, response) {
+    socket.send(JSON.stringify({
+        kind: "host_response",
+        ...response,
+        request_id: requestId,
+    }));
+}
+export function sendFrame(socket, frame) {
+    socket.send(JSON.stringify(frame));
+}
+export function chunkToBase64(chunk) {
+    if (typeof chunk === "string") {
+        return Buffer.from(chunk, "utf8").toString("base64");
+    }
+    return Buffer.from(chunk).toString("base64");
+}
+//# sourceMappingURL=tunnel-frames.js.map

package/node_modules/@tutti/relay-client/dist/tunnel-types.d.ts

@@ -0,0 +1,61 @@
+import type { HostConnectionRef, RelayProjectRef } from "@tutti/shared/ids";
+import type { RelaySessionContext } from "@tutti/shared/schemas/internal";
+export type RelayTunnelHeaderValue = string | readonly string[];
+export type RelayTunnelHeaders = Record<string, RelayTunnelHeaderValue>;
+export type RelayHostTunnelRequest = {
+    request_id: string;
+    method: string;
+    path: string;
+    headers: RelayTunnelHeaders;
+    body_base64?: string;
+    metadata: {
+        relay_session_context: RelaySessionContext;
+    };
+};
+export type RelayHostTunnelResponse = {
+    request_id: string;
+    status_code: number;
+    headers?: RelayTunnelHeaders;
+    body_base64?: string;
+};
+export type RelayHostTunnelStreamStart = {
+    request_id: string;
+    status_code: number;
+    headers?: RelayTunnelHeaders;
+};
+export type RelayHostTunnelStreamSink = {
+    signal: AbortSignal;
+    start: (response: Omit<RelayHostTunnelStreamStart, "request_id">) => void;
+    write: (chunk: Buffer | Uint8Array | string) => void;
+    end: () => void;
+    error: () => void;
+};
+export type RelayHostTunnelRequestHandler = (request: RelayHostTunnelRequest) => Promise<RelayHostTunnelResponse>;
+export type RelayHostTunnelStreamRequestHandler = (request: RelayHostTunnelRequest, sink: RelayHostTunnelStreamSink) => Promise<void> | void;
+export type RelayHostTunnelWebSocketLike = {
+    on(event: "open", listener: () => void): void;
+    on(event: "message", listener: (data: unknown) => void): void;
+    on(event: "close", listener: () => void): void;
+    on(event: "error", listener: (error: unknown) => void): void;
+    send(data: string, callback?: (error?: Error) => void): void;
+    close(code?: number, reason?: string): void;
+};
+export type RelayHostTunnelConnector = (options: {
+    url: string;
+    headers: Record<string, string>;
+}) => RelayHostTunnelWebSocketLike;
+export type RelayHostTunnelHandle = {
+    connected: Promise<void>;
+    closed: Promise<void>;
+    close: (code?: number, reason?: string) => void;
+};
+export type ConnectRelayHostTunnelOptions = {
+    tunnelUrl: string;
+    relayProjectRef: RelayProjectRef;
+    hostConnectionRef: HostConnectionRef;
+    hostConnectionToken: string;
+    handleRequest: RelayHostTunnelRequestHandler;
+    handleStreamRequest?: RelayHostTunnelStreamRequestHandler;
+    connect?: RelayHostTunnelConnector;
+};
+//# sourceMappingURL=tunnel-types.d.ts.map

package/node_modules/@tutti/relay-client/dist/tunnel-types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=tunnel-types.js.map

package/node_modules/@tutti/relay-client/dist/tunnel.d.ts

@@ -0,0 +1,4 @@
+import type { ConnectRelayHostTunnelOptions, RelayHostTunnelHandle } from "./tunnel-types.js";
+export type * from "./tunnel-types.js";
+export declare function connectRelayHostTunnel(options: ConnectRelayHostTunnelOptions): RelayHostTunnelHandle;
+//# sourceMappingURL=tunnel.d.ts.map

package/node_modules/@tutti/relay-client/dist/tunnel.js

@@ -0,0 +1,144 @@
+import { createRequire } from "node:module";
+import { chunkToBase64, internalErrorResponse, parseHostRequestFrame, parseHostStreamCancelFrame, sendFrame, sendResponse, } from "./tunnel-frames.js";
+const loadNativeModule = createRequire(import.meta.url);
+function defaultConnector(options) {
+    const wsModule = loadNativeModule("ws");
+    const WebSocketCtor = typeof wsModule === "function" ? wsModule : (wsModule.WebSocket ?? wsModule.default);
+    if (WebSocketCtor === undefined) {
+        throw new Error("ws WebSocket constructor is unavailable");
+    }
+    return new WebSocketCtor(options.url, { headers: options.headers });
+}
+function tunnelUrl(options) {
+    const url = new URL(options.tunnelUrl);
+    url.searchParams.set("role", "host");
+    url.searchParams.set("relay_project_ref", options.relayProjectRef);
+    url.searchParams.set("host_connection_ref", options.hostConnectionRef);
+    return url.toString();
+}
+export function connectRelayHostTunnel(options) {
+    const socket = (options.connect ?? defaultConnector)({
+        url: tunnelUrl(options),
+        headers: {
+            authorization: `Bearer ${options.hostConnectionToken}`,
+        },
+    });
+    let resolveConnected;
+    let rejectConnected;
+    let connectedSettled = false;
+    const connected = new Promise((resolve, reject) => {
+        resolveConnected = () => {
+            connectedSettled = true;
+            resolve();
+        };
+        rejectConnected = (error) => {
+            connectedSettled = true;
+            reject(error);
+        };
+    });
+    let resolveClosed;
+    const closed = new Promise((resolve) => {
+        resolveClosed = resolve;
+    });
+    const streamControllers = new Map();
+    socket.on("open", () => {
+        resolveConnected();
+    });
+    socket.on("message", (data) => {
+        const cancelRequestId = parseHostStreamCancelFrame(data);
+        if (cancelRequestId !== null) {
+            streamControllers.get(cancelRequestId)?.abort();
+            streamControllers.delete(cancelRequestId);
+            return;
+        }
+        const streamRequest = parseHostRequestFrame(data, "host_stream_request");
+        if (streamRequest !== null) {
+            if (options.handleStreamRequest === undefined) {
+                sendFrame(socket, {
+                    kind: "host_stream_error",
+                    request_id: streamRequest.request_id,
+                });
+                return;
+            }
+            const controller = new AbortController();
+            streamControllers.set(streamRequest.request_id, controller);
+            const sink = {
+                signal: controller.signal,
+                start: (response) => {
+                    sendFrame(socket, {
+                        kind: "host_stream_start",
+                        request_id: streamRequest.request_id,
+                        ...response,
+                    });
+                },
+                write: (chunk) => {
+                    if (controller.signal.aborted) {
+                        return;
+                    }
+                    sendFrame(socket, {
+                        kind: "host_stream_chunk",
+                        request_id: streamRequest.request_id,
+                        body_base64: chunkToBase64(chunk),
+                    });
+                },
+                end: () => {
+                    streamControllers.delete(streamRequest.request_id);
+                    sendFrame(socket, {
+                        kind: "host_stream_end",
+                        request_id: streamRequest.request_id,
+                    });
+                },
+                error: () => {
+                    streamControllers.delete(streamRequest.request_id);
+                    sendFrame(socket, {
+                        kind: "host_stream_error",
+                        request_id: streamRequest.request_id,
+                    });
+                },
+            };
+            void Promise.resolve()
+                .then(() => options.handleStreamRequest?.(streamRequest, sink))
+                .catch(() => {
+                if (!controller.signal.aborted) {
+                    sink.error();
+                }
+            });
+            return;
+        }
+        const request = parseHostRequestFrame(data, "host_request");
+        if (request === null) {
+            return;
+        }
+        void Promise.resolve()
+            .then(() => options.handleRequest(request))
+            .then((response) => {
+            sendResponse(socket, request.request_id, response);
+        })
+            .catch(() => {
+            sendResponse(socket, request.request_id, internalErrorResponse(request.request_id));
+        });
+    });
+    socket.on("error", (error) => {
+        if (!connectedSettled) {
+            rejectConnected(error instanceof Error ? error : new Error("Relay host tunnel failed"));
+        }
+    });
+    socket.on("close", () => {
+        for (const controller of streamControllers.values()) {
+            controller.abort();
+        }
+        streamControllers.clear();
+        if (!connectedSettled) {
+            rejectConnected(new Error("Relay host tunnel closed before it opened"));
+        }
+        resolveClosed();
+    });
+    return {
+        connected,
+        closed,
+        close: (code = 1000, reason = "closed") => {
+            socket.close(code, reason);
+        },
+    };
+}
+//# sourceMappingURL=tunnel.js.map

package/node_modules/@tutti/relay-client/package.json

@@ -0,0 +1,18 @@
+{
+  "name": "@tutti/relay-client",
+  "version": "0.0.0",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "development": "./dist/index.js",
+      "import": "./dist/index.js"
+    }
+  },
+  "dependencies": {
+    "@tutti/shared": "0.0.0",
+    "ws": "^8.20.0"
+  }
+}