@drej/opensandbox 0.1.2 → 0.1.4

package/dist/index.d.mts

@@ -0,0 +1,249 @@
+//#region src/types.d.ts
+interface Resources {
+  cpu?: string;
+  memory?: string;
+  gpu?: string;
+}
+interface ImageAuth {
+  username: string;
+  password: string;
+}
+interface ImageSpec {
+  uri: string;
+  auth?: ImageAuth;
+}
+declare enum SandboxState {
+  Pending = "Pending",
+  Running = "Running",
+  Pausing = "Pausing",
+  Paused = "Paused",
+  Resuming = "Resuming",
+  Stopping = "Stopping",
+  Terminated = "Terminated",
+  Failed = "Failed",
+  Unknown = "Unknown"
+}
+interface SandboxStatus {
+  state: SandboxState;
+  reason?: string;
+  message?: string;
+  lastTransitionAt?: string;
+}
+interface Sandbox {
+  id: string;
+  status: SandboxStatus;
+  createdAt: string;
+  expiresAt?: string | null;
+  image?: ImageSpec;
+  snapshotId?: string;
+  entrypoint?: string[];
+  metadata?: Record<string, string>;
+  platform?: unknown;
+}
+interface CreateSandboxOptions {
+  image?: ImageSpec;
+  snapshotId?: string;
+  timeout?: number;
+  resourceLimits?: Resources;
+  entrypoint?: string[];
+  env?: Record<string, string>;
+  metadata?: Record<string, string>;
+  secureAccess?: boolean;
+}
+interface ListSandboxesOptions {
+  state?: SandboxState;
+  limit?: number;
+  offset?: number;
+}
+declare enum SnapshotState {
+  Pending = "Pending",
+  Committing = "Committing",
+  Pushing = "Pushing",
+  Ready = "Ready",
+  Failed = "Failed"
+}
+interface Snapshot {
+  id: string;
+  sandboxId: string;
+  state: SnapshotState;
+  createdAt: string;
+}
+interface ListSnapshotsOptions {
+  sandboxId?: string;
+  limit?: number;
+  offset?: number;
+}
+interface SandboxEndpoint {
+  endpoint: string;
+  headers?: Record<string, string>;
+}
+interface DiagnosticLog {
+  name: string;
+  size: number;
+  url?: string;
+  inline?: string;
+}
+interface DiagnosticEvent {
+  timestamp: string;
+  type: string;
+  message: string;
+}
+declare enum SSEEventType {
+  Init = "init",
+  Status = "status",
+  Stdout = "stdout",
+  Stderr = "stderr",
+  Result = "result",
+  ExecutionComplete = "execution_complete",
+  ExecutionCount = "execution_count",
+  Error = "error",
+  Ping = "ping",
+  Message = "message"
+}
+interface SSEEvent {
+  type: SSEEventType;
+  text?: string;
+  results?: Record<string, string>;
+  error?: {
+    name?: string;
+    message: string;
+    evalue?: string;
+  };
+  execution_count?: number;
+  execution_time?: number;
+  timestamp: number;
+}
+declare enum CodeLanguage {
+  Python = "python",
+  JavaScript = "javascript",
+  TypeScript = "typescript",
+  Go = "go",
+  Java = "java",
+  Bash = "bash"
+}
+interface CodeContext {
+  id: string;
+  language: CodeLanguage;
+}
+interface ExecuteCodeOptions {
+  code: string;
+  context?: {
+    id: string;
+    language: CodeLanguage;
+  };
+}
+interface ExecuteCommandOptions {
+  command: string;
+  cwd?: string;
+  background?: boolean;
+  timeout?: number;
+  uid?: number;
+  gid?: number;
+  envs?: Record<string, string>;
+}
+interface CommandStatus {
+  session: string;
+  status: "running" | "completed" | "failed";
+  exitCode?: number;
+}
+interface FileInfo {
+  path: string;
+  type: "file" | "directory" | "symlink";
+  size: number;
+  mode: number;
+  modified_at: string;
+  created_at: string;
+  owner: string;
+  group: string;
+}
+interface FileReplacement {
+  path: string;
+  old: string;
+  new: string;
+}
+interface Metrics {
+  cpu: number;
+  memory: number;
+  timestamp: string;
+}
+//#endregion
+//#region src/control.d.ts
+declare class OpenSandboxError extends Error {
+  readonly status: number;
+  constructor(message: string, status: number);
+}
+declare class ControlClient {
+  private baseUrl;
+  private apiKey;
+  private signal?;
+  constructor(options: {
+    baseUrl: string;
+    apiKey: string;
+    signal?: AbortSignal;
+  });
+  /** Return a new `ControlClient` instance that passes `signal` to every fetch call. */
+  withSignal(signal: AbortSignal): ControlClient;
+  private request;
+  createSandbox(options: CreateSandboxOptions): Promise<Sandbox>;
+  listSandboxes(options?: ListSandboxesOptions): Promise<Sandbox[]>;
+  getSandbox(id: string): Promise<Sandbox>;
+  deleteSandbox(id: string): Promise<void>;
+  pauseSandbox(id: string): Promise<void>;
+  resumeSandbox(id: string): Promise<void>;
+  renewExpiration(id: string): Promise<void>;
+  getEndpoint(sandboxId: string, port: number, useServerProxy?: boolean): Promise<SandboxEndpoint>;
+  getDiagnosticLogs(sandboxId: string): Promise<DiagnosticLog[]>;
+  getDiagnosticEvents(sandboxId: string): Promise<DiagnosticEvent[]>;
+  createSnapshot(sandboxId: string): Promise<Snapshot>;
+  listSnapshots(options?: ListSnapshotsOptions): Promise<Snapshot[]>;
+  getSnapshot(id: string): Promise<Snapshot>;
+  deleteSnapshot(id: string): Promise<void>;
+}
+//#endregion
+//#region src/exec.d.ts
+declare class ExecClient {
+  private baseUrl;
+  private accessToken;
+  private signal?;
+  constructor(options: {
+    baseUrl?: string;
+    accessToken: string;
+    signal?: AbortSignal;
+  });
+  /** Return a new `ExecClient` instance that passes `signal` to every fetch call. */
+  withSignal(signal: AbortSignal): ExecClient;
+  private get authHeader();
+  private request;
+  private streamRequest;
+  ping(): Promise<{
+    status: string;
+  }>;
+  listContexts(language?: string): Promise<CodeContext[]>;
+  clearContexts(language?: string): Promise<void>;
+  deleteContext(contextId: string): Promise<void>;
+  createContext(language: string): Promise<CodeContext>;
+  executeCode(options: ExecuteCodeOptions): AsyncGenerator<SSEEvent>;
+  interruptCode(): Promise<void>;
+  executeCommand(options: ExecuteCommandOptions): AsyncGenerator<SSEEvent>;
+  interruptCommand(): Promise<void>;
+  getCommandStatus(session: string): Promise<CommandStatus>;
+  getCommandOutput(session: string): Promise<{
+    stdout: string;
+    stderr: string;
+  }>;
+  getFileInfo(path: string): Promise<FileInfo>;
+  deleteFile(path: string): Promise<void>;
+  setPermissions(path: string, mode: string): Promise<void>;
+  moveFile(from: string, to: string): Promise<void>;
+  searchFiles(pattern: string, path?: string): Promise<string[]>;
+  replaceInFiles(replacements: FileReplacement[]): Promise<void>;
+  uploadFile(path: string, content: Blob | BufferSource | string): Promise<void>;
+  downloadFile(path: string): Promise<ReadableStream<Uint8Array>>;
+  listDirectory(path: string, depth?: number): Promise<FileInfo[]>;
+  createDirectory(path: string): Promise<void>;
+  deleteDirectory(path: string): Promise<void>;
+  getMetrics(): Promise<Metrics>;
+  watchMetrics(): AsyncGenerator<SSEEvent>;
+}
+//#endregion
+export { type CodeContext, CodeLanguage, type CommandStatus, ControlClient, type CreateSandboxOptions, type DiagnosticEvent, type DiagnosticLog, ExecClient, type ExecuteCodeOptions, type ExecuteCommandOptions, type FileInfo, type FileReplacement, type ImageAuth, type ImageSpec, type ListSandboxesOptions, type ListSnapshotsOptions, type Metrics, OpenSandboxError, type Resources, type SSEEvent, SSEEventType, type Sandbox, type SandboxEndpoint, SandboxState, type SandboxStatus, type Snapshot, SnapshotState };

package/dist/index.mjs

@@ -0,0 +1,346 @@
+//#region src/control.ts
+function flattenSnapshot(raw) {
+	return {
+		id: raw.id,
+		sandboxId: raw.sandboxId,
+		state: raw.status.state,
+		createdAt: raw.createdAt
+	};
+}
+var OpenSandboxError = class extends Error {
+	status;
+	constructor(message, status) {
+		super(message);
+		this.status = status;
+		this.name = "OpenSandboxError";
+	}
+};
+var ControlClient = class ControlClient {
+	baseUrl;
+	apiKey;
+	signal;
+	constructor(options) {
+		this.baseUrl = options.baseUrl.replace(/\/$/, "");
+		this.apiKey = options.apiKey;
+		this.signal = options.signal;
+	}
+	/** Return a new `ControlClient` instance that passes `signal` to every fetch call. */
+	withSignal(signal) {
+		return new ControlClient({
+			baseUrl: this.baseUrl,
+			apiKey: this.apiKey,
+			signal
+		});
+	}
+	async request(method, path, body) {
+		const res = await fetch(`${this.baseUrl}${path}`, {
+			method,
+			headers: {
+				"OPEN-SANDBOX-API-KEY": this.apiKey,
+				...body !== void 0 ? { "Content-Type": "application/json" } : {}
+			},
+			...body !== void 0 ? { body: JSON.stringify(body) } : {},
+			signal: this.signal
+		});
+		if (!res.ok) throw new OpenSandboxError(await res.text().catch(() => "") || "OpenSandbox API error", res.status);
+		if (res.status === 204) return void 0;
+		return res.json();
+	}
+	createSandbox(options) {
+		return this.request("POST", "/v1/sandboxes", options);
+	}
+	listSandboxes(options = {}) {
+		const params = new URLSearchParams();
+		if (options.state) params.set("state", options.state);
+		if (options.limit !== void 0) params.set("limit", String(options.limit));
+		if (options.offset !== void 0) params.set("offset", String(options.offset));
+		const qs = params.toString();
+		return this.request("GET", `/v1/sandboxes${qs ? `?${qs}` : ""}`);
+	}
+	getSandbox(id) {
+		return this.request("GET", `/v1/sandboxes/${id}`);
+	}
+	deleteSandbox(id) {
+		return this.request("DELETE", `/v1/sandboxes/${id}`);
+	}
+	pauseSandbox(id) {
+		return this.request("POST", `/v1/sandboxes/${id}/pause`);
+	}
+	resumeSandbox(id) {
+		return this.request("POST", `/v1/sandboxes/${id}/resume`);
+	}
+	renewExpiration(id) {
+		return this.request("POST", `/v1/sandboxes/${id}/renew-expiration`);
+	}
+	getEndpoint(sandboxId, port, useServerProxy) {
+		const qs = useServerProxy ? "?use_server_proxy=true" : "";
+		return this.request("GET", `/v1/sandboxes/${sandboxId}/endpoints/${port}${qs}`);
+	}
+	getDiagnosticLogs(sandboxId) {
+		return this.request("GET", `/v1/sandboxes/${sandboxId}/diagnostics/logs`);
+	}
+	getDiagnosticEvents(sandboxId) {
+		return this.request("GET", `/v1/sandboxes/${sandboxId}/diagnostics/events`);
+	}
+	async createSnapshot(sandboxId) {
+		return flattenSnapshot(await this.request("POST", `/v1/sandboxes/${sandboxId}/snapshots`));
+	}
+	listSnapshots(options = {}) {
+		const params = new URLSearchParams();
+		if (options.sandboxId) params.set("sandboxId", options.sandboxId);
+		if (options.limit !== void 0) params.set("limit", String(options.limit));
+		if (options.offset !== void 0) params.set("offset", String(options.offset));
+		const qs = params.toString();
+		return this.request("GET", `/v1/snapshots${qs ? `?${qs}` : ""}`);
+	}
+	async getSnapshot(id) {
+		return flattenSnapshot(await this.request("GET", `/v1/snapshots/${id}`));
+	}
+	deleteSnapshot(id) {
+		return this.request("DELETE", `/v1/snapshots/${id}`);
+	}
+};
+//#endregion
+//#region src/types.ts
+let SandboxState = /* @__PURE__ */ function(SandboxState) {
+	SandboxState["Pending"] = "Pending";
+	SandboxState["Running"] = "Running";
+	SandboxState["Pausing"] = "Pausing";
+	SandboxState["Paused"] = "Paused";
+	SandboxState["Resuming"] = "Resuming";
+	SandboxState["Stopping"] = "Stopping";
+	SandboxState["Terminated"] = "Terminated";
+	SandboxState["Failed"] = "Failed";
+	SandboxState["Unknown"] = "Unknown";
+	return SandboxState;
+}({});
+let SnapshotState = /* @__PURE__ */ function(SnapshotState) {
+	SnapshotState["Pending"] = "Pending";
+	SnapshotState["Committing"] = "Committing";
+	SnapshotState["Pushing"] = "Pushing";
+	SnapshotState["Ready"] = "Ready";
+	SnapshotState["Failed"] = "Failed";
+	return SnapshotState;
+}({});
+let SSEEventType = /* @__PURE__ */ function(SSEEventType) {
+	SSEEventType["Init"] = "init";
+	SSEEventType["Status"] = "status";
+	SSEEventType["Stdout"] = "stdout";
+	SSEEventType["Stderr"] = "stderr";
+	SSEEventType["Result"] = "result";
+	SSEEventType["ExecutionComplete"] = "execution_complete";
+	SSEEventType["ExecutionCount"] = "execution_count";
+	SSEEventType["Error"] = "error";
+	SSEEventType["Ping"] = "ping";
+	SSEEventType["Message"] = "message";
+	return SSEEventType;
+}({});
+let CodeLanguage = /* @__PURE__ */ function(CodeLanguage) {
+	CodeLanguage["Python"] = "python";
+	CodeLanguage["JavaScript"] = "javascript";
+	CodeLanguage["TypeScript"] = "typescript";
+	CodeLanguage["Go"] = "go";
+	CodeLanguage["Java"] = "java";
+	CodeLanguage["Bash"] = "bash";
+	return CodeLanguage;
+}({});
+//#endregion
+//#region src/exec.ts
+async function* parseSSE(stream) {
+	const reader = stream.getReader();
+	const decoder = new TextDecoder();
+	let buffer = "";
+	try {
+		while (true) {
+			const { done, value } = await reader.read();
+			if (done) break;
+			buffer += decoder.decode(value, { stream: true });
+			const blocks = buffer.split("\n\n");
+			buffer = blocks.pop() ?? "";
+			for (const block of blocks) {
+				const trimmed = block.trim();
+				if (!trimmed) continue;
+				if (trimmed.startsWith("{")) try {
+					yield JSON.parse(trimmed);
+				} catch {}
+				else {
+					let type;
+					let data;
+					for (const line of block.split("\n")) if (line.startsWith("event:")) type = line.slice(6).trim();
+					else if (line.startsWith("data:")) data = line.slice(5).trim();
+					if (data !== void 0) yield {
+						type: type ?? "message",
+						...JSON.parse(data)
+					};
+				}
+			}
+		}
+	} finally {
+		reader.releaseLock();
+	}
+}
+var ExecClient = class ExecClient {
+	baseUrl;
+	accessToken;
+	signal;
+	constructor(options) {
+		this.baseUrl = (options.baseUrl ?? "http://localhost:44772").replace(/\/$/, "");
+		this.accessToken = options.accessToken;
+		this.signal = options.signal;
+	}
+	/** Return a new `ExecClient` instance that passes `signal` to every fetch call. */
+	withSignal(signal) {
+		return new ExecClient({
+			baseUrl: this.baseUrl,
+			accessToken: this.accessToken,
+			signal
+		});
+	}
+	get authHeader() {
+		return { "X-EXECD-ACCESS-TOKEN": this.accessToken };
+	}
+	async request(method, path, body) {
+		const res = await fetch(`${this.baseUrl}${path}`, {
+			method,
+			headers: {
+				...this.authHeader,
+				...body !== void 0 ? { "Content-Type": "application/json" } : {}
+			},
+			...body !== void 0 ? { body: JSON.stringify(body) } : {},
+			signal: this.signal
+		});
+		if (!res.ok) {
+			const text = await res.text().catch(() => "");
+			throw new Error(text || `execd error ${res.status}`);
+		}
+		if (res.status === 204) return void 0;
+		return res.json();
+	}
+	async *streamRequest(method, path, body) {
+		const res = await fetch(`${this.baseUrl}${path}`, {
+			method,
+			headers: {
+				...this.authHeader,
+				...body !== void 0 ? { "Content-Type": "application/json" } : {}
+			},
+			...body !== void 0 ? { body: JSON.stringify(body) } : {},
+			signal: this.signal
+		});
+		if (!res.ok) {
+			const text = await res.text().catch(() => "");
+			throw new Error(text || `execd error ${res.status}`);
+		}
+		if (!res.body) return;
+		yield* parseSSE(res.body);
+	}
+	ping() {
+		return this.request("GET", "/ping");
+	}
+	listContexts(language) {
+		const qs = language ? `?language=${encodeURIComponent(language)}` : "";
+		return this.request("GET", `/code/contexts${qs}`);
+	}
+	clearContexts(language) {
+		const qs = language ? `?language=${encodeURIComponent(language)}` : "";
+		return this.request("DELETE", `/code/contexts${qs}`);
+	}
+	deleteContext(contextId) {
+		return this.request("DELETE", `/code/contexts/${contextId}`);
+	}
+	createContext(language) {
+		return this.request("POST", "/code/context", { language });
+	}
+	async *executeCode(options) {
+		yield* this.streamRequest("POST", "/code", options);
+	}
+	interruptCode() {
+		return this.request("DELETE", "/code");
+	}
+	async *executeCommand(options) {
+		yield* this.streamRequest("POST", "/command", options);
+	}
+	interruptCommand() {
+		return this.request("DELETE", "/command");
+	}
+	getCommandStatus(session) {
+		return this.request("GET", `/command/status/${session}`);
+	}
+	getCommandOutput(session) {
+		return this.request("GET", `/command/output/${session}`);
+	}
+	async getFileInfo(path) {
+		const entry = (await this.request("GET", `/files/info?path=${encodeURIComponent(path)}`))[path];
+		if (!entry) throw new Error(`getFileInfo: no entry for path ${path}`);
+		return entry;
+	}
+	deleteFile(path) {
+		return this.request("DELETE", `/files?path=${encodeURIComponent(path)}`);
+	}
+	setPermissions(path, mode) {
+		return this.request("POST", "/files/permissions", { [path]: { mode: parseInt(mode, 10) } });
+	}
+	moveFile(from, to) {
+		return this.request("POST", "/files/mv", [{
+			src: from,
+			dest: to
+		}]);
+	}
+	async searchFiles(pattern, path = "/") {
+		const params = new URLSearchParams({
+			path,
+			pattern
+		});
+		return (await this.request("GET", `/files/search?${params}`)).map((e) => e.path);
+	}
+	replaceInFiles(replacements) {
+		const body = {};
+		for (const r of replacements) body[r.path] = {
+			old: r.old,
+			new: r.new
+		};
+		return this.request("POST", "/files/replace", body);
+	}
+	async uploadFile(path, content) {
+		const formData = new FormData();
+		formData.append("metadata", new File([JSON.stringify({ path })], "metadata.json", { type: "application/json" }));
+		formData.append("file", new File([content], path.split("/").pop() ?? "file", { type: "application/octet-stream" }));
+		const res = await fetch(`${this.baseUrl}/files/upload`, {
+			method: "POST",
+			headers: this.authHeader,
+			body: formData,
+			signal: this.signal
+		});
+		if (!res.ok) {
+			const text = await res.text().catch(() => "");
+			throw new Error(text || `execd error ${res.status}`);
+		}
+	}
+	async downloadFile(path) {
+		const res = await fetch(`${this.baseUrl}/files/download?path=${encodeURIComponent(path)}`, {
+			headers: this.authHeader,
+			signal: this.signal
+		});
+		if (!res.ok) throw new Error(`execd error ${res.status}`);
+		if (!res.body) throw new Error("empty response body");
+		return res.body;
+	}
+	listDirectory(path, depth) {
+		const params = new URLSearchParams({ path });
+		if (depth !== void 0) params.set("depth", String(depth));
+		return this.request("GET", `/directories/list?${params}`);
+	}
+	createDirectory(path) {
+		return this.request("POST", "/directories", { [path]: { mode: 755 } });
+	}
+	deleteDirectory(path) {
+		return this.request("DELETE", `/directories?path=${encodeURIComponent(path)}`);
+	}
+	getMetrics() {
+		return this.request("GET", "/metrics");
+	}
+	async *watchMetrics() {
+		yield* this.streamRequest("GET", "/metrics/watch");
+	}
+};
+//#endregion
+export { CodeLanguage, ControlClient, ExecClient, OpenSandboxError, SSEEventType, SandboxState, SnapshotState };

package/package.json

@@ -1,18 +1,28 @@
 {
   "name": "@drej/opensandbox",
-  "version": "0.1.2",
-  "main": "./src/index.ts",
-  "types": "./dist/index.d.ts",
+  "version": "0.1.4",
   "files": [
     "dist"
   ],
-  "publishConfig": { "access": "public" },
+  "type": "module",
+  "main": "./dist/index.mjs",
+  "types": "./dist/index.d.mts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.mjs",
+      "types": "./dist/index.d.mts"
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
   "scripts": {
-    "typecheck": "bunx tsc --noEmit",
-    "build:types": "tsc --project tsconfig.build.json"
+    "build": "tsdown",
+    "typecheck": "bunx tsc --noEmit"
   },
   "devDependencies": {
-    "bun-types": "latest",
-    "typescript": "latest"
+    "bun-types": "1.3.14",
+    "tsdown": "0.22.3",
+    "typescript": "6.0.3"
   }
 }

package/dist/control.d.ts

@@ -1,28 +0,0 @@
-import type { Sandbox, CreateSandboxOptions, ListSandboxesOptions, Snapshot, ListSnapshotsOptions, SandboxEndpoint, DiagnosticLog, DiagnosticEvent } from "./types";
-export declare class OpenSandboxError extends Error {
-    readonly status: number;
-    constructor(message: string, status: number);
-}
-export declare class ControlClient {
-    private baseUrl;
-    private apiKey;
-    constructor(options: {
-        baseUrl: string;
-        apiKey: string;
-    });
-    private request;
-    createSandbox(options: CreateSandboxOptions): Promise<Sandbox>;
-    listSandboxes(options?: ListSandboxesOptions): Promise<Sandbox[]>;
-    getSandbox(id: string): Promise<Sandbox>;
-    deleteSandbox(id: string): Promise<void>;
-    pauseSandbox(id: string): Promise<void>;
-    resumeSandbox(id: string): Promise<void>;
-    renewExpiration(id: string): Promise<void>;
-    getEndpoint(sandboxId: string, port: number): Promise<SandboxEndpoint>;
-    getDiagnosticLogs(sandboxId: string): Promise<DiagnosticLog[]>;
-    getDiagnosticEvents(sandboxId: string): Promise<DiagnosticEvent[]>;
-    createSnapshot(sandboxId: string): Promise<Snapshot>;
-    listSnapshots(options?: ListSnapshotsOptions): Promise<Snapshot[]>;
-    getSnapshot(id: string): Promise<Snapshot>;
-    deleteSnapshot(id: string): Promise<void>;
-}

package/dist/exec.d.ts

@@ -1,41 +0,0 @@
-import type { SSEEvent, CodeContext, ExecuteCodeOptions, ExecuteCommandOptions, CommandStatus, FileInfo, FileReplacement, DirectoryEntry, Metrics } from "./types";
-export declare class ExecClient {
-    private baseUrl;
-    private accessToken;
-    constructor(options: {
-        baseUrl?: string;
-        accessToken: string;
-    });
-    private get authHeader();
-    private request;
-    private streamRequest;
-    ping(): Promise<{
-        status: string;
-    }>;
-    listContexts(language?: string): Promise<CodeContext[]>;
-    clearContexts(language?: string): Promise<void>;
-    deleteContext(contextId: string): Promise<void>;
-    createContext(language: string): Promise<CodeContext>;
-    executeCode(options: ExecuteCodeOptions): AsyncGenerator<SSEEvent>;
-    interruptCode(): Promise<void>;
-    executeCommand(options: ExecuteCommandOptions): AsyncGenerator<SSEEvent>;
-    interruptCommand(): Promise<void>;
-    getCommandStatus(session: string): Promise<CommandStatus>;
-    getCommandOutput(session: string): Promise<{
-        stdout: string;
-        stderr: string;
-    }>;
-    getFileInfo(path: string): Promise<FileInfo>;
-    deleteFile(path: string): Promise<void>;
-    setPermissions(path: string, mode: string): Promise<void>;
-    moveFile(from: string, to: string): Promise<void>;
-    searchFiles(pattern: string, dir?: string): Promise<string[]>;
-    replaceInFiles(replacements: FileReplacement[]): Promise<void>;
-    uploadFile(path: string, content: Blob | BufferSource | string): Promise<void>;
-    downloadFile(path: string): Promise<ReadableStream<Uint8Array>>;
-    listDirectory(path: string, depth?: number): Promise<DirectoryEntry[]>;
-    createDirectory(path: string): Promise<void>;
-    deleteDirectory(path: string): Promise<void>;
-    getMetrics(): Promise<Metrics>;
-    watchMetrics(): AsyncGenerator<SSEEvent>;
-}

package/dist/index.d.ts

@@ -1,4 +0,0 @@
-export { ControlClient, OpenSandboxError } from "./control";
-export { ExecClient } from "./exec";
-export { SandboxState, SnapshotState, SSEEventType } from "./types";
-export type { Resources, ImageAuth, ImageSpec, Sandbox, SandboxStatus, CreateSandboxOptions, ListSandboxesOptions, Snapshot, ListSnapshotsOptions, SandboxEndpoint, DiagnosticLog, DiagnosticEvent, SSEEvent, CodeContext, ExecuteCodeOptions, ExecuteCommandOptions, CommandStatus, FileInfo, FileReplacement, DirectoryEntry, Metrics, } from "./types";

package/dist/types.d.ts

@@ -1,162 +0,0 @@
-export interface Resources {
-    cpu?: string;
-    memory?: string;
-    gpu?: string;
-}
-export interface ImageAuth {
-    username: string;
-    password: string;
-}
-export interface ImageSpec {
-    uri: string;
-    auth?: ImageAuth;
-}
-export declare enum SandboxState {
-    Pending = "Pending",
-    Running = "Running",
-    Pausing = "Pausing",
-    Paused = "Paused",
-    Resuming = "Resuming",
-    Stopping = "Stopping",
-    Terminated = "Terminated",
-    Failed = "Failed",
-    Unknown = "Unknown"
-}
-export interface SandboxStatus {
-    state: SandboxState;
-    reason?: string;
-    message?: string;
-    lastTransitionAt?: string;
-}
-export interface Sandbox {
-    id: string;
-    status: SandboxStatus;
-    createdAt: string;
-    expiresAt?: string | null;
-    image?: ImageSpec;
-    snapshotId?: string;
-    entrypoint?: string[];
-    metadata?: Record<string, string>;
-    platform?: unknown;
-}
-export interface CreateSandboxOptions {
-    image?: ImageSpec;
-    snapshotId?: string;
-    timeout?: number;
-    resourceLimits?: Resources;
-    entrypoint?: string[];
-    env?: Record<string, string>;
-    metadata?: Record<string, string>;
-    secureAccess?: boolean;
-}
-export interface ListSandboxesOptions {
-    state?: SandboxState;
-    limit?: number;
-    offset?: number;
-}
-export declare enum SnapshotState {
-    Pending = "Pending",
-    Committing = "Committing",
-    Pushing = "Pushing",
-    Ready = "Ready",
-    Failed = "Failed"
-}
-export interface Snapshot {
-    id: string;
-    sandboxId: string;
-    state: SnapshotState;
-    createdAt: string;
-}
-export interface ListSnapshotsOptions {
-    sandboxId?: string;
-    limit?: number;
-    offset?: number;
-}
-export interface SandboxEndpoint {
-    endpoint: string;
-    headers?: Record<string, string>;
-}
-export interface DiagnosticLog {
-    name: string;
-    size: number;
-    url?: string;
-    inline?: string;
-}
-export interface DiagnosticEvent {
-    timestamp: string;
-    type: string;
-    message: string;
-}
-export declare enum SSEEventType {
-    Init = "init",
-    Status = "status",
-    Stdout = "stdout",
-    Stderr = "stderr",
-    Result = "result",
-    ExecutionComplete = "execution_complete",
-    ExecutionCount = "execution_count",
-    Error = "error",
-    Ping = "ping",
-    Message = "message"
-}
-export interface SSEEvent {
-    type: SSEEventType;
-    text?: string;
-    results?: Record<string, string>;
-    error?: {
-        name?: string;
-        message: string;
-        evalue?: string;
-    };
-    execution_count?: number;
-    execution_time?: number;
-    timestamp: number;
-}
-export interface CodeContext {
-    id: string;
-    language: string;
-}
-export interface ExecuteCodeOptions {
-    code: string;
-    context?: {
-        id: string;
-        language: string;
-    };
-}
-export interface ExecuteCommandOptions {
-    command: string;
-    cwd?: string;
-    background?: boolean;
-    timeout?: number;
-    uid?: number;
-    gid?: number;
-    envs?: Record<string, string>;
-}
-export interface CommandStatus {
-    session: string;
-    status: "running" | "completed" | "failed";
-    exitCode?: number;
-}
-export interface FileInfo {
-    path: string;
-    size: number;
-    mode: string;
-    modifiedAt: string;
-    isDirectory: boolean;
-}
-export interface DirectoryEntry {
-    name: string;
-    path: string;
-    isDirectory: boolean;
-    size?: number;
-}
-export interface FileReplacement {
-    path: string;
-    old: string;
-    new: string;
-}
-export interface Metrics {
-    cpu: number;
-    memory: number;
-    timestamp: string;
-}