@neta-art/cohub 1.0.0

package/dist/apis/spaces.js

@@ -0,0 +1,373 @@
+import { ensureRealtimeConnected } from "../realtime.js";
+const DEFAULT_DEDUP_WINDOW_MS = 2000;
+const toSessionEventName = (type) => {
+    switch (type) {
+        case "session.turn.progress":
+            return "turn.progress";
+        case "session.turn.final":
+            return "turn.final";
+        case "session.turn.error":
+            return "turn.error";
+        case "session.message.persisted":
+            return "message.persisted";
+        default:
+            return null;
+    }
+};
+export class SpacesApi {
+    transport;
+    constructor(transport) {
+        this.transport = transport;
+    }
+    list(customFetch) {
+        return this.transport.request("/api/spaces", {
+            method: "GET",
+            fetch: customFetch,
+        });
+    }
+    get(spaceId, customFetch) {
+        return this.transport.request(`/api/spaces/${spaceId}`, {
+            fetch: customFetch,
+        });
+    }
+    create(input, headers) {
+        return this.transport.request("/api/spaces", {
+            method: "POST",
+            headers: {
+                ...headers,
+                "Content-Type": "application/json",
+            },
+            body: JSON.stringify(input ?? {}),
+        });
+    }
+}
+export class SpaceFilesApi {
+    transport;
+    spaceId;
+    constructor(transport, spaceId) {
+        this.transport = transport;
+        this.spaceId = spaceId;
+    }
+    list(path = "", customFetch) {
+        const params = new URLSearchParams();
+        if (path)
+            params.set("path", path);
+        const query = params.toString();
+        return this.transport.request(`/api/spaces/${this.spaceId}/fs/tree${query ? `?${query}` : ""}`, { fetch: customFetch });
+    }
+    read(path, customFetch) {
+        const params = new URLSearchParams({ path });
+        return this.transport.request(`/api/spaces/${this.spaceId}/fs/file?${params.toString()}`, { fetch: customFetch });
+    }
+    getDownloadUrl(path) {
+        const params = new URLSearchParams({ path });
+        return `/api/spaces/${this.spaceId}/fs/download?${params.toString()}`;
+    }
+    write(input) {
+        return this.transport.request(`/api/spaces/${this.spaceId}/fs/file`, {
+            method: "PUT",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify(input),
+        });
+    }
+    createDir(path) {
+        return this.transport.request(`/api/spaces/${this.spaceId}/fs/dir`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ path }),
+        });
+    }
+    delete(path, recursive = false) {
+        const params = new URLSearchParams({ path });
+        if (recursive)
+            params.set("recursive", "true");
+        return this.transport.request(`/api/spaces/${this.spaceId}/fs/node?${params.toString()}`, { method: "DELETE" });
+    }
+    move(input) {
+        return this.transport.request(`/api/spaces/${this.spaceId}/fs/move`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify(input),
+        });
+    }
+}
+class SessionMessagesClient {
+    transport;
+    sessionId;
+    lastSentSignature = "";
+    lastSentSessionId = "";
+    lastSentAt = 0;
+    constructor(transport, sessionId) {
+        this.transport = transport;
+        this.sessionId = sessionId;
+    }
+    list(customFetch) {
+        return this.transport.request(`/api/sessions/${this.sessionId}/messages`, {
+            fetch: customFetch,
+        });
+    }
+    listPaginated(options, customFetch) {
+        const params = new URLSearchParams();
+        if (options?.cursor !== undefined)
+            params.set("cursor", String(options.cursor));
+        if (options?.limit !== undefined)
+            params.set("limit", String(options.limit));
+        if (options?.direction)
+            params.set("direction", options.direction);
+        const query = params.toString();
+        return this.transport.request(`/api/sessions/${this.sessionId}/messages${query ? `?${query}` : ""}`, {
+            fetch: customFetch,
+        });
+    }
+    async send(input) {
+        const signature = JSON.stringify({ sessionId: this.sessionId, input });
+        const now = Date.now();
+        if (this.sessionId === this.lastSentSessionId &&
+            signature === this.lastSentSignature &&
+            now - this.lastSentAt < DEFAULT_DEDUP_WINDOW_MS) {
+            throw new Error("Duplicate message ignored");
+        }
+        this.lastSentSessionId = this.sessionId;
+        this.lastSentSignature = signature;
+        this.lastSentAt = now;
+        return this.transport.request(`/api/sessions/${this.sessionId}/messages`, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+            },
+            body: JSON.stringify({
+                content: input.content,
+                model: input.model,
+                provider: input.provider,
+                clientMessageId: input.clientMessageId,
+            }),
+        });
+    }
+}
+class SessionRealtimeClient {
+    websocketClient;
+    spaceId;
+    sessionId;
+    constructor(websocketClient, spaceId, sessionId) {
+        this.websocketClient = websocketClient;
+        this.spaceId = spaceId;
+        this.sessionId = sessionId;
+    }
+    subscribe(handlers) {
+        if (!this.websocketClient) {
+            throw new Error("realtime transport is not configured for this client");
+        }
+        ensureRealtimeConnected(this.websocketClient);
+        const unsubscribe = this.websocketClient.on("event", (event) => {
+            if (event.spaceId !== this.spaceId || event.sessionId !== this.sessionId)
+                return;
+            handlers.event?.(event);
+            const eventName = toSessionEventName(event.type);
+            if (eventName === "turn.progress")
+                handlers.progress?.(event);
+            if (eventName === "turn.final")
+                handlers.final?.(event);
+            if (eventName === "turn.error")
+                handlers.error?.(event);
+            if (eventName === "message.persisted")
+                handlers.persisted?.(event);
+        });
+        return () => unsubscribe();
+    }
+    on(type, handler) {
+        return this.subscribe({
+            event: (event) => {
+                if (toSessionEventName(event.type) === type)
+                    handler(event);
+            },
+        });
+    }
+}
+export class SessionClient {
+    spaceId;
+    id;
+    transport;
+    messages;
+    realtime;
+    constructor(spaceId, id, transport, websocketClient) {
+        this.spaceId = spaceId;
+        this.id = id;
+        this.transport = transport;
+        this.messages = new SessionMessagesClient(transport, id);
+        this.realtime = new SessionRealtimeClient(websocketClient, spaceId, id);
+    }
+    get(customFetch) {
+        return this.transport.request(`/api/sessions/${this.id}`, {
+            fetch: customFetch,
+        });
+    }
+    subscribe(handlers) {
+        return this.realtime.subscribe(handlers);
+    }
+    on(type, handler) {
+        return this.realtime.on(type, handler);
+    }
+}
+export class SpaceSessionsApi {
+    transport;
+    spaceId;
+    websocketClient;
+    constructor(transport, spaceId, websocketClient) {
+        this.transport = transport;
+        this.spaceId = spaceId;
+        this.websocketClient = websocketClient;
+    }
+    create(input) {
+        return this.transport.request(`/api/spaces/${this.spaceId}/sessions`, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+            },
+            body: JSON.stringify(input ?? {}),
+        });
+    }
+    list(customFetch) {
+        return this.transport.request(`/api/spaces/${this.spaceId}/sessions`, {
+            fetch: customFetch,
+        });
+    }
+    byId(sessionId) {
+        return new SessionClient(this.spaceId, sessionId, this.transport, this.websocketClient);
+    }
+}
+export class SpaceEventsApi {
+    websocketClient;
+    spaceId;
+    constructor(websocketClient, spaceId) {
+        this.websocketClient = websocketClient;
+        this.spaceId = spaceId;
+    }
+    subscribe(handler) {
+        if (!this.websocketClient) {
+            throw new Error("realtime transport is not configured for this client");
+        }
+        ensureRealtimeConnected(this.websocketClient);
+        return this.websocketClient.on("event", (event) => {
+            if (event.spaceId !== this.spaceId)
+                return;
+            handler(event);
+        });
+    }
+    on(type, handler) {
+        return this.subscribe((event) => {
+            if (type === "event") {
+                handler(event);
+                return;
+            }
+            if (toSessionEventName(event.type) === type)
+                handler(event);
+        });
+    }
+}
+export class SpaceMembersApi {
+    transport;
+    spaceId;
+    constructor(transport, spaceId) {
+        this.transport = transport;
+        this.spaceId = spaceId;
+    }
+    list() {
+        return this.transport.request(`/api/spaces/${this.spaceId}/members`);
+    }
+    update(userId, role) {
+        return this.transport.request(`/api/spaces/${this.spaceId}/members`, {
+            method: "PUT",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ userId, role }),
+        });
+    }
+    remove(userId) {
+        return this.transport.request(`/api/spaces/${this.spaceId}/members`, {
+            method: "DELETE",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ userId }),
+        });
+    }
+}
+export class SpaceAccessApi {
+    transport;
+    spaceId;
+    constructor(transport, spaceId) {
+        this.transport = transport;
+        this.spaceId = spaceId;
+    }
+    get() {
+        return this.transport.request(`/api/spaces/${this.spaceId}/access`);
+    }
+    set(body) {
+        return this.transport.request(`/api/spaces/${this.spaceId}/access`, {
+            method: "PUT",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify(body),
+        });
+    }
+}
+export class SpaceCheckpointsApi {
+    transport;
+    spaceId;
+    constructor(transport, spaceId) {
+        this.transport = transport;
+        this.spaceId = spaceId;
+    }
+    create(description) {
+        return this.transport.request(`/api/spaces/${this.spaceId}/checkpoints`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ description: description ?? null }),
+        });
+    }
+    list() {
+        return this.transport.request(`/api/spaces/${this.spaceId}/checkpoints`);
+    }
+    get(checkpointId, customFetch) {
+        return this.transport.request(`/api/spaces/${this.spaceId}/checkpoints/${checkpointId}`, { fetch: customFetch });
+    }
+}
+export class SpaceClient {
+    id;
+    transport;
+    websocketClient;
+    files;
+    sessions;
+    members;
+    access;
+    checkpoints;
+    constructor(id, transport, websocketClient) {
+        this.id = id;
+        this.transport = transport;
+        this.websocketClient = websocketClient;
+        this.files = new SpaceFilesApi(transport, id);
+        this.sessions = new SpaceSessionsApi(transport, id, websocketClient);
+        this.members = new SpaceMembersApi(transport, id);
+        this.access = new SpaceAccessApi(transport, id);
+        this.checkpoints = new SpaceCheckpointsApi(transport, id);
+    }
+    get(customFetch) {
+        return this.transport.request(`/api/spaces/${this.id}`, {
+            fetch: customFetch,
+        });
+    }
+    rename(name) {
+        return this.transport.request(`/api/spaces/${this.id}`, {
+            method: "PATCH",
+            headers: {
+                "Content-Type": "application/json",
+            },
+            body: JSON.stringify({ name }),
+        });
+    }
+    session(sessionId) {
+        return new SessionClient(this.id, sessionId, this.transport, this.websocketClient);
+    }
+    subscribe(handler) {
+        return new SpaceEventsApi(this.websocketClient, this.id).subscribe(handler);
+    }
+    on(type, handler) {
+        return new SpaceEventsApi(this.websocketClient, this.id).on(type, handler);
+    }
+}

package/dist/apis/tasks.d.ts

@@ -0,0 +1,20 @@
+import type { HttpTransport } from "../transport.js";
+import type { CreateScheduledTaskInput, TaskRunRecord } from "../types.js";
+export declare class TasksApi {
+    private readonly transport;
+    constructor(transport: HttpTransport);
+    get(taskRunId: string): Promise<{
+        run: TaskRunRecord;
+    }>;
+    list(filters?: {
+        cronJobId?: string;
+        spaceId?: string;
+    }): Promise<{
+        runs: TaskRunRecord[];
+    }>;
+    createScheduled(data: CreateScheduledTaskInput): Promise<{
+        ok: true;
+        taskRunId: string;
+        scheduledAt: string;
+    }>;
+}

package/dist/apis/tasks.js

@@ -0,0 +1,25 @@
+export class TasksApi {
+    transport;
+    constructor(transport) {
+        this.transport = transport;
+    }
+    get(taskRunId) {
+        return this.transport.request(`/api/tasks/${taskRunId}`);
+    }
+    list(filters) {
+        const params = new URLSearchParams();
+        if (filters?.cronJobId)
+            params.set("cronJobId", filters.cronJobId);
+        if (filters?.spaceId)
+            params.set("spaceId", filters.spaceId);
+        const query = params.toString();
+        return this.transport.request(`/api/tasks${query ? `?${query}` : ""}`);
+    }
+    createScheduled(data) {
+        return this.transport.request("/api/tasks", {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify(data),
+        });
+    }
+}

package/dist/apis/user.d.ts

@@ -0,0 +1,20 @@
+import { type HttpTransport, type Fetch } from "../transport.js";
+import type { UserSshKey } from "../types.js";
+export declare class UserApi {
+    private readonly transport;
+    private readonly transportBaseUrl;
+    private readonly setStoredAuthToken?;
+    private readonly clearStoredAuthToken?;
+    constructor(transport: HttpTransport, transportBaseUrl: string, setStoredAuthToken?: ((token: string) => void) | undefined, clearStoredAuthToken?: (() => void) | undefined);
+    getMe(customFetch?: Fetch): Promise<unknown>;
+    setAuthToken(token: string): Promise<any>;
+    clearAuthToken(): Promise<null>;
+    getSshKeys(customFetch?: Fetch): Promise<UserSshKey[]>;
+    createSshKey(data: {
+        key: string;
+        title: string;
+    }): Promise<UserSshKey>;
+    deleteSshKey(id: string): Promise<{
+        ok: true;
+    }>;
+}

package/dist/apis/user.js

@@ -0,0 +1,58 @@
+import { HttpError } from "../transport.js";
+export class UserApi {
+    transport;
+    transportBaseUrl;
+    setStoredAuthToken;
+    clearStoredAuthToken;
+    constructor(transport, transportBaseUrl, setStoredAuthToken, clearStoredAuthToken) {
+        this.transport = transport;
+        this.transportBaseUrl = transportBaseUrl;
+        this.setStoredAuthToken = setStoredAuthToken;
+        this.clearStoredAuthToken = clearStoredAuthToken;
+    }
+    getMe(customFetch) {
+        return this.transport.request("/api/me", { fetch: customFetch });
+    }
+    async setAuthToken(token) {
+        const trimmedToken = token.trim();
+        const response = await fetch(this.transportBaseUrl ? `${this.transportBaseUrl}/api/me` : "/api/me", {
+            headers: {
+                Authorization: `Bearer ${trimmedToken}`,
+            },
+        });
+        if (!response.ok) {
+            const contentType = response.headers.get("content-type") ?? "";
+            const body = contentType.includes("application/json")
+                ? await response.json().catch(() => null)
+                : await response.text().catch(() => response.statusText);
+            const message = typeof body === "string" ? body : JSON.stringify(body ?? null);
+            throw new HttpError(message || response.statusText, response.status, body);
+        }
+        this.setStoredAuthToken?.(trimmedToken);
+        return response.json();
+    }
+    async clearAuthToken() {
+        this.clearStoredAuthToken?.();
+        return null;
+    }
+    getSshKeys(customFetch) {
+        return this.transport.request("/api/user/ssh-keys", {
+            method: "GET",
+            fetch: customFetch,
+        });
+    }
+    createSshKey(data) {
+        return this.transport.request("/api/user/ssh-keys", {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+            },
+            body: JSON.stringify(data),
+        });
+    }
+    deleteSshKey(id) {
+        return this.transport.request(`/api/user/ssh-keys/${id}`, {
+            method: "DELETE",
+        });
+    }
+}

package/dist/client.d.ts

@@ -0,0 +1,22 @@
+import { ChannelsApi } from "./apis/channels.js";
+import { CronJobsApi } from "./apis/cron-jobs.js";
+import { ModelsApi } from "./apis/models.js";
+import { SessionAccessApi } from "./apis/session-access.js";
+import { SpaceClient, SpacesApi } from "./apis/spaces.js";
+import { TasksApi } from "./apis/tasks.js";
+import { UserApi } from "./apis/user.js";
+import { type CohubClientOptions } from "./transport.js";
+export declare class CohubClient {
+    readonly spaces: SpacesApi;
+    readonly channels: ChannelsApi;
+    readonly user: UserApi;
+    readonly models: ModelsApi;
+    readonly sessionAccess: SessionAccessApi;
+    readonly tasks: TasksApi;
+    readonly cronJobs: CronJobsApi;
+    private readonly transport;
+    private readonly websocketClient;
+    constructor(options?: CohubClientOptions);
+    space(spaceId: string): SpaceClient;
+}
+export declare const createCohubClient: (options?: CohubClientOptions) => CohubClient;

package/dist/client.js

@@ -0,0 +1,38 @@
+import { ChannelsApi } from "./apis/channels.js";
+import { CronJobsApi } from "./apis/cron-jobs.js";
+import { ModelsApi } from "./apis/models.js";
+import { SessionAccessApi } from "./apis/session-access.js";
+import { SpaceClient, SpacesApi } from "./apis/spaces.js";
+import { TasksApi } from "./apis/tasks.js";
+import { UserApi } from "./apis/user.js";
+import { HttpTransport } from "./transport.js";
+import { createWebsocketClient } from "./websocket.js";
+export class CohubClient {
+    spaces;
+    channels;
+    user;
+    models;
+    sessionAccess;
+    tasks;
+    cronJobs;
+    transport;
+    websocketClient;
+    constructor(options = {}) {
+        this.transport = new HttpTransport(options);
+        this.websocketClient = createWebsocketClient({
+            ...options.websocket,
+            getAccessToken: options.getAccessToken,
+        });
+        this.spaces = new SpacesApi(this.transport);
+        this.channels = new ChannelsApi(this.transport);
+        this.user = new UserApi(this.transport, options.baseUrl ?? "", options.setStoredAuthToken, options.clearStoredAuthToken);
+        this.models = new ModelsApi(options.fetch ?? fetch, options.baseUrl ?? "");
+        this.sessionAccess = new SessionAccessApi(this.transport);
+        this.tasks = new TasksApi(this.transport);
+        this.cronJobs = new CronJobsApi(this.transport);
+    }
+    space(spaceId) {
+        return new SpaceClient(spaceId, this.transport, this.websocketClient);
+    }
+}
+export const createCohubClient = (options) => new CohubClient(options);

package/dist/http.d.ts

@@ -0,0 +1,24 @@
+import { ChannelsApi } from "./apis/channels.js";
+import { CronJobsApi } from "./apis/cron-jobs.js";
+import { ModelsApi } from "./apis/models.js";
+import { SessionAccessApi } from "./apis/session-access.js";
+import { SpaceClient, SpacesApi } from "./apis/spaces.js";
+import { TasksApi } from "./apis/tasks.js";
+import { UserApi } from "./apis/user.js";
+import { HttpTransport, HttpError, type CohubClientOptions, type Fetch } from "./transport.js";
+export declare class CohubHttpClient {
+    readonly spaces: SpacesApi;
+    readonly channels: ChannelsApi;
+    readonly user: UserApi;
+    readonly models: ModelsApi;
+    readonly sessionAccess: SessionAccessApi;
+    readonly tasks: TasksApi;
+    readonly cronJobs: CronJobsApi;
+    private readonly transport;
+    constructor(options?: CohubClientOptions);
+    space(spaceId: string): SpaceClient;
+}
+export declare const createHttpClient: (options?: CohubClientOptions) => CohubHttpClient;
+export { HttpTransport, HttpError };
+export type { CohubClientOptions, Fetch };
+export * from "./types.js";

package/dist/http.js

@@ -0,0 +1,34 @@
+import { ChannelsApi } from "./apis/channels.js";
+import { CronJobsApi } from "./apis/cron-jobs.js";
+import { ModelsApi } from "./apis/models.js";
+import { SessionAccessApi } from "./apis/session-access.js";
+import { SpaceClient, SpacesApi } from "./apis/spaces.js";
+import { TasksApi } from "./apis/tasks.js";
+import { UserApi } from "./apis/user.js";
+import { HttpTransport, HttpError } from "./transport.js";
+export class CohubHttpClient {
+    spaces;
+    channels;
+    user;
+    models;
+    sessionAccess;
+    tasks;
+    cronJobs;
+    transport;
+    constructor(options = {}) {
+        this.transport = new HttpTransport(options);
+        this.spaces = new SpacesApi(this.transport);
+        this.channels = new ChannelsApi(this.transport);
+        this.user = new UserApi(this.transport, options.baseUrl ?? "", options.setStoredAuthToken, options.clearStoredAuthToken);
+        this.models = new ModelsApi(options.fetch ?? fetch, options.baseUrl ?? "");
+        this.sessionAccess = new SessionAccessApi(this.transport);
+        this.tasks = new TasksApi(this.transport);
+        this.cronJobs = new CronJobsApi(this.transport);
+    }
+    space(spaceId) {
+        return new SpaceClient(spaceId, this.transport, null);
+    }
+}
+export const createHttpClient = (options) => new CohubHttpClient(options);
+export { HttpTransport, HttpError };
+export * from "./types.js";

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+export { CohubHttpClient, createHttpClient } from "./http.js";
+export { CohubClient, createCohubClient } from "./client.js";
+export { WebsocketClient, createWebsocketClient } from "./websocket.js";
+export { HttpError } from "./transport.js";
+export type { CohubClientOptions, Fetch } from "./transport.js";
+export * from "./types.js";
+export type { SessionEventName, SessionSubscriptionHandlers, SpaceEventName } from "./apis/spaces.js";

package/dist/index.js

@@ -0,0 +1,5 @@
+export { CohubHttpClient, createHttpClient } from "./http.js";
+export { CohubClient, createCohubClient } from "./client.js";
+export { WebsocketClient, createWebsocketClient } from "./websocket.js";
+export { HttpError } from "./transport.js";
+export * from "./types.js";

package/dist/realtime.d.ts

@@ -0,0 +1,2 @@
+import type { WebsocketClient } from "./websocket.js";
+export declare function ensureRealtimeConnected(websocketClient: WebsocketClient): void;

package/dist/realtime.js

@@ -0,0 +1,5 @@
+export function ensureRealtimeConnected(websocketClient) {
+    void websocketClient.connect().catch((error) => {
+        console.error("[CohubClient] Failed to connect realtime websocket:", error);
+    });
+}

package/dist/transport.d.ts

@@ -0,0 +1,27 @@
+import type { WebsocketClientOptions } from "./websocket.js";
+export type Fetch = typeof globalThis.fetch;
+export type CohubClientOptions = {
+    baseUrl?: string;
+    getAccessToken?: () => Promise<string | null> | string | null;
+    onUnauthorized?: () => Promise<void> | void;
+    setStoredAuthToken?: (token: string) => void;
+    clearStoredAuthToken?: () => void;
+    fetch?: Fetch;
+    websocket?: WebsocketClientOptions;
+};
+export declare class HttpError extends Error {
+    readonly status: number;
+    readonly body: unknown;
+    constructor(message: string, status: number, body: unknown);
+}
+export declare class HttpTransport {
+    private readonly baseUrl;
+    private readonly fetcher;
+    private readonly getAccessToken?;
+    private readonly onUnauthorized?;
+    constructor(options?: CohubClientOptions);
+    private withAuthorization;
+    request<T>(path: string, init?: RequestInit & {
+        fetch?: Fetch;
+    }): Promise<T>;
+}