@kazzle/app 0.1.929 → 0.1.930

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kazzle/app",
-  "version": "0.1.929",
+  "version": "0.1.930",
   "description": "Contracts, tool helpers, Vite helper, and templates for building Kazzle apps.",
   "license": "UNLICENSED",
   "repository": {