withruntime 0.3.1 → 0.5.0

package/dist/e2b/client.d.ts

@@ -0,0 +1,58 @@
+import { Runtime } from "../client.js";
+/** The Runtime sandbox the adapter drives. */
+export type RuntimeSandbox = Awaited<ReturnType<Runtime["sandboxes"]["create"]>>;
+/** What `Sandbox.create` sends to Runtime. */
+export type RuntimeCreate = NonNullable<Parameters<Runtime["sandboxes"]["create"]>[0]>;
+/** E2B's connection options, as far as they mean anything on Runtime. */
+export interface ConnectionOpts {
+    /** A Runtime key. Default: RUNTIME_API_KEY, then E2B_API_KEY if it holds a
+     * Runtime key, then the key `npx withruntime login` saved. An E2B key
+     * (`e2b_...`) is never sent anywhere. */
+    apiKey?: string;
+    /** Per call, retries included. */
+    requestTimeoutMs?: number;
+    signal?: AbortSignal;
+    /** Accepted and ignored, as E2B ignores them. */
+    validateApiKey?: boolean;
+    /** Accepted and ignored: Runtime's SDK retries by itself. */
+    retries?: number;
+    /** Accepted and ignored: Runtime's SDK does not take a logger. */
+    logger?: unknown;
+    /** E2B endpoints. Refused: this package only talks to Runtime. */
+    domain?: string;
+    apiUrl?: string;
+    sandboxUrl?: string;
+    debug?: boolean;
+    headers?: Record<string, string>;
+    apiHeaders?: Record<string, string>;
+    proxy?: string;
+}
+/** Runtime-only options, for code that has been through the switch. */
+export interface RuntimeOpts {
+    /** A Runtime client to use instead of one made from the key. */
+    client?: Runtime;
+    /** Fields sent as they are with the create, over the adapter's own: for
+     * example `{ funding: "trial" }`, `{ memoryMiB: 4096 }` or `{ region }`. */
+    create?: Partial<RuntimeCreate>;
+}
+/** Refuses the E2B-only connection options: they point at E2B, and quietly
+ * dropping one would send the call somewhere its author did not mean. */
+export declare function refuseE2BConnection(opts?: ConnectionOpts): void;
+/** The Runtime client for these options: an explicit client, else one per key,
+ * made once and reused so its connections stay open. */
+export declare function clientFor(opts?: ConnectionOpts & {
+    runtime?: RuntimeOpts;
+}): Runtime;
+/** Explicit key, then RUNTIME_API_KEY, then E2B_API_KEY when it holds a
+ * Runtime key; undefined lets the Runtime SDK find the saved login. */
+export declare function pickKey(explicit?: string): string | undefined;
+/** Test hook: forget the cached clients. */
+export declare function resetClients(): void;
+/** Request options for a Runtime call from E2B's. */
+export declare function request(opts?: {
+    requestTimeoutMs?: number;
+    signal?: AbortSignal;
+}): {
+    signal?: AbortSignal | undefined;
+    timeoutMs?: number | undefined;
+};

package/dist/e2b/client.js

@@ -0,0 +1,66 @@
+import { Runtime } from "../client.js";
+import { AuthenticationError, NotSupportedError } from "./errors.js";
+const env = (name) => typeof process === "undefined" ? undefined : process.env[name];
+const isE2BKey = (key) => key.startsWith("e2b_");
+/** Refuses the E2B-only connection options: they point at E2B, and quietly
+ * dropping one would send the call somewhere its author did not mean. */
+export function refuseE2BConnection(opts = {}) {
+    for (const field of [
+        "domain",
+        "apiUrl",
+        "sandboxUrl",
+        "headers",
+        "apiHeaders",
+        "proxy",
+    ]) {
+        if (opts[field] !== undefined)
+            throw new NotSupportedError(`The E2B connection option "${field}"`, field === "proxy"
+                ? "Set HTTPS_PROXY in the environment instead; Runtime's SDK reads it."
+                : "Remove it: this package talks only to Runtime (RUNTIME_API_URL overrides the API origin).");
+    }
+    if (opts.debug)
+        throw new NotSupportedError("E2B's debug mode (a local envd)", "Remove debug: true; there is no local Runtime guest to connect to.");
+}
+const clients = new Map();
+/** The Runtime client for these options: an explicit client, else one per key,
+ * made once and reused so its connections stay open. */
+export function clientFor(opts = {}) {
+    refuseE2BConnection(opts);
+    if (opts.runtime?.client)
+        return opts.runtime.client;
+    const key = pickKey(opts.apiKey);
+    const cacheKey = key ?? "";
+    let client = clients.get(cacheKey);
+    if (!client) {
+        client = new Runtime(key ? { apiKey: key } : {});
+        clients.set(cacheKey, client);
+    }
+    return client;
+}
+/** Explicit key, then RUNTIME_API_KEY, then E2B_API_KEY when it holds a
+ * Runtime key; undefined lets the Runtime SDK find the saved login. */
+export function pickKey(explicit) {
+    const runtimeKey = env("RUNTIME_API_KEY");
+    if (explicit !== undefined && !isE2BKey(explicit))
+        return explicit;
+    if (runtimeKey)
+        return runtimeKey;
+    if (explicit !== undefined)
+        throw new AuthenticationError("The apiKey passed is an E2B API key (e2b_...), and it was not sent. Set RUNTIME_API_KEY to a Runtime key " +
+            "(https://withruntime.com/account/keys, or run `npx withruntime login`), or pass the Runtime key as apiKey.");
+    // An E2B key left in E2B_API_KEY is skipped, never sent: the Runtime SDK
+    // then uses the key `npx withruntime login` saved, or says none was found.
+    const e2bVariable = env("E2B_API_KEY");
+    return e2bVariable && !isE2BKey(e2bVariable) ? e2bVariable : undefined;
+}
+/** Test hook: forget the cached clients. */
+export function resetClients() {
+    clients.clear();
+}
+/** Request options for a Runtime call from E2B's. */
+export function request(opts = {}) {
+    return {
+        ...(opts.requestTimeoutMs ? { timeoutMs: opts.requestTimeoutMs } : {}),
+        ...(opts.signal ? { signal: opts.signal } : {}),
+    };
+}

package/dist/e2b/code-interpreter.d.ts

@@ -0,0 +1,144 @@
+/** `@e2b/code-interpreter`, on Runtime. Change the import:
+ *
+ *   import { Sandbox } from "withruntime/e2b/code-interpreter";
+ *
+ * runCode runs in Runtime's interpreter (sandbox.runtime.interpreter):
+ * stateful Python and JavaScript contexts, as in E2B. Other languages throw
+ * NotSupportedError. */
+import type { Runtime } from "../client.js";
+import type { ConnectionOpts } from "./client.js";
+import { Sandbox as BaseSandbox } from "./sandbox.js";
+export * from "./index.js";
+export type RunCodeLanguage = "python" | "javascript" | "typescript" | "r" | "java" | "bash" | (string & {});
+/** A line of output, as E2B's callbacks receive it. */
+export declare class OutputMessage {
+    readonly line: string;
+    /** Unix epoch in nanoseconds (from the client's clock). */
+    readonly timestamp: number;
+    readonly error: boolean;
+    constructor(line: string, 
+    /** Unix epoch in nanoseconds (from the client's clock). */
+    timestamp: number, error: boolean);
+    toString(): string;
+}
+export declare class ExecutionError {
+    name: string;
+    value: string;
+    traceback: string;
+    constructor(name: string, value: string, traceback: string);
+}
+export type MIMEType = string;
+export type RawData = {
+    [key: MIMEType]: unknown;
+};
+type ResultFields = {
+    text?: string;
+    html?: string;
+    markdown?: string;
+    svg?: string;
+    png?: string;
+    jpeg?: string;
+    pdf?: string;
+    latex?: string;
+    json?: string;
+    javascript?: string;
+};
+/** One rich result, as E2B's: text, html, png (base64) and the rest. `chart`
+ * and E2B's `data` (its own DataFrame format) are never set on Runtime; a
+ * DataFrame arrives in `extra` under application/vnd.runtime.table+json. */
+export declare class Result implements ResultFields {
+    readonly isMainResult: boolean;
+    readonly text?: string;
+    readonly html?: string;
+    readonly markdown?: string;
+    readonly svg?: string;
+    readonly png?: string;
+    readonly jpeg?: string;
+    readonly pdf?: string;
+    readonly latex?: string;
+    readonly json?: string;
+    readonly javascript?: string;
+    readonly data?: Record<string, unknown>;
+    readonly chart?: undefined;
+    readonly extra?: Record<string, unknown>;
+    readonly raw: RawData;
+    constructor(rawData: RawData, isMainResult: boolean);
+    formats(): string[];
+    toJSON(): {
+        extra?: Record<string, unknown> | undefined;
+        text: string | undefined;
+        html: string | undefined;
+        markdown: string | undefined;
+        svg: string | undefined;
+        png: string | undefined;
+        jpeg: string | undefined;
+        pdf: string | undefined;
+        latex: string | undefined;
+        json: string | undefined;
+        javascript: string | undefined;
+    };
+}
+export type Logs = {
+    stdout: string[];
+    stderr: string[];
+};
+export declare class Execution {
+    results: Result[];
+    logs: Logs;
+    error?: ExecutionError | undefined;
+    executionCount?: number | undefined;
+    constructor(results?: Result[], logs?: Logs, error?: ExecutionError | undefined, executionCount?: number | undefined);
+    /** The main result's text. */
+    get text(): string | undefined;
+    toJSON(): {
+        results: Result[];
+        logs: Logs;
+        error: ExecutionError | undefined;
+    };
+}
+export type Context = {
+    id: string;
+    language: string;
+    cwd: string;
+};
+export interface RunCodeOpts {
+    onStdout?: (output: OutputMessage) => unknown;
+    onStderr?: (output: OutputMessage) => unknown;
+    onResult?: (data: Result) => unknown;
+    onError?: (error: ExecutionError) => unknown;
+    /** Refused when set: Runtime's contexts take their environment when made. */
+    envs?: Record<string, string>;
+    /** Default 60 000, as in E2B. */
+    timeoutMs?: number;
+    /** Accepted and ignored: Runtime's SDK allows the run its timeout plus a minute. */
+    requestTimeoutMs?: number;
+}
+export interface CreateCodeContextOpts {
+    cwd?: string;
+    language?: RunCodeLanguage;
+    requestTimeoutMs?: number;
+}
+/** The code interpreter sandbox: everything the base Sandbox has, plus runCode
+ * and code contexts. */
+export declare class Sandbox extends BaseSandbox {
+    #private;
+    protected static readonly defaultTemplate: string;
+    /** Runs code in a stateful context. Errors in the code come back in
+     * `execution.error`, as in E2B; a run past `timeoutMs` throws TimeoutError. */
+    runCode(code: string, opts?: RunCodeOpts & {
+        language?: RunCodeLanguage;
+        context?: Context;
+    }): Promise<Execution>;
+    createCodeContext(opts?: CreateCodeContextOpts): Promise<Context>;
+    removeCodeContext(context: Context | string): Promise<void>;
+    listCodeContexts(): Promise<Context[]>;
+    restartCodeContext(context: Context | string): Promise<void>;
+}
+export default Sandbox;
+/** E2B's client with bound options, for the code interpreter. */
+export declare class E2B {
+    readonly Sandbox: typeof Sandbox;
+    constructor(opts?: Omit<ConnectionOpts, "signal"> & {
+        client?: Runtime;
+    });
+}

package/dist/e2b/code-interpreter.js

@@ -0,0 +1,244 @@
+import { guard, NotSupportedError, SandboxError, TimeoutError } from "./errors.js";
+import { bind } from "./index.js";
+import { Sandbox as BaseSandbox } from "./sandbox.js";
+export * from "./index.js";
+/** A line of output, as E2B's callbacks receive it. */
+export class OutputMessage {
+    line;
+    timestamp;
+    error;
+    constructor(line, 
+    /** Unix epoch in nanoseconds (from the client's clock). */
+    timestamp, error) {
+        this.line = line;
+        this.timestamp = timestamp;
+        this.error = error;
+    }
+    toString() {
+        return this.line;
+    }
+}
+export class ExecutionError {
+    name;
+    value;
+    traceback;
+    constructor(name, value, traceback) {
+        this.name = name;
+        this.value = value;
+        this.traceback = traceback;
+    }
+}
+const FORMATS = {
+    "text/plain": "text",
+    "text/html": "html",
+    "text/markdown": "markdown",
+    "image/svg+xml": "svg",
+    "image/png": "png",
+    "image/jpeg": "jpeg",
+    "application/pdf": "pdf",
+    "text/latex": "latex",
+    "application/json": "json",
+    "application/javascript": "javascript",
+};
+/** One rich result, as E2B's: text, html, png (base64) and the rest. `chart`
+ * and E2B's `data` (its own DataFrame format) are never set on Runtime; a
+ * DataFrame arrives in `extra` under application/vnd.runtime.table+json. */
+export class Result {
+    isMainResult;
+    text;
+    html;
+    markdown;
+    svg;
+    png;
+    jpeg;
+    pdf;
+    latex;
+    json;
+    javascript;
+    data;
+    chart;
+    extra;
+    raw;
+    constructor(rawData, isMainResult) {
+        this.raw = rawData;
+        this.isMainResult = isMainResult;
+        const extra = {};
+        const fields = {};
+        for (const [mime, value] of Object.entries(rawData)) {
+            const field = FORMATS[mime];
+            if (field)
+                fields[field] = value;
+            else
+                extra[mime] = value;
+        }
+        Object.assign(this, fields);
+        if (Object.keys(extra).length)
+            this.extra = extra;
+    }
+    formats() {
+        return [
+            ...Object.values(FORMATS).filter((field) => this[field] !== undefined),
+            ...Object.keys(this.extra ?? {}),
+        ];
+    }
+    toJSON() {
+        return {
+            text: this.text,
+            html: this.html,
+            markdown: this.markdown,
+            svg: this.svg,
+            png: this.png,
+            jpeg: this.jpeg,
+            pdf: this.pdf,
+            latex: this.latex,
+            json: this.json,
+            javascript: this.javascript,
+            ...(this.extra ? { extra: this.extra } : {}),
+        };
+    }
+}
+export class Execution {
+    results;
+    logs;
+    error;
+    executionCount;
+    constructor(results = [], logs = { stdout: [], stderr: [] }, error, executionCount) {
+        this.results = results;
+        this.logs = logs;
+        this.error = error;
+        this.executionCount = executionCount;
+    }
+    /** The main result's text. */
+    get text() {
+        return this.results.find((result) => result.isMainResult)?.text;
+    }
+    toJSON() {
+        return { results: this.results, logs: this.logs, error: this.error };
+    }
+}
+const TEXT_MIME = /^text\/|json|javascript|svg|latex/;
+/** Output as E2B's logs: one entry per line, each keeping its newline. */
+function lines(text) {
+    return text.match(/[^\n]*\n|[^\n]+$/g) ?? [];
+}
+function language(requested) {
+    if (requested === undefined || requested === "python")
+        return "python";
+    if (requested === "javascript" || requested === "js")
+        return "javascript";
+    throw new NotSupportedError(`Running ${requested} code in the interpreter`, requested === "bash"
+        ? "Use sandbox.commands.run(code)."
+        : "Runtime's interpreter runs Python and JavaScript; install the language and run it with sandbox.commands.run(...).");
+}
+/** The code interpreter sandbox: everything the base Sandbox has, plus runCode
+ * and code contexts. */
+export class Sandbox extends BaseSandbox {
+    static defaultTemplate = "code-interpreter-v1";
+    /** Contexts made to carry the sandbox's envs, one per language. */
+    #envContexts = new Map();
+    get #interpreter() {
+        return this.runtime.interpreter;
+    }
+    /** The context a run goes to: the one asked for; else, when the sandbox has
+     * envs, a context made once with them; else Runtime's default one. */
+    async #contextFor(lang, context) {
+        if (context)
+            return context.id;
+        if (!Object.keys(this.envs).length)
+            return undefined;
+        let id = this.#envContexts.get(lang);
+        if (!id) {
+            id = guard("sandbox", async () => {
+                const made = await this.#interpreter.contexts.create({
+                    id: `e2b-${lang}`,
+                    language: lang,
+                    env: this.envs,
+                });
+                return made.id;
+            }).catch(async (error) => {
+                // Made already, by another object connected to this sandbox.
+                const existing = (await this.#interpreter.contexts.list()).find((one) => one.id === `e2b-${lang}`);
+                if (existing)
+                    return existing.id;
+                throw error;
+            });
+            this.#envContexts.set(lang, id);
+        }
+        return id;
+    }
+    async #inline(result) {
+        const data = { ...result.data };
+        for (const [mime, ref] of Object.entries(result.refs ?? {})) {
+            if (data[mime] !== undefined)
+                continue;
+            const bytes = await guard("sandbox", () => this.#interpreter.result(ref));
+            data[mime] = TEXT_MIME.test(mime)
+                ? new TextDecoder().decode(bytes)
+                : Buffer.from(bytes).toString("base64");
+        }
+        return data;
+    }
+    /** Runs code in a stateful context. Errors in the code come back in
+     * `execution.error`, as in E2B; a run past `timeoutMs` throws TimeoutError. */
+    async runCode(code, opts = {}) {
+        if (opts.language !== undefined && opts.context !== undefined)
+            throw new SandboxError("Pass language or context, not both.");
+        if (opts.envs && Object.keys(opts.envs).length)
+            throw new NotSupportedError("Environment variables for one run (runCode envs)", "Make a context with them: sandbox.runtime.interpreter.contexts.create({ env }), then runCode(code, { context: { id } }).");
+        const lang = language(opts.context?.language ?? opts.language);
+        const context = await this.#contextFor(lang, opts.context);
+        const now = () => Date.now() * 1_000_000;
+        const streaming = opts.onStdout || opts.onStderr || opts.onResult || opts.onError;
+        const execution = await guard("sandbox", () => this.#interpreter.run(code, {
+            ...(context ? { context } : { language: lang }),
+            timeoutMs: opts.timeoutMs ?? 60_000,
+            ...(streaming
+                ? {
+                    onStdout: (text) => void opts.onStdout?.(new OutputMessage(text, now(), false)),
+                    onStderr: (text) => void opts.onStderr?.(new OutputMessage(text, now(), true)),
+                    onError: (error) => void opts.onError?.(new ExecutionError(error.name, error.value, error.traceback)),
+                }
+                : {}),
+        }));
+        if (execution.status === "timeout")
+            throw new TimeoutError(`Execution timed out after ${opts.timeoutMs ?? 60_000} ms: pass a larger 'timeoutMs'.`);
+        if (execution.status === "lost")
+            throw new SandboxError("The interpreter lost this run (its context stopped); run it again.");
+        const results = await Promise.all(execution.results.map(async (result) => new Result(await this.#inline(result), result.main)));
+        if (opts.onResult)
+            for (const result of results)
+                await opts.onResult(result);
+        return new Execution(results, { stdout: lines(execution.stdout), stderr: lines(execution.stderr) }, execution.error
+            ? new ExecutionError(execution.error.name, execution.error.value, execution.error.traceback)
+            : undefined, execution.executionCount ?? undefined);
+    }
+    async createCodeContext(opts = {}) {
+        const lang = language(opts.language);
+        const made = await guard("sandbox", () => this.#interpreter.contexts.create({
+            language: lang,
+            ...(opts.cwd ? { cwd: opts.cwd } : {}),
+            ...(Object.keys(this.envs).length ? { env: this.envs } : {}),
+        }));
+        return { id: made.id, language: made.language, cwd: made.cwd };
+    }
+    async removeCodeContext(context) {
+        const id = typeof context === "string" ? context : context.id;
+        await guard("sandbox", () => this.#interpreter.contexts.remove(id));
+    }
+    async listCodeContexts() {
+        const contexts = await guard("sandbox", () => this.#interpreter.contexts.list());
+        return contexts.map((one) => ({ id: one.id, language: one.language, cwd: one.cwd }));
+    }
+    async restartCodeContext(context) {
+        const id = typeof context === "string" ? context : context.id;
+        await guard("sandbox", () => this.#interpreter.contexts.restart(id));
+    }
+}
+export default Sandbox;
+/** E2B's client with bound options, for the code interpreter. */
+export class E2B {
+    Sandbox;
+    constructor(opts = {}) {
+        this.Sandbox = bind(Sandbox, opts);
+    }
+}

package/dist/e2b/commands.d.ts

@@ -0,0 +1,100 @@
+import type { Process } from "../sandbox.js";
+import type { RuntimeSandbox } from "./client.js";
+import { type CommandResult } from "./errors.js";
+export type { CommandResult };
+export type Username = "user" | "root" | (string & {});
+export interface CommandRequestOpts {
+    requestTimeoutMs?: number;
+    signal?: AbortSignal;
+}
+export interface CommandStartOpts extends CommandRequestOpts {
+    background?: boolean;
+    cwd?: string;
+    /** Only the default user. Runtime runs commands as `runtime`, the sandbox's
+     * owner, with passwordless sudo; E2B's `root` is refused rather than
+     * silently run as someone else. */
+    user?: Username;
+    envs?: Record<string, string>;
+    onStdout?: (data: string) => void | Promise<void>;
+    onStderr?: (data: string) => void | Promise<void>;
+    stdin?: boolean;
+    /** Default 60 000, as in E2B. 0 is no limit (Runtime's longest, 24 hours). */
+    timeoutMs?: number;
+}
+export type CommandConnectOpts = Pick<CommandStartOpts, "onStderr" | "onStdout" | "timeoutMs"> & CommandRequestOpts;
+/** A command as E2B lists it. `pid` is a number derived from Runtime's process
+ * id (stable for the life of the process), not the Linux pid. */
+export interface ProcessInfo {
+    pid: number;
+    tag?: string;
+    cmd: string;
+    args: string[];
+    envs: Record<string, string>;
+    cwd?: string;
+}
+/** The shared state a sandbox's modules need: the Runtime sandbox, the
+ * environment given at create, and the one-time /home/user link. */
+export interface SandboxContext {
+    readonly runtime: RuntimeSandbox;
+    readonly envs: Record<string, string>;
+    /** Makes /home/user (E2B's home) lead to /workspace (Runtime's), once, when
+     * something names it. */
+    ensureHome(text: string | undefined): Promise<void>;
+}
+/** E2B's pids are numbers; Runtime's process ids are strings. The number is a
+ * 31-bit FNV-1a hash of the id, so every client derives the same one. */
+export declare function pidOf(processId: string): number;
+/** `sandbox.commands`: E2B's command module over Runtime's exec and processes. */
+export declare class Commands {
+    #private;
+    constructor(ctx: SandboxContext);
+    /** Runs a command. In the foreground it resolves with the result and throws
+     * CommandExitError on a non-zero exit and TimeoutError past `timeoutMs`; with
+     * `background: true` it resolves at once with a CommandHandle. */
+    run(cmd: string, opts?: CommandStartOpts & {
+        background?: false;
+    }): Promise<CommandResult>;
+    run(cmd: string, opts: CommandStartOpts & {
+        background: true;
+    }): Promise<CommandHandle>;
+    run(cmd: string, opts?: CommandStartOpts & {
+        background?: boolean;
+    }): Promise<CommandHandle | CommandResult>;
+    /** Running commands. */
+    list(_opts?: CommandRequestOpts): Promise<ProcessInfo[]>;
+    /** Kills a command with SIGKILL, as E2B does. False when there is none. */
+    kill(pid: number, _opts?: CommandRequestOpts): Promise<boolean>;
+    /** Sends input to a command started with `stdin: true`. */
+    sendStdin(pid: number, data: string | Uint8Array, _opts?: CommandRequestOpts): Promise<void>;
+    closeStdin(pid: number, _opts?: CommandRequestOpts): Promise<void>;
+    /** Attaches to a running command; output from now on reaches the handle. */
+    connect(pid: number, opts?: CommandConnectOpts): Promise<CommandHandle>;
+}
+/** A command started in the background: E2B's CommandHandle over a Runtime
+ * process. Output streams into `stdout`/`stderr` and the callbacks as it
+ * arrives. */
+export declare class CommandHandle {
+    #private;
+    readonly pid: number;
+    constructor(process: Process, options: {
+        stdin: boolean;
+        timeoutMs: number;
+        cursor?: number;
+        onStdout?: (data: string) => void | Promise<void>;
+        onStderr?: (data: string) => void | Promise<void>;
+    });
+    /** The exit code, or undefined while the command runs. */
+    get exitCode(): number | undefined;
+    get error(): string | undefined;
+    get stdout(): string;
+    get stderr(): string;
+    /** Waits for the command to end. Throws CommandExitError on a non-zero exit,
+     * as E2B does. */
+    wait(): Promise<CommandResult>;
+    /** Stops receiving output; the command keeps running. */
+    disconnect(): Promise<void>;
+    /** Kills the command with SIGKILL. False when it had already ended. */
+    kill(): Promise<boolean>;
+    sendStdin(data: string | Uint8Array, _opts?: CommandRequestOpts): Promise<void>;
+    closeStdin(_opts?: CommandRequestOpts): Promise<void>;
+}