@belonguniverseai/react-sdk 0.6.33 → 0.6.34

package/dist/api/client.d.ts

@@ -2076,6 +2076,181 @@ export declare const createApiClient: (baseUrl: string) => {
             };
         }>;
     };
+} & {
+    v1: {
+        proactive: import('hono/client').ClientRequest<string, "/v1/proactive", {
+            $get: {
+                input: {};
+                output: {
+                    error: "proactive_unavailable";
+                };
+                outputFormat: "json";
+                status: 404;
+            } | {
+                input: {};
+                output: {
+                    enabled: boolean;
+                    lastCheckAt: string | null;
+                    nextCheckAt: string | null;
+                    checkingCount: number;
+                    slackAvailable: boolean;
+                    watchedApps: readonly string[];
+                    chat: {
+                        sessionId: string;
+                        unreadCount: number;
+                        lastMessageAt: string | null;
+                        lastMessage: string | null;
+                        activeRunId: string | null;
+                    } | null;
+                };
+                outputFormat: "json";
+                status: 200;
+            };
+            $put: {
+                input: {
+                    json: {
+                        enabled: boolean;
+                    };
+                };
+                output: {
+                    error: {
+                        type: string;
+                        requiredScope: string;
+                    };
+                };
+                outputFormat: "json";
+                status: 403;
+            } | {
+                input: {
+                    json: {
+                        enabled: boolean;
+                    };
+                };
+                output: {
+                    enabled: boolean;
+                };
+                outputFormat: "json";
+                status: 200;
+            } | {
+                input: {
+                    json: {
+                        enabled: boolean;
+                    };
+                };
+                output: {
+                    error: "proactive_unavailable";
+                };
+                outputFormat: "json";
+                status: 404;
+            };
+        }>;
+    };
+} & {
+    v1: {
+        proactive: {
+            chat: import('hono/client').ClientRequest<string, "/v1/proactive/chat", {
+                $post: {
+                    input: {
+                        json: {
+                            workspaceExternalId?: string | undefined;
+                        };
+                    };
+                    output: {
+                        error: {
+                            type: string;
+                            requiredScope: string;
+                        };
+                    };
+                    outputFormat: "json";
+                    status: 403;
+                } | {
+                    input: {
+                        json: {
+                            workspaceExternalId?: string | undefined;
+                        };
+                    };
+                    output: {
+                        sessionId: string;
+                    };
+                    outputFormat: "json";
+                    status: 200;
+                } | {
+                    input: {
+                        json: {
+                            workspaceExternalId?: string | undefined;
+                        };
+                    };
+                    output: {
+                        error: "proactive_unavailable";
+                    };
+                    outputFormat: "json";
+                    status: 404;
+                };
+            }>;
+        };
+    };
+} & {
+    v1: {
+        proactive: {
+            check: import('hono/client').ClientRequest<string, "/v1/proactive/check", {
+                $post: {
+                    input: {};
+                    output: {
+                        error: {
+                            type: string;
+                            requiredScope: string;
+                        };
+                    };
+                    outputFormat: "json";
+                    status: 403;
+                } | {
+                    input: {};
+                    output: {
+                        startedCount: number;
+                    };
+                    outputFormat: "json";
+                    status: 202;
+                } | {
+                    input: {};
+                    output: {
+                        error: "proactive_unavailable";
+                    };
+                    outputFormat: "json";
+                    status: 404;
+                };
+            }>;
+        };
+    };
+} & {
+    v1: {
+        proactive: {
+            read: import('hono/client').ClientRequest<string, "/v1/proactive/read", {
+                $post: {
+                    input: {};
+                    output: null;
+                    outputFormat: "body";
+                    status: 204;
+                } | {
+                    input: {};
+                    output: {
+                        error: {
+                            type: string;
+                            requiredScope: string;
+                        };
+                    };
+                    outputFormat: "json";
+                    status: 403;
+                } | {
+                    input: {};
+                    output: {
+                        error: "proactive_unavailable";
+                    };
+                    outputFormat: "json";
+                    status: 404;
+                };
+            }>;
+        };
+    };
 } & {
     v1: {
         sessions: {
@@ -6461,6 +6636,358 @@ export declare const createApiClient: (baseUrl: string) => {
             }>;
         };
     };
+} & {
+    v1: {
+        computer: {
+            command: import('hono/client').ClientRequest<string, "/v1/computer/command", {
+                $post: {
+                    input: {
+                        json: {
+                            command: {
+                                op: "shell";
+                                command: string;
+                                cwd: string | null;
+                                timeoutMs: number;
+                            };
+                        };
+                    };
+                    output: {
+                        result: {
+                            op: "shell";
+                            exitCode: number | null;
+                            stdout: string;
+                            stderr: string;
+                            timedOut: boolean;
+                            truncated: boolean;
+                            durationMs: number;
+                        };
+                    };
+                    outputFormat: "json";
+                    status: 200;
+                } | {
+                    input: {
+                        json: {
+                            command: {
+                                op: "shell";
+                                command: string;
+                                cwd: string | null;
+                                timeoutMs: number;
+                            };
+                        };
+                    };
+                    output: {
+                        error: {
+                            type: "computer_not_paired";
+                        };
+                    };
+                    outputFormat: "json";
+                    status: 409;
+                } | {
+                    input: {
+                        json: {
+                            command: {
+                                op: "shell";
+                                command: string;
+                                cwd: string | null;
+                                timeoutMs: number;
+                            };
+                        };
+                    };
+                    output: {
+                        error: {
+                            type: "computer_not_connected";
+                        };
+                    };
+                    outputFormat: "json";
+                    status: 409;
+                } | {
+                    input: {
+                        json: {
+                            command: {
+                                op: "shell";
+                                command: string;
+                                cwd: string | null;
+                                timeoutMs: number;
+                            };
+                        };
+                    };
+                    output: {
+                        error: {
+                            type: "computer_busy";
+                        };
+                    };
+                    outputFormat: "json";
+                    status: 409;
+                } | {
+                    input: {
+                        json: {
+                            command: {
+                                op: "shell";
+                                command: string;
+                                cwd: string | null;
+                                timeoutMs: number;
+                            };
+                        };
+                    };
+                    output: {
+                        error: {
+                            type: "computer_disconnected";
+                        };
+                    };
+                    outputFormat: "json";
+                    status: 502;
+                } | {
+                    input: {
+                        json: {
+                            command: {
+                                op: "shell";
+                                command: string;
+                                cwd: string | null;
+                                timeoutMs: number;
+                            };
+                        };
+                    };
+                    output: {
+                        error: {
+                            type: "command_timeout";
+                        };
+                    };
+                    outputFormat: "json";
+                    status: 504;
+                };
+            }>;
+        };
+    };
+} & {
+    v1: {
+        computer: {
+            pairings: import('hono/client').ClientRequest<string, "/v1/computer/pairings", {
+                $post: {
+                    input: {};
+                    output: {
+                        error: {
+                            type: string;
+                            requiredScope: string;
+                        };
+                    };
+                    outputFormat: "json";
+                    status: 403;
+                } | {
+                    input: {};
+                    output: {
+                        pairingCode: string;
+                        expiresAt: string;
+                    };
+                    outputFormat: "json";
+                    status: 201;
+                } | {
+                    input: {};
+                    output: {
+                        error: {
+                            readonly type: "tenant_inactive";
+                        };
+                    };
+                    outputFormat: "json";
+                    status: 403;
+                };
+            }>;
+        };
+    };
+} & {
+    v1: {
+        computer: {
+            device: import('hono/client').ClientRequest<string, "/v1/computer/device", {
+                $get: {
+                    input: {};
+                    output: {
+                        device: {
+                            deviceId: string;
+                            name: string;
+                            os: "macos" | "windows" | "linux";
+                            appVersion: string;
+                            pairedAt: string;
+                            lastSeenAt: string | null;
+                            online: boolean;
+                        } | null;
+                        downloadUrl: string | null;
+                    };
+                    outputFormat: "json";
+                    status: 200;
+                };
+                $delete: {
+                    input: {};
+                    output: null;
+                    outputFormat: "body";
+                    status: 204;
+                } | {
+                    input: {};
+                    output: {
+                        error: {
+                            type: string;
+                            requiredScope: string;
+                        };
+                    };
+                    outputFormat: "json";
+                    status: 403;
+                } | {
+                    input: {};
+                    output: {
+                        error: {
+                            readonly type: "computer_not_paired";
+                        };
+                    };
+                    outputFormat: "json";
+                    status: 404;
+                };
+            }>;
+        };
+    };
+} & {
+    v1: {
+        computer: {
+            pairings: {
+                claim: import('hono/client').ClientRequest<string, "/v1/computer/pairings/claim", {
+                    $post: {
+                        input: {
+                            json: {
+                                pairingCode: string;
+                                deviceName: string;
+                                os: "macos" | "windows" | "linux";
+                                appVersion: string;
+                            };
+                        };
+                        output: {
+                            error: "pairing_code_invalid";
+                        };
+                        outputFormat: "json";
+                        status: 404;
+                    } | {
+                        input: {
+                            json: {
+                                pairingCode: string;
+                                deviceName: string;
+                                os: "macos" | "windows" | "linux";
+                                appVersion: string;
+                            };
+                        };
+                        output: {
+                            readonly deviceId: string;
+                            readonly deviceToken: string;
+                        };
+                        outputFormat: "json";
+                        status: 201;
+                    };
+                }>;
+            };
+        };
+    };
+} & {
+    v1: {
+        computer: {
+            stream: import('hono/client').ClientRequest<string, "/v1/computer/stream", {
+                $get: {
+                    input: {
+                        query: {
+                            protocol: string | string[];
+                            os: string | string[];
+                            appVersion: string | string[];
+                            shell?: string | string[];
+                        };
+                    };
+                    output: {};
+                    outputFormat: string;
+                    status: import('hono/utils/http-status').StatusCode;
+                };
+            }>;
+        };
+    };
+} & {
+    v1: {
+        computer: {
+            heartbeat: import('hono/client').ClientRequest<string, "/v1/computer/heartbeat", {
+                $post: {
+                    input: {};
+                    output: null;
+                    outputFormat: "body";
+                    status: 204;
+                };
+            }>;
+        };
+    };
+} & {
+    v1: {
+        computer: {
+            ack: import('hono/client').ClientRequest<string, "/v1/computer/ack", {
+                $post: {
+                    input: {
+                        json: {
+                            commandId: string;
+                        };
+                    };
+                    output: null;
+                    outputFormat: "body";
+                    status: 204;
+                } | {
+                    input: {
+                        json: {
+                            commandId: string;
+                        };
+                    };
+                    output: {
+                        error: "unknown_command";
+                    };
+                    outputFormat: "json";
+                    status: 404;
+                };
+            }>;
+        };
+    };
+} & {
+    v1: {
+        computer: {
+            result: import('hono/client').ClientRequest<string, "/v1/computer/result", {
+                $post: {
+                    input: {
+                        json: {
+                            commandId: string;
+                            result: {
+                                op: "shell";
+                                exitCode: number | null;
+                                stdout: string;
+                                stderr: string;
+                                timedOut: boolean;
+                                truncated: boolean;
+                                durationMs: number;
+                            };
+                        };
+                    };
+                    output: null;
+                    outputFormat: "body";
+                    status: 204;
+                } | {
+                    input: {
+                        json: {
+                            commandId: string;
+                            result: {
+                                op: "shell";
+                                exitCode: number | null;
+                                stdout: string;
+                                stderr: string;
+                                timedOut: boolean;
+                                truncated: boolean;
+                                durationMs: number;
+                            };
+                        };
+                    };
+                    output: {
+                        error: "unknown_command";
+                    };
+                    outputFormat: "json";
+                    status: 404;
+                };
+            }>;
+        };
+    };
 } & {
     v1: {
         config: {
@@ -8429,7 +8956,7 @@ export declare const createApiClient: (baseUrl: string) => {
                                         to?: readonly string[] | undefined;
                                         cc?: readonly string[] | undefined;
                                     }[];
-                                    outcome: "sent" | "partial" | "not_sent";
+                                    outcome: "sent" | "partial" | "not_sent" | "unknown";
                                     reason: "no_match" | "missing_outcome" | "provider_failed" | null;
                                 } | null;
                             }[];
@@ -9743,7 +10270,7 @@ export declare const createApiClient: (baseUrl: string) => {
                                         to?: readonly string[] | undefined;
                                         cc?: readonly string[] | undefined;
                                     }[];
-                                    outcome: "sent" | "partial" | "not_sent";
+                                    outcome: "sent" | "partial" | "not_sent" | "unknown";
                                     reason: "no_match" | "missing_outcome" | "provider_failed" | null;
                                 } | null;
                             }[];
@@ -11790,6 +12317,23 @@ export declare const createApiClient: (baseUrl: string) => {
                             };
                             outputFormat: "json";
                             status: 409;
+                        } | {
+                            input: {
+                                param: {
+                                    projectId: string;
+                                };
+                            } & {
+                                query: {
+                                    workspaceExternalId?: string | string[];
+                                };
+                            };
+                            output: {
+                                error: {
+                                    type: "project_handover_too_many_files";
+                                };
+                            };
+                            outputFormat: "json";
+                            status: 409;
                         } | {
                             input: {
                                 param: {
@@ -12817,6 +13361,23 @@ export declare const createApiClient: (baseUrl: string) => {
                             };
                             outputFormat: "json";
                             status: 409;
+                        } | {
+                            input: {
+                                param: {
+                                    projectId: string;
+                                };
+                            } & {
+                                query: {
+                                    workspaceExternalId?: string | string[];
+                                };
+                            };
+                            output: {
+                                error: {
+                                    type: "project_handover_too_many_files";
+                                };
+                            };
+                            outputFormat: "json";
+                            status: 409;
                         } | {
                             input: {
                                 param: {

package/dist/api/computer.d.ts

@@ -0,0 +1,60 @@
+import { z } from 'zod';
+import { ApiClient } from './client.ts';
+declare const computerDeviceSchema: z.ZodObject<{
+    deviceId: z.ZodUUID;
+    name: z.ZodString;
+    os: z.ZodEnum<{
+        macos: "macos";
+        windows: "windows";
+        linux: "linux";
+    }>;
+    appVersion: z.ZodString;
+    pairedAt: z.ZodISODateTime;
+    lastSeenAt: z.ZodNullable<z.ZodISODateTime>;
+    online: z.ZodBoolean;
+}, z.core.$strip>;
+declare const computerStatusSchema: z.ZodObject<{
+    device: z.ZodNullable<z.ZodObject<{
+        deviceId: z.ZodUUID;
+        name: z.ZodString;
+        os: z.ZodEnum<{
+            macos: "macos";
+            windows: "windows";
+            linux: "linux";
+        }>;
+        appVersion: z.ZodString;
+        pairedAt: z.ZodISODateTime;
+        lastSeenAt: z.ZodNullable<z.ZodISODateTime>;
+        online: z.ZodBoolean;
+    }, z.core.$strip>>;
+    downloadUrl: z.ZodNullable<z.ZodURL>;
+}, z.core.$strip>;
+export type ComputerDevice = z.infer<typeof computerDeviceSchema>;
+export type ComputerStatus = z.infer<typeof computerStatusSchema>;
+export declare const fetchComputerStatus: (client: ApiClient) => Promise<ComputerStatus>;
+/** A one-time code; single attempt, since a retried POST would mint a second one. */
+export declare const createComputerPairing: (client: ApiClient) => Promise<{
+    pairingCode: string;
+    expiresAt: string;
+}>;
+export declare const revokeComputer: (client: ApiClient) => Promise<void>;
+/**
+ * The deep link the desktop app registers for. It carries the API this dock
+ * talks to (an absolute URL, resolved against the host page), so the app
+ * pairs with the right regional cell without asking.
+ */
+export declare const computerPairingLink: (pairingCode: string, apiBaseUrl: string) => string;
+export declare const useComputerStatus: (ownerCacheKey: string) => import('@tanstack/react-query').UseQueryResult<NoInfer<{
+    device: {
+        deviceId: string;
+        name: string;
+        os: "macos" | "windows" | "linux";
+        appVersion: string;
+        pairedAt: string;
+        lastSeenAt: string | null;
+        online: boolean;
+    } | null;
+    downloadUrl: string | null;
+}>, Error>;
+export declare const useRevokeComputer: (ownerCacheKey: string) => () => Promise<void>;
+export {};

package/dist/api/proactive.d.ts

@@ -0,0 +1,36 @@
+import { z } from 'zod';
+import { ApiClient } from './client.ts';
+declare const proactiveSchema: z.ZodObject<{
+    enabled: z.ZodBoolean;
+    lastCheckAt: z.ZodNullable<z.ZodISODateTime>;
+    nextCheckAt: z.ZodNullable<z.ZodISODateTime>;
+    checkingCount: z.ZodNumber;
+    slackAvailable: z.ZodBoolean;
+    watchedApps: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    chat: z.ZodDefault<z.ZodNullable<z.ZodObject<{
+        sessionId: z.ZodString;
+        unreadCount: z.ZodNumber;
+        lastMessageAt: z.ZodNullable<z.ZodISODateTime>;
+        lastMessage: z.ZodNullable<z.ZodString>;
+        activeRunId: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export type Proactive = z.infer<typeof proactiveSchema>;
+export type ProactiveState = {
+    readonly status: "ready";
+    readonly proactive: Proactive;
+} | {
+    readonly status: "unavailable";
+};
+/** The pinned chat, created on first use, moved to the Workspace it's opened from. */
+export declare const openPinnedChat: (client: ApiClient, workspaceExternalId: string | null) => Promise<string>;
+export declare const fetchProactive: (client: ApiClient) => Promise<ProactiveState>;
+/** How often the dock re-reads it, and how often while a check is deciding. */
+export declare const PROACTIVE_POLL_MS = 30000;
+export declare const PROACTIVE_ACTIVE_POLL_MS = 4000;
+/** Keyed by the account speaking to the API, so it is purged on a switch. */
+export declare const useProactive: () => import('@tanstack/react-query').UseQueryResult<NoInfer<ProactiveState>, Error>;
+export declare const useSetProactiveEnabled: () => import('@tanstack/react-query').UseMutationResult<void, Error, boolean, unknown>;
+export declare const useCheckNow: () => import('@tanstack/react-query').UseMutationResult<number, Error, void, unknown>;
+export declare const useMarkProactiveRead: () => import('@tanstack/react-query').UseMutationResult<void, Error, void, unknown>;
+export {};