@cloudflare/sandbox 0.0.0-6a2c669 → 0.0.0-6c54d07

package/dist/chunk-BFVUNTP4.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/file-stream.ts"],"sourcesContent":["import type { FileChunk, FileMetadata, FileStreamEvent } from '@repo/shared';\n\n/**\n * Parse SSE (Server-Sent Events) lines from a stream\n */\nasync function* parseSSE(stream: ReadableStream<Uint8Array>): AsyncGenerator<FileStreamEvent> {\n  const reader = stream.getReader();\n  const decoder = new TextDecoder();\n  let buffer = '';\n\n  try {\n    while (true) {\n      const { done, value } = await reader.read();\n\n      if (done) {\n        break;\n      }\n\n      buffer += decoder.decode(value, { stream: true });\n      const lines = buffer.split('\\n');\n\n      // Keep the last incomplete line in the buffer\n      buffer = lines.pop() || '';\n\n      for (const line of lines) {\n        if (line.startsWith('data: ')) {\n          const data = line.slice(6); // Remove 'data: ' prefix\n          try {\n            const event = JSON.parse(data) as FileStreamEvent;\n            yield event;\n          } catch {\n            // Skip invalid JSON events and continue processing\n          }\n        }\n      }\n    }\n  } finally {\n    reader.releaseLock();\n  }\n}\n\n/**\n * Stream a file from the sandbox with automatic base64 decoding for binary files\n *\n * @param stream - The ReadableStream from readFileStream()\n * @returns AsyncGenerator that yields FileChunk (string for text, Uint8Array for binary)\n *\n * @example\n * ```ts\n * const stream = await sandbox.readFileStream('/path/to/file.png');\n * for await (const chunk of streamFile(stream)) {\n *   if (chunk instanceof Uint8Array) {\n *     // Binary chunk\n *     console.log('Binary chunk:', chunk.length, 'bytes');\n *   } else {\n *     // Text chunk\n *     console.log('Text chunk:', chunk);\n *   }\n * }\n * ```\n */\nexport async function* streamFile(stream: ReadableStream<Uint8Array>): AsyncGenerator<FileChunk, FileMetadata> {\n  let metadata: FileMetadata | null = null;\n\n  for await (const event of parseSSE(stream)) {\n    switch (event.type) {\n      case 'metadata':\n        metadata = {\n          mimeType: event.mimeType,\n          size: event.size,\n          isBinary: event.isBinary,\n          encoding: event.encoding,\n        };\n        break;\n\n      case 'chunk':\n        if (!metadata) {\n          throw new Error('Received chunk before metadata');\n        }\n\n        if (metadata.isBinary && metadata.encoding === 'base64') {\n          // Decode base64 to Uint8Array for binary files\n          const binaryString = atob(event.data);\n          const bytes = new Uint8Array(binaryString.length);\n          for (let i = 0; i < binaryString.length; i++) {\n            bytes[i] = binaryString.charCodeAt(i);\n          }\n          yield bytes;\n        } else {\n          // Text files - yield as-is\n          yield event.data;\n        }\n        break;\n\n      case 'complete':\n        if (!metadata) {\n          throw new Error('Stream completed without metadata');\n        }\n        return metadata;\n\n      case 'error':\n        throw new Error(`File streaming error: ${event.error}`);\n    }\n  }\n\n  throw new Error('Stream ended unexpectedly');\n}\n\n/**\n * Collect an entire file into memory from a stream\n *\n * @param stream - The ReadableStream from readFileStream()\n * @returns Object containing the file content and metadata\n *\n * @example\n * ```ts\n * const stream = await sandbox.readFileStream('/path/to/file.txt');\n * const { content, metadata } = await collectFile(stream);\n * console.log('Content:', content);\n * console.log('MIME type:', metadata.mimeType);\n * ```\n */\nexport async function collectFile(stream: ReadableStream<Uint8Array>): Promise<{\n  content: string | Uint8Array;\n  metadata: FileMetadata;\n}> {\n  const chunks: Array<string | Uint8Array> = [];\n\n  // Iterate through the generator and get the return value (metadata)\n  const generator = streamFile(stream);\n  let result = await generator.next();\n\n  while (!result.done) {\n    chunks.push(result.value);\n    result = await generator.next();\n  }\n\n  const metadata = result.value;\n\n  if (!metadata) {\n    throw new Error('Failed to get file metadata');\n  }\n\n  // Combine chunks based on type\n  if (metadata.isBinary) {\n    // Binary file - combine Uint8Arrays\n    const totalLength = chunks.reduce((sum, chunk) =>\n      sum + (chunk instanceof Uint8Array ? chunk.length : 0), 0\n    );\n    const combined = new Uint8Array(totalLength);\n    let offset = 0;\n    for (const chunk of chunks) {\n      if (chunk instanceof Uint8Array) {\n        combined.set(chunk, offset);\n        offset += chunk.length;\n      }\n    }\n    return { content: combined, metadata };\n  } else {\n    // Text file - combine strings\n    const combined = chunks.filter(c => typeof c === 'string').join('');\n    return { content: combined, metadata };\n  }\n}\n"],"mappings":";AAKA,gBAAgB,SAAS,QAAqE;AAC5F,QAAM,SAAS,OAAO,UAAU;AAChC,QAAM,UAAU,IAAI,YAAY;AAChC,MAAI,SAAS;AAEb,MAAI;AACF,WAAO,MAAM;AACX,YAAM,EAAE,MAAM,MAAM,IAAI,MAAM,OAAO,KAAK;AAE1C,UAAI,MAAM;AACR;AAAA,MACF;AAEA,gBAAU,QAAQ,OAAO,OAAO,EAAE,QAAQ,KAAK,CAAC;AAChD,YAAM,QAAQ,OAAO,MAAM,IAAI;AAG/B,eAAS,MAAM,IAAI,KAAK;AAExB,iBAAW,QAAQ,OAAO;AACxB,YAAI,KAAK,WAAW,QAAQ,GAAG;AAC7B,gBAAM,OAAO,KAAK,MAAM,CAAC;AACzB,cAAI;AACF,kBAAM,QAAQ,KAAK,MAAM,IAAI;AAC7B,kBAAM;AAAA,UACR,QAAQ;AAAA,UAER;AAAA,QACF;AAAA,MACF;AAAA,IACF;AAAA,EACF,UAAE;AACA,WAAO,YAAY;AAAA,EACrB;AACF;AAsBA,gBAAuB,WAAW,QAA6E;AAC7G,MAAI,WAAgC;AAEpC,mBAAiB,SAAS,SAAS,MAAM,GAAG;AAC1C,YAAQ,MAAM,MAAM;AAAA,MAClB,KAAK;AACH,mBAAW;AAAA,UACT,UAAU,MAAM;AAAA,UAChB,MAAM,MAAM;AAAA,UACZ,UAAU,MAAM;AAAA,UAChB,UAAU,MAAM;AAAA,QAClB;AACA;AAAA,MAEF,KAAK;AACH,YAAI,CAAC,UAAU;AACb,gBAAM,IAAI,MAAM,gCAAgC;AAAA,QAClD;AAEA,YAAI,SAAS,YAAY,SAAS,aAAa,UAAU;AAEvD,gBAAM,eAAe,KAAK,MAAM,IAAI;AACpC,gBAAM,QAAQ,IAAI,WAAW,aAAa,MAAM;AAChD,mBAAS,IAAI,GAAG,IAAI,aAAa,QAAQ,KAAK;AAC5C,kBAAM,CAAC,IAAI,aAAa,WAAW,CAAC;AAAA,UACtC;AACA,gBAAM;AAAA,QACR,OAAO;AAEL,gBAAM,MAAM;AAAA,QACd;AACA;AAAA,MAEF,KAAK;AACH,YAAI,CAAC,UAAU;AACb,gBAAM,IAAI,MAAM,mCAAmC;AAAA,QACrD;AACA,eAAO;AAAA,MAET,KAAK;AACH,cAAM,IAAI,MAAM,yBAAyB,MAAM,KAAK,EAAE;AAAA,IAC1D;AAAA,EACF;AAEA,QAAM,IAAI,MAAM,2BAA2B;AAC7C;AAgBA,eAAsB,YAAY,QAG/B;AACD,QAAM,SAAqC,CAAC;AAG5C,QAAM,YAAY,WAAW,MAAM;AACnC,MAAI,SAAS,MAAM,UAAU,KAAK;AAElC,SAAO,CAAC,OAAO,MAAM;AACnB,WAAO,KAAK,OAAO,KAAK;AACxB,aAAS,MAAM,UAAU,KAAK;AAAA,EAChC;AAEA,QAAM,WAAW,OAAO;AAExB,MAAI,CAAC,UAAU;AACb,UAAM,IAAI,MAAM,6BAA6B;AAAA,EAC/C;AAGA,MAAI,SAAS,UAAU;AAErB,UAAM,cAAc,OAAO;AAAA,MAAO,CAAC,KAAK,UACtC,OAAO,iBAAiB,aAAa,MAAM,SAAS;AAAA,MAAI;AAAA,IAC1D;AACA,UAAM,WAAW,IAAI,WAAW,WAAW;AAC3C,QAAI,SAAS;AACb,eAAW,SAAS,QAAQ;AAC1B,UAAI,iBAAiB,YAAY;AAC/B,iBAAS,IAAI,OAAO,MAAM;AAC1B,kBAAU,MAAM;AAAA,MAClB;AAAA,IACF;AACA,WAAO,EAAE,SAAS,UAAU,SAAS;AAAA,EACvC,OAAO;AAEL,UAAM,WAAW,OAAO,OAAO,OAAK,OAAO,MAAM,QAAQ,EAAE,KAAK,EAAE;AAClE,WAAO,EAAE,SAAS,UAAU,SAAS;AAAA,EACvC;AACF;","names":[]}

package/dist/chunk-EKSWCBCA.js

@@ -0,0 +1,86 @@
+// src/sse-parser.ts
+async function* parseSSEStream(stream, signal) {
+  const reader = stream.getReader();
+  const decoder = new TextDecoder();
+  let buffer = "";
+  try {
+    while (true) {
+      if (signal?.aborted) {
+        throw new Error("Operation was aborted");
+      }
+      const { done, value } = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true });
+      const lines = buffer.split("\n");
+      buffer = lines.pop() || "";
+      for (const line of lines) {
+        if (line.trim() === "") continue;
+        if (line.startsWith("data: ")) {
+          const data = line.substring(6);
+          if (data === "[DONE]" || data.trim() === "") continue;
+          try {
+            const event = JSON.parse(data);
+            yield event;
+          } catch {
+          }
+        }
+      }
+    }
+    if (buffer.trim() && buffer.startsWith("data: ")) {
+      const data = buffer.substring(6);
+      if (data !== "[DONE]" && data.trim()) {
+        try {
+          const event = JSON.parse(data);
+          yield event;
+        } catch {
+        }
+      }
+    }
+  } finally {
+    reader.releaseLock();
+  }
+}
+async function* responseToAsyncIterable(response, signal) {
+  if (!response.ok) {
+    throw new Error(`Response not ok: ${response.status} ${response.statusText}`);
+  }
+  if (!response.body) {
+    throw new Error("No response body");
+  }
+  yield* parseSSEStream(response.body, signal);
+}
+function asyncIterableToSSEStream(events, options) {
+  const encoder = new TextEncoder();
+  const serialize = options?.serialize || JSON.stringify;
+  return new ReadableStream({
+    async start(controller) {
+      try {
+        for await (const event of events) {
+          if (options?.signal?.aborted) {
+            controller.error(new Error("Operation was aborted"));
+            break;
+          }
+          const data = serialize(event);
+          const sseEvent = `data: ${data}
+
+`;
+          controller.enqueue(encoder.encode(sseEvent));
+        }
+        controller.enqueue(encoder.encode("data: [DONE]\n\n"));
+      } catch (error) {
+        controller.error(error);
+      } finally {
+        controller.close();
+      }
+    },
+    cancel() {
+    }
+  });
+}
+
+export {
+  parseSSEStream,
+  responseToAsyncIterable,
+  asyncIterableToSSEStream
+};
+//# sourceMappingURL=chunk-EKSWCBCA.js.map

package/dist/chunk-EKSWCBCA.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/sse-parser.ts"],"sourcesContent":["/**\n * Server-Sent Events (SSE) parser for streaming responses\n * Converts ReadableStream<Uint8Array> to typed AsyncIterable<T>\n */\n\n/**\n * Parse a ReadableStream of SSE events into typed AsyncIterable\n * @param stream - The ReadableStream from fetch response\n * @param signal - Optional AbortSignal for cancellation\n */\nexport async function* parseSSEStream<T>(\n  stream: ReadableStream<Uint8Array>,\n  signal?: AbortSignal\n): AsyncIterable<T> {\n  const reader = stream.getReader();\n  const decoder = new TextDecoder();\n  let buffer = '';\n\n  try {\n    while (true) {\n      // Check for cancellation\n      if (signal?.aborted) {\n        throw new Error('Operation was aborted');\n      }\n\n      const { done, value } = await reader.read();\n      if (done) break;\n\n      // Decode chunk and add to buffer\n      buffer += decoder.decode(value, { stream: true });\n\n      // Process complete SSE events in buffer\n      const lines = buffer.split('\\n');\n\n      // Keep the last incomplete line in buffer\n      buffer = lines.pop() || '';\n\n      for (const line of lines) {\n        // Skip empty lines\n        if (line.trim() === '') continue;\n\n        // Process SSE data lines\n        if (line.startsWith('data: ')) {\n          const data = line.substring(6);\n\n          // Skip [DONE] markers or empty data\n          if (data === '[DONE]' || data.trim() === '') continue;\n\n          try {\n            const event = JSON.parse(data) as T;\n            yield event;\n          } catch {\n            // Skip invalid JSON events and continue processing\n          }\n        }\n        // Handle other SSE fields if needed (event:, id:, retry:)\n        // For now, we only care about data: lines\n      }\n    }\n\n    // Process any remaining data in buffer\n    if (buffer.trim() && buffer.startsWith('data: ')) {\n      const data = buffer.substring(6);\n      if (data !== '[DONE]' && data.trim()) {\n        try {\n          const event = JSON.parse(data) as T;\n          yield event;\n        } catch {\n          // Skip invalid JSON in final event\n        }\n      }\n    }\n  } finally {\n    // Clean up resources\n    reader.releaseLock();\n  }\n}\n\n\n/**\n * Helper to convert a Response with SSE stream directly to AsyncIterable\n * @param response - Response object with SSE stream\n * @param signal - Optional AbortSignal for cancellation\n */\nexport async function* responseToAsyncIterable<T>(\n  response: Response,\n  signal?: AbortSignal\n): AsyncIterable<T> {\n  if (!response.ok) {\n    throw new Error(`Response not ok: ${response.status} ${response.statusText}`);\n  }\n\n  if (!response.body) {\n    throw new Error('No response body');\n  }\n\n  yield* parseSSEStream<T>(response.body, signal);\n}\n\n/**\n * Create an SSE-formatted ReadableStream from an AsyncIterable\n * (Useful for Worker endpoints that need to forward AsyncIterable as SSE)\n * @param events - AsyncIterable of events\n * @param options - Stream options\n */\nexport function asyncIterableToSSEStream<T>(\n  events: AsyncIterable<T>,\n  options?: {\n    signal?: AbortSignal;\n    serialize?: (event: T) => string;\n  }\n): ReadableStream<Uint8Array> {\n  const encoder = new TextEncoder();\n  const serialize = options?.serialize || JSON.stringify;\n\n  return new ReadableStream({\n    async start(controller) {\n      try {\n        for await (const event of events) {\n          if (options?.signal?.aborted) {\n            controller.error(new Error('Operation was aborted'));\n            break;\n          }\n\n          const data = serialize(event);\n          const sseEvent = `data: ${data}\\n\\n`;\n          controller.enqueue(encoder.encode(sseEvent));\n        }\n\n        // Send completion marker\n        controller.enqueue(encoder.encode('data: [DONE]\\n\\n'));\n      } catch (error) {\n        controller.error(error);\n      } finally {\n        controller.close();\n      }\n    },\n\n    cancel() {\n      // Handle stream cancellation\n    }\n  });\n}"],"mappings":";AAUA,gBAAuB,eACrB,QACA,QACkB;AAClB,QAAM,SAAS,OAAO,UAAU;AAChC,QAAM,UAAU,IAAI,YAAY;AAChC,MAAI,SAAS;AAEb,MAAI;AACF,WAAO,MAAM;AAEX,UAAI,QAAQ,SAAS;AACnB,cAAM,IAAI,MAAM,uBAAuB;AAAA,MACzC;AAEA,YAAM,EAAE,MAAM,MAAM,IAAI,MAAM,OAAO,KAAK;AAC1C,UAAI,KAAM;AAGV,gBAAU,QAAQ,OAAO,OAAO,EAAE,QAAQ,KAAK,CAAC;AAGhD,YAAM,QAAQ,OAAO,MAAM,IAAI;AAG/B,eAAS,MAAM,IAAI,KAAK;AAExB,iBAAW,QAAQ,OAAO;AAExB,YAAI,KAAK,KAAK,MAAM,GAAI;AAGxB,YAAI,KAAK,WAAW,QAAQ,GAAG;AAC7B,gBAAM,OAAO,KAAK,UAAU,CAAC;AAG7B,cAAI,SAAS,YAAY,KAAK,KAAK,MAAM,GAAI;AAE7C,cAAI;AACF,kBAAM,QAAQ,KAAK,MAAM,IAAI;AAC7B,kBAAM;AAAA,UACR,QAAQ;AAAA,UAER;AAAA,QACF;AAAA,MAGF;AAAA,IACF;AAGA,QAAI,OAAO,KAAK,KAAK,OAAO,WAAW,QAAQ,GAAG;AAChD,YAAM,OAAO,OAAO,UAAU,CAAC;AAC/B,UAAI,SAAS,YAAY,KAAK,KAAK,GAAG;AACpC,YAAI;AACF,gBAAM,QAAQ,KAAK,MAAM,IAAI;AAC7B,gBAAM;AAAA,QACR,QAAQ;AAAA,QAER;AAAA,MACF;AAAA,IACF;AAAA,EACF,UAAE;AAEA,WAAO,YAAY;AAAA,EACrB;AACF;AAQA,gBAAuB,wBACrB,UACA,QACkB;AAClB,MAAI,CAAC,SAAS,IAAI;AAChB,UAAM,IAAI,MAAM,oBAAoB,SAAS,MAAM,IAAI,SAAS,UAAU,EAAE;AAAA,EAC9E;AAEA,MAAI,CAAC,SAAS,MAAM;AAClB,UAAM,IAAI,MAAM,kBAAkB;AAAA,EACpC;AAEA,SAAO,eAAkB,SAAS,MAAM,MAAM;AAChD;AAQO,SAAS,yBACd,QACA,SAI4B;AAC5B,QAAM,UAAU,IAAI,YAAY;AAChC,QAAM,YAAY,SAAS,aAAa,KAAK;AAE7C,SAAO,IAAI,eAAe;AAAA,IACxB,MAAM,MAAM,YAAY;AACtB,UAAI;AACF,yBAAiB,SAAS,QAAQ;AAChC,cAAI,SAAS,QAAQ,SAAS;AAC5B,uBAAW,MAAM,IAAI,MAAM,uBAAuB,CAAC;AACnD;AAAA,UACF;AAEA,gBAAM,OAAO,UAAU,KAAK;AAC5B,gBAAM,WAAW,SAAS,IAAI;AAAA;AAAA;AAC9B,qBAAW,QAAQ,QAAQ,OAAO,QAAQ,CAAC;AAAA,QAC7C;AAGA,mBAAW,QAAQ,QAAQ,OAAO,kBAAkB,CAAC;AAAA,MACvD,SAAS,OAAO;AACd,mBAAW,MAAM,KAAK;AAAA,MACxB,UAAE;AACA,mBAAW,MAAM;AAAA,MACnB;AAAA,IACF;AAAA,IAEA,SAAS;AAAA,IAET;AAAA,EACF,CAAC;AACH;","names":[]}

package/dist/chunk-JXZMAU2C.js

@@ -0,0 +1,559 @@
+import {
+  validateLanguage
+} from "./chunk-Z532A7QC.js";
+
+// ../shared/dist/interpreter-types.js
+var Execution = class {
+  code;
+  context;
+  /**
+   * All results from the execution
+   */
+  results = [];
+  /**
+   * Accumulated stdout and stderr
+   */
+  logs = {
+    stdout: [],
+    stderr: []
+  };
+  /**
+   * Execution error if any
+   */
+  error;
+  /**
+   * Execution count (for interpreter)
+   */
+  executionCount;
+  constructor(code, context) {
+    this.code = code;
+    this.context = context;
+  }
+  /**
+   * Convert to a plain object for serialization
+   */
+  toJSON() {
+    return {
+      code: this.code,
+      logs: this.logs,
+      error: this.error,
+      executionCount: this.executionCount,
+      results: this.results.map((result) => ({
+        text: result.text,
+        html: result.html,
+        png: result.png,
+        jpeg: result.jpeg,
+        svg: result.svg,
+        latex: result.latex,
+        markdown: result.markdown,
+        javascript: result.javascript,
+        json: result.json,
+        chart: result.chart,
+        data: result.data
+      }))
+    };
+  }
+};
+var ResultImpl = class {
+  raw;
+  constructor(raw) {
+    this.raw = raw;
+  }
+  get text() {
+    return this.raw.text || this.raw.data?.["text/plain"];
+  }
+  get html() {
+    return this.raw.html || this.raw.data?.["text/html"];
+  }
+  get png() {
+    return this.raw.png || this.raw.data?.["image/png"];
+  }
+  get jpeg() {
+    return this.raw.jpeg || this.raw.data?.["image/jpeg"];
+  }
+  get svg() {
+    return this.raw.svg || this.raw.data?.["image/svg+xml"];
+  }
+  get latex() {
+    return this.raw.latex || this.raw.data?.["text/latex"];
+  }
+  get markdown() {
+    return this.raw.markdown || this.raw.data?.["text/markdown"];
+  }
+  get javascript() {
+    return this.raw.javascript || this.raw.data?.["application/javascript"];
+  }
+  get json() {
+    return this.raw.json || this.raw.data?.["application/json"];
+  }
+  get chart() {
+    return this.raw.chart;
+  }
+  get data() {
+    return this.raw.data;
+  }
+  formats() {
+    const formats = [];
+    if (this.text)
+      formats.push("text");
+    if (this.html)
+      formats.push("html");
+    if (this.png)
+      formats.push("png");
+    if (this.jpeg)
+      formats.push("jpeg");
+    if (this.svg)
+      formats.push("svg");
+    if (this.latex)
+      formats.push("latex");
+    if (this.markdown)
+      formats.push("markdown");
+    if (this.javascript)
+      formats.push("javascript");
+    if (this.json)
+      formats.push("json");
+    if (this.chart)
+      formats.push("chart");
+    return formats;
+  }
+};
+
+// ../shared/dist/logger/index.js
+import { AsyncLocalStorage } from "async_hooks";
+
+// ../shared/dist/logger/types.js
+var LogLevel;
+(function(LogLevel2) {
+  LogLevel2[LogLevel2["DEBUG"] = 0] = "DEBUG";
+  LogLevel2[LogLevel2["INFO"] = 1] = "INFO";
+  LogLevel2[LogLevel2["WARN"] = 2] = "WARN";
+  LogLevel2[LogLevel2["ERROR"] = 3] = "ERROR";
+})(LogLevel || (LogLevel = {}));
+
+// ../shared/dist/logger/logger.js
+var COLORS = {
+  reset: "\x1B[0m",
+  debug: "\x1B[36m",
+  // Cyan
+  info: "\x1B[32m",
+  // Green
+  warn: "\x1B[33m",
+  // Yellow
+  error: "\x1B[31m",
+  // Red
+  dim: "\x1B[2m"
+  // Dim
+};
+var CloudflareLogger = class _CloudflareLogger {
+  baseContext;
+  minLevel;
+  pretty;
+  /**
+   * Create a new CloudflareLogger
+   *
+   * @param baseContext Base context included in all log entries
+   * @param minLevel Minimum log level to output (default: INFO)
+   * @param pretty Enable pretty printing for human-readable output (default: false)
+   */
+  constructor(baseContext, minLevel = LogLevel.INFO, pretty = false) {
+    this.baseContext = baseContext;
+    this.minLevel = minLevel;
+    this.pretty = pretty;
+  }
+  /**
+   * Log debug-level message
+   */
+  debug(message, context) {
+    if (this.shouldLog(LogLevel.DEBUG)) {
+      const logData = this.buildLogData("debug", message, context);
+      this.output(console.log, logData);
+    }
+  }
+  /**
+   * Log info-level message
+   */
+  info(message, context) {
+    if (this.shouldLog(LogLevel.INFO)) {
+      const logData = this.buildLogData("info", message, context);
+      this.output(console.log, logData);
+    }
+  }
+  /**
+   * Log warning-level message
+   */
+  warn(message, context) {
+    if (this.shouldLog(LogLevel.WARN)) {
+      const logData = this.buildLogData("warn", message, context);
+      this.output(console.warn, logData);
+    }
+  }
+  /**
+   * Log error-level message
+   */
+  error(message, error, context) {
+    if (this.shouldLog(LogLevel.ERROR)) {
+      const logData = this.buildLogData("error", message, context, error);
+      this.output(console.error, logData);
+    }
+  }
+  /**
+   * Create a child logger with additional context
+   */
+  child(context) {
+    return new _CloudflareLogger({ ...this.baseContext, ...context }, this.minLevel, this.pretty);
+  }
+  /**
+   * Check if a log level should be output
+   */
+  shouldLog(level) {
+    return level >= this.minLevel;
+  }
+  /**
+   * Build log data object
+   */
+  buildLogData(level, message, context, error) {
+    const logData = {
+      level,
+      msg: message,
+      ...this.baseContext,
+      ...context,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    if (error) {
+      logData.error = {
+        message: error.message,
+        stack: error.stack,
+        name: error.name
+      };
+    }
+    return logData;
+  }
+  /**
+   * Output log data to console (pretty or JSON)
+   */
+  output(consoleFn, data) {
+    if (this.pretty) {
+      this.outputPretty(consoleFn, data);
+    } else {
+      this.outputJson(consoleFn, data);
+    }
+  }
+  /**
+   * Output as JSON (production)
+   */
+  outputJson(consoleFn, data) {
+    consoleFn(JSON.stringify(data));
+  }
+  /**
+   * Output as pretty-printed, colored text (development)
+   *
+   * Format: LEVEL [component] message (trace: tr_...) {context}
+   * Example: INFO [sandbox-do] Command started (trace: tr_7f3a9b2c) {commandId: "cmd-123"}
+   */
+  outputPretty(consoleFn, data) {
+    const { level, msg, timestamp, traceId, component, sandboxId, sessionId, processId, commandId, operation, duration, error, ...rest } = data;
+    const levelStr = String(level || "INFO").toUpperCase();
+    const levelColor = this.getLevelColor(levelStr);
+    const componentBadge = component ? `[${component}]` : "";
+    const traceIdShort = traceId ? String(traceId).substring(0, 12) : "";
+    let logLine = `${levelColor}${levelStr.padEnd(5)}${COLORS.reset} ${componentBadge} ${msg}`;
+    if (traceIdShort) {
+      logLine += ` ${COLORS.dim}(trace: ${traceIdShort})${COLORS.reset}`;
+    }
+    const contextFields = [];
+    if (operation)
+      contextFields.push(`operation: ${operation}`);
+    if (commandId)
+      contextFields.push(`commandId: ${String(commandId).substring(0, 12)}`);
+    if (sandboxId)
+      contextFields.push(`sandboxId: ${sandboxId}`);
+    if (sessionId)
+      contextFields.push(`sessionId: ${String(sessionId).substring(0, 12)}`);
+    if (processId)
+      contextFields.push(`processId: ${processId}`);
+    if (duration !== void 0)
+      contextFields.push(`duration: ${duration}ms`);
+    if (contextFields.length > 0) {
+      logLine += ` ${COLORS.dim}{${contextFields.join(", ")}}${COLORS.reset}`;
+    }
+    consoleFn(logLine);
+    if (error && typeof error === "object") {
+      const errorObj = error;
+      if (errorObj.message) {
+        consoleFn(`  ${COLORS.error}Error: ${errorObj.message}${COLORS.reset}`);
+      }
+      if (errorObj.stack) {
+        consoleFn(`  ${COLORS.dim}${errorObj.stack}${COLORS.reset}`);
+      }
+    }
+    if (Object.keys(rest).length > 0) {
+      consoleFn(`  ${COLORS.dim}${JSON.stringify(rest, null, 2)}${COLORS.reset}`);
+    }
+  }
+  /**
+   * Get ANSI color code for log level
+   */
+  getLevelColor(level) {
+    const levelLower = level.toLowerCase();
+    switch (levelLower) {
+      case "debug":
+        return COLORS.debug;
+      case "info":
+        return COLORS.info;
+      case "warn":
+        return COLORS.warn;
+      case "error":
+        return COLORS.error;
+      default:
+        return COLORS.reset;
+    }
+  }
+};
+
+// ../shared/dist/logger/trace-context.js
+var TraceContext = class _TraceContext {
+  /**
+   * HTTP header name for trace ID propagation
+   */
+  static TRACE_HEADER = "X-Trace-Id";
+  /**
+   * Generate a new trace ID
+   *
+   * Format: "tr_" + 16 random hex characters
+   * Example: "tr_7f3a9b2c4e5d6f1a"
+   *
+   * @returns Newly generated trace ID
+   */
+  static generate() {
+    const randomHex = crypto.randomUUID().replace(/-/g, "").substring(0, 16);
+    return `tr_${randomHex}`;
+  }
+  /**
+   * Extract trace ID from HTTP request headers
+   *
+   * @param headers Request headers
+   * @returns Trace ID if present, null otherwise
+   */
+  static fromHeaders(headers) {
+    return headers.get(_TraceContext.TRACE_HEADER);
+  }
+  /**
+   * Create headers object with trace ID for outgoing requests
+   *
+   * @param traceId Trace ID to include
+   * @returns Headers object with X-Trace-Id set
+   */
+  static toHeaders(traceId) {
+    return { [_TraceContext.TRACE_HEADER]: traceId };
+  }
+  /**
+   * Get the header name used for trace ID propagation
+   *
+   * @returns Header name ("X-Trace-Id")
+   */
+  static getHeaderName() {
+    return _TraceContext.TRACE_HEADER;
+  }
+};
+
+// ../shared/dist/logger/index.js
+function createNoOpLogger() {
+  return {
+    debug: () => {
+    },
+    info: () => {
+    },
+    warn: () => {
+    },
+    error: () => {
+    },
+    child: () => createNoOpLogger()
+  };
+}
+var loggerStorage = new AsyncLocalStorage();
+function getLogger() {
+  const logger = loggerStorage.getStore();
+  if (!logger) {
+    throw new Error("Logger not initialized in async context. Ensure runWithLogger() is called at the entry point (e.g., fetch handler).");
+  }
+  return logger;
+}
+function runWithLogger(logger, fn) {
+  return loggerStorage.run(logger, fn);
+}
+function createLogger(context) {
+  const minLevel = getLogLevelFromEnv();
+  const pretty = isPrettyPrintEnabled();
+  const baseContext = {
+    ...context,
+    traceId: context.traceId || TraceContext.generate(),
+    component: context.component
+  };
+  return new CloudflareLogger(baseContext, minLevel, pretty);
+}
+function getLogLevelFromEnv() {
+  const envLevel = getEnvVar("SANDBOX_LOG_LEVEL") || "info";
+  switch (envLevel.toLowerCase()) {
+    case "debug":
+      return LogLevel.DEBUG;
+    case "info":
+      return LogLevel.INFO;
+    case "warn":
+      return LogLevel.WARN;
+    case "error":
+      return LogLevel.ERROR;
+    default:
+      return LogLevel.INFO;
+  }
+}
+function isPrettyPrintEnabled() {
+  const format = getEnvVar("SANDBOX_LOG_FORMAT");
+  if (format) {
+    return format.toLowerCase() === "pretty";
+  }
+  return false;
+}
+function getEnvVar(name) {
+  if (typeof process !== "undefined" && process.env) {
+    return process.env[name];
+  }
+  if (typeof Bun !== "undefined") {
+    const bunEnv = Bun.env;
+    if (bunEnv) {
+      return bunEnv[name];
+    }
+  }
+  return void 0;
+}
+
+// ../shared/dist/types.js
+function isExecResult(value) {
+  return value && typeof value.success === "boolean" && typeof value.exitCode === "number" && typeof value.stdout === "string" && typeof value.stderr === "string";
+}
+function isProcess(value) {
+  return value && typeof value.id === "string" && typeof value.command === "string" && typeof value.status === "string";
+}
+function isProcessStatus(value) {
+  return ["starting", "running", "completed", "failed", "killed", "error"].includes(value);
+}
+
+// src/interpreter.ts
+var CodeInterpreter = class {
+  interpreterClient;
+  contexts = /* @__PURE__ */ new Map();
+  constructor(sandbox) {
+    this.interpreterClient = sandbox.client.interpreter;
+  }
+  /**
+   * Create a new code execution context
+   */
+  async createCodeContext(options = {}) {
+    validateLanguage(options.language);
+    const context = await this.interpreterClient.createCodeContext(options);
+    this.contexts.set(context.id, context);
+    return context;
+  }
+  /**
+   * Run code with optional context
+   */
+  async runCode(code, options = {}) {
+    let context = options.context;
+    if (!context) {
+      const language = options.language || "python";
+      context = await this.getOrCreateDefaultContext(language);
+    }
+    const execution = new Execution(code, context);
+    await this.interpreterClient.runCodeStream(context.id, code, options.language, {
+      onStdout: (output) => {
+        execution.logs.stdout.push(output.text);
+        if (options.onStdout) return options.onStdout(output);
+      },
+      onStderr: (output) => {
+        execution.logs.stderr.push(output.text);
+        if (options.onStderr) return options.onStderr(output);
+      },
+      onResult: async (result) => {
+        execution.results.push(new ResultImpl(result));
+        if (options.onResult) return options.onResult(result);
+      },
+      onError: (error) => {
+        execution.error = error;
+        if (options.onError) return options.onError(error);
+      }
+    });
+    return execution;
+  }
+  /**
+   * Run code and return a streaming response
+   */
+  async runCodeStream(code, options = {}) {
+    let context = options.context;
+    if (!context) {
+      const language = options.language || "python";
+      context = await this.getOrCreateDefaultContext(language);
+    }
+    const response = await this.interpreterClient.doFetch("/api/execute/code", {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Accept: "text/event-stream"
+      },
+      body: JSON.stringify({
+        context_id: context.id,
+        code,
+        language: options.language
+      })
+    });
+    if (!response.ok) {
+      const errorData = await response.json().catch(() => ({ error: "Unknown error" }));
+      throw new Error(
+        errorData.error || `Failed to execute code: ${response.status}`
+      );
+    }
+    if (!response.body) {
+      throw new Error("No response body for streaming execution");
+    }
+    return response.body;
+  }
+  /**
+   * List all code contexts
+   */
+  async listCodeContexts() {
+    const contexts = await this.interpreterClient.listCodeContexts();
+    for (const context of contexts) {
+      this.contexts.set(context.id, context);
+    }
+    return contexts;
+  }
+  /**
+   * Delete a code context
+   */
+  async deleteCodeContext(contextId) {
+    await this.interpreterClient.deleteCodeContext(contextId);
+    this.contexts.delete(contextId);
+  }
+  async getOrCreateDefaultContext(language) {
+    for (const context of this.contexts.values()) {
+      if (context.language === language) {
+        return context;
+      }
+    }
+    return this.createCodeContext({ language });
+  }
+};
+
+export {
+  Execution,
+  ResultImpl,
+  LogLevel,
+  TraceContext,
+  createNoOpLogger,
+  getLogger,
+  runWithLogger,
+  createLogger,
+  isExecResult,
+  isProcess,
+  isProcessStatus,
+  CodeInterpreter
+};
+//# sourceMappingURL=chunk-JXZMAU2C.js.map