withruntime 0.11.2 → 0.14.0

package/dist/record-cli.js

@@ -0,0 +1,308 @@
+import { spawn } from "node:child_process";
+import { RuntimeError } from "./errors.js";
+import { named } from "./cli-name.js";
+/** Private until launch. CLOUD.md section 4. cli.ts does not call this module. */
+export const RECORD_PRODUCTS = ["queue", "stream"];
+export const RECORD_HELP = {
+    queue: `runtime queue <command> (private until launch)
+  create --name work [--input '{"settings":{"fifo":false}}']
+  get <id> | list [--input '{"limit":10}']
+  update <id> --input '{"labels":{"team":"orders"}}'
+  delete <id> | purge <id>
+  send <id> --input '{"body":"hello"}'
+  receive <id> [--input '{"max":1,"waitSeconds":20}']
+  consume <id> --exec '<command>' [--max 1] [--wait-seconds 20]
+    [--visibility-seconds 30]  Body on stdin; exit 0 acknowledges.
+    A failure releases the message immediately. max counts attempts, including
+    failures. Omit max to run until Ctrl-C. Cancellation releases known receipts.
+    --timeout-ms bounds each network call (default 30000); settlement can finish
+    after cancellation. Set visibility longer than processing; repeats are possible.
+    Consume makes a key per operation; --idempotency-key does not apply.
+  ack <id> --input '{"receiptHandles":["receipt"]}'
+  retry <id> --input '{"receiptHandle":"receipt","visibilitySeconds":0}'
+  wait <id> [--state ready|deleted] [--poll-ms 250]
+  Every call: --idempotency-key <key> --timeout-ms <ms>; use --json for JSON.
+  Retry a lost reply with the same key and input. Receives also need that key.
+  Settings: visibilityTimeoutSeconds, retentionSeconds, maxMessageBytes,
+  delaySeconds, fifo, deadLetter {queue,maxReceives}. At most 32 labels.
+  Send: body, attributes, delaySeconds, groupId, dedupId. Receive: max 1-10,
+  waitSeconds 0-20, visibilitySeconds. get returns the SQS URL.
+`,
+    stream: `runtime stream <command> (private until launch)
+  create --name events [--input '{"partitions":1}']
+  get <id> | list [--input '{"limit":10}']
+  update <id> --input '{"retentionMs":86400000}' | delete <id>
+  publish <id> --input '{"records":[{"key":"order","value":"hello","headers":[]}]}'
+  read <id> --input '{"partition":0,"offset":"0","maxBytes":1048576,"waitMs":0}'
+  trim <id> --input '{"partition":0,"before":"100"}'
+  wait <id> [--state ready|deleted] [--poll-ms 250]
+  Every call: --idempotency-key <key> --timeout-ms <ms>; use --json for JSON.
+  Retry a lost reply with the same key and input. Offsets and retentionBytes
+  are decimal strings. Read takes offset OR time (Unix milliseconds).
+  get returns the Kafka bootstrap address and topic. At most 32 labels.
+`,
+};
+function usage(product, message) {
+    throw new RuntimeError({
+        code: "usage",
+        status: 0,
+        message,
+        hint: `Run \`${named("runtime")} ${product} help\`.`,
+    });
+}
+/** Parsed like networkProductCommand; never obtains credentials for help or bad flags. */
+export async function recordCommand(product, args, out, client, signal) {
+    if (args.rest?.length)
+        usage(product, "This command takes no arguments after --.");
+    const [given = "help", id, ...extra] = args.positional;
+    const verb = given === "ls" ? "list" : given === "rm" ? "delete" : given;
+    const actions = product === "queue"
+        ? ["send", "receive", "ack", "retry", "purge", "consume"]
+        : ["publish", "read", "trim"];
+    if (!["help", "create", "get", "list", "update", "delete", "wait", ...actions].includes(verb))
+        usage(product, `Unknown command ${given}.`);
+    const hasInput = [
+        "create",
+        "list",
+        "update",
+        "send",
+        "receive",
+        "ack",
+        "retry",
+        "publish",
+        "read",
+        "trim",
+    ].includes(verb);
+    const allowed = new Set([
+        ...(verb === "consume" ? [] : ["idempotency-key"]),
+        "timeout-ms",
+        ...(hasInput ? ["input"] : []),
+        ...(verb === "create" ? ["name"] : []),
+        ...(verb === "wait" ? ["state", "poll-ms"] : []),
+        ...(verb === "consume" ? ["exec", "max", "wait-seconds", "visibility-seconds"] : []),
+    ]);
+    for (const [flag, values] of args.flags) {
+        if (!allowed.has(flag))
+            usage(product, `Unknown option --${flag} for ${verb}.`);
+        if (values.length !== 1 || !values[0])
+            usage(product, `Give --${flag} exactly once with a value.`);
+    }
+    if (extra.length || (["help", "create", "list"].includes(verb) && id))
+        usage(product, "Unexpected positional argument.");
+    if (verb === "help") {
+        out.write(named(RECORD_HELP[product]));
+        return 0;
+    }
+    if (!["create", "list"].includes(verb) && !id)
+        usage(product, "Give the resource id.");
+    const flag = (key) => args.flags.get(key)?.[0];
+    const number = (key) => {
+        const text = flag(key);
+        if (text === undefined)
+            return undefined;
+        const value = Number(text);
+        if (!/^\d+$/.test(text) || !Number.isSafeInteger(value))
+            usage(product, `--${key} needs a nonnegative safe integer.`);
+        return value;
+    };
+    let input = {};
+    if (flag("input") !== undefined) {
+        try {
+            input = JSON.parse(flag("input"));
+        }
+        catch {
+            usage(product, "--input needs a JSON object.");
+        }
+        if (!input || Array.isArray(input) || typeof input !== "object")
+            usage(product, "--input needs a JSON object.");
+    }
+    if (flag("name")) {
+        if (Object.hasOwn(input, "name"))
+            usage(product, "Give name in --name or --input, not both.");
+        input.name = flag("name");
+    }
+    if (verb === "create" && (typeof input.name !== "string" || !input.name.trim()))
+        usage(product, "Give a name with --name or --input.");
+    if (["update", "send", "ack", "retry", "publish", "read", "trim"].includes(verb) &&
+        !flag("input"))
+        usage(product, `${verb} needs --input.`);
+    const state = flag("state") ?? "ready";
+    if (verb === "wait" && state !== "ready" && state !== "deleted")
+        usage(product, "--state must be ready or deleted.");
+    const timeoutMs = number("timeout-ms");
+    const pollMs = number("poll-ms");
+    const options = {
+        idempotencyKey: flag("idempotency-key") ?? crypto.randomUUID(),
+        ...(timeoutMs === undefined ? {} : { timeoutMs }),
+    };
+    const consumeOptions = verb === "consume"
+        ? {
+            ...(number("max") === undefined ? {} : { max: number("max") }),
+            ...(number("wait-seconds") === undefined ? {} : { waitSeconds: number("wait-seconds") }),
+            ...(number("visibility-seconds") === undefined
+                ? {}
+                : { visibilitySeconds: number("visibility-seconds") }),
+            ...(timeoutMs === undefined ? {} : { timeoutMs }),
+        }
+        : {};
+    if (verb === "consume") {
+        if (!flag("exec")?.trim())
+            usage(product, "consume needs --exec with a command.");
+        if ((consumeOptions.waitSeconds ?? 20) > 20)
+            usage(product, "--wait-seconds must be 0 to 20.");
+        if ((consumeOptions.visibilitySeconds ?? 30) > 43_200)
+            usage(product, "--visibility-seconds must be 0 to 43200.");
+        if (timeoutMs !== undefined && (timeoutMs < 1 || timeoutMs > 2_147_483_647))
+            usage(product, "consume --timeout-ms must be 1 to 2147483647.");
+    }
+    const api = await client();
+    const resource = product === "queue" ? api.queues : api.streams;
+    let result;
+    switch (verb) {
+        case "consume": {
+            const stopped = new AbortController();
+            const interrupt = () => stopped.abort();
+            const combined = signal ? AbortSignal.any([signal, stopped.signal]) : stopped.signal;
+            process.on("SIGINT", interrupt);
+            process.on("SIGTERM", interrupt);
+            try {
+                const consumed = await api.queues.consume(id, (message, running) => executeMessage(flag("exec"), message.body, running, out), { ...consumeOptions, signal: combined });
+                out.write(JSON.stringify(consumed, null, out.json ? undefined : 2));
+                return consumed.aborted ? 130 : consumed.retried ? 1 : 0;
+            }
+            finally {
+                process.removeListener("SIGINT", interrupt);
+                process.removeListener("SIGTERM", interrupt);
+            }
+        }
+        case "create":
+            result =
+                product === "queue"
+                    ? await api.queues.create(input, options)
+                    : await api.streams.create(input, options);
+            break;
+        case "update":
+            result =
+                product === "queue"
+                    ? await api.queues.update(id, input, options)
+                    : await api.streams.update(id, input, options);
+            break;
+        case "list":
+            result = await resource.list(input, options);
+            break;
+        case "get":
+            result = await resource.get(id, options);
+            break;
+        case "delete":
+            result = await resource.delete(id, options);
+            break;
+        case "wait":
+            result = await resource.wait(id, state, {
+                ...options,
+                ...(pollMs === undefined ? {} : { pollMs }),
+            });
+            break;
+        case "send":
+            result = await api.queues.send(id, input, options);
+            break;
+        case "receive":
+            result = await api.queues.receive(id, input, options);
+            break;
+        case "ack": {
+            const receipts = await api.queues.ack(id, input, options);
+            if (receipts.failed.length)
+                throw new RuntimeError({
+                    code: receipts.failed[0].code,
+                    status: 0,
+                    message: receipts.failed[0].message,
+                    hint: receipts.failed[0].hint,
+                    details: { ...receipts },
+                    idempotencyKey: options.idempotencyKey,
+                });
+            result = receipts;
+            break;
+        }
+        case "retry":
+            result = await api.queues.retry(id, input, options);
+            break;
+        case "purge":
+            result = await api.queues.purge(id, options);
+            break;
+        case "publish":
+            result = await api.streams.publish(id, input, options);
+            break;
+        case "read":
+            result = await api.streams.read(id, input, options);
+            break;
+        case "trim":
+            result = await api.streams.trim(id, input, options);
+            break;
+    }
+    // Include cursors, receipt failures and endpoint settings in either output mode.
+    out.write(JSON.stringify(result, null, out.json ? undefined : 2));
+    return 0;
+}
+/** Only the requested command is shell code. Message bytes go through stdin.
+ * Output goes to stderr so stdout keeps the CLI's JSON result parseable. */
+function executeMessage(command, body, signal, out) {
+    return new Promise((resolve, reject) => {
+        const failed = (message) => new RuntimeError({
+            code: "command_failed",
+            status: 0,
+            message,
+            hint: "Fix the consumer command; the message will be made visible again.",
+        });
+        if (signal.aborted) {
+            reject(failed("Consumer command cancelled."));
+            return;
+        }
+        const grouped = process.platform !== "win32";
+        const child = spawn(command, {
+            shell: true,
+            detached: grouped,
+            stdio: ["pipe", "pipe", "pipe"],
+        });
+        const abort = () => {
+            if (grouped && child.pid) {
+                try {
+                    process.kill(-child.pid, "SIGKILL");
+                }
+                catch (error) {
+                    if (error.code !== "ESRCH")
+                        child.kill("SIGKILL");
+                }
+            }
+            else
+                child.kill("SIGKILL");
+        };
+        signal.addEventListener("abort", abort, { once: true });
+        if (signal.aborted)
+            abort();
+        child.stdout.on("data", (bytes) => out.error(bytes.toString("utf8")));
+        child.stderr.on("data", (bytes) => out.error(bytes.toString("utf8")));
+        let inputError;
+        child.stdin.on("error", (error) => {
+            if (error.code !== "EPIPE") {
+                inputError = error;
+                abort();
+            }
+        });
+        child.once("error", (error) => {
+            signal.removeEventListener("abort", abort);
+            const failure = failed(`Consumer could not start: ${error.message}`);
+            out.error(`${failure.code}: ${failure.message} ${failure.hint}`);
+            reject(failure);
+        });
+        child.once("close", (code, killed) => {
+            signal.removeEventListener("abort", abort);
+            if (code === 0 && !signal.aborted && !inputError) {
+                resolve();
+                return;
+            }
+            const failure = failed(inputError?.message ?? `Consumer exited ${code ?? killed ?? "without a status"}.`);
+            out.error(`${failure.code}: ${failure.message} ${failure.hint}`);
+            reject(failure);
+        });
+        child.stdin.end(body);
+    });
+}

package/dist/renamed-products.d.ts

@@ -0,0 +1,38 @@
+import { type ProductName } from "./product-names.js";
+import type { Sandboxes } from "./client.js";
+import type { Snapshots } from "./snapshots.js";
+import type { ClientExtensions } from "./products/index.js";
+/** The client's properties under their old words, each the product it became. */
+export type RenamedProducts = {
+    /** @deprecated Renamed `runtime.sandboxes`; works for 30 days after the rename, with a warning. */
+    readonly sandbox: Sandboxes;
+    /** @deprecated Renamed `runtime.snapshots`; works for 30 days after the rename, with a warning. */
+    readonly snapshot: Snapshots;
+    /** @deprecated Renamed `runtime.images`; works for 30 days after the rename, with a warning. */
+    readonly image: ClientExtensions["images"];
+    /** @deprecated Renamed `runtime.volumes`; works for 30 days after the rename, with a warning. */
+    readonly volume: ClientExtensions["volumes"];
+    /** @deprecated Renamed `runtime.jobs`; works for 30 days after the rename, with a warning. */
+    readonly job: ClientExtensions["jobs"];
+    /** @deprecated Renamed `runtime.domains`; works for 30 days after the rename, with a warning. */
+    readonly domain: ClientExtensions["domains"];
+    /** @deprecated Renamed `runtime.ports`; works for 30 days after the rename, with a warning. */
+    readonly port: ClientExtensions["ports"];
+    /** @deprecated Renamed `runtime.ips`; works for 30 days after the rename, with a warning. */
+    readonly address: ClientExtensions["ips"];
+    /** @deprecated Renamed `runtime.ips`; works for 30 days after the rename, with a warning. */
+    readonly addresses: ClientExtensions["ips"];
+    /** @deprecated Renamed `runtime.networks`; works for 30 days after the rename, with a warning. */
+    readonly network: ClientExtensions["networks"];
+    /** @deprecated Renamed `runtime.networks.wireguard`; works for 30 days after the rename, with a warning. */
+    readonly tunnel: ClientExtensions["networks"]["wireguard"];
+};
+/** Puts each old word on `client` as a property that answers the product it
+ * became and says so once per process, or, from the table's date, throws
+ * name_retired with a hint naming the new property. An old word the client
+ * already uses for something else is left alone. */
+export declare function installRenamedProducts(client: object, options?: {
+    now?: () => Date;
+    table?: readonly ProductName[];
+    say?: (line: string) => void;
+}): void;

package/dist/renamed-products.js

@@ -0,0 +1,34 @@
+import { RuntimeError } from "./errors.js";
+import { PRODUCT_NAMES, wordOf } from "./product-names.js";
+import { resolveWord, sdkPath } from "./product-renames.js";
+const said = new Set();
+/** Puts each old word on `client` as a property that answers the product it
+ * became and says so once per process, or, from the table's date, throws
+ * name_retired with a hint naming the new property. An old word the client
+ * already uses for something else is left alone. */
+export function installRenamedProducts(client, options = {}) {
+    const table = options.table ?? PRODUCT_NAMES;
+    for (const product of table) {
+        for (const old of product.old) {
+            const [property] = sdkPath(wordOf(old.name));
+            if (property === undefined || property in client)
+                continue;
+            Object.defineProperty(client, property, {
+                configurable: true,
+                enumerable: false,
+                get() {
+                    const use = resolveWord(old.name, "sdk", options.now?.() ?? new Date(), table);
+                    if (use === undefined || use.kind === "current")
+                        return undefined;
+                    if (use.kind === "retired")
+                        throw new RuntimeError({ ...use.error });
+                    if (!said.has(use.warning)) {
+                        said.add(use.warning);
+                        (options.say ?? console.warn)(`Runtime: ${use.warning}`);
+                    }
+                    return sdkPath(use.to).reduce((at, key) => at[key], client);
+                },
+            });
+        }
+    }
+}

package/dist/runloop/index.d.ts

@@ -1,4 +1,5 @@
 import { PagePromise, DevboxViewsCursorIDPage } from "./pagination.js";
+export { RunloopSDK, Devbox, Execution, ExecutionResult, RunloopError } from "./sdk.js";
 import type { Runtime } from "../client.js";
 import { Sandbox } from "../sandbox.js";
 import { DiskSnapshots, type DevboxSnapshotDiskParams, type DevboxSnapshotView, type DiskSnapshotListParams } from "./snapshots.js";
@@ -101,6 +102,12 @@ export interface DevboxListParams {
 }
 export declare class Runloop {
     readonly devboxes: Devboxes;
+    get secrets(): never;
+    get objects(): never;
+    get axons(): never;
+    get gatewayConfigs(): never;
+    get mcpConfigs(): never;
+    get networkPolicies(): never;
     constructor(options?: ClientOptions & {
         bearerToken?: string;
         baseURL?: string;
@@ -302,10 +309,10 @@ export declare class Executions {
     kill(id: string, execution: string, body?: {
         kill_process_group?: boolean | null;
     } | RequestOptions, options?: RequestOptions): Promise<DevboxAsyncExecutionDetailView>;
-    sendStdIn(id: string, execution: string, body?: {
+    sendStdIn(id: string, execution: string, body: {
         text?: string | null;
         signal?: "EOF" | "INTERRUPT" | null;
-    } | RequestOptions, options?: RequestOptions): Promise<{
+    }, options?: RequestOptions): Promise<{
         devbox_id: string;
         execution_id: string;
         success: boolean;

package/dist/runloop/index.js

@@ -1,5 +1,7 @@
 import { PagePromise, DevboxViewsCursorIDPage } from "./pagination.js";
+export { RunloopSDK, Devbox, Execution, ExecutionResult, RunloopError } from "./sdk.js";
 import { Sandbox } from "../sandbox.js";
+import { timeoutSignal } from "../transport.js";
 import { DiskSnapshots, requestOptions, snapshotOptions, snapshotView, nativeOptions, } from "./snapshots.js";
 export { DiskSnapshots, } from "./snapshots.js";
 export { PagePromise, DevboxSnapshotViewsDiskSnapshotsCursorIDPage, DevboxViewsCursorIDPage, } from "./pagination.js";
@@ -82,6 +84,24 @@ function view(sandbox) {
 }
 export class Runloop {
     devboxes;
+    get secrets() {
+        throw new CompatibilityError("Runloop", "duplicate-name secret rows and secret-ID handles; use the Runtime secrets API");
+    }
+    get objects() {
+        throw new CompatibilityError("Runloop", "signed storage-object uploads; use Runtime sandbox files");
+    }
+    get axons() {
+        throw new CompatibilityError("Runloop", "Axon registries and deleted event records; use the Runtime events API");
+    }
+    get gatewayConfigs() {
+        throw new CompatibilityError("Runloop", "named gateway bindings; use the Runtime secrets API with direct service requests");
+    }
+    get mcpConfigs() {
+        throw new CompatibilityError("Runloop", "named MCP grants; use the Runtime secrets API with your MCP client");
+    }
+    get networkPolicies() {
+        throw new CompatibilityError("Runloop", "reusable named network-policy bindings; use Runtime sandbox egress settings");
+    }
     constructor(options = {}) {
         const { bearerToken, baseURL, ...rest } = options;
         this.devboxes = new Devboxes(client({ ...rest, apiKey: rest.apiKey ?? bearerToken, baseUrl: rest.baseUrl ?? baseURL }));
@@ -217,7 +237,7 @@ export class Devboxes {
             throw new Error("timeoutMs must be positive");
         if (options.signal?.aborted)
             throw new LongPollAbortError("Long poll aborted", undefined);
-        const deadline = timeoutMs === undefined ? undefined : AbortSignal.timeout(timeoutMs);
+        const deadline = timeoutMs === undefined ? undefined : timeoutSignal(timeoutMs);
         const signal = deadline && options.signal
             ? AbortSignal.any([deadline, options.signal])
             : (deadline ?? options.signal);
@@ -484,21 +504,22 @@ export class Executions {
         await (await (await lookup(this.runtime, id, nativeOptions(options))).processes.get(execution, nativeOptions(options))).kill("SIGKILL", nativeOptions(options));
         return this.retrieve(id, execution, {}, options);
     }
-    async sendStdIn(id, execution, body = {}, options = {}) {
-        if (requestOptions(body) &&
-            (body.signal === undefined || (typeof body.signal === "object" && body.signal !== null)))
-            return this.sendStdIn(id, execution, {}, body);
+    async sendStdIn(id, execution, body, options = {}) {
         options.signal?.throwIfAborted();
+        if (!body || typeof body !== "object" || Array.isArray(body))
+            throw new TypeError("Runloop stdin requires a body with nonempty text or a signal");
         only("Runloop stdin", body, ["text", "signal"]);
-        const text = "text" in body ? body.text : undefined;
+        const text = body.text;
         const bodySignal = body.signal;
-        if (text !== undefined && text !== null && typeof text !== "string")
-            throw new TypeError("Runloop stdin text must be a string");
+        if (text !== undefined && text !== null && (typeof text !== "string" || text.length === 0))
+            throw new TypeError("Runloop stdin text must be a nonempty string");
         if (bodySignal !== undefined &&
             bodySignal !== null &&
             bodySignal !== "EOF" &&
             bodySignal !== "INTERRUPT")
             throw new TypeError("Runloop stdin signal must be EOF or INTERRUPT");
+        if ((text != null) === (bodySignal != null))
+            throw new TypeError("Runloop stdin requires exactly one of nonempty text or a signal");
         if (options.idempotencyKey !== undefined && (text || bodySignal === "EOF"))
             throw new CompatibilityError("Runloop", "caller idempotency keys for process input; native offsets protect transport retries");
         const p = await (await lookup(this.runtime, id, nativeOptions(options))).processes.get(execution, nativeOptions(options));

package/dist/runloop/sdk.d.ts

@@ -0,0 +1,131 @@
+import { Runloop, type DevboxAsyncExecutionDetailView, type DevboxCreateParams, type DevboxExecuteParams, type RequestOptions } from "./index.js";
+export declare class RunloopError extends Error {
+    constructor(message: string);
+}
+/** The high-level command handles share the low-level adapter's validation,
+ * cancellation and process input path; they never send a provider request. */
+export declare class RunloopSDK {
+    readonly api: Runloop;
+    readonly devbox: {
+        fromId: (id: string) => Devbox;
+        create: (params?: DevboxCreateParams, request?: RequestOptions) => Promise<Devbox>;
+    };
+    constructor(options?: ConstructorParameters<typeof Runloop>[0]);
+    get secret(): never;
+    get storageObject(): never;
+    get axon(): never;
+    get gatewayConfig(): never;
+    get mcpConfig(): never;
+    get networkPolicy(): never;
+}
+export declare class Devbox {
+    private readonly client;
+    readonly id: string;
+    readonly cmd: {
+        execAsync: (command: string, params?: Omit<DevboxExecuteParams, "command">, options?: RequestOptions) => Promise<Execution>;
+        exec: (command: string, params?: Omit<DevboxExecuteParams, "command">, options?: RequestOptions) => Promise<ExecutionResult>;
+    };
+    constructor(client: Runloop, id: string);
+    getInfo(options?: RequestOptions): Promise<{
+        id: string;
+        name: string | null;
+        metadata: {
+            [k: string]: string;
+        };
+        status: string;
+        create_time_ms: number;
+        end_time_ms: number | null;
+        capabilities: never[];
+        state_transitions: never[];
+        launch_parameters: {
+            custom_cpu_cores: number;
+            custom_gb_memory: number;
+            custom_disk_size: number;
+            keep_alive_time_seconds: number;
+            resource_size_request: "CUSTOM_SIZE";
+        };
+    }>;
+    shutdown(options?: RequestOptions): Promise<{
+        id: string;
+        name: string | null;
+        metadata: {
+            [k: string]: string;
+        };
+        status: string;
+        create_time_ms: number;
+        end_time_ms: number | null;
+        capabilities: never[];
+        state_transitions: never[];
+        launch_parameters: {
+            custom_cpu_cores: number;
+            custom_gb_memory: number;
+            custom_disk_size: number;
+            keep_alive_time_seconds: number;
+            resource_size_request: "CUSTOM_SIZE";
+        };
+    }>;
+    suspend(options?: RequestOptions): Promise<{
+        id: string;
+        name: string | null;
+        metadata: {
+            [k: string]: string;
+        };
+        status: string;
+        create_time_ms: number;
+        end_time_ms: number | null;
+        capabilities: never[];
+        state_transitions: never[];
+        launch_parameters: {
+            custom_cpu_cores: number;
+            custom_gb_memory: number;
+            custom_disk_size: number;
+            keep_alive_time_seconds: number;
+            resource_size_request: "CUSTOM_SIZE";
+        };
+    }>;
+    resume(options?: RequestOptions): Promise<{
+        id: string;
+        name: string | null;
+        metadata: {
+            [k: string]: string;
+        };
+        status: string;
+        create_time_ms: number;
+        end_time_ms: number | null;
+        capabilities: never[];
+        state_transitions: never[];
+        launch_parameters: {
+            custom_cpu_cores: number;
+            custom_gb_memory: number;
+            custom_disk_size: number;
+            keep_alive_time_seconds: number;
+            resource_size_request: "CUSTOM_SIZE";
+        };
+    }>;
+}
+export declare class Execution {
+    private readonly client;
+    readonly devboxId: string;
+    readonly executionId: string;
+    private readonly streamingPromise?;
+    constructor(client: Runloop, devboxId: string, executionId: string, _initialResult: DevboxAsyncExecutionDetailView, streamingPromise?: Promise<void> | undefined);
+    sendStdIn(input: string, options?: RequestOptions): Promise<void>;
+    closeStdIn(options?: RequestOptions): Promise<void>;
+    private input;
+    getState(options?: RequestOptions): Promise<DevboxAsyncExecutionDetailView>;
+    kill(options?: RequestOptions): Promise<void>;
+    result(options?: RequestOptions): Promise<ExecutionResult>;
+}
+export declare class ExecutionResult {
+    private readonly client;
+    private readonly devboxId;
+    readonly executionId: string;
+    readonly result: DevboxAsyncExecutionDetailView;
+    constructor(client: Runloop, devboxId: string, executionId: string, result: DevboxAsyncExecutionDetailView);
+    get exitCode(): number | null;
+    get success(): boolean;
+    get failed(): boolean;
+    stdout(numLines?: number): Promise<string>;
+    stderr(numLines?: number): Promise<string>;
+    private output;
+}