@neta-art/cohub 1.0.0

package/dist/transport.js

@@ -0,0 +1,57 @@
+export class HttpError extends Error {
+    status;
+    body;
+    constructor(message, status, body) {
+        super(message);
+        this.name = "HttpError";
+        this.status = status;
+        this.body = body;
+    }
+}
+export class HttpTransport {
+    baseUrl;
+    fetcher;
+    getAccessToken;
+    onUnauthorized;
+    constructor(options = {}) {
+        this.baseUrl = options.baseUrl ?? "";
+        this.fetcher = options.fetch ?? fetch;
+        this.getAccessToken = options.getAccessToken;
+        this.onUnauthorized = options.onUnauthorized;
+    }
+    async withAuthorization(init) {
+        const headers = new Headers(init?.headers);
+        const token = this.getAccessToken ? await this.getAccessToken() : null;
+        if (token) {
+            headers.set("Authorization", `Bearer ${token}`);
+        }
+        else {
+            headers.delete("Authorization");
+        }
+        return {
+            ...init,
+            headers,
+        };
+    }
+    async request(path, init) {
+        const fetcher = init?.fetch ?? this.fetcher;
+        const url = this.baseUrl ? `${this.baseUrl}${path}` : path;
+        const response = await fetcher(url, await this.withAuthorization(init));
+        if (response.status === 401) {
+            await this.onUnauthorized?.();
+            throw new HttpError("unauthorized", 401, null);
+        }
+        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);
+        }
+        if (response.status === 204) {
+            return null;
+        }
+        return response.json();
+    }
+}

package/dist/types.d.ts

@@ -0,0 +1,211 @@
+import type { SessionBindingRecord as ProtocolSessionBindingRecord, SessionRecord as ProtocolSessionRecord } from "@neta-art/cohub-protocol/model";
+import type { ChannelConfig } from "@neta-art/cohub-protocol/gateway";
+import type { ContentBlock } from "@neta-art/cohub-protocol/core";
+import type { MessageRecord } from "@neta-art/cohub-protocol/model";
+export type { ChannelConfig, DiscordChannelConfig, } from "@neta-art/cohub-protocol/gateway";
+export type ApiError = {
+    message: string;
+};
+export type { ContentBlock, MessageRecord };
+export type SpaceFsEntry = {
+    name: string;
+    path: string;
+    type: "file" | "dir" | "symlink";
+    size: number;
+    mimeType: string | null;
+    mtimeMs: number;
+};
+export type SpaceFsTreeResponse = {
+    path: string;
+    entries: SpaceFsEntry[];
+};
+export type SpaceFsFileKind = "text" | "binary";
+export type SpaceFsEncoding = "utf-8" | "base64";
+export type SpaceFsFileResponse = {
+    path: string;
+    name: string;
+    size: number;
+    mimeType: string | null;
+    mtimeMs: number;
+    kind: SpaceFsFileKind;
+    encoding: SpaceFsEncoding;
+    content: string;
+};
+export type SpaceFsWriteFileInput = {
+    path: string;
+    content: string;
+    encoding: SpaceFsEncoding;
+};
+export type SpaceFsMoveInput = {
+    fromPath: string;
+    toPath: string;
+};
+export type SessionBindingRecord = ProtocolSessionBindingRecord;
+export type SessionRecord = ProtocolSessionRecord & {
+    bindings?: SessionBindingRecord[];
+    totalMessages?: number;
+    totalToolCalls?: number;
+    totalInputTokens?: number;
+    totalOutputTokens?: number;
+    totalCost?: string | number | null;
+};
+export type SpaceRecord = {
+    id: string;
+    userUuid: string;
+    name: string | null;
+    description: string | null;
+    storageRepoName?: string | null;
+    baseCheckpointId?: string | null;
+    headCheckpointId?: string | null;
+    title: string | null;
+    status: string | null;
+    meta: Record<string, unknown> | null;
+    createdAt: string;
+    updatedAt: string;
+    channels?: {
+        id: string;
+        name: string | null;
+        provider: string;
+        status: string;
+    }[];
+    accessLevel?: "minimal";
+};
+export type SpaceBootstrapSource = {
+    type: "blank";
+} | {
+    type: "git_repo";
+    repoUrl?: string;
+    ref?: string | null;
+} | {
+    type: "checkpoint";
+    checkpointId: string;
+};
+export type SpaceCreateResponse = {
+    space: SpaceRecord;
+    taskRunId: string;
+};
+export type SpaceListItem = SpaceRecord;
+export type SessionMessagesResponse = {
+    space: SpaceRecord;
+    session: SessionRecord;
+    messages: MessageRecord[];
+};
+export type SessionMessagesPaginatedResponse = {
+    space: SpaceRecord;
+    session: SessionRecord;
+    messages: MessageRecord[];
+    hasMore: boolean;
+    nextCursor: number | undefined;
+};
+export type ModelCatalogEntry = {
+    provider: string;
+    id: string;
+    model: Record<string, unknown>;
+};
+export type Channel = {
+    id: string;
+    userUuid: string;
+    provider: string;
+    name: string;
+    status: string;
+    createdAt: string;
+    updatedAt: string;
+    boundSpace: {
+        id: string;
+        title: string | null;
+        status: string;
+    } | null;
+};
+export type SpaceEnvInput = {
+    name: string;
+    value: string;
+};
+export type SpaceChannelBindingInput = {
+    channelId: string;
+    config?: ChannelConfig | null;
+};
+export type SpaceSessionsResponse = {
+    space: SpaceRecord;
+    sessions: SessionRecord[];
+};
+export type UserSshKey = {
+    id: string;
+    key: string;
+    title: string;
+    giteaKeyId: number;
+    createdAt: string;
+};
+export type CronJobRecord = {
+    id: string;
+    userUuid: string;
+    title: string;
+    taskType: string;
+    payload: Record<string, unknown>;
+    cronExpression: string;
+    timezone: string;
+    bullJobKey: string;
+    spaceId: string | null;
+    sessionId: string | null;
+    enabled: boolean;
+    createdAt: string;
+    updatedAt: string;
+};
+export type TaskRunRecord = {
+    id: string;
+    jobId: string;
+    cronJobId: string | null;
+    taskType: string;
+    status: "pending" | "running" | "completed" | "failed";
+    payload: unknown;
+    result: unknown;
+    errorMessage: string | null;
+    attemptCount: number;
+    spaceId: string | null;
+    sessionId: string | null;
+    userUuid: string | null;
+    scheduledAt: string | null;
+    startedAt: string | null;
+    finishedAt: string | null;
+    createdAt: string;
+    updatedAt: string;
+};
+export type CheckpointRecord = {
+    id: string;
+    spaceId: string;
+    commitHash: string;
+    description: string;
+    parentCheckpointId: string | null;
+    forkCount: number;
+    meta: Record<string, unknown> | null;
+    createdAt: string;
+};
+export type SpaceCheckpointDetailResponse = {
+    checkpoint: CheckpointRecord;
+};
+export type CreateCronJobInput = {
+    title: string;
+    taskType: string;
+    payload: Record<string, unknown>;
+    cronExpression: string;
+    timezone?: string;
+    spaceId?: string;
+    sessionId?: string;
+};
+export type CreateScheduledTaskInput = {
+    taskType: string;
+    payload: Record<string, unknown>;
+    scheduleAt: string;
+    spaceId?: string;
+    sessionId?: string;
+};
+export type SpaceRole = "host" | "maker" | "guest";
+export type SpaceMember = {
+    userId: string;
+    role: SpaceRole;
+    createdAt: string;
+    updatedAt: string;
+};
+export type SpaceAccessPolicy = {
+    signed_in_user: SpaceRole | null;
+    anonymous_user: SpaceRole | null;
+};

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/dist/websocket.d.ts

@@ -0,0 +1,119 @@
+import { type ChannelEnvelope } from "@neta-art/cohub-protocol/realtime";
+import type { ContentBlock } from "@neta-art/cohub-protocol/core";
+export type WebsocketEventPayload = ChannelEnvelope;
+export type WebSocketLike = {
+    readonly readyState: number;
+    onopen: ((event: Event) => void) | null;
+    onmessage: ((event: MessageEvent) => void) | null;
+    onerror: ((event: Event) => void) | null;
+    onclose: ((event: CloseEvent) => void) | null;
+    send(data: string): void;
+    close(code?: number, reason?: string): void;
+};
+export type WebSocketConstructor = new (url: string) => WebSocketLike;
+export type WebsocketClientOptions = {
+    url?: string;
+    autoReconnect?: boolean;
+    reconnectBaseDelayMs?: number;
+    reconnectMaxDelayMs?: number;
+    pingIntervalMs?: number;
+    pongTimeoutMs?: number;
+    debug?: boolean;
+    getAccessToken?: () => Promise<string | null> | string | null;
+    WebSocketImpl?: WebSocketConstructor;
+};
+export type WebsocketClientState = "idle" | "connecting" | "open" | "closed";
+export type WebsocketClientEvents = {
+    open: {
+        connectionId?: string | null;
+    };
+    close: {
+        code: number;
+        reason: string;
+        willReconnect: boolean;
+    };
+    error: {
+        error: unknown;
+    };
+    event: WebsocketEventPayload;
+    ready: {
+        connectionId: string;
+    };
+    auth: {
+        connectionId: string;
+        user: Record<string, unknown>;
+    };
+    messageAccepted: {
+        requestId?: string | null;
+        clientMessageId?: string | null;
+        sessionId?: string | null;
+        spaceId?: string | null;
+    };
+    serverError: {
+        code?: string;
+        message?: string;
+        requestId?: string | null;
+        sessionId?: string | null;
+        spaceId?: string | null;
+        clientMessageId?: string | null;
+    };
+    pong: {
+        requestId?: string | null;
+    };
+};
+type EventHandler<T> = (payload: T) => void;
+export declare class WebsocketClient {
+    private readonly url;
+    private readonly autoReconnect;
+    private readonly reconnectBaseDelayMs;
+    private readonly reconnectMaxDelayMs;
+    private readonly pingIntervalMs;
+    private readonly pongTimeoutMs;
+    private readonly debug;
+    private readonly getAccessToken?;
+    private readonly WebSocketImpl;
+    private ws;
+    private pingTimer;
+    private reconnectTimer;
+    private reconnectAttempt;
+    private manuallyClosed;
+    private connectPromise;
+    private authWaiter;
+    private awaitingPong;
+    private lastPingRequestId;
+    private pongDeadlineAt;
+    state: WebsocketClientState;
+    connectionId: string | null;
+    private readonly listeners;
+    constructor(options?: WebsocketClientOptions);
+    on<K extends keyof WebsocketClientEvents>(type: K, handler: EventHandler<WebsocketClientEvents[K]>): () => void;
+    off<K extends keyof WebsocketClientEvents>(type: K, handler: EventHandler<WebsocketClientEvents[K]>): void;
+    private emit;
+    private log;
+    connect(): Promise<void>;
+    disconnect(code?: number, reason?: string): Promise<void>;
+    sendMessage(input: {
+        spaceId: string;
+        sessionId: string;
+        content: ContentBlock[];
+        clientMessageId?: string;
+        requestId?: string;
+        model?: string;
+        provider?: string;
+    }): Promise<void>;
+    ack(eventId?: string, requestId?: string): void;
+    ping(requestId?: string): void;
+    private ensureOpen;
+    private send;
+    private authenticate;
+    private createAuthWaiter;
+    private resolveAuthWaiter;
+    private rejectAuthWaiter;
+    private handleMessage;
+    private startPingLoop;
+    private stopPingLoop;
+    private clearReconnectTimer;
+    private scheduleReconnect;
+}
+export declare const createWebsocketClient: (options?: WebsocketClientOptions) => WebsocketClient;
+export {};