@kazzle/app 0.1.927 → 0.1.930

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());
+    }
+}

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

@@ -0,0 +1,11 @@
+export { Kazzle } from './kazzle';
+export { KazzleApiError, type KazzleOptions } from './http';
+export { ExecStream, KazzleExecError, type ExecEvent, type ExecResult } from './sse';
+export { ComputersApi } from './computers';
+export { FsApi, type FsGrepOptions } from './computers.fs';
+export { TerminalsApi } from './computers.terminals';
+export { DesktopApi } from './computers.desktop';
+export { Browser, BrowsersApi } from './browsers';
+export { TabsApi } from './browsers.tabs';
+export { ProfilesApi } from './browsers.profiles';
+export type { ActionResult, BrowserCreateOptions, BrowserCreateResponse, BrowserRow, BrowserState, ComputerCreateResponse, ComputerRow, ExecOptions, FsDeleteResponse, FsGlobResponse, FsGrepMatch, FsGrepResponse, FsReadResponse, FsTransferResponse, FsWriteResponse, ListResponse, OkResponse, ProfileCreateOptions, ProfileCreateResponse, ProfileRow, TabRow, } from './sdk.types';

package/dist/vendor/kazzle/index.js

@@ -0,0 +1,12 @@
+// kazzle — typed client for the Kazzle computers and browsers REST API.
+// Quickstart in README.md; endpoint semantics in docs/platform/computers-api.mdx.
+export { Kazzle } from './kazzle';
+export { KazzleApiError } from './http';
+export { ExecStream, KazzleExecError } from './sse';
+export { ComputersApi } from './computers';
+export { FsApi } from './computers.fs';
+export { TerminalsApi } from './computers.terminals';
+export { DesktopApi } from './computers.desktop';
+export { Browser, BrowsersApi } from './browsers';
+export { TabsApi } from './browsers.tabs';
+export { ProfilesApi } from './browsers.profiles';

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

@@ -0,0 +1,10 @@
+import { type KazzleOptions } from './http';
+import { ComputersApi } from './computers';
+import { BrowsersApi } from './browsers';
+export declare class Kazzle {
+    readonly computers: ComputersApi;
+    readonly browsers: BrowsersApi;
+    /** Resolved API base URL (option, then KAZZLE_API_URL, then https://api.kazzle.app). */
+    readonly baseUrl: string;
+    constructor(options?: KazzleOptions);
+}

package/dist/vendor/kazzle/kazzle.js

@@ -0,0 +1,18 @@
+// Kazzle SDK entry: `new Kazzle({ apiKey })` → kazzle.computers.* and
+// kazzle.browsers.*. One KazzleHttp instance owns auth and error mapping for
+// every namespace.
+import { KazzleHttp } from './http';
+import { ComputersApi } from './computers';
+import { BrowsersApi } from './browsers';
+export class Kazzle {
+    computers;
+    browsers;
+    /** Resolved API base URL (option, then KAZZLE_API_URL, then https://api.kazzle.app). */
+    baseUrl;
+    constructor(options = {}) {
+        const http = new KazzleHttp(options);
+        this.baseUrl = http.baseUrl;
+        this.computers = new ComputersApi(http);
+        this.browsers = new BrowsersApi(http);
+    }
+}

package/dist/vendor/kazzle/sdk.types.d.ts

@@ -0,0 +1,134 @@
+/** Every list endpoint returns { items, total }. */
+export interface ListResponse<T> {
+    items: T[];
+    total: number;
+}
+export interface OkResponse {
+    ok: boolean;
+}
+export interface ComputerCreateResponse {
+    id: string;
+    /** Connection state: "offline" right after create, "online" once up. */
+    state: string;
+}
+export interface ComputerRow {
+    id: string;
+    label: string | null;
+    type: string | null;
+    platform: string;
+    state: string;
+    created_at: number;
+}
+export interface ExecOptions {
+    command: string;
+    cwd?: string;
+    shell?: string;
+    timeoutMs?: number;
+    env?: Record<string, string>;
+}
+/**
+ * Tool-action result (terminals, desktop, tabs): `content` plus optional
+ * `row`/`items`/`total` and action-specific fields. All keys are snake_case
+ * on the wire, matching the documented API surface.
+ */
+export interface ActionResult {
+    content?: string;
+    row?: Record<string, unknown>;
+    items?: unknown[];
+    total?: number;
+    [key: string]: unknown;
+}
+/** POST /computers/{id}/terminals — the new PTY session id is top-level. */
+export interface TerminalCreateResponse extends ActionResult {
+    session_id: string;
+}
+export interface FsReadResponse {
+    path: string;
+    /** utf8 text, or base64 when `encoding` is "base64". */
+    content: string;
+    encoding?: 'base64';
+    size_bytes: number;
+}
+export interface FsWriteResponse {
+    ok: boolean;
+    path: string;
+    size_bytes: number;
+}
+export interface FsDeleteResponse {
+    ok: boolean;
+    path: string;
+}
+export interface FsTransferResponse {
+    ok: boolean;
+    from: string;
+    to: string;
+}
+export interface FsGrepMatch {
+    path: string;
+    line: number;
+    snippet: string;
+}
+export interface FsGrepResponse {
+    matches: FsGrepMatch[];
+    total: number;
+}
+export interface FsGlobResponse {
+    files: string[];
+    total: number;
+}
+export interface BrowserCreateOptions {
+    /** Host the browser on this computer (its own pages: app previews, localhost). Omit for a stealth cloud browser. */
+    computerId?: string;
+    /** Reuse a saved profile's logins and cookies. */
+    profileId?: string;
+    /** Open this page in the first tab. */
+    url?: string;
+}
+export interface BrowserCreateResponse {
+    id: string;
+    tab_id: string;
+    computer_id: string | null;
+    provider: string;
+    url: string | null;
+    live_view_url: string | null;
+}
+export interface BrowserRow {
+    id: string;
+    computer_id: string | null;
+    provider: string;
+    live_view_url: string | null;
+}
+export interface TabRow {
+    id: string;
+    url: string | null;
+    title: string | null;
+    active: boolean | null;
+}
+export interface BrowserState {
+    id: string;
+    computer_id: string | null;
+    provider: string;
+    profile_id: string | null;
+    live_view_url: string | null;
+    tabs: TabRow[];
+}
+/** POST /browsers/{id}/tabs — the new tab id is top-level. */
+export interface TabOpenResponse extends ActionResult {
+    tab_id: string;
+}
+export interface ProfileCreateOptions {
+    /** The computer whose built-in browser profile to ensure. Omit for the space's stealth profile. */
+    computerId?: string;
+    name?: string;
+}
+export interface ProfileRow {
+    id: string;
+    name: string;
+    provider: string;
+    computer_id: string | null;
+    created_at: number;
+}
+export interface ProfileCreateResponse extends ProfileRow {
+    /** False when the durable profile already existed (create is an ensure). */
+    created: boolean;
+}

package/dist/vendor/kazzle/sdk.types.js

@@ -0,0 +1,6 @@
+// Wire types for the Kazzle computers and browsers REST API.
+//
+// Field names mirror the JSON the API returns (snake_case), so a response can
+// be logged or forwarded without translation. Request options are camelCase
+// and mapped to the wire shape inside the SDK.
+export {};

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

@@ -0,0 +1,45 @@
+export type ExecEvent = {
+    type: 'stdout';
+    text: string;
+} | {
+    type: 'stderr';
+    text: string;
+} | {
+    type: 'error';
+    error: string;
+} | {
+    type: 'exit';
+    code: number;
+};
+export interface ExecResult {
+    /** Joined stdout (stderr is merged into stdout by the PTY). */
+    text: string;
+    exitCode: number;
+}
+/** The exec `error` frame: offline computer, spawn failure, or timeout. */
+export declare class KazzleExecError extends Error {
+    readonly result: ExecResult;
+    constructor(message: string, result: ExecResult);
+}
+interface SseFrame {
+    event: string;
+    data: string;
+}
+/** Parse an SSE byte stream into frames. Handles frames split across chunks. */
+export declare function parseSseStream(stream: ReadableStream<Uint8Array>): AsyncGenerator<SseFrame>;
+/**
+ * The result of `kazzle.computers.exec()`: an async iterable of ExecEvents,
+ * plus `.text()` which drains the stream and resolves the joined stdout and
+ * exit code. Iterate OR call `.text()` — the underlying stream reads once.
+ */
+export declare class ExecStream implements AsyncIterable<ExecEvent> {
+    private readonly response;
+    constructor(response: Promise<Response>);
+    [Symbol.asyncIterator](): AsyncIterator<ExecEvent>;
+    /**
+     * Drain the stream: joined stdout plus the exit code. Throws KazzleExecError
+     * when the server reports an `error` frame (offline, spawn failure, timeout).
+     */
+    text(): Promise<ExecResult>;
+}
+export {};

package/dist/vendor/kazzle/sse.js

@@ -0,0 +1,112 @@
+// Server-sent events parsing for `POST /computers/{id}/exec`.
+//
+// The exec endpoint streams `stdout` frames ({ text }), optional `error`
+// frames ({ error }), then exactly one `exit` frame ({ code }). ExecStream
+// exposes the frames as an async iterator plus a `.text()` convenience.
+/** The exec `error` frame: offline computer, spawn failure, or timeout. */
+export class KazzleExecError extends Error {
+    result;
+    constructor(message, result) {
+        super(message);
+        this.name = 'KazzleExecError';
+        this.result = result;
+    }
+}
+/** Parse an SSE byte stream into frames. Handles frames split across chunks. */
+export async function* parseSseStream(stream) {
+    const decoder = new TextDecoder();
+    const reader = stream.getReader();
+    let buffer = '';
+    try {
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            buffer += decoder.decode(value, { stream: true });
+            let boundary;
+            while ((boundary = buffer.indexOf('\n\n')) !== -1) {
+                const raw = buffer.slice(0, boundary);
+                buffer = buffer.slice(boundary + 2);
+                const frame = parseFrame(raw);
+                if (frame)
+                    yield frame;
+            }
+        }
+        const tail = parseFrame(buffer);
+        if (tail)
+            yield tail;
+    }
+    finally {
+        reader.releaseLock();
+    }
+}
+function parseFrame(raw) {
+    let event = 'message';
+    const data = [];
+    for (const line of raw.split('\n')) {
+        if (line.startsWith('event:'))
+            event = line.slice('event:'.length).trim();
+        else if (line.startsWith('data:'))
+            data.push(line.slice('data:'.length).trimStart());
+    }
+    if (data.length === 0)
+        return null;
+    return { event, data: data.join('\n') };
+}
+function toExecEvent(frame) {
+    const payload = JSON.parse(frame.data);
+    switch (frame.event) {
+        case 'stdout':
+            return { type: 'stdout', text: String(payload.text ?? '') };
+        case 'stderr':
+            return { type: 'stderr', text: String(payload.text ?? '') };
+        case 'error':
+            return { type: 'error', error: String(payload.error ?? 'Command failed') };
+        case 'exit':
+            return { type: 'exit', code: typeof payload.code === 'number' ? payload.code : -1 };
+        default:
+            return null;
+    }
+}
+/**
+ * The result of `kazzle.computers.exec()`: an async iterable of ExecEvents,
+ * plus `.text()` which drains the stream and resolves the joined stdout and
+ * exit code. Iterate OR call `.text()` — the underlying stream reads once.
+ */
+export class ExecStream {
+    response;
+    constructor(response) {
+        this.response = response;
+    }
+    async *[Symbol.asyncIterator]() {
+        const response = await this.response;
+        if (!response.body)
+            throw new Error('Exec response has no body stream');
+        for await (const frame of parseSseStream(response.body)) {
+            const event = toExecEvent(frame);
+            if (event)
+                yield event;
+        }
+    }
+    /**
+     * Drain the stream: joined stdout plus the exit code. Throws KazzleExecError
+     * when the server reports an `error` frame (offline, spawn failure, timeout).
+     */
+    async text() {
+        const chunks = [];
+        let exitCode = -1;
+        let error;
+        for await (const event of this) {
+            if (event.type === 'stdout' || event.type === 'stderr')
+                chunks.push(event.text);
+            else if (event.type === 'exit')
+                exitCode = event.code;
+            else if (event.type === 'error')
+                error = event.error;
+        }
+        const result = { text: chunks.join(''), exitCode };
+        if (error)
+            throw new KazzleExecError(error, result);
+        return result;
+    }
+}