@cofy-x/axern-sdk 0.2.0-bootstrap.0

package/dist/resources.js

@@ -0,0 +1,107 @@
+/**
+ * @license
+ * Copyright 2026 cofy-x
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { SandboxValidationError } from "./errors/index.js";
+export function buildResourceSpec(options) {
+    const requests = resourceQuantity("requestCpu", options.requestCpu, "requestMemory", options.requestMemory);
+    const limits = resourceQuantity("limitCpu", options.limitCpu, "limitMemory", options.limitMemory);
+    if (requests === undefined && limits === undefined) {
+        return undefined;
+    }
+    return { requests, limits };
+}
+function resourceQuantity(cpuName, cpuValue, memoryName, memoryValue) {
+    const cpu = parseCpuQuantity(cpuName, cpuValue);
+    const memory = parseMemoryQuantity(memoryName, memoryValue);
+    if (cpu <= 0 && memory <= 0) {
+        return undefined;
+    }
+    return {
+        cpu_milli: cpu,
+        memory_bytes: memory,
+    };
+}
+function parseCpuQuantity(name, value) {
+    const quantity = resourceQuantityText(name, value);
+    if (quantity === "") {
+        return 0;
+    }
+    if (quantity.startsWith("-")) {
+        throw new SandboxValidationError(`${name} must be non-negative`);
+    }
+    if (quantity.endsWith("m")) {
+        return parseScaledDecimal(name, quantity.slice(0, -1), 1n);
+    }
+    return parseScaledDecimal(name, quantity, 1000n);
+}
+function parseMemoryQuantity(name, value) {
+    const quantity = resourceQuantityText(name, value);
+    if (quantity === "") {
+        return 0;
+    }
+    if (quantity.startsWith("-")) {
+        throw new SandboxValidationError(`${name} must be non-negative`);
+    }
+    const [number, factor] = splitMemoryQuantity(quantity);
+    return parseScaledDecimal(name, number, factor);
+}
+function resourceQuantityText(name, value) {
+    if (value === undefined) {
+        return "";
+    }
+    if (typeof value === "number") {
+        if (!Number.isFinite(value)) {
+            throw new SandboxValidationError(`${name} must be a resource quantity`);
+        }
+        return String(value);
+    }
+    return value.trim();
+}
+function splitMemoryQuantity(value) {
+    const units = [
+        ["tib", 1024n ** 4n],
+        ["gib", 1024n ** 3n],
+        ["mib", 1024n ** 2n],
+        ["kib", 1024n],
+        ["ti", 1024n ** 4n],
+        ["gi", 1024n ** 3n],
+        ["mi", 1024n ** 2n],
+        ["ki", 1024n],
+        ["tb", 1000n ** 4n],
+        ["gb", 1000n ** 3n],
+        ["mb", 1000n ** 2n],
+        ["kb", 1000n],
+        ["b", 1n],
+    ];
+    const lower = value.toLowerCase();
+    for (const [suffix, factor] of units) {
+        if (lower.endsWith(suffix)) {
+            return [value.slice(0, -suffix.length).trim(), factor];
+        }
+    }
+    return [value, 1n];
+}
+function parseScaledDecimal(name, value, scale) {
+    const quantity = value.trim();
+    if (quantity === "") {
+        throw new SandboxValidationError(`${name} is required`);
+    }
+    const match = quantity.match(/^(\+)?(\d+|\d*\.\d+)$/);
+    if (match === null) {
+        throw new SandboxValidationError(`${name} must be a decimal number`);
+    }
+    const [wholePart, fractionPart = ""] = quantity.replace(/^\+/, "").split(".");
+    const whole = wholePart === "" ? "0" : wholePart;
+    const numerator = BigInt(`${whole}${fractionPart}`) * scale;
+    const denominator = 10n ** BigInt(fractionPart.length);
+    if (numerator % denominator !== 0n) {
+        throw new SandboxValidationError(`${name} must resolve to a whole unit`);
+    }
+    const parsed = numerator / denominator;
+    if (parsed > BigInt(Number.MAX_SAFE_INTEGER)) {
+        throw new SandboxValidationError(`${name} is too large`);
+    }
+    return Number(parsed);
+}

package/dist/sandbox/archive.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @license
+ * Copyright 2026 cofy-x
+ * SPDX-License-Identifier: Apache-2.0
+ */
+export declare const defaultArchiveChunkSize: number;
+export declare function directoryArchiveChunks(localPath: string, chunkSize?: number): AsyncIterable<Buffer>;
+export declare function extractDirectoryArchive(chunks: AsyncIterable<Buffer | Uint8Array>, localPath: string, overwrite?: boolean): Promise<void>;

package/dist/sandbox/archive.js

@@ -0,0 +1,228 @@
+/**
+ * @license
+ * Copyright 2026 cofy-x
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { createReadStream, createWriteStream } from "node:fs";
+import { mkdir, opendir, readdir, lstat } from "node:fs/promises";
+import path from "node:path";
+import { Readable } from "node:stream";
+import { pipeline } from "node:stream/promises";
+import * as tar from "tar-stream";
+export const defaultArchiveChunkSize = 1024 * 1024;
+export async function* directoryArchiveChunks(localPath, chunkSize = defaultArchiveChunkSize) {
+    const pack = tar.pack();
+    const producer = writeDirectoryArchive(pack, localPath);
+    producer.catch((error) => pack.destroy(error instanceof Error ? error : new Error(String(error))));
+    try {
+        for await (const chunk of pack) {
+            yield* splitChunk(Buffer.from(chunk), chunkSize);
+        }
+        await producer;
+    }
+    catch (error) {
+        await producer.catch(() => undefined);
+        pack.destroy(error instanceof Error ? error : new Error(String(error)));
+        throw error;
+    }
+}
+export async function extractDirectoryArchive(chunks, localPath, overwrite = true) {
+    if (!overwrite && !(await localPathMissingOrEmpty(localPath))) {
+        throw new Error(`local path ${localPath} already exists and is not empty`);
+    }
+    await ensureNoLocalSymlink(localPath);
+    const rootAbs = path.resolve(localPath);
+    await mkdir(rootAbs, { recursive: true, mode: 0o755 });
+    const extract = tar.extract();
+    const input = Readable.from(chunks);
+    let entryError;
+    extract.on("entry", (header, stream, next) => {
+        void (async () => {
+            try {
+                const target = safeTarTarget(rootAbs, header.name);
+                if (target === rootAbs && header.type !== "directory") {
+                    throw new Error(`archive root entry ${header.name} must be a directory`);
+                }
+                if (header.type === "symlink" || header.type === "link") {
+                    throw new Error(`archive entry ${header.name} uses unsupported link type`);
+                }
+                if (header.type === "directory") {
+                    await ensureNoLocalSymlinkPath(rootAbs, target);
+                    await mkdir(target, { recursive: true, mode: (header.mode ?? 0o755) & 0o777 });
+                    stream.resume();
+                    next();
+                    return;
+                }
+                if (header.type !== "file" && header.type !== "contiguous-file" && header.type !== undefined && header.type !== null) {
+                    throw new Error(`archive entry ${header.name} has unsupported type ${header.type}`);
+                }
+                if (!overwrite) {
+                    await ensureMissing(target);
+                }
+                const parent = path.dirname(target);
+                await ensureNoLocalSymlinkPath(rootAbs, parent);
+                await mkdir(parent, { recursive: true, mode: 0o755 });
+                await ensureNoLocalSymlink(target);
+                await pipeline(stream, createWriteStream(target, { mode: (header.mode ?? 0o644) & 0o777 }));
+                next();
+            }
+            catch (error) {
+                entryError = error;
+                extract.destroy();
+                stream.resume();
+                next();
+            }
+        })();
+    });
+    try {
+        await pipeline(input, extract);
+    }
+    catch (error) {
+        throw entryError ?? error;
+    }
+}
+async function writeDirectoryArchive(pack, root) {
+    try {
+        const info = await lstat(root);
+        if (info.isSymbolicLink()) {
+            throw new Error(`local path ${root} is a symlink`);
+        }
+        if (!info.isDirectory()) {
+            throw new Error(`local path ${root} is not a directory`);
+        }
+        await addDirectoryEntries(pack, root, root);
+        pack.finalize();
+    }
+    catch (error) {
+        pack.destroy(error instanceof Error ? error : new Error(String(error)));
+        throw error;
+    }
+}
+async function addDirectoryEntries(pack, root, current) {
+    const dir = await opendir(current);
+    for await (const entry of dir) {
+        const fullPath = path.join(current, entry.name);
+        const info = await lstat(fullPath);
+        if (info.isSymbolicLink()) {
+            throw new Error(`local symlink ${fullPath} is not supported`);
+        }
+        const name = path.relative(root, fullPath).split(path.sep).join("/");
+        if (info.isDirectory()) {
+            await entryHeader(pack, {
+                name: name.endsWith("/") ? name : `${name}/`,
+                type: "directory",
+                mode: info.mode & 0o777,
+                mtime: info.mtime,
+            });
+            await addDirectoryEntries(pack, root, fullPath);
+            continue;
+        }
+        if (!info.isFile()) {
+            throw new Error(`local path ${fullPath} is not a regular file`);
+        }
+        const tarEntry = pack.entry({
+            name,
+            type: "file",
+            size: info.size,
+            mode: info.mode & 0o777,
+            mtime: info.mtime,
+        });
+        await pipeline(createReadStream(fullPath), tarEntry);
+    }
+}
+function entryHeader(pack, header) {
+    return new Promise((resolve, reject) => {
+        pack.entry(header, (error) => {
+            if (error) {
+                reject(error);
+            }
+            else {
+                resolve();
+            }
+        });
+    });
+}
+function* splitChunk(chunk, chunkSize) {
+    const size = chunkSize > 0 ? chunkSize : defaultArchiveChunkSize;
+    for (let offset = 0; offset < chunk.length; offset += size) {
+        yield chunk.subarray(offset, Math.min(offset + size, chunk.length));
+    }
+}
+function safeTarTarget(rootAbs, name) {
+    if (name.length === 0) {
+        throw new Error("archive entry path is empty");
+    }
+    const clean = path.posix.normalize(name);
+    const rootEntry = clean === "." && (name === "." || name === "./");
+    if (path.posix.isAbsolute(name) || (clean === "." && !rootEntry) || clean === ".." || clean.startsWith("../")) {
+        throw new Error(`archive entry ${name} escapes target directory`);
+    }
+    if (rootEntry) {
+        return rootAbs;
+    }
+    const target = path.resolve(rootAbs, ...clean.split("/"));
+    const rel = path.relative(rootAbs, target);
+    if (rel === ".." || rel.startsWith(`..${path.sep}`) || path.isAbsolute(rel)) {
+        throw new Error(`archive entry ${name} escapes target directory`);
+    }
+    return target;
+}
+async function ensureMissing(target) {
+    try {
+        await lstat(target);
+    }
+    catch (error) {
+        if (isNodeError(error, "ENOENT")) {
+            return;
+        }
+        throw error;
+    }
+    throw new Error(`local path ${target} already exists`);
+}
+async function ensureNoLocalSymlink(target) {
+    try {
+        const info = await lstat(target);
+        if (info.isSymbolicLink()) {
+            throw new Error(`local path ${target} is a symlink`);
+        }
+    }
+    catch (error) {
+        if (isNodeError(error, "ENOENT")) {
+            return;
+        }
+        throw error;
+    }
+}
+async function ensureNoLocalSymlinkPath(rootAbs, targetAbs) {
+    const rel = path.relative(rootAbs, targetAbs);
+    if (rel === "") {
+        await ensureNoLocalSymlink(rootAbs);
+        return;
+    }
+    let current = rootAbs;
+    for (const part of rel.split(path.sep)) {
+        current = path.join(current, part);
+        await ensureNoLocalSymlink(current);
+    }
+}
+async function localPathMissingOrEmpty(localPath) {
+    try {
+        const info = await lstat(localPath);
+        if (info.isSymbolicLink()) {
+            throw new Error(`local path ${localPath} is a symlink`);
+        }
+        if (!info.isDirectory()) {
+            return false;
+        }
+        return (await readdir(localPath)).length === 0;
+    }
+    catch (error) {
+        if (isNodeError(error, "ENOENT")) {
+            return true;
+        }
+        throw error;
+    }
+}
+function isNodeError(error, code) {
+    return typeof error === "object" && error !== null && "code" in error && error.code === code;
+}

package/dist/sandbox/index.d.ts

@@ -0,0 +1,86 @@
+/**
+ * @license
+ * Copyright 2026 cofy-x
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { AxernClient } from "../client/index.js";
+import type { SandboxProcess } from "../node/process.js";
+import type { ResourceQuantity } from "../resources.js";
+import type { ChmodOptions, CapabilityStatus, Command, ComputerUseDisplay, ComputerUseKeyboardOptions, ComputerUseMouseOptions, ComputerUseScreenshot, ComputerUseScreenshotOptions, ComputerUseStatus, CopyOptions, DownloadDirOptions, ExecOptions, ExecResult, ImageExecOptions, ImageProcessOptions, MkdirOptions, MoveOptions, NodeCallOptions, ProcessOptions, RemoveOptions, SandboxFileInfo, TunnelMetadata, TunnelOptions, TouchOptions, UploadDirOptions, VolumeMount, WriteFileOptions } from "../types.js";
+export interface SandboxOptions {
+    client: AxernClient;
+    templateId?: string;
+    image?: string;
+    environmentId?: string;
+    namespace?: string;
+    argv?: string[];
+    env?: Record<string, string>;
+    cwd?: string;
+    runtimeClass?: string;
+    volumes?: readonly VolumeMount[];
+    requestCpu?: ResourceQuantity;
+    requestMemory?: ResourceQuantity;
+    limitCpu?: ResourceQuantity;
+    limitMemory?: ResourceQuantity;
+    readyTimeoutMs?: number;
+    labels?: Record<string, string>;
+    registryCredentialId?: string;
+    rootfsReadonly?: boolean;
+    tunnel?: TunnelOptions;
+}
+export interface SandboxState {
+    environmentId: string;
+    serviceId: string;
+    allocationId: string;
+    nodeId: string;
+    attempt: number;
+    startedAt: Date;
+}
+export interface SandboxMetadata extends SandboxState {
+    namespace: string;
+    runtimeClass: string;
+    labels: Record<string, string>;
+    source: "template" | "image" | "environment";
+    tunnel?: TunnelMetadata;
+}
+export declare class Sandbox {
+    private readonly client;
+    private readonly options;
+    private createdEnvironment;
+    private environmentId;
+    private serviceId;
+    private currentState?;
+    private currentMetadata?;
+    private tunnelRuntime?;
+    constructor(options: SandboxOptions);
+    get state(): SandboxState;
+    get metadata(): SandboxMetadata;
+    start(): Promise<this>;
+    close(): Promise<void>;
+    exec(command: Command, options?: ExecOptions): Promise<ExecResult>;
+    process(command: Command, options?: ProcessOptions): Promise<SandboxProcess>;
+    execImage(image: string, command: Command, options?: ImageExecOptions): Promise<ExecResult>;
+    processImage(image: string, command: Command, options?: ImageProcessOptions): Promise<SandboxProcess>;
+    capabilityStatus(options?: NodeCallOptions): Promise<CapabilityStatus>;
+    computerUseStatus(options?: NodeCallOptions): Promise<ComputerUseStatus>;
+    computerUseScreenshot(options?: ComputerUseScreenshotOptions): Promise<ComputerUseScreenshot>;
+    computerUseDisplay(options?: NodeCallOptions): Promise<ComputerUseDisplay>;
+    computerUseMouse(options?: ComputerUseMouseOptions): Promise<void>;
+    computerUseKeyboard(options?: ComputerUseKeyboardOptions): Promise<void>;
+    stat(path: string): Promise<SandboxFileInfo>;
+    listDir(path: string): Promise<SandboxFileInfo[]>;
+    exists(path: string): Promise<boolean>;
+    readFile(path: string): Promise<Buffer>;
+    readText(path: string, encoding?: BufferEncoding): Promise<string>;
+    writeFile(path: string, data: Buffer | Uint8Array | string, options?: WriteFileOptions): Promise<void>;
+    writeText(path: string, data: string, options?: WriteFileOptions): Promise<void>;
+    mkdir(path: string, options?: MkdirOptions): Promise<void>;
+    remove(path: string, options?: RemoveOptions): Promise<void>;
+    copy(srcPath: string, dstPath: string, options?: CopyOptions): Promise<void>;
+    move(srcPath: string, dstPath: string, options?: MoveOptions): Promise<void>;
+    chmod(path: string, mode: number, options?: ChmodOptions): Promise<void>;
+    touch(path: string, options?: TouchOptions): Promise<void>;
+    uploadDir(localPath: string, remotePath: string, options?: UploadDirOptions): Promise<void>;
+    downloadDir(remotePath: string, localPath: string, options?: DownloadDirOptions): Promise<void>;
+    private nodeClient;
+}

package/dist/sandbox/index.js

@@ -0,0 +1,204 @@
+/**
+ * @license
+ * Copyright 2026 cofy-x
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { SandboxStateError } from "../errors/index.js";
+import { startTunnelRuntime, tunnelMetadata } from "../tunnel/runtime.js";
+import { directoryArchiveChunks, extractDirectoryArchive } from "./archive.js";
+import { defaultSandboxArgv, sandboxLabels, sandboxMetadata, validateSandboxOptions, waitReadyReplica } from "./lifecycle.js";
+export class Sandbox {
+    client;
+    options;
+    createdEnvironment = false;
+    environmentId = "";
+    serviceId = "";
+    currentState;
+    currentMetadata;
+    tunnelRuntime;
+    constructor(options) {
+        validateSandboxOptions(options);
+        this.client = options.client;
+        this.options = options;
+    }
+    get state() {
+        if (this.currentState === undefined) {
+            throw new SandboxStateError("sandbox is not started");
+        }
+        return this.currentState;
+    }
+    get metadata() {
+        if (this.currentMetadata === undefined) {
+            throw new SandboxStateError("sandbox is not started");
+        }
+        return this.currentMetadata;
+    }
+    async start() {
+        if (this.currentState !== undefined) {
+            return this;
+        }
+        let environmentId = this.options.environmentId ?? "";
+        try {
+            if (environmentId === "") {
+                const environment = await this.client.createEnvironment({
+                    namespace: this.options.namespace,
+                    templateId: this.options.templateId,
+                    image: this.options.image,
+                    registryCredentialId: this.options.registryCredentialId,
+                    rootfsReadonly: this.options.rootfsReadonly,
+                    labels: sandboxLabels(this.options.labels),
+                });
+                environmentId = String(environment.id ?? "");
+                this.environmentId = environmentId;
+                this.createdEnvironment = true;
+            }
+            const service = await this.client.createService({
+                namespace: this.options.namespace,
+                environmentId,
+                argv: this.options.argv ?? defaultSandboxArgv,
+                env: this.options.env,
+                cwd: this.options.cwd,
+                runtimeClass: this.options.runtimeClass,
+                volumes: this.options.volumes,
+                requestCpu: this.options.requestCpu,
+                requestMemory: this.options.requestMemory,
+                limitCpu: this.options.limitCpu,
+                limitMemory: this.options.limitMemory,
+                labels: sandboxLabels(this.options.labels),
+            });
+            this.serviceId = String(service.id ?? "");
+            const replica = await waitReadyReplica(this.serviceId, this.options.readyTimeoutMs ?? 180_000, (serviceId) => this.client.listServiceReplicas(serviceId));
+            this.currentState = {
+                environmentId,
+                serviceId: this.serviceId,
+                allocationId: String(replica.id ?? ""),
+                nodeId: String(replica.node_id ?? ""),
+                attempt: Number(replica.attempt ?? 0),
+                startedAt: new Date(),
+            };
+            this.currentMetadata = sandboxMetadata(this.options, this.currentState);
+            if (this.options.tunnel !== undefined) {
+                this.tunnelRuntime = await startTunnelRuntime({
+                    control: this.client.tunnelClient(),
+                    allocationId: this.currentState.allocationId,
+                    tunnel: this.options.tunnel,
+                    transport: this.client.tunnelTransport(),
+                });
+                this.currentMetadata = {
+                    ...this.currentMetadata,
+                    tunnel: tunnelMetadata(this.tunnelRuntime),
+                };
+            }
+            return this;
+        }
+        catch (error) {
+            await this.close();
+            throw error;
+        }
+    }
+    async close() {
+        const serviceId = this.serviceId;
+        const tunnelRuntime = this.tunnelRuntime;
+        this.serviceId = "";
+        this.tunnelRuntime = undefined;
+        this.currentState = undefined;
+        this.currentMetadata = undefined;
+        if (tunnelRuntime !== undefined) {
+            await tunnelRuntime.stop().catch(() => undefined);
+        }
+        if (serviceId !== "") {
+            await this.client.deleteService(serviceId).catch(() => undefined);
+        }
+        if (this.createdEnvironment && this.environmentId !== "") {
+            const environmentId = this.environmentId;
+            this.environmentId = "";
+            this.createdEnvironment = false;
+            await this.client.deleteEnvironment(environmentId).catch(() => undefined);
+        }
+    }
+    async exec(command, options = {}) {
+        return this.nodeClient().exec(command, options);
+    }
+    async process(command, options = {}) {
+        return this.nodeClient().process(command, options);
+    }
+    async execImage(image, command, options = {}) {
+        return this.nodeClient().execImage(image, command, options);
+    }
+    async processImage(image, command, options = {}) {
+        return this.nodeClient().processImage(image, command, options);
+    }
+    async capabilityStatus(options = {}) {
+        return this.nodeClient().capabilityStatus(options);
+    }
+    async computerUseStatus(options = {}) {
+        return this.nodeClient().computerUseStatus(options);
+    }
+    async computerUseScreenshot(options = {}) {
+        return this.nodeClient().computerUseScreenshot(options);
+    }
+    async computerUseDisplay(options = {}) {
+        return this.nodeClient().computerUseDisplay(options);
+    }
+    async computerUseMouse(options = {}) {
+        return this.nodeClient().computerUseMouse(options);
+    }
+    async computerUseKeyboard(options = {}) {
+        return this.nodeClient().computerUseKeyboard(options);
+    }
+    async stat(path) {
+        return this.nodeClient().stat(path);
+    }
+    async listDir(path) {
+        return this.nodeClient().listDir(path);
+    }
+    async exists(path) {
+        return this.nodeClient().exists(path);
+    }
+    async readFile(path) {
+        return this.nodeClient().readFile(path);
+    }
+    async readText(path, encoding = "utf8") {
+        return this.nodeClient().readText(path, encoding);
+    }
+    async writeFile(path, data, options = {}) {
+        return this.nodeClient().writeFile(path, data, options);
+    }
+    async writeText(path, data, options = {}) {
+        return this.nodeClient().writeText(path, data, options);
+    }
+    async mkdir(path, options = {}) {
+        return this.nodeClient().mkdir(path, options);
+    }
+    async remove(path, options = {}) {
+        return this.nodeClient().remove(path, options);
+    }
+    async copy(srcPath, dstPath, options = {}) {
+        return this.nodeClient().copy(srcPath, dstPath, options);
+    }
+    async move(srcPath, dstPath, options = {}) {
+        return this.nodeClient().move(srcPath, dstPath, options);
+    }
+    async chmod(path, mode, options = {}) {
+        return this.nodeClient().chmod(path, mode, options);
+    }
+    async touch(path, options = {}) {
+        return this.nodeClient().touch(path, options);
+    }
+    async uploadDir(localPath, remotePath, options = {}) {
+        await this.nodeClient().uploadArchive(remotePath, () => directoryArchiveChunks(localPath, options.chunkSize), {
+            createParents: options.createParents ?? true,
+            overwrite: options.overwrite ?? true,
+            rpcTimeoutMs: options.rpcTimeoutMs,
+        });
+    }
+    async downloadDir(remotePath, localPath, options = {}) {
+        await extractDirectoryArchive(this.nodeClient().downloadArchive(remotePath, { rpcTimeoutMs: options.rpcTimeoutMs }), localPath, options.overwrite ?? true);
+    }
+    nodeClient() {
+        if (this.currentState === undefined) {
+            throw new SandboxStateError("sandbox is not started");
+        }
+        return this.client.nodeSandbox(this.currentState.allocationId);
+    }
+}

package/dist/sandbox/lifecycle.d.ts

@@ -0,0 +1,11 @@
+/**
+ * @license
+ * Copyright 2026 cofy-x
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { SandboxMetadata, SandboxOptions, SandboxState } from "./index.js";
+export declare const defaultSandboxArgv: string[];
+export declare function validateSandboxOptions(options: SandboxOptions): void;
+export declare function sandboxLabels(labels: Record<string, string> | undefined): Record<string, string>;
+export declare function sandboxMetadata(options: SandboxOptions, state: SandboxState): SandboxMetadata;
+export declare function waitReadyReplica(serviceId: string, timeoutMs: number, listReplicas: (serviceId: string) => Promise<Record<string, unknown>[]>): Promise<Record<string, unknown>>;