@tangle-network/sandbox 0.10.2 → 0.10.3

package/dist/runtime.d.ts

@@ -0,0 +1,62 @@
+import { A as CommitTaskSessionOptions, B as CreateTaskSessionOptions, Cr as SandboxTerminalInfo, Gr as SessionMessage, Kt as ListMessagesOptions, Lr as SendSessionMessageOptions, Rr as SendSessionMessageRequest, Si as WriteFileOptions, Sr as SandboxTerminalCreateOptions, Tr as SandboxTerminalRequestOptions, Ur as SessionInfo, ai as TaskSessionCommitResult, br as SandboxRuntimeProfileList, dt as FileWriteResult, ii as TaskSessionChanges, it as FileReadBatchResult, lt as FileTreeOptions, pr as SandboxPortBinding, rt as FileReadBatchOptions, si as TaskSessionInfo, ut as FileTreeResult, vr as SandboxRuntimeHealth, wr as SandboxTerminalManager, z as CreateSessionOptions, zr as SentSessionMessage } from "./types-Cmpv-ox_.js";
+import { a as NotFoundError, c as SandboxError, d as ServerError, f as StateError, i as NetworkError, l as SandboxErrorJson, m as ValidationError, n as CapabilityError, o as PartialFailureError, p as TimeoutError, s as QuotaError, t as AuthError, u as SandboxFailureDetail } from "./errors--P_nbLzM.js";
+
+//#region src/runtime-api.d.ts
+interface RuntimeTransport {
+  ensureRunning(): Promise<void>;
+  fetch(path: string, init?: RequestInit): Promise<Response>;
+}
+/** Internal typed client for routes served by a sandbox runtime. */
+declare class SandboxRuntimeApi {
+  private readonly transport;
+  readonly terminals: SandboxTerminalManager;
+  constructor(transport: RuntimeTransport);
+  health(): Promise<SandboxRuntimeHealth>;
+  ports(): Promise<SandboxPortBinding[]>;
+  profiles(): Promise<SandboxRuntimeProfileList>;
+  readFiles(paths: string[], options?: FileReadBatchOptions): Promise<FileReadBatchResult>;
+  writeFile(path: string, content: string, options?: WriteFileOptions): Promise<FileWriteResult>;
+  deleteFile(path: string, options?: Pick<WriteFileOptions, "sessionId">): Promise<void>;
+  fileTree(path: string, options?: FileTreeOptions): Promise<FileTreeResult>;
+  createSession(options: CreateSessionOptions): Promise<SessionInfo>;
+  messages(id: string, options?: Omit<ListMessagesOptions, "sessionId">): Promise<SessionMessage[]>;
+  createTaskSession(options: CreateTaskSessionOptions): Promise<TaskSessionInfo>;
+  sendSessionMessage(id: string, request: SendSessionMessageRequest, options?: SendSessionMessageOptions): Promise<SentSessionMessage>;
+  deleteSession(id: string): Promise<void>;
+  taskSessionChanges(id: string): Promise<TaskSessionChanges>;
+  commitTaskSession(id: string, options?: CommitTaskSessionOptions): Promise<TaskSessionCommitResult>;
+  private createTerminal;
+  private writeTerminal;
+  private listTerminals;
+  private getTerminal;
+  private json;
+  private request;
+  private assertOk;
+}
+//#endregion
+//#region src/runtime-client.d.ts
+interface SandboxRuntimeClientConfig {
+  /** Browser-safe proxy base returned by `box.mintScopedToken()`. */
+  baseUrl: string;
+  /** Short-lived scoped token returned by `box.mintScopedToken()`. */
+  token: string;
+  /** Request timeout in milliseconds. Defaults to 30 seconds. */
+  timeoutMs?: number;
+  /** Fetch implementation override for Workers, tests, or custom runtimes. */
+  fetch?: typeof globalThis.fetch;
+}
+/**
+ * Browser- and Worker-safe client for one sandbox runtime.
+ *
+ * Construct it from the scoped token response returned by
+ * `box.mintScopedToken()`. The full Sandbox API key remains server-side.
+ */
+declare class SandboxRuntimeClient extends SandboxRuntimeApi {
+  private readonly auth;
+  constructor(config: SandboxRuntimeClientConfig);
+  /** Replace an expiring scoped token without rebuilding consumers. */
+  updateToken(token: string): void;
+}
+declare function createSandboxRuntimeClient(config: SandboxRuntimeClientConfig): SandboxRuntimeClient;
+//#endregion
+export { AuthError, CapabilityError, type FileReadBatchOptions, type FileReadBatchResult, type FileTreeOptions, type FileTreeResult, type FileWriteResult, type ListMessagesOptions, NetworkError, NotFoundError, PartialFailureError, QuotaError, SandboxError, type SandboxErrorJson, type SandboxFailureDetail, SandboxRuntimeClient, type SandboxRuntimeClientConfig, type SandboxRuntimeHealth, type SandboxTerminalCreateOptions, type SandboxTerminalInfo, type SandboxTerminalManager, type SandboxTerminalRequestOptions, ServerError, type SessionMessage, StateError, TimeoutError, ValidationError, type WriteFileOptions, createSandboxRuntimeClient };

package/dist/runtime.js

@@ -0,0 +1,81 @@
+import { t as SandboxRuntimeApi } from "./runtime-api-CYA2DUQw.js";
+import { a as NotFoundError, c as SandboxError, d as TimeoutError, f as ValidationError, i as NetworkError, l as ServerError, n as CapabilityError, o as PartialFailureError, s as QuotaError, t as AuthError, u as StateError } from "./errors-DSz87Rkk.js";
+//#region src/runtime-client.ts
+const DEFAULT_RUNTIME_TIMEOUT_MS = 3e4;
+function requireToken(token) {
+	const value = token.trim();
+	if (!value) throw new ValidationError("Scoped runtime token is required");
+	return value;
+}
+function requireBaseUrl(baseUrl) {
+	let url;
+	try {
+		url = new URL(baseUrl);
+	} catch {
+		throw new ValidationError("Scoped runtime base URL must be absolute");
+	}
+	if (url.protocol !== "https:" && url.protocol !== "http:") throw new ValidationError("Scoped runtime base URL must use HTTP or HTTPS");
+	if (url.username || url.password) throw new ValidationError("Scoped runtime base URL must not include credentials");
+	if (url.search || url.hash) throw new ValidationError("Scoped runtime base URL must not include a query or fragment");
+	return url.toString().replace(/\/+$/, "");
+}
+function requireTimeout(timeoutMs) {
+	const value = timeoutMs ?? DEFAULT_RUNTIME_TIMEOUT_MS;
+	if (!Number.isFinite(value) || value <= 0) throw new ValidationError("Scoped runtime timeout must be positive");
+	return value;
+}
+/**
+* Browser- and Worker-safe client for one sandbox runtime.
+*
+* Construct it from the scoped token response returned by
+* `box.mintScopedToken()`. The full Sandbox API key remains server-side.
+*/
+var SandboxRuntimeClient = class extends SandboxRuntimeApi {
+	auth;
+	constructor(config) {
+		const baseUrl = requireBaseUrl(config.baseUrl);
+		const auth = { token: requireToken(config.token) };
+		const timeoutMs = requireTimeout(config.timeoutMs);
+		const fetchImpl = config.fetch ?? globalThis.fetch;
+		if (typeof fetchImpl !== "function") throw new ValidationError("Scoped runtime client requires a fetch implementation");
+		super({
+			ensureRunning: async () => void 0,
+			fetch: async (path, init = {}) => {
+				if (!path.startsWith("/") || path.startsWith("//")) throw new ValidationError("Scoped runtime request paths must start with one slash");
+				const headers = new Headers(init.headers);
+				headers.set("Authorization", `Bearer ${auth.token}`);
+				const isFormData = typeof FormData !== "undefined" && init.body instanceof FormData;
+				if (init.body !== void 0 && !isFormData && !headers.has("Content-Type")) headers.set("Content-Type", "application/json");
+				const timeoutSignal = AbortSignal.timeout(timeoutMs);
+				const signal = init.signal ? AbortSignal.any([init.signal, timeoutSignal]) : timeoutSignal;
+				try {
+					return await fetchImpl(`${baseUrl}${path}`, {
+						...init,
+						headers,
+						signal
+					});
+				} catch (error) {
+					if (timeoutSignal.aborted && !init.signal?.aborted) throw new TimeoutError(timeoutMs, void 0, {
+						origin: "runtime",
+						endpoint: path
+					});
+					if (init.signal?.aborted) throw error;
+					throw new NetworkError(`Scoped runtime request failed: ${path}`, error instanceof Error ? error : new Error(String(error)), {
+						origin: "runtime",
+						endpoint: path
+					});
+				}
+			}
+		});
+		this.auth = auth;
+	}
+	/** Replace an expiring scoped token without rebuilding consumers. */
+	updateToken(token) {
+		this.auth.token = requireToken(token);
+	}
+};
+function createSandboxRuntimeClient(config) {
+	return new SandboxRuntimeClient(config);
+}
+//#endregion
+export { AuthError, CapabilityError, NetworkError, NotFoundError, PartialFailureError, QuotaError, SandboxError, SandboxRuntimeClient, ServerError, StateError, TimeoutError, ValidationError, createSandboxRuntimeClient };