@kazzle/app 0.1.929 → 0.1.931

package/dist/vendor/kazzle/computers.desktop.js

@@ -0,0 +1,144 @@
+// kazzle.computers.desktop.* — screen capture, input, apps, and windows
+// (/computers/{id}/desktop/*). Input actions target a live desktop session
+// (virtual display) created with sessions.create().
+import { apiPath } from './http';
+class DesktopSessionsApi {
+    http;
+    constructor(http) {
+        this.http = http;
+    }
+    /** Create a live desktop session (virtual display) for input actions. */
+    create(computerId, options = {}) {
+        return this.http.json('POST', apiPath `/computers/${computerId}/desktop/sessions`, options);
+    }
+    list(computerId) {
+        return this.http.json('GET', apiPath `/computers/${computerId}/desktop/sessions`);
+    }
+    close(computerId, sessionId) {
+        return this.http.json('DELETE', apiPath `/computers/${computerId}/desktop/sessions/${sessionId}`);
+    }
+}
+/** Mouse and keyboard input inside a live session. Every body carries the sessionId. */
+class DesktopInputApi {
+    http;
+    constructor(http) {
+        this.http = http;
+    }
+    post(computerId, segment, body) {
+        return this.http.json('POST', `${apiPath `/computers/${computerId}/desktop/input/`}${segment}`, body);
+    }
+    click(computerId, body) {
+        return this.post(computerId, 'click', body);
+    }
+    doubleClick(computerId, body) {
+        return this.post(computerId, 'double_click', body);
+    }
+    mouseDown(computerId, body) {
+        return this.post(computerId, 'mouse_down', body);
+    }
+    mouseUp(computerId, body) {
+        return this.post(computerId, 'mouse_up', body);
+    }
+    move(computerId, body) {
+        return this.post(computerId, 'move', body);
+    }
+    drag(computerId, body) {
+        return this.post(computerId, 'drag', body);
+    }
+    scroll(computerId, body) {
+        return this.post(computerId, 'scroll', body);
+    }
+    type(computerId, body) {
+        return this.post(computerId, 'type', body);
+    }
+    /** Press a key combo, e.g. "ctrl+c". */
+    key(computerId, body) {
+        return this.post(computerId, 'key', body);
+    }
+}
+/** Structured control of applications (attach, inspect the UI tree, press elements). */
+class DesktopAppsApi {
+    http;
+    constructor(http) {
+        this.http = http;
+    }
+    post(computerId, segment, body) {
+        return this.http.json('POST', `${apiPath `/computers/${computerId}/desktop/apps/`}${segment}`, body);
+    }
+    /** List the applications available on the computer with their bundle ids. */
+    list(computerId) {
+        return this.http.json('GET', apiPath `/computers/${computerId}/desktop/apps`);
+    }
+    /** Start (attach to) an application. The result row carries controlled_app_session_id. */
+    start(computerId, body) {
+        return this.post(computerId, 'start', body);
+    }
+    stop(computerId, body) {
+        return this.post(computerId, 'stop', body);
+    }
+    status(computerId, body) {
+        return this.post(computerId, 'status', body);
+    }
+    /** Accessibility-tree inspection of the controlled application. */
+    inspect(computerId, body) {
+        return this.post(computerId, 'inspect', body);
+    }
+    press(computerId, body) {
+        return this.post(computerId, 'press', body);
+    }
+    setValue(computerId, body) {
+        return this.post(computerId, 'set_value', body);
+    }
+    /** Screenshot the controlled application's window. Returns PNG bytes. */
+    capture(computerId, body) {
+        return this.http.binary(apiPath `/computers/${computerId}/desktop/apps/capture`, body);
+    }
+}
+class DesktopWindowsApi {
+    http;
+    constructor(http) {
+        this.http = http;
+    }
+    /** The active window in a live session. */
+    active(computerId, body) {
+        return this.http.json('POST', apiPath `/computers/${computerId}/desktop/windows/active`, body);
+    }
+    /** Raise a window of a controlled application. */
+    raise(computerId, body) {
+        return this.http.json('POST', apiPath `/computers/${computerId}/desktop/windows/raise`, body);
+    }
+    /** Move/resize a window inside a live session. */
+    place(computerId, body) {
+        return this.http.json('POST', apiPath `/computers/${computerId}/desktop/windows/place`, body);
+    }
+}
+export class DesktopApi {
+    http;
+    sessions;
+    input;
+    apps;
+    windows;
+    constructor(http) {
+        this.http = http;
+        this.sessions = new DesktopSessionsApi(http);
+        this.input = new DesktopInputApi(http);
+        this.apps = new DesktopAppsApi(http);
+        this.windows = new DesktopWindowsApi(http);
+    }
+    /** Screenshot a display. Omit displayId for the primary display. Returns PNG bytes. */
+    capture(computerId, options = {}) {
+        return this.http.binary(apiPath `/computers/${computerId}/desktop/capture`, options);
+    }
+    /** List the computer's displays with ids for capture(). */
+    displays(computerId) {
+        return this.http.json('GET', apiPath `/computers/${computerId}/desktop/displays`);
+    }
+    /** Check screen-recording / input permissions on the computer. */
+    permissions(computerId) {
+        return this.http.json('GET', apiPath `/computers/${computerId}/desktop/permissions`);
+    }
+    /** Screen geometry for a live session. */
+    screen(computerId, body) {
+        return this.http.json('POST', apiPath `/computers/${computerId}/desktop/screen`, body);
+    }
+}

package/dist/vendor/kazzle/computers.fs.d.ts

@@ -0,0 +1,44 @@
+import { type KazzleHttp } from './http';
+import type { FsDeleteResponse, FsGlobResponse, FsGrepResponse, FsReadResponse, FsTransferResponse, FsWriteResponse } from './sdk.types';
+export interface FsGrepOptions {
+    pattern: string;
+    path?: string;
+    include?: string;
+    caseSensitive?: boolean;
+    maxResults?: number;
+}
+export declare class FsApi {
+    private readonly http;
+    constructor(http: KazzleHttp);
+    /** Read a file. Text comes back as utf8; binary as base64 with `encoding: "base64"`. Reads are capped at 2 MB. */
+    read(computerId: string, options: {
+        path: string;
+    }): Promise<FsReadResponse>;
+    /** Write a file, creating parent directories as needed. Pass `encoding: "base64"` for binary payloads. */
+    write(computerId: string, options: {
+        path: string;
+        content: string;
+        encoding?: 'utf-8' | 'base64';
+    }): Promise<FsWriteResponse>;
+    /** Delete a file or directory. */
+    delete(computerId: string, options: {
+        path: string;
+    }): Promise<FsDeleteResponse>;
+    /** Move (rename) a file or directory. */
+    move(computerId: string, options: {
+        from: string;
+        to: string;
+    }): Promise<FsTransferResponse>;
+    /** Copy a file or directory. */
+    copy(computerId: string, options: {
+        from: string;
+        to: string;
+    }): Promise<FsTransferResponse>;
+    /** Search file contents (ripgrep semantics). */
+    grep(computerId: string, options: FsGrepOptions): Promise<FsGrepResponse>;
+    /** Find files by glob pattern, e.g. "**\/*.ts". */
+    glob(computerId: string, options: {
+        pattern: string;
+        maxResults?: number;
+    }): Promise<FsGlobResponse>;
+}

package/dist/vendor/kazzle/computers.fs.js

@@ -0,0 +1,37 @@
+// kazzle.computers.fs.* — computer filesystem operations (/computers/{id}/fs/*).
+// Paths are relative to the computer's space root.
+import { apiPath } from './http';
+export class FsApi {
+    http;
+    constructor(http) {
+        this.http = http;
+    }
+    /** Read a file. Text comes back as utf8; binary as base64 with `encoding: "base64"`. Reads are capped at 2 MB. */
+    read(computerId, options) {
+        return this.http.json('POST', apiPath `/computers/${computerId}/fs/read`, options);
+    }
+    /** Write a file, creating parent directories as needed. Pass `encoding: "base64"` for binary payloads. */
+    write(computerId, options) {
+        return this.http.json('POST', apiPath `/computers/${computerId}/fs/write`, options);
+    }
+    /** Delete a file or directory. */
+    delete(computerId, options) {
+        return this.http.json('POST', apiPath `/computers/${computerId}/fs/delete`, options);
+    }
+    /** Move (rename) a file or directory. */
+    move(computerId, options) {
+        return this.http.json('POST', apiPath `/computers/${computerId}/fs/move`, options);
+    }
+    /** Copy a file or directory. */
+    copy(computerId, options) {
+        return this.http.json('POST', apiPath `/computers/${computerId}/fs/copy`, options);
+    }
+    /** Search file contents (ripgrep semantics). */
+    grep(computerId, options) {
+        return this.http.json('POST', apiPath `/computers/${computerId}/fs/grep`, options);
+    }
+    /** Find files by glob pattern, e.g. "**\/*.ts". */
+    glob(computerId, options) {
+        return this.http.json('POST', apiPath `/computers/${computerId}/fs/glob`, options);
+    }
+}

package/dist/vendor/kazzle/computers.js

@@ -0,0 +1,55 @@
+// kazzle.computers.* — cloud computer lifecycle plus the per-computer
+// sub-surfaces: fs, exec (SSE), terminals, desktop.
+import { apiPath } from './http';
+import { ExecStream } from './sse';
+import { FsApi } from './computers.fs';
+import { TerminalsApi } from './computers.terminals';
+import { DesktopApi } from './computers.desktop';
+export class ComputersApi {
+    http;
+    fs;
+    terminals;
+    desktop;
+    constructor(http) {
+        this.http = http;
+        this.fs = new FsApi(http);
+        this.terminals = new TerminalsApi(http);
+        this.desktop = new DesktopApi(http);
+    }
+    /** Create a cloud computer. It boots with a persistent disk; state is "offline" until it comes up. */
+    create() {
+        return this.http.json('POST', '/computers', {});
+    }
+    /** List the computers in the API key's space. */
+    list() {
+        return this.http.json('GET', '/computers');
+    }
+    get(computerId) {
+        return this.http.json('GET', apiPath `/computers/${computerId}`);
+    }
+    /** Resume a suspended computer from its snapshot. Wakes take seconds; the disk is preserved. */
+    wake(computerId) {
+        return this.http.json('POST', apiPath `/computers/${computerId}/wake`, {});
+    }
+    /** Suspend the computer. The disk is kept; wake it later to resume. */
+    stop(computerId) {
+        return this.http.json('POST', apiPath `/computers/${computerId}/stop`, {});
+    }
+    /** Re-provision a computer whose sandbox is missing or wedged. The persistent volume is reattached. */
+    repair(computerId) {
+        return this.http.json('POST', apiPath `/computers/${computerId}/repair`, {});
+    }
+    /** Destroy the computer and delete its disk. Permanent; use stop() to keep the files. */
+    destroy(computerId) {
+        return this.http.json('DELETE', apiPath `/computers/${computerId}`);
+    }
+    /**
+     * Run one command and stream the result. Returns an ExecStream: iterate the
+     * SSE events (`stdout`/`error`/`exit`), or call `.text()` for the joined
+     * stdout and exit code. stderr is merged into stdout (PTY). For long-running
+     * processes use terminals instead.
+     */
+    exec(computerId, options) {
+        return new ExecStream(this.http.request('POST', apiPath `/computers/${computerId}/exec`, options));
+    }
+}

package/dist/vendor/kazzle/computers.terminals.d.ts

@@ -0,0 +1,36 @@
+import { type KazzleHttp } from './http';
+import type { ActionResult, TerminalCreateResponse } from './sdk.types';
+export declare class TerminalsApi {
+    private readonly http;
+    constructor(http: KazzleHttp);
+    /** Open a persistent PTY session. The response's session_id is the id for the other calls. */
+    create(computerId: string, options?: {
+        shell?: string;
+        cwd?: string;
+    }): Promise<TerminalCreateResponse>;
+    /** List terminal sessions on this computer. */
+    list(computerId: string, options?: {
+        offset?: number;
+        limit?: number;
+    }): Promise<ActionResult>;
+    /** Send input to the session's stdin. Include \n to submit. */
+    write(computerId: string, sessionId: string, options: {
+        input: string;
+    }): Promise<ActionResult>;
+    /** Read buffered output (live or recently exited). Lines are 1-based; the response reports total_lines. */
+    read(computerId: string, sessionId: string, options?: {
+        startLine?: number;
+        endLine?: number;
+    }): Promise<ActionResult>;
+    /** Send a control signal: "interrupt", "eof", or "suspend". */
+    ctrl(computerId: string, sessionId: string, options: {
+        signal: 'interrupt' | 'eof' | 'suspend';
+    }): Promise<ActionResult>;
+    /** Block until a regex matches the session output or the timeout elapses. */
+    wait(computerId: string, sessionId: string, options: {
+        pattern: string;
+        timeoutMs?: number;
+    }): Promise<ActionResult>;
+    /** Kill the session's process and delete the session. */
+    kill(computerId: string, sessionId: string): Promise<ActionResult>;
+}

package/dist/vendor/kazzle/computers.terminals.js

@@ -0,0 +1,38 @@
+// kazzle.computers.terminals.* — persistent PTY sessions (/computers/{id}/terminals).
+// Use these for long-running processes (dev servers, watchers); use exec() for
+// one-shot commands.
+import { apiPath } from './http';
+export class TerminalsApi {
+    http;
+    constructor(http) {
+        this.http = http;
+    }
+    /** Open a persistent PTY session. The response's session_id is the id for the other calls. */
+    create(computerId, options = {}) {
+        return this.http.json('POST', apiPath `/computers/${computerId}/terminals`, options);
+    }
+    /** List terminal sessions on this computer. */
+    list(computerId, options = {}) {
+        return this.http.json('GET', apiPath `/computers/${computerId}/terminals`, undefined, options);
+    }
+    /** Send input to the session's stdin. Include \n to submit. */
+    write(computerId, sessionId, options) {
+        return this.http.json('POST', apiPath `/computers/${computerId}/terminals/${sessionId}/write`, options);
+    }
+    /** Read buffered output (live or recently exited). Lines are 1-based; the response reports total_lines. */
+    read(computerId, sessionId, options = {}) {
+        return this.http.json('POST', apiPath `/computers/${computerId}/terminals/${sessionId}/read`, options);
+    }
+    /** Send a control signal: "interrupt", "eof", or "suspend". */
+    ctrl(computerId, sessionId, options) {
+        return this.http.json('POST', apiPath `/computers/${computerId}/terminals/${sessionId}/ctrl`, options);
+    }
+    /** Block until a regex matches the session output or the timeout elapses. */
+    wait(computerId, sessionId, options) {
+        return this.http.json('POST', apiPath `/computers/${computerId}/terminals/${sessionId}/wait`, options);
+    }
+    /** Kill the session's process and delete the session. */
+    kill(computerId, sessionId) {
+        return this.http.json('DELETE', apiPath `/computers/${computerId}/terminals/${sessionId}`);
+    }
+}

package/dist/vendor/kazzle/generated/operations.d.ts

@@ -0,0 +1,8 @@
+export interface ApiOperation {
+    method: string;
+    path: string;
+}
+/** Every customer API operation the SDK must cover. */
+export declare const API_OPERATIONS: readonly ApiOperation[];
+/** URL segments under /browsers/{browserId}/tabs/{tabId}/. */
+export declare const TAB_ACTION_SEGMENTS: readonly string[];

package/dist/vendor/kazzle/generated/operations.js

@@ -0,0 +1,137 @@
+// GENERATED FILE — do not edit.
+// Source of truth: shared/api/openapi.json (Computers API + Browsers API tags).
+// Regenerate with `bun run generate` in packages/kazzle-sdk after the server
+// API surface changes; src/operations.sync.test.ts fails on drift.
+/** Every customer API operation the SDK must cover. */
+export const API_OPERATIONS = [
+    { method: 'GET', path: '/browsers' },
+    { method: 'POST', path: '/browsers' },
+    { method: 'DELETE', path: '/browsers/{browserId}' },
+    { method: 'GET', path: '/browsers/{browserId}' },
+    { method: 'GET', path: '/browsers/{browserId}/tabs' },
+    { method: 'POST', path: '/browsers/{browserId}/tabs' },
+    { method: 'DELETE', path: '/browsers/{browserId}/tabs/{tabId}' },
+    { method: 'POST', path: '/browsers/{browserId}/tabs/{tabId}/back' },
+    { method: 'POST', path: '/browsers/{browserId}/tabs/{tabId}/check' },
+    { method: 'POST', path: '/browsers/{browserId}/tabs/{tabId}/click' },
+    { method: 'POST', path: '/browsers/{browserId}/tabs/{tabId}/close' },
+    { method: 'POST', path: '/browsers/{browserId}/tabs/{tabId}/console' },
+    { method: 'POST', path: '/browsers/{browserId}/tabs/{tabId}/content' },
+    { method: 'POST', path: '/browsers/{browserId}/tabs/{tabId}/dialog' },
+    { method: 'POST', path: '/browsers/{browserId}/tabs/{tabId}/dom' },
+    { method: 'POST', path: '/browsers/{browserId}/tabs/{tabId}/download' },
+    { method: 'POST', path: '/browsers/{browserId}/tabs/{tabId}/drag' },
+    { method: 'POST', path: '/browsers/{browserId}/tabs/{tabId}/eval' },
+    { method: 'POST', path: '/browsers/{browserId}/tabs/{tabId}/extract' },
+    { method: 'POST', path: '/browsers/{browserId}/tabs/{tabId}/fill_form' },
+    { method: 'POST', path: '/browsers/{browserId}/tabs/{tabId}/find' },
+    { method: 'POST', path: '/browsers/{browserId}/tabs/{tabId}/focus' },
+    { method: 'POST', path: '/browsers/{browserId}/tabs/{tabId}/forward' },
+    { method: 'POST', path: '/browsers/{browserId}/tabs/{tabId}/hover' },
+    { method: 'POST', path: '/browsers/{browserId}/tabs/{tabId}/key' },
+    { method: 'POST', path: '/browsers/{browserId}/tabs/{tabId}/live' },
+    { method: 'POST', path: '/browsers/{browserId}/tabs/{tabId}/move' },
+    { method: 'POST', path: '/browsers/{browserId}/tabs/{tabId}/nav' },
+    { method: 'POST', path: '/browsers/{browserId}/tabs/{tabId}/network' },
+    { method: 'POST', path: '/browsers/{browserId}/tabs/{tabId}/options' },
+    { method: 'POST', path: '/browsers/{browserId}/tabs/{tabId}/pdf' },
+    { method: 'POST', path: '/browsers/{browserId}/tabs/{tabId}/reload' },
+    { method: 'POST', path: '/browsers/{browserId}/tabs/{tabId}/screenshot' },
+    { method: 'POST', path: '/browsers/{browserId}/tabs/{tabId}/scroll' },
+    { method: 'POST', path: '/browsers/{browserId}/tabs/{tabId}/select' },
+    { method: 'POST', path: '/browsers/{browserId}/tabs/{tabId}/snapshot' },
+    { method: 'POST', path: '/browsers/{browserId}/tabs/{tabId}/status' },
+    { method: 'POST', path: '/browsers/{browserId}/tabs/{tabId}/type' },
+    { method: 'POST', path: '/browsers/{browserId}/tabs/{tabId}/uncheck' },
+    { method: 'POST', path: '/browsers/{browserId}/tabs/{tabId}/upload' },
+    { method: 'POST', path: '/browsers/{browserId}/tabs/{tabId}/wait' },
+    { method: 'GET', path: '/browsers/profiles' },
+    { method: 'POST', path: '/browsers/profiles' },
+    { method: 'DELETE', path: '/browsers/profiles/{profileId}' },
+    { method: 'GET', path: '/computers' },
+    { method: 'POST', path: '/computers' },
+    { method: 'DELETE', path: '/computers/{computerId}' },
+    { method: 'GET', path: '/computers/{computerId}' },
+    { method: 'GET', path: '/computers/{computerId}/desktop/apps' },
+    { method: 'POST', path: '/computers/{computerId}/desktop/apps/capture' },
+    { method: 'POST', path: '/computers/{computerId}/desktop/apps/inspect' },
+    { method: 'POST', path: '/computers/{computerId}/desktop/apps/press' },
+    { method: 'POST', path: '/computers/{computerId}/desktop/apps/set_value' },
+    { method: 'POST', path: '/computers/{computerId}/desktop/apps/start' },
+    { method: 'POST', path: '/computers/{computerId}/desktop/apps/status' },
+    { method: 'POST', path: '/computers/{computerId}/desktop/apps/stop' },
+    { method: 'POST', path: '/computers/{computerId}/desktop/capture' },
+    { method: 'GET', path: '/computers/{computerId}/desktop/displays' },
+    { method: 'POST', path: '/computers/{computerId}/desktop/input/click' },
+    { method: 'POST', path: '/computers/{computerId}/desktop/input/double_click' },
+    { method: 'POST', path: '/computers/{computerId}/desktop/input/drag' },
+    { method: 'POST', path: '/computers/{computerId}/desktop/input/key' },
+    { method: 'POST', path: '/computers/{computerId}/desktop/input/mouse_down' },
+    { method: 'POST', path: '/computers/{computerId}/desktop/input/mouse_up' },
+    { method: 'POST', path: '/computers/{computerId}/desktop/input/move' },
+    { method: 'POST', path: '/computers/{computerId}/desktop/input/scroll' },
+    { method: 'POST', path: '/computers/{computerId}/desktop/input/type' },
+    { method: 'GET', path: '/computers/{computerId}/desktop/permissions' },
+    { method: 'POST', path: '/computers/{computerId}/desktop/screen' },
+    { method: 'GET', path: '/computers/{computerId}/desktop/sessions' },
+    { method: 'POST', path: '/computers/{computerId}/desktop/sessions' },
+    { method: 'DELETE', path: '/computers/{computerId}/desktop/sessions/{sessionId}' },
+    { method: 'POST', path: '/computers/{computerId}/desktop/windows/active' },
+    { method: 'POST', path: '/computers/{computerId}/desktop/windows/place' },
+    { method: 'POST', path: '/computers/{computerId}/desktop/windows/raise' },
+    { method: 'POST', path: '/computers/{computerId}/exec' },
+    { method: 'POST', path: '/computers/{computerId}/fs/copy' },
+    { method: 'POST', path: '/computers/{computerId}/fs/delete' },
+    { method: 'POST', path: '/computers/{computerId}/fs/glob' },
+    { method: 'POST', path: '/computers/{computerId}/fs/grep' },
+    { method: 'POST', path: '/computers/{computerId}/fs/move' },
+    { method: 'POST', path: '/computers/{computerId}/fs/read' },
+    { method: 'POST', path: '/computers/{computerId}/fs/write' },
+    { method: 'POST', path: '/computers/{computerId}/repair' },
+    { method: 'POST', path: '/computers/{computerId}/stop' },
+    { method: 'GET', path: '/computers/{computerId}/terminals' },
+    { method: 'POST', path: '/computers/{computerId}/terminals' },
+    { method: 'DELETE', path: '/computers/{computerId}/terminals/{sessionId}' },
+    { method: 'POST', path: '/computers/{computerId}/terminals/{sessionId}/ctrl' },
+    { method: 'POST', path: '/computers/{computerId}/terminals/{sessionId}/read' },
+    { method: 'POST', path: '/computers/{computerId}/terminals/{sessionId}/wait' },
+    { method: 'POST', path: '/computers/{computerId}/terminals/{sessionId}/write' },
+    { method: 'POST', path: '/computers/{computerId}/wake' },
+];
+/** URL segments under /browsers/{browserId}/tabs/{tabId}/. */
+export const TAB_ACTION_SEGMENTS = [
+    'back',
+    'check',
+    'click',
+    'close',
+    'console',
+    'content',
+    'dialog',
+    'dom',
+    'download',
+    'drag',
+    'eval',
+    'extract',
+    'fill_form',
+    'find',
+    'focus',
+    'forward',
+    'hover',
+    'key',
+    'live',
+    'move',
+    'nav',
+    'network',
+    'options',
+    'pdf',
+    'reload',
+    'screenshot',
+    'scroll',
+    'select',
+    'snapshot',
+    'status',
+    'type',
+    'uncheck',
+    'upload',
+    'wait',
+];

package/dist/vendor/kazzle/http.d.ts

@@ -0,0 +1,39 @@
+export interface KazzleOptions {
+    /** `kzl_` API key. Defaults to the KAZZLE_API_KEY environment variable. */
+    apiKey?: string;
+    /** API base URL override for dev/local, e.g. http://localhost:8080. Defaults to the KAZZLE_API_URL environment variable, then https://api.kazzle.app. */
+    baseUrl?: string;
+    /** Fetch implementation override, for tests. */
+    fetch?: typeof globalThis.fetch;
+}
+/** A non-2xx response from the API. `status` and the body's `error` are always set. */
+export declare class KazzleApiError extends Error {
+    readonly status: number;
+    readonly code: string | undefined;
+    readonly body: Record<string, unknown>;
+    constructor(status: number, body: Record<string, unknown>);
+}
+/** Template tag that URL-encodes interpolated path params: apiPath`/computers/${id}/wake`. */
+export declare function apiPath(strings: TemplateStringsArray, ...params: string[]): string;
+export type Query = Record<string, string | number | undefined>;
+/**
+ * Wire casing: SDK request options are camelCase; the API's documented surface
+ * is snake_case. JSON bodies are deep-converted on the way out, so every
+ * namespace method can pass its options object straight through.
+ */
+export declare function toWireBody(value: unknown): unknown;
+export declare class KazzleHttp {
+    readonly baseUrl: string;
+    private readonly apiKey;
+    private readonly fetchImpl;
+    constructor(options?: KazzleOptions);
+    url(path: string, query?: Query): string;
+    /**
+     * Raw request. JSON bodies are re-cased to the snake_case wire shape; non-2xx
+     * responses are read as JSON and thrown as KazzleApiError.
+     */
+    request(method: string, path: string, body?: unknown, query?: Query): Promise<Response>;
+    json<T>(method: string, path: string, body?: unknown, query?: Query): Promise<T>;
+    /** POST returning raw bytes (screenshot, pdf, capture). */
+    binary(path: string, body?: unknown): Promise<Uint8Array>;
+}

package/dist/vendor/kazzle/http.js

@@ -0,0 +1,103 @@
+// HTTP core for the `kazzle` package: auth, URL building, JSON/binary/SSE requests.
+//
+// Dependency-free on purpose (uses global fetch). Every namespace call funnels
+// through KazzleHttp, so auth and error mapping live in exactly one place.
+/** Default API base. Source of truth: shared/types/auth.types.ts (apiUrlForEnv). */
+const DEFAULT_BASE_URL = 'https://api.kazzle.app';
+/** A non-2xx response from the API. `status` and the body's `error` are always set. */
+export class KazzleApiError extends Error {
+    status;
+    code;
+    body;
+    constructor(status, body) {
+        const message = typeof body.error === 'string' ? body.error : `Kazzle API request failed with status ${status}`;
+        super(message);
+        this.name = 'KazzleApiError';
+        this.status = status;
+        this.code = typeof body.code === 'string' ? body.code : undefined;
+        this.body = body;
+    }
+}
+function envVar(name) {
+    if (typeof process === 'undefined' || !process.env)
+        return undefined;
+    return process.env[name];
+}
+/** Template tag that URL-encodes interpolated path params: apiPath`/computers/${id}/wake`. */
+export function apiPath(strings, ...params) {
+    return strings.reduce((out, part, i) => out + part + (i < params.length ? encodeURIComponent(params[i]) : ''), '');
+}
+/**
+ * Keys whose VALUES are opaque customer data (env var names like MY_VAR, JSON
+ * eval arguments) — never re-cased. Source of truth: server/tools/tool-api.casing.ts.
+ */
+const OPAQUE_VALUE_KEYS = new Set(['env', 'arguments']);
+function camelToSnakeKey(key) {
+    return key.replace(/([A-Z])/g, '_$1').toLowerCase();
+}
+/**
+ * Wire casing: SDK request options are camelCase; the API's documented surface
+ * is snake_case. JSON bodies are deep-converted on the way out, so every
+ * namespace method can pass its options object straight through.
+ */
+export function toWireBody(value) {
+    if (Array.isArray(value))
+        return value.map(toWireBody);
+    if (value === null || typeof value !== 'object')
+        return value;
+    const out = {};
+    for (const [key, entry] of Object.entries(value)) {
+        out[camelToSnakeKey(key)] = OPAQUE_VALUE_KEYS.has(key) ? entry : toWireBody(entry);
+    }
+    return out;
+}
+export class KazzleHttp {
+    baseUrl;
+    apiKey;
+    fetchImpl;
+    constructor(options = {}) {
+        const apiKey = options.apiKey ?? envVar('KAZZLE_API_KEY');
+        if (!apiKey) {
+            throw new Error('Missing Kazzle API key. Pass `new Kazzle({ apiKey })` or set the KAZZLE_API_KEY environment variable.');
+        }
+        this.apiKey = apiKey;
+        const baseUrl = options.baseUrl ?? envVar('KAZZLE_API_URL') ?? DEFAULT_BASE_URL;
+        this.baseUrl = baseUrl.replace(/\/+$/, '');
+        this.fetchImpl = options.fetch ?? globalThis.fetch;
+    }
+    url(path, query) {
+        const params = Object.entries(query ?? {}).filter(([, value]) => value !== undefined);
+        const search = params.length
+            ? `?${new URLSearchParams(params.map(([key, value]) => [key, String(value)])).toString()}`
+            : '';
+        return `${this.baseUrl}${path}${search}`;
+    }
+    /**
+     * Raw request. JSON bodies are re-cased to the snake_case wire shape; non-2xx
+     * responses are read as JSON and thrown as KazzleApiError.
+     */
+    async request(method, path, body, query) {
+        const response = await this.fetchImpl(this.url(path, query), {
+            method,
+            headers: {
+                authorization: `Bearer ${this.apiKey}`,
+                ...(body !== undefined ? { 'content-type': 'application/json' } : {}),
+            },
+            ...(body !== undefined ? { body: JSON.stringify(toWireBody(body)) } : {}),
+        });
+        if (!response.ok) {
+            const errorBody = await response.json().catch(() => ({}));
+            throw new KazzleApiError(response.status, errorBody);
+        }
+        return response;
+    }
+    async json(method, path, body, query) {
+        const response = await this.request(method, path, body, query);
+        return await response.json();
+    }
+    /** POST returning raw bytes (screenshot, pdf, capture). */
+    async binary(path, body) {
+        const response = await this.request('POST', path, body ?? {});
+        return new Uint8Array(await response.arrayBuffer());
+    }
+}