@xfey/tutti 0.1.47 → 0.1.48

package/node_modules/@sinclair/typebox/syntax/package.json

@@ -0,0 +1,4 @@
+{
+  "main": "../build/cjs/syntax/index.js",
+  "types": "../build/cjs/syntax/index.d.ts"
+}

package/node_modules/@sinclair/typebox/system/package.json

@@ -0,0 +1,4 @@
+{
+  "main": "../build/cjs/system/index.js",
+  "types": "../build/cjs/system/index.d.ts"
+}

package/node_modules/@sinclair/typebox/type/package.json

@@ -0,0 +1,4 @@
+{
+  "main": "../build/cjs/type/index.js",
+  "types": "../build/cjs/type/index.d.ts"
+}

package/node_modules/@sinclair/typebox/value/package.json

@@ -0,0 +1,4 @@
+{
+  "main": "../build/cjs/value/index.js",
+  "types": "../build/cjs/value/index.d.ts"
+}

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

@@ -0,0 +1,187 @@
+import { type HostConnectionRef, type IdempotencyKey, type ProjectId, type RelayProjectRef, type RelayUploadRef } from "@tutti/shared/ids";
+import type { RelayUploadPurpose, Sha256Digest } from "@tutti/shared/schemas/api";
+export type RelayHostControlFetch = (input: string | URL, init?: RequestInit) => Promise<Response>;
+export type RelayProjectProjection = {
+    relay_project_ref: RelayProjectRef;
+    display_name: string;
+    host_status: "online" | "offline" | "unknown";
+};
+export type HostConnectionProjection = {
+    host_connection_ref: HostConnectionRef;
+    relay_project_ref: RelayProjectRef;
+    status: "registered" | "online" | "replaced";
+    heartbeat_interval_ms: number;
+    tunnel_url: string;
+    connected_at: string;
+};
+export type JoinTokenProjection = {
+    join_url?: string;
+    expires_at: string;
+    reusable: true;
+    state: "active" | "expired" | "revoked";
+    visibility: "visible_once" | "not_recoverable";
+};
+export type RegisterRelayHostConnectionPayload = {
+    project_identity: {
+        source: "git_config";
+        project_id: ProjectId;
+    };
+    host_auth: {
+        kind: "host_registration_secret_v1";
+        secret: string;
+    };
+    display_name: string;
+    host: {
+        server_version: string;
+        host_project_api_base_path: "/api/v1";
+        capabilities: {
+            sse: boolean;
+            provider_config_query: boolean;
+            browser_secret_write: false;
+            repo_viewer: boolean;
+        };
+    };
+    join_token?: {
+        mode: "reuse_active" | "rotate";
+        ttl_seconds?: number;
+    };
+};
+export type RegisterRelayHostConnectionResult = {
+    relay_project: RelayProjectProjection;
+    host_connection: HostConnectionProjection;
+    join_token: JoinTokenProjection;
+    host_connection_token: string;
+};
+export type RegisterRelayHostConnectionResponse = {
+    command_id: IdempotencyKey;
+    disposition: {
+        kind: "registered";
+    } | {
+        kind: "interrupted";
+        retry_with_new_command_id: true;
+    };
+    result?: RegisterRelayHostConnectionResult;
+};
+export type RefreshRelayJoinTokenPayload = {
+    project_identity: {
+        source: "git_config";
+        project_id: ProjectId;
+    };
+    host_auth: {
+        kind: "host_registration_secret_v1";
+        secret: string;
+    };
+    relay_project_ref: RelayProjectRef;
+    host_connection_ref: HostConnectionRef;
+    join_token?: {
+        mode: "reuse_active" | "rotate";
+        ttl_seconds?: number;
+    };
+};
+export type RefreshRelayJoinTokenResponse = {
+    join_token: JoinTokenProjection;
+};
+export type ArchiveRelayProjectResponse = {
+    command_id: IdempotencyKey;
+    disposition: {
+        kind: "archived";
+    } | {
+        kind: "already_archived";
+    } | {
+        kind: "interrupted";
+        retry_with_new_command_id: true;
+    };
+};
+export type RelayUploadProjection = {
+    upload_id: RelayUploadRef;
+    relay_project_ref: RelayProjectRef;
+    purpose: RelayUploadPurpose;
+    file_name: string;
+    size_bytes: number;
+    sha256: Sha256Digest;
+    media_type?: string;
+    expires_at: string;
+};
+export type RelayUploadSignedRequest = {
+    method: "GET" | "DELETE";
+    url: string;
+};
+export type ResolveRelayUploadResponse = {
+    upload: RelayUploadProjection;
+    get: RelayUploadSignedRequest & {
+        method: "GET";
+    };
+    delete: RelayUploadSignedRequest & {
+        method: "DELETE";
+    };
+};
+export type CompleteRelayUploadResponse = {
+    upload: RelayUploadProjection;
+};
+export type RegisterRelayHostConnectionOptions = {
+    relayUrl: string;
+    projectId: ProjectId;
+    hostRegistrationSecret: string;
+    displayName: string;
+    serverVersion: string;
+    commandId?: IdempotencyKey;
+    issuedAt?: Date;
+    joinToken?: {
+        mode: "reuse_active" | "rotate";
+        ttlSeconds?: number;
+    };
+    capabilities?: Partial<RegisterRelayHostConnectionPayload["host"]["capabilities"]>;
+    fetch?: RelayHostControlFetch;
+    timeoutMs?: number;
+    signal?: AbortSignal;
+};
+export type RefreshRelayJoinTokenOptions = {
+    relayUrl: string;
+    projectId: ProjectId;
+    relayProjectRef: RelayProjectRef;
+    hostConnectionRef: HostConnectionRef;
+    hostRegistrationSecret: string;
+    joinToken?: {
+        mode: "reuse_active" | "rotate";
+        ttlSeconds?: number;
+    };
+    fetch?: RelayHostControlFetch;
+    timeoutMs?: number;
+};
+export type ArchiveRelayProjectOptions = {
+    relayUrl: string;
+    projectId: ProjectId;
+    relayProjectRef: RelayProjectRef;
+    hostRegistrationSecret: string;
+    commandId?: IdempotencyKey;
+    issuedAt?: Date;
+    fetch?: RelayHostControlFetch;
+    timeoutMs?: number;
+};
+export type ResolveRelayUploadOptions = {
+    relayUrl: string;
+    projectId: ProjectId;
+    relayProjectRef: RelayProjectRef;
+    hostConnectionRef: HostConnectionRef;
+    hostRegistrationSecret: string;
+    uploadId: RelayUploadRef;
+    fetch?: RelayHostControlFetch;
+    timeoutMs?: number;
+};
+export type CompleteRelayUploadOptions = ResolveRelayUploadOptions & {
+    status: "completed" | "aborted";
+};
+export type RelayHostControlClientErrorCode = "relay_unavailable" | "relay_registration_failed";
+export declare class RelayHostControlClientError extends Error {
+    readonly code: RelayHostControlClientErrorCode;
+    readonly retryable: boolean;
+    readonly statusCode?: number | undefined;
+    readonly relayErrorCode?: string | undefined;
+    constructor(code: RelayHostControlClientErrorCode, message: string, retryable: boolean, statusCode?: number | undefined, relayErrorCode?: string | undefined);
+}
+export declare function registerRelayHostConnection(options: RegisterRelayHostConnectionOptions): Promise<RegisterRelayHostConnectionResponse>;
+export declare function refreshRelayJoinToken(options: RefreshRelayJoinTokenOptions): Promise<RefreshRelayJoinTokenResponse>;
+export declare function archiveRelayProject(options: ArchiveRelayProjectOptions): Promise<ArchiveRelayProjectResponse>;
+export declare function resolveRelayUpload(options: ResolveRelayUploadOptions): Promise<ResolveRelayUploadResponse>;
+export declare function completeRelayUpload(options: CompleteRelayUploadOptions): Promise<CompleteRelayUploadResponse>;
+//# sourceMappingURL=host-control.d.ts.map

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

@@ -0,0 +1,351 @@
+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 archiveProjectUrl(relayUrl) {
+    return new URL("/host-control/v1/projects/archive", 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 createArchiveRelayProjectPayload(options) {
+    return {
+        project_identity: {
+            source: "git_config",
+            project_id: options.projectId,
+        },
+        relay_project_ref: options.relayProjectRef,
+        host_auth: {
+            kind: "host_registration_secret_v1",
+            secret: options.hostRegistrationSecret,
+        },
+    };
+}
+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, externalSignal) {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => {
+        controller.abort();
+    }, timeoutMs);
+    try {
+        return await fetchImpl(url, {
+            ...init,
+            signal: externalSignal === undefined
+                ? controller.signal
+                : AbortSignal.any([controller.signal, externalSignal]),
+        });
+    }
+    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 assertArchiveRelayProjectResponse(value) {
+    if (!isRecord(value) ||
+        stringField(value, "command_id") === undefined ||
+        !isRecord(value.disposition)) {
+        throw new RelayHostControlClientError("relay_registration_failed", "Relay project archive response is invalid", false);
+    }
+    const kind = stringField(value.disposition, "kind");
+    if (kind !== "archived" && kind !== "already_archived" && kind !== "interrupted") {
+        throw new RelayHostControlClientError("relay_registration_failed", "Relay project archive disposition is invalid", false);
+    }
+    if (kind === "interrupted" && value.disposition.retry_with_new_command_id !== true) {
+        throw new RelayHostControlClientError("relay_registration_failed", "Relay project archive disposition 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, options.signal);
+        }
+        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 archiveRelayProject(options) {
+    const fetchImpl = options.fetch ?? fetch;
+    const commandId = options.commandId ?? createIdempotencyKey();
+    const issuedAt = options.issuedAt ?? new Date();
+    let response;
+    try {
+        response = await fetchWithTimeout(fetchImpl, archiveProjectUrl(options.relayUrl), {
+            method: "POST",
+            headers: {
+                accept: "application/json",
+                "content-type": "application/json",
+            },
+            body: JSON.stringify({
+                command_id: commandId,
+                issued_at: issuedAt.toISOString(),
+                payload: createArchiveRelayProjectPayload(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 project archive failed with HTTP ${response.status}`, response.status >= 500, response.status, relayErrorCode);
+    }
+    return assertArchiveRelayProjectResponse(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