@termfleet/core 0.1.0

package/dist/provider-url-resolver.js

@@ -0,0 +1,37 @@
+import { normalizeProviderOrigin } from "./contracts/provider-url.js";
+export const providerProxyPathPrefix = "/providers/";
+export function providerProxyKey(providerBaseUrl) {
+    return encodeURIComponent(normalizeProviderOrigin(providerBaseUrl));
+}
+export function providerProxyPath(providerBaseUrl) {
+    return `${providerProxyPathPrefix}${providerProxyKey(providerBaseUrl)}`;
+}
+export const directProviderUrlResolver = {
+    httpBase: (providerBaseUrl) => normalizeProviderOrigin(providerBaseUrl),
+    socketTarget: (providerBaseUrl) => ({
+        origin: normalizeProviderOrigin(providerBaseUrl),
+        path: "/control/socket.io"
+    }),
+    wsAuthQuery: () => ({}),
+    wsBase: (providerBaseUrl) => toWebSocketOrigin(normalizeProviderOrigin(providerBaseUrl))
+};
+export function consoleProxyProviderUrlResolver(consoleOrigin, options = {}) {
+    const origin = new URL(consoleOrigin).origin;
+    return {
+        httpBase: (providerBaseUrl) => `${origin}${providerProxyPath(providerBaseUrl)}`,
+        socketTarget: (providerBaseUrl) => ({
+            origin,
+            path: `${providerProxyPath(providerBaseUrl)}/control/socket.io`
+        }),
+        wsAuthQuery: () => {
+            const token = options.sessionToken?.();
+            return token ? { termfleet_session: token } : {};
+        },
+        wsBase: (providerBaseUrl) => `${toWebSocketOrigin(origin)}${providerProxyPath(providerBaseUrl)}`
+    };
+}
+function toWebSocketOrigin(httpOrigin) {
+    const url = new URL(httpOrigin);
+    url.protocol = url.protocol === "https:" ? "wss:" : "ws:";
+    return url.origin;
+}

package/dist/registry-client.d.ts

@@ -0,0 +1,93 @@
+import type { AuthOrganizationId, AuthSessionResource, AuthSignInResponse } from "./contracts/auth.js";
+import type { TerminalThemeProfile } from "./types.js";
+import { type CanvasComment, type CanvasPoint } from "./contracts/canvas.js";
+import { type ConsoleLayout } from "./contracts/console-layout.js";
+import { type RegistryProviderRecord } from "./contracts/registry.js";
+export type RegistryClientOptions = {
+    baseUrl: string;
+};
+export type ProviderAccessTokenResource = {
+    expireAt: number;
+    object: "provider_access_token";
+    providerBaseUrl: string;
+    token: string;
+};
+export declare class RegistryClient {
+    private readonly baseUrl;
+    constructor({ baseUrl }: RegistryClientOptions);
+    providers(options?: {
+        authToken?: string;
+    }): Promise<RegistryProviderRecord[]>;
+    registerLocalProvider(provider: RegistryProviderRecord): Promise<RegistryProviderRecord>;
+    unregisterLocalProvider(baseUrl: string): Promise<RegistryProviderRecord>;
+    registerSharedProvider(provider: RegistryProviderRecord, options?: {
+        authToken?: string;
+    }): Promise<RegistryProviderRecord>;
+    unregisterSharedProvider(baseUrl: string, options?: {
+        authToken?: string;
+    }): Promise<RegistryProviderRecord>;
+    providerAccessToken(baseUrl: string, options?: {
+        authToken?: string;
+    }): Promise<ProviderAccessTokenResource>;
+    startDockerWorker(options?: Partial<RegistryProviderRecord> & {
+        terminalThemeProfile?: TerminalThemeProfile;
+    }): Promise<RegistryProviderRecord>;
+    startLocalProvider(options: {
+        kind: "iterm" | "virtual-tmux" | "wezterm";
+        label?: string;
+    }): Promise<RegistryProviderRecord>;
+    signIn(identifier: string, password: string): Promise<AuthSignInResponse>;
+    session(authToken?: string): Promise<AuthSessionResource>;
+    signOut(authToken?: string): Promise<unknown>;
+    switchOrganization(organizationId: AuthOrganizationId, options?: {
+        authToken?: string;
+    }): Promise<AuthSessionResource>;
+    consoleLayout(options?: {
+        authToken?: string;
+    }): Promise<ConsoleLayout>;
+    saveConsoleLayoutPatch(patch: ConsoleLayout, options?: {
+        authToken?: string;
+    }): Promise<ConsoleLayout>;
+    orgCanvasLayout(options: {
+        authToken?: string;
+        canvasId: string;
+        organizationId: AuthOrganizationId;
+    }): Promise<ConsoleLayout>;
+    saveOrgCanvasLayoutPatch(patch: ConsoleLayout, options: {
+        authToken?: string;
+        canvasId: string;
+        organizationId: AuthOrganizationId;
+    }): Promise<ConsoleLayout>;
+    canvasComments(options: {
+        authToken?: string;
+        canvasId: string;
+        organizationId: AuthOrganizationId;
+    }): Promise<CanvasComment[]>;
+    createCanvasComment(options: {
+        authToken?: string;
+        body: string;
+        canvasId: string;
+        organizationId: AuthOrganizationId;
+        position: CanvasPoint;
+    }): Promise<CanvasComment>;
+    createCanvasCommentReply(options: {
+        authToken?: string;
+        body: string;
+        canvasId: string;
+        commentId: string;
+        organizationId: AuthOrganizationId;
+    }): Promise<CanvasComment>;
+    updateCanvasCommentResolution(options: {
+        authToken?: string;
+        canvasId: string;
+        commentId: string;
+        organizationId: AuthOrganizationId;
+        resolved: boolean;
+    }): Promise<CanvasComment>;
+    private orgCanvasPath;
+    private writeJson;
+    private requestJson;
+    private request;
+    private url;
+}
+export declare function registryClientForOrigin(baseUrl: string): RegistryClient;

package/dist/registry-client.js

@@ -0,0 +1,170 @@
+import { asError } from "@termfleet/core/lib/errors.js";
+import { parseCanvasComment, parseCanvasCommentsList } from "./contracts/canvas.js";
+import { parseConsoleLayout } from "./contracts/console-layout.js";
+import { normalizeRegistryPayload } from "./contracts/registry.js";
+export class RegistryClient {
+    baseUrl;
+    constructor({ baseUrl }) {
+        this.baseUrl = normalizeBaseUrl(baseUrl);
+    }
+    async providers(options = {}) {
+        const response = await this.request("/api/registry/providers", {
+            headers: bearerHeaders(options.authToken)
+        });
+        return normalizeRegistryPayload(await readRegistryJson(response));
+    }
+    async registerLocalProvider(provider) {
+        return normalizeRegistryRecord(await this.writeJson("POST", "/api/registry/local-providers", provider));
+    }
+    async unregisterLocalProvider(baseUrl) {
+        const url = this.url("/api/registry/local-providers");
+        url.searchParams.set("baseUrl", baseUrl);
+        return normalizeRegistryRecord(await this.requestJson(url, { method: "DELETE" }));
+    }
+    async registerSharedProvider(provider, options = {}) {
+        return normalizeRegistryRecord(await this.writeJson("POST", "/api/registry/remote-providers", provider, bearerHeaders(options.authToken)));
+    }
+    async unregisterSharedProvider(baseUrl, options = {}) {
+        const url = this.url("/api/registry/remote-providers");
+        url.searchParams.set("baseUrl", baseUrl);
+        return normalizeRegistryRecord(await this.requestJson(url, {
+            headers: bearerHeaders(options.authToken),
+            method: "DELETE"
+        }));
+    }
+    async providerAccessToken(baseUrl, options = {}) {
+        return await this.writeJson("POST", "/api/registry/provider-tokens", { baseUrl }, bearerHeaders(options.authToken));
+    }
+    async startDockerWorker(options = {}) {
+        return normalizeRegistryRecord(await this.writeJson("POST", "/api/docker-worker/start", options));
+    }
+    async startLocalProvider(options) {
+        return normalizeRegistryRecord(await this.writeJson("POST", "/api/local-provider/start", options));
+    }
+    async signIn(identifier, password) {
+        return await this.writeJson("POST", "/api/auth/sign-in", { identifier, password });
+    }
+    async session(authToken) {
+        return await this.requestJson("/api/auth/session", {
+            headers: bearerHeaders(authToken)
+        });
+    }
+    async signOut(authToken) {
+        return await this.writeJson("POST", "/api/auth/sign-out", undefined, bearerHeaders(authToken));
+    }
+    async switchOrganization(organizationId, options = {}) {
+        return await this.writeJson("POST", "/api/auth/active-organization", { organizationId }, bearerHeaders(options.authToken));
+    }
+    async consoleLayout(options = {}) {
+        return parseConsoleLayout(await this.requestJson("/api/console-layout", {
+            headers: bearerHeaders(options.authToken)
+        }));
+    }
+    async saveConsoleLayoutPatch(patch, options = {}) {
+        return parseConsoleLayout(await this.writeJson("PATCH", "/api/console-layout", patch, bearerHeaders(options.authToken)));
+    }
+    async orgCanvasLayout(options) {
+        return parseConsoleLayout(await this.requestJson(this.orgCanvasPath(options.organizationId, options.canvasId, "layout"), {
+            headers: bearerHeaders(options.authToken)
+        }));
+    }
+    async saveOrgCanvasLayoutPatch(patch, options) {
+        return parseConsoleLayout(await this.writeJson("PATCH", this.orgCanvasPath(options.organizationId, options.canvasId, "layout"), patch, bearerHeaders(options.authToken)));
+    }
+    async canvasComments(options) {
+        return parseCanvasCommentsList(await this.requestJson(this.orgCanvasPath(options.organizationId, options.canvasId, "comments"), {
+            headers: bearerHeaders(options.authToken)
+        }));
+    }
+    async createCanvasComment(options) {
+        return parseCanvasComment(await this.writeJson("POST", this.orgCanvasPath(options.organizationId, options.canvasId, "comments"), {
+            body: options.body,
+            coordinateSpace: "canvas",
+            position: options.position
+        }, bearerHeaders(options.authToken)));
+    }
+    async createCanvasCommentReply(options) {
+        return parseCanvasComment(await this.writeJson("POST", `${this.orgCanvasPath(options.organizationId, options.canvasId, "comments")}/${encodeURIComponent(options.commentId)}/replies`, {
+            body: options.body
+        }, bearerHeaders(options.authToken)));
+    }
+    async updateCanvasCommentResolution(options) {
+        return parseCanvasComment(await this.writeJson("PATCH", `${this.orgCanvasPath(options.organizationId, options.canvasId, "comments")}/${encodeURIComponent(options.commentId)}`, {
+            resolved: options.resolved
+        }, bearerHeaders(options.authToken)));
+    }
+    orgCanvasPath(organizationId, canvasId, suffix) {
+        return `/api/registry/orgs/${encodeURIComponent(organizationId)}/canvases/${encodeURIComponent(canvasId)}/${suffix}`;
+    }
+    async writeJson(method, path, body, headers = {}) {
+        return await this.requestJson(path, {
+            body: body === undefined ? undefined : JSON.stringify(body),
+            headers: {
+                ...headers,
+                ...(body === undefined ? {} : { "content-type": "application/json" })
+            },
+            method
+        });
+    }
+    async requestJson(input, init) {
+        const response = await this.request(input, init);
+        return await readRegistryJson(response);
+    }
+    async request(input, init) {
+        const response = await fetch(input instanceof URL ? input : this.url(input), {
+            ...init,
+            credentials: init?.credentials ?? "include"
+        });
+        if (!response.ok) {
+            throw new Error(await readRegistryErrorMessage(response));
+        }
+        return response;
+    }
+    url(path) {
+        return new URL(path, this.baseUrl);
+    }
+}
+export function registryClientForOrigin(baseUrl) {
+    return new RegistryClient({ baseUrl });
+}
+function bearerHeaders(authToken) {
+    return authToken ? { authorization: `Bearer ${authToken}` } : {};
+}
+function normalizeRegistryRecord(value) {
+    const [record] = normalizeRegistryPayload([value]);
+    if (!record) {
+        throw new Error("Registry did not return the registered provider.");
+    }
+    return record;
+}
+function normalizeBaseUrl(baseUrl) {
+    return baseUrl.endsWith("/") ? baseUrl : `${baseUrl}/`;
+}
+// Registry error responses are JSON like {"error":"..."} — surface the inner
+// message rather than the raw body, so the UI never shows literal JSON.
+async function readRegistryErrorMessage(response) {
+    const body = await response.text();
+    try {
+        const parsed = JSON.parse(body);
+        const message = typeof parsed.error === "string" ? parsed.error
+            : typeof parsed.message === "string" ? parsed.message
+                : undefined;
+        if (message)
+            return message;
+    }
+    catch {
+        // Not JSON — fall through to the raw text.
+    }
+    return body || `Registry request failed (${response.status}).`;
+}
+async function readRegistryJson(response) {
+    const body = await response.text();
+    try {
+        return JSON.parse(body);
+    }
+    catch (error) {
+        const contentType = response.headers.get("content-type") ?? "unknown content-type";
+        const preview = body.replace(/\s+/g, " ").slice(0, 120);
+        throw new Error(`Registry returned non-JSON from ${response.url} (${response.status}, ${contentType}): ${preview || asError(error).message}`);
+    }
+}

package/dist/registry.d.ts

@@ -0,0 +1,56 @@
+import { type RegistryProviderRecord, type RegistryProviderSource } from "./contracts/registry.js";
+export type ProviderRegistryOptions = {
+    localRegistryFile: string;
+    remoteRegistryUrl?: string;
+    remoteRegistryUrls?: string[];
+    remoteCacheTtlMs?: number;
+    onRemoteReadError?: (message: string) => void;
+};
+export declare class ProviderRegistry {
+    private readonly localRegistryFile;
+    private readonly remoteRegistryUrls;
+    private readonly remoteCacheTtlMs;
+    private readonly onRemoteReadError?;
+    private remoteRegistryCache;
+    private remoteRegistryRead?;
+    private readonly remoteTokenCache;
+    private readonly remoteTokenRead;
+    private lastRegistryReadFailure;
+    private localWriteChain;
+    constructor(options: ProviderRegistryOptions);
+    list(options?: {
+        authToken?: string;
+        runtimeProviders?: RegistryProviderRecord[];
+    }): Promise<RegistryProviderRecord[]>;
+    listRemoteWithToken(authToken: string | undefined): Promise<RegistryProviderRecord[]>;
+    resolveProvider(target: string, options?: {
+        authToken?: string;
+        runtimeProviders?: RegistryProviderRecord[];
+    }): Promise<RegistryProviderRecord>;
+    register(provider: RegistryProviderRecord): Promise<RegistryProviderRecord>;
+    registerLocal(provider: RegistryProviderRecord): Promise<RegistryProviderRecord>;
+    registerRemote(provider: RegistryProviderRecord, options?: {
+        authToken?: string;
+    }): Promise<RegistryProviderRecord>;
+    removeRemote(baseUrl: string, options?: {
+        authToken?: string;
+    }): Promise<RegistryProviderRecord>;
+    removeLocal(baseUrl: string): Promise<RegistryProviderRecord>;
+    readLocal(): Promise<RegistryProviderRecord[]>;
+    writeLocal(provider: RegistryProviderRecord): Promise<RegistryProviderRecord>;
+    stampInstanceId(baseUrl: string, instanceId: string): Promise<{
+        conflictWith?: string;
+        stamped: boolean;
+    }>;
+    private withLocalLock;
+    private writeLocalFile;
+    private readRemote;
+    private readRemoteForList;
+    private assertRemoteConfigured;
+    private fetchRemote;
+    private writeRemote;
+    private deleteRemote;
+}
+export declare function decorateRegistryProviders(providers: RegistryProviderRecord[], registrySource: RegistryProviderSource): RegistryProviderRecord[];
+export declare function providerId(provider: RegistryProviderRecord): string;
+export declare function normalizeProviderTarget(target: string): string;