@kazzle/app 0.1.927 → 0.1.930

package/dist/vendor/kazzle/browsers.tabs.js

@@ -0,0 +1,132 @@
+// kazzle.browsers.tabs.* — tab-scoped browser actions
+// (/browsers/{id}/tabs/{tid}/{action}). Each method maps to exactly one
+// endpoint; action() is the generic escape hatch for the same set.
+import { apiPath } from './http';
+export class TabsApi {
+    http;
+    constructor(http) {
+        this.http = http;
+    }
+    /** List the open tabs of a browser session. */
+    list(browserId) {
+        return this.http.json('GET', apiPath `/browsers/${browserId}/tabs`);
+    }
+    /** Open a new tab. The new tab id is the response's tab_id. */
+    open(browserId, options = {}) {
+        return this.http.json('POST', apiPath `/browsers/${browserId}/tabs`, options);
+    }
+    /** POST one tab action by its URL segment. The named methods below all funnel through this. */
+    action(browserId, tabId, segment, body = {}) {
+        return this.http.json('POST', `${apiPath `/browsers/${browserId}/tabs/${tabId}/`}${segment}`, body);
+    }
+    binary(browserId, tabId, segment, body) {
+        return this.http.binary(`${apiPath `/browsers/${browserId}/tabs/${tabId}/`}${segment}`, body);
+    }
+    nav(browserId, tabId, body) {
+        return this.action(browserId, tabId, 'nav', body);
+    }
+    back(browserId, tabId) {
+        return this.action(browserId, tabId, 'back');
+    }
+    forward(browserId, tabId) {
+        return this.action(browserId, tabId, 'forward');
+    }
+    reload(browserId, tabId) {
+        return this.action(browserId, tabId, 'reload');
+    }
+    /** Returns PNG (or JPEG) bytes. */
+    screenshot(browserId, tabId, body = {}) {
+        return this.binary(browserId, tabId, 'screenshot', body);
+    }
+    /** Returns PDF bytes. */
+    pdf(browserId, tabId, body = {}) {
+        return this.binary(browserId, tabId, 'pdf', body);
+    }
+    /** Accessibility snapshot. Element refs from it target later click/type calls. */
+    snapshot(browserId, tabId, body = {}) {
+        return this.action(browserId, tabId, 'snapshot', body);
+    }
+    eval(browserId, tabId, body) {
+        return this.action(browserId, tabId, 'eval', body);
+    }
+    click(browserId, tabId, body) {
+        return this.action(browserId, tabId, 'click', body);
+    }
+    type(browserId, tabId, body) {
+        return this.action(browserId, tabId, 'type', body);
+    }
+    select(browserId, tabId, body) {
+        return this.action(browserId, tabId, 'select', body);
+    }
+    fillForm(browserId, tabId, body) {
+        return this.action(browserId, tabId, 'fill_form', body);
+    }
+    check(browserId, tabId, body) {
+        return this.action(browserId, tabId, 'check', body);
+    }
+    uncheck(browserId, tabId, body) {
+        return this.action(browserId, tabId, 'uncheck', body);
+    }
+    hover(browserId, tabId, body) {
+        return this.action(browserId, tabId, 'hover', body);
+    }
+    drag(browserId, tabId, body) {
+        return this.action(browserId, tabId, 'drag', body);
+    }
+    upload(browserId, tabId, body) {
+        return this.action(browserId, tabId, 'upload', body);
+    }
+    dialog(browserId, tabId, body) {
+        return this.action(browserId, tabId, 'dialog', body);
+    }
+    key(browserId, tabId, body) {
+        return this.action(browserId, tabId, 'key', body);
+    }
+    scroll(browserId, tabId, body) {
+        return this.action(browserId, tabId, 'scroll', body);
+    }
+    content(browserId, tabId, body = {}) {
+        return this.action(browserId, tabId, 'content', body);
+    }
+    dom(browserId, tabId, body) {
+        return this.action(browserId, tabId, 'dom', body);
+    }
+    extract(browserId, tabId, body) {
+        return this.action(browserId, tabId, 'extract', body);
+    }
+    find(browserId, tabId, body) {
+        return this.action(browserId, tabId, 'find', body);
+    }
+    options(browserId, tabId, body) {
+        return this.action(browserId, tabId, 'options', body);
+    }
+    console(browserId, tabId, body = {}) {
+        return this.action(browserId, tabId, 'console', body);
+    }
+    network(browserId, tabId, body = {}) {
+        return this.action(browserId, tabId, 'network', body);
+    }
+    wait(browserId, tabId, body) {
+        return this.action(browserId, tabId, 'wait', body);
+    }
+    status(browserId, tabId, body = {}) {
+        return this.action(browserId, tabId, 'status', body);
+    }
+    download(browserId, tabId, body) {
+        return this.action(browserId, tabId, 'download', body);
+    }
+    /** Live view URL for the tab. */
+    live(browserId, tabId, body = {}) {
+        return this.action(browserId, tabId, 'live', body);
+    }
+    focus(browserId, tabId) {
+        return this.action(browserId, tabId, 'focus');
+    }
+    move(browserId, tabId, body) {
+        return this.action(browserId, tabId, 'move', body);
+    }
+    /** Close the tab (DELETE /browsers/{id}/tabs/{tid}; POST .../close does the same). */
+    close(browserId, tabId) {
+        return this.http.json('DELETE', apiPath `/browsers/${browserId}/tabs/${tabId}`);
+    }
+}

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

@@ -0,0 +1,35 @@
+import { type KazzleHttp } from './http';
+import { ExecStream } from './sse';
+import { FsApi } from './computers.fs';
+import { TerminalsApi } from './computers.terminals';
+import { DesktopApi } from './computers.desktop';
+import type { ComputerCreateResponse, ComputerRow, ExecOptions, ListResponse, OkResponse } from './sdk.types';
+export declare class ComputersApi {
+    private readonly http;
+    readonly fs: FsApi;
+    readonly terminals: TerminalsApi;
+    readonly desktop: DesktopApi;
+    constructor(http: KazzleHttp);
+    /** Create a cloud computer. It boots with a persistent disk; state is "offline" until it comes up. */
+    create(): Promise<ComputerCreateResponse>;
+    /** List the computers in the API key's space. */
+    list(): Promise<ListResponse<ComputerRow>>;
+    get(computerId: string): Promise<ComputerRow>;
+    /** Resume a suspended computer from its snapshot. Wakes take seconds; the disk is preserved. */
+    wake(computerId: string): Promise<OkResponse & {
+        id: string;
+    }>;
+    /** Suspend the computer. The disk is kept; wake it later to resume. */
+    stop(computerId: string): Promise<OkResponse>;
+    /** Re-provision a computer whose sandbox is missing or wedged. The persistent volume is reattached. */
+    repair(computerId: string): Promise<OkResponse>;
+    /** Destroy the computer and delete its disk. Permanent; use stop() to keep the files. */
+    destroy(computerId: string): Promise<OkResponse>;
+    /**
+     * 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: string, options: ExecOptions): ExecStream;
+}

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

@@ -0,0 +1,152 @@
+import { type KazzleHttp } from './http';
+import type { ActionResult, ListResponse } from './sdk.types';
+declare class DesktopSessionsApi {
+    private readonly http;
+    constructor(http: KazzleHttp);
+    /** Create a live desktop session (virtual display) for input actions. */
+    create(computerId: string, options?: {
+        name?: string;
+        resolution?: string;
+    }): Promise<ActionResult>;
+    list(computerId: string): Promise<ListResponse<Record<string, unknown>> & ActionResult>;
+    close(computerId: string, sessionId: string): Promise<ActionResult>;
+}
+/** Mouse and keyboard input inside a live session. Every body carries the sessionId. */
+declare class DesktopInputApi {
+    private readonly http;
+    constructor(http: KazzleHttp);
+    private post;
+    click(computerId: string, body: {
+        sessionId: string;
+        x: number;
+        y: number;
+        button?: string;
+    }): Promise<ActionResult>;
+    doubleClick(computerId: string, body: {
+        sessionId: string;
+        x: number;
+        y: number;
+    }): Promise<ActionResult>;
+    mouseDown(computerId: string, body: {
+        sessionId: string;
+        x: number;
+        y: number;
+        button?: string;
+    }): Promise<ActionResult>;
+    mouseUp(computerId: string, body: {
+        sessionId: string;
+        x: number;
+        y: number;
+        button?: string;
+    }): Promise<ActionResult>;
+    move(computerId: string, body: {
+        sessionId: string;
+        x: number;
+        y: number;
+    }): Promise<ActionResult>;
+    drag(computerId: string, body: {
+        sessionId: string;
+        x: number;
+        y: number;
+        toX: number;
+        toY: number;
+    }): Promise<ActionResult>;
+    scroll(computerId: string, body: {
+        sessionId: string;
+        deltaX?: number;
+        deltaY?: number;
+        x?: number;
+        y?: number;
+    }): Promise<ActionResult>;
+    type(computerId: string, body: {
+        sessionId: string;
+        text: string;
+    }): Promise<ActionResult>;
+    /** Press a key combo, e.g. "ctrl+c". */
+    key(computerId: string, body: {
+        sessionId: string;
+        key: string;
+    }): Promise<ActionResult>;
+}
+/** Structured control of applications (attach, inspect the UI tree, press elements). */
+declare class DesktopAppsApi {
+    private readonly http;
+    constructor(http: KazzleHttp);
+    private post;
+    /** List the applications available on the computer with their bundle ids. */
+    list(computerId: string): Promise<ActionResult>;
+    /** Start (attach to) an application. The result row carries controlled_app_session_id. */
+    start(computerId: string, body: {
+        bundleId: string;
+        windowTitle?: string;
+        physicalInput?: boolean;
+    }): Promise<ActionResult>;
+    stop(computerId: string, body: {
+        controlledAppSessionId: string;
+    }): Promise<ActionResult>;
+    status(computerId: string, body: {
+        controlledAppSessionId: string;
+    }): Promise<ActionResult>;
+    /** Accessibility-tree inspection of the controlled application. */
+    inspect(computerId: string, body: {
+        controlledAppSessionId: string;
+        depth?: number;
+    }): Promise<ActionResult>;
+    press(computerId: string, body: {
+        controlledAppSessionId: string;
+        elementPath: string;
+    }): Promise<ActionResult>;
+    setValue(computerId: string, body: {
+        controlledAppSessionId: string;
+        elementPath: string;
+        value: string;
+    }): Promise<ActionResult>;
+    /** Screenshot the controlled application's window. Returns PNG bytes. */
+    capture(computerId: string, body: {
+        controlledAppSessionId: string;
+    }): Promise<Uint8Array>;
+}
+declare class DesktopWindowsApi {
+    private readonly http;
+    constructor(http: KazzleHttp);
+    /** The active window in a live session. */
+    active(computerId: string, body: {
+        sessionId: string;
+    }): Promise<ActionResult>;
+    /** Raise a window of a controlled application. */
+    raise(computerId: string, body: {
+        controlledAppSessionId: string;
+        windowPath: string;
+    }): Promise<ActionResult>;
+    /** Move/resize a window inside a live session. */
+    place(computerId: string, body: {
+        sessionId: string;
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+        controlledAppSessionId?: string;
+        windowPath?: string;
+    }): Promise<ActionResult>;
+}
+export declare class DesktopApi {
+    private readonly http;
+    readonly sessions: DesktopSessionsApi;
+    readonly input: DesktopInputApi;
+    readonly apps: DesktopAppsApi;
+    readonly windows: DesktopWindowsApi;
+    constructor(http: KazzleHttp);
+    /** Screenshot a display. Omit displayId for the primary display. Returns PNG bytes. */
+    capture(computerId: string, options?: {
+        displayId?: string;
+    }): Promise<Uint8Array>;
+    /** List the computer's displays with ids for capture(). */
+    displays(computerId: string): Promise<ActionResult>;
+    /** Check screen-recording / input permissions on the computer. */
+    permissions(computerId: string): Promise<ActionResult>;
+    /** Screen geometry for a live session. */
+    screen(computerId: string, body: {
+        sessionId: string;
+    }): Promise<ActionResult>;
+}
+export {};

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