@useatlas/create 0.0.6 → 0.0.7

package/templates/docker/src/lib/tools/explore.ts

@@ -9,40 +9,32 @@
  * - sidecar: HTTP-isolated container with no secrets (Railway)
  * - just-bash: OverlayFs ensures read-only access; writes stay in memory (dev, or production fallback)
  *
- * Runtime selection priority: sandbox plugin > Vercel sandbox > nsjail (explicit) > sidecar > nsjail (auto-detect) > just-bash.
+ * Default selection priority: sandbox plugin > Vercel sandbox > nsjail (explicit) > sidecar > nsjail (auto-detect) > just-bash.
+ * Operators can override the built-in priority via `sandbox.priority` in atlas.config.ts
+ * or `ATLAS_SANDBOX_PRIORITY` env var. Plugin backends always take highest priority.
  * A production warning is logged when falling back to just-bash.
+ *
+ * Org scoping: when an activeOrganizationId is present in the request
+ * context, the explore tool reads from `semantic/.orgs/{orgId}/` instead
+ * of `semantic/`. Each org's directory is maintained by the dual-write
+ * sync layer (semantic-sync.ts). Backends are cached per semantic root.
  */
 
 import { tool } from "ai";
 import { z } from "zod";
-import * as path from "path";
-import { createLogger } from "@atlas/api/lib/logger";
+import { createLogger, getRequestContext } from "@atlas/api/lib/logger";
 import { withSpan } from "@atlas/api/lib/tracing";
+import { getConfig, type SandboxBackendName } from "@atlas/api/lib/config";
+import { getSemanticRoot } from "@atlas/api/lib/semantic/sync";
+import { getSetting } from "@atlas/api/lib/settings";
+import { useVercelSandbox, useSidecar } from "./backends/detect";
 
 const log = createLogger("explore");
 
-const SEMANTIC_ROOT = path.resolve(process.cwd(), "semantic");
-
-// --- Backend interface ---
+// --- Backend interface (canonical source: ./backends/types.ts) ---
 
-export interface ExecResult {
-  stdout: string;
-  stderr: string;
-  exitCode: number;
-}
-
-/**
- * Shell backend for the explore tool.
- *
- * Implementations MUST provide read-only filesystem access scoped to the
- * semantic layer directory. Commands execute within /semantic as the working
- * directory. Writes should be silently discarded or cause errors, never
- * modify the host filesystem.
- */
-export interface ExploreBackend {
-  exec(command: string): Promise<ExecResult>;
-  close?(): Promise<void>;
-}
+export type { ExecResult, ExploreBackend } from "./backends/types";
+import type { ExploreBackend } from "./backends/types";
 
 // --- Self-hosted backend (just-bash) ---
 
@@ -89,10 +81,6 @@ async function createBashBackend(
 
 // --- Runtime detection ---
 
-function useVercelSandbox(): boolean {
-  return process.env.ATLAS_RUNTIME === "vercel" || !!process.env.VERCEL;
-}
-
 let _nsjailAvailable: boolean | null = null;
 
 function useNsjail(): boolean {
@@ -101,7 +89,7 @@ function useNsjail(): boolean {
   // Auto-detect nsjail on PATH (deferred require to avoid loading module at startup)
   try {
     // eslint-disable-next-line @typescript-eslint/no-require-imports
-    const { isNsjailAvailable } = require("./explore-nsjail");
+    const { isNsjailAvailable } = require("./backends/nsjail");
     _nsjailAvailable = isNsjailAvailable();
   } catch (err) {
     if (
@@ -114,7 +102,7 @@ function useNsjail(): boolean {
     } else {
       log.error(
         { error: err instanceof Error ? err.message : String(err) },
-        "Unexpected error loading explore-nsjail module",
+        "Unexpected error loading nsjail module",
       );
       _nsjailAvailable = false;
     }
@@ -122,17 +110,13 @@ function useNsjail(): boolean {
   return _nsjailAvailable ?? false;
 }
 
-function useSidecar(): boolean {
-  return !!process.env.ATLAS_SANDBOX_URL;
-}
-
 /** Track nsjail init failures to avoid infinite retry loops. */
 let _nsjailFailed = false;
 
 /** Track sidecar init failures so the health endpoint reports accurately. */
 let _sidecarFailed = false;
 
-export type ExploreBackendType = "vercel-sandbox" | "nsjail" | "sidecar" | "just-bash" | "plugin";
+export type ExploreBackendType = SandboxBackendName | "plugin";
 
 /** Name of the active sandbox plugin (if any). Set during backend init. */
 let _activeSandboxPluginId: string | null = null;
@@ -142,15 +126,46 @@ export function getActiveSandboxPluginId(): string | null {
   return _activeSandboxPluginId;
 }
 
+/**
+ * Check if a specific backend is available (sync, for health reporting).
+ */
+function isBackendAvailable(name: SandboxBackendName): boolean {
+  switch (name) {
+    case "vercel-sandbox":
+      return useVercelSandbox();
+    case "nsjail":
+      if (_nsjailFailed) return false;
+      return process.env.ATLAS_SANDBOX === "nsjail" || useNsjail();
+    case "sidecar":
+      return useSidecar() && !_sidecarFailed;
+    case "just-bash":
+      return true;
+  }
+}
+
 /**
  * Returns which explore backend is active (for health endpoint).
  *
  * Plugin detection is lazy — _activeSandboxPluginId is only set after the
  * first explore command triggers getExploreBackend(). Before that, this
  * function falls through to the built-in detection chain.
+ *
+ * When `sandbox.priority` is configured, the first available backend in the
+ * priority list is returned instead of the hardcoded chain.
  */
 export function getExploreBackendType(): ExploreBackendType {
   if (_activeSandboxPluginId) return "plugin";
+
+  // Config-driven priority
+  const configPriority = getConfig()?.sandbox?.priority;
+  if (configPriority && configPriority.length > 0) {
+    for (const name of configPriority) {
+      if (isBackendAvailable(name)) return name;
+    }
+    return "just-bash";
+  }
+
+  // Default chain
   if (useVercelSandbox()) return "vercel-sandbox";
   // Explicit nsjail (ATLAS_SANDBOX=nsjail) — hard-fail if unavailable
   if (process.env.ATLAS_SANDBOX === "nsjail" && !_nsjailFailed) return "nsjail";
@@ -161,11 +176,96 @@ export function getExploreBackendType(): ExploreBackendType {
   return "just-bash";
 }
 
-let backendPromise: Promise<ExploreBackend> | null = null;
+/**
+ * Try to create a specific backend by name. Returns null if the backend
+ * is not available (env vars not set, binary not found, etc.).
+ */
+async function tryCreateBackend(name: SandboxBackendName, semanticRoot: string, orgId?: string): Promise<ExploreBackend | null> {
+  switch (name) {
+    case "vercel-sandbox": {
+      if (!useVercelSandbox()) return null;
+      try {
+        const { createSandboxBackend } = await import("./explore-sandbox");
+        return createSandboxBackend(semanticRoot);
+      } catch (err) {
+        const detail = err instanceof Error ? err.message : String(err);
+        log.warn(
+          { error: detail },
+          "vercel-sandbox backend failed to initialize — trying next in priority",
+        );
+        return null;
+      }
+    }
+
+    case "nsjail": {
+      if (_nsjailFailed) return null;
+      // Check if nsjail is available (explicit or auto-detect)
+      if (process.env.ATLAS_SANDBOX !== "nsjail" && !useNsjail()) return null;
+      try {
+        const { createNsjailBackend } = await import("./explore-nsjail");
+        return await createNsjailBackend(semanticRoot, {
+          onInfrastructureError: invalidateExploreBackend,
+          onNsjailFailed: markNsjailFailed,
+        });
+      } catch (err) {
+        _nsjailFailed = true;
+        const detail = err instanceof Error ? err.message : String(err);
+        log.warn(
+          { error: detail },
+          "nsjail backend failed to initialize — trying next in priority",
+        );
+        return null;
+      }
+    }
 
-/** Clear cached backend so the next call recreates it. */
+    case "sidecar": {
+      // Workspace-level URL override takes priority over env var
+      const wsSidecarUrl = orgId ? getSetting("ATLAS_SANDBOX_URL", orgId) : undefined;
+      const sidecarUrl = wsSidecarUrl ?? process.env.ATLAS_SANDBOX_URL;
+      if ((!sidecarUrl && !useSidecar()) || _sidecarFailed) return null;
+      if (!sidecarUrl) return null;
+      try {
+        const { createSidecarBackend } = await import("./explore-sidecar");
+        return createSidecarBackend(sidecarUrl, { semanticRoot });
+      } catch (err) {
+        _sidecarFailed = true;
+        const detail = err instanceof Error ? err.message : String(err);
+        log.warn(
+          { error: detail },
+          "sidecar backend failed to initialize — trying next in priority",
+        );
+        return null;
+      }
+    }
+
+    case "just-bash": {
+      if (process.env.NODE_ENV === "production") {
+        log.warn(
+          "SECURITY DEGRADATION: Explore tool running without process isolation (just-bash fallback). " +
+            "In production, this means shell commands execute directly on the host with only OverlayFs " +
+            "read-only protection — no namespace, network, or resource isolation. " +
+            "Install nsjail, configure a sidecar (ATLAS_SANDBOX_URL), or deploy on Vercel for sandboxed execution. " +
+            "See: https://github.com/google/nsjail",
+        );
+      } else {
+        log.debug("Explore tool using just-bash backend (acceptable for development)");
+      }
+      return createBashBackend(semanticRoot);
+    }
+  }
+}
+
+/**
+ * Backend cache keyed by semantic root path.
+ *
+ * For self-hosted (no orgs), there's exactly one entry. For multi-tenant,
+ * each org gets its own backend instance (most backends are cheap to create).
+ */
+const backendCache = new Map<string, Promise<ExploreBackend>>();
+
+/** Clear cached backends so the next call recreates them. */
 export function invalidateExploreBackend(): void {
-  backendPromise = null;
+  backendCache.clear();
   _activeSandboxPluginId = null;
 }
 
@@ -173,7 +273,7 @@ export function invalidateExploreBackend(): void {
  *  Called from explore-nsjail.ts on exit code 109 (sandbox setup failure). */
 export function markNsjailFailed(): void {
   _nsjailFailed = true;
-  backendPromise = null;
+  backendCache.clear();
 }
 
 /** Permanently mark the sidecar as failed so health reports "just-bash".
@@ -182,16 +282,60 @@ export function markSidecarFailed(): void {
   _sidecarFailed = true;
 }
 
-function getExploreBackend(): Promise<ExploreBackend> {
-  if (!backendPromise) {
-    backendPromise = (async (): Promise<ExploreBackend> => {
+function getExploreBackend(semanticRoot: string, orgId?: string): Promise<ExploreBackend> {
+  // Workspace override changes the effective backend, so include it in the cache key
+  const wsOverride = orgId ? getSetting("ATLAS_SANDBOX_BACKEND", orgId) : undefined;
+  const cacheKeyVal = wsOverride ? `${semanticRoot}\0${wsOverride}` : semanticRoot;
+
+  let promise = backendCache.get(cacheKeyVal);
+  if (!promise) {
+    promise = (async (): Promise<ExploreBackend> => {
+      // Priority -1: Workspace-level backend override (SaaS self-serve)
+      if (wsOverride) {
+        log.info(
+          { backend: wsOverride, orgId, source: "workspace-setting" },
+          "Workspace sandbox override: %s",
+          wsOverride,
+        );
+        // Check if override is a built-in backend name
+        const builtInNames: readonly string[] = ["vercel-sandbox", "nsjail", "sidecar", "just-bash"];
+        if (builtInNames.includes(wsOverride)) {
+          const backend = await tryCreateBackend(wsOverride as SandboxBackendName, semanticRoot, orgId);
+          if (backend) return backend;
+          log.warn(
+            { backend: wsOverride, orgId },
+            "Workspace sandbox override %s unavailable — falling through to default",
+            wsOverride,
+          );
+        } else {
+          // Try as a plugin ID
+          try {
+            const { plugins } = await import("@atlas/api/lib/plugins/registry");
+            const { wireSandboxPlugins } = await import("@atlas/api/lib/plugins/wiring");
+            const result = await wireSandboxPlugins(plugins, semanticRoot);
+            if (result.backend && result.pluginId === wsOverride) {
+              _activeSandboxPluginId = result.pluginId;
+              return result.backend as ExploreBackend;
+            }
+          } catch (err) {
+            const detail = err instanceof Error ? err.message : String(err);
+            log.warn(
+              { backend: wsOverride, orgId, err: detail },
+              "Workspace sandbox plugin override %s failed — falling through to default",
+              wsOverride,
+            );
+          }
+        }
+        // Override not available — fall through to normal chain
+      }
+
       // Priority 0: Sandbox plugins (sorted by priority, highest first)
       // Skipped when ATLAS_SANDBOX=nsjail — operator explicitly wants nsjail only
       if (process.env.ATLAS_SANDBOX !== "nsjail") {
         try {
           const { plugins } = await import("@atlas/api/lib/plugins/registry");
           const { wireSandboxPlugins } = await import("@atlas/api/lib/plugins/wiring");
-          const result = await wireSandboxPlugins(plugins, SEMANTIC_ROOT);
+          const result = await wireSandboxPlugins(plugins, semanticRoot);
           if (result.failed.length > 0) {
             log.warn(
               { failed: result.failed, selectedPlugin: result.pluginId },
@@ -214,17 +358,56 @@ function getExploreBackend(): Promise<ExploreBackend> {
         }
       }
 
+      // --- Config-driven priority ---
+      const configPriority = getConfig()?.sandbox?.priority;
+      if (configPriority && configPriority.length > 0) {
+        log.info(
+          { priority: configPriority },
+          "Using configured sandbox priority: %s",
+          configPriority.join(" > "),
+        );
+        for (const name of configPriority) {
+          const backend = await tryCreateBackend(name, semanticRoot, orgId);
+          if (backend) {
+            log.info(
+              { backend: name, source: "config" },
+              "Explore backend selected: %s (config priority)",
+              name,
+            );
+            return backend;
+          }
+          log.debug({ backend: name }, "Backend %s unavailable — trying next in priority", name);
+        }
+        // All config backends failed
+        if (configPriority.includes("just-bash")) {
+          // just-bash was in the list but somehow failed (should not happen) — try once more
+          log.warn(
+            { priority: configPriority },
+            "All higher-priority backends in sandbox.priority unavailable — using just-bash",
+          );
+          return createBashBackend(semanticRoot);
+        }
+        // Operator did NOT include just-bash — respect their intent
+        throw new Error(
+          `All backends in sandbox.priority (${configPriority.join(", ")}) failed to initialize. ` +
+          "Add 'just-bash' to the priority list if you want an unsandboxed fallback, " +
+          "or fix the backend configuration.",
+        );
+      }
+
+      // --- Default priority chain ---
+
       // Priority 1: Vercel Sandbox (Firecracker VM)
       if (useVercelSandbox()) {
         const { createSandboxBackend } = await import("./explore-sandbox");
-        return createSandboxBackend(SEMANTIC_ROOT);
+        return createSandboxBackend(semanticRoot);
       }
 
       // Priority 2: nsjail explicit (ATLAS_SANDBOX=nsjail) — hard-fail if init fails
       if (process.env.ATLAS_SANDBOX === "nsjail" && !_nsjailFailed) {
         try {
           const { createNsjailBackend } = await import("./explore-nsjail");
-          return await createNsjailBackend(SEMANTIC_ROOT, {
+          return await createNsjailBackend(semanticRoot, {
             onInfrastructureError: invalidateExploreBackend,
             onNsjailFailed: markNsjailFailed,
           });
@@ -243,14 +426,14 @@ function getExploreBackend(): Promise<ExploreBackend> {
       // Skips nsjail auto-detection entirely — no noisy namespace warnings.
       if (useSidecar()) {
         const { createSidecarBackend } = await import("./explore-sidecar");
-        return createSidecarBackend(process.env.ATLAS_SANDBOX_URL!);
+        return createSidecarBackend(process.env.ATLAS_SANDBOX_URL!, { semanticRoot });
       }
 
       // Priority 4: nsjail auto-detect (binary on PATH, graceful fallback)
       if (!_nsjailFailed && useNsjail()) {
         try {
           const { createNsjailBackend } = await import("./explore-nsjail");
-          return await createNsjailBackend(SEMANTIC_ROOT, {
+          return await createNsjailBackend(semanticRoot, {
             onInfrastructureError: invalidateExploreBackend,
             onNsjailFailed: markNsjailFailed,
           });
@@ -276,13 +459,14 @@ function getExploreBackend(): Promise<ExploreBackend> {
       } else {
         log.debug("Explore tool using just-bash backend (acceptable for development)");
       }
-      return createBashBackend(SEMANTIC_ROOT);
+      return createBashBackend(semanticRoot);
     })().catch((err) => {
-      backendPromise = null; // allow retry on next call
+      backendCache.delete(cacheKeyVal); // allow retry on next call
       throw err;
     });
+    backendCache.set(cacheKeyVal, promise);
   }
-  return backendPromise;
+  return promise;
 }
 
 // --- Tool definition ---
@@ -314,12 +498,16 @@ Always start by listing the root directory to see what sources are available.`,
   }),
 
   execute: async ({ command }) => {
+    // Resolve org-scoped semantic root from request context
+    const orgId = getRequestContext()?.user?.activeOrganizationId;
+    const semanticRoot = getSemanticRoot(orgId);
+
     let backend: ExploreBackend;
     try {
-      backend = await getExploreBackend();
+      backend = await getExploreBackend(semanticRoot, orgId);
     } catch (err) {
       const detail = err instanceof Error ? err.message : String(err);
-      log.error({ err: detail }, "Explore backend initialization failed");
+      log.error({ err: detail, orgId }, "Explore backend initialization failed");
       return `Error: Explore tool is unavailable — ${detail}`;
     }
 
@@ -348,13 +536,17 @@ Always start by listing the root directory to see what sources are available.`,
       const start = performance.now();
       const result = await withSpan(
         "atlas.explore",
-        { command: execCommand.slice(0, 200) },
+        {
+          "atlas.command": execCommand.slice(0, 200),
+          "atlas.backend": getExploreBackendType(),
+          ...(orgId ? { "atlas.org_id": orgId } : {}),
+        },
         () => backend.exec(execCommand),
       );
       const durationMs = Math.round(performance.now() - start);
 
       log.debug(
-        { command: execCommand, durationMs, exitCode: result.exitCode },
+        { command: execCommand, durationMs, exitCode: result.exitCode, orgId },
         "explore command",
       );
 

package/templates/docker/src/lib/tools/index.ts

@@ -0,0 +1,17 @@
+/**
+ * Tools barrel export.
+ *
+ * Re-exports tool definitions, the registry, and shared backend utilities
+ * so callers can import from `@atlas/api/lib/tools` instead of individual files.
+ */
+
+// Registry
+export { ToolRegistry, buildRegistry, defaultRegistry } from "./registry";
+export type { AtlasTool } from "./registry";
+
+// Tool definitions
+export { explore } from "./explore";
+export { executePython } from "./python";
+
+// Backend types and utilities
+export * from "./backends";

package/templates/docker/src/lib/tools/python-nsjail.ts

@@ -11,6 +11,8 @@
  */
 
 import type { PythonBackend, PythonResult } from "./python";
+import { PYTHON_SECURITY_AND_SETUP, PYTHON_EXEC_AND_COLLECT } from "./python-wrapper";
+import { readLimited, MAX_OUTPUT, parsePositiveInt } from "./backends/shared";
 import { randomUUID } from "crypto";
 import { mkdirSync, writeFileSync, rmSync } from "fs";
 import { join } from "path";
@@ -18,9 +20,6 @@ import { createLogger } from "@atlas/api/lib/logger";
 
 const log = createLogger("python-nsjail");
 
-/** Maximum bytes to read from stdout/stderr (1 MB). */
-const MAX_OUTPUT = 1024 * 1024;
-
 /** Default Python execution timeout in seconds. */
 const DEFAULT_TIME_LIMIT = 30;
 
@@ -31,11 +30,9 @@ const DEFAULT_MEMORY_LIMIT = 512;
 const DEFAULT_NPROC = 16;
 
 /**
- * Python wrapper script — same logic as the sidecar's PYTHON_WRAPPER.
- *
- * Handles: import guard (sidecar-side enforcement), data injection
- * (JSON on stdin → DataFrame/dict), stdout capture, chart collection
- * (PNG files + Recharts dicts), and structured output via result marker.
+ * Non-streaming Python wrapper for nsjail. Composes shared fragments
+ * (PYTHON_SECURITY_AND_SETUP, PYTHON_EXEC_AND_COLLECT) with stdin-based
+ * data injection and marker-based result emission.
  */
 const PYTHON_WRAPPER = `
 import sys, json, io, base64, glob, os, ast
@@ -43,53 +40,11 @@ import sys, json, io, base64, glob, os, ast
 _marker = os.environ["ATLAS_RESULT_MARKER"]
 _chart_dir = os.environ.get("ATLAS_CHART_DIR", "/tmp")
 
-# --- Import guard (sidecar-side enforcement) ---
-_BLOCKED_MODULES = {
-    "subprocess", "os", "socket", "shutil", "sys", "ctypes", "importlib",
-    "code", "signal", "multiprocessing", "threading", "pty", "fcntl",
-    "termios", "resource", "posixpath",
-    "http", "urllib", "requests", "httpx", "aiohttp", "webbrowser",
-    "pickle", "tempfile", "pathlib",
-}
-_BLOCKED_BUILTINS = {
-    "compile", "exec", "eval", "__import__", "open", "breakpoint",
-    "getattr", "globals", "locals", "vars", "dir", "delattr", "setattr",
-}
-
-_user_code = open(sys.argv[1]).read()
-try:
-    _tree = ast.parse(_user_code)
-except SyntaxError as e:
-    print(_marker + json.dumps({"success": False, "error": f"SyntaxError: {e.msg} (line {e.lineno})"}))
+def _report_error(msg):
+    print(_marker + json.dumps({"success": False, "error": msg}))
     sys.exit(0)
 
-_blocked = None
-for _node in ast.walk(_tree):
-    if _blocked:
-        break
-    if isinstance(_node, ast.Import):
-        for _alias in _node.names:
-            _mod = _alias.name.split('.')[0]
-            if _mod in _BLOCKED_MODULES:
-                _blocked = f'Blocked import: "{_mod}" is not allowed'
-                break
-    elif isinstance(_node, ast.ImportFrom):
-        if _node.module:
-            _mod = _node.module.split('.')[0]
-            if _mod in _BLOCKED_MODULES:
-                _blocked = f'Blocked import: "{_mod}" is not allowed'
-    elif isinstance(_node, ast.Call):
-        _name = None
-        if isinstance(_node.func, ast.Name):
-            _name = _node.func.id
-        elif isinstance(_node.func, ast.Attribute):
-            _name = _node.func.attr
-        if _name and _name in _BLOCKED_BUILTINS:
-            _blocked = f'Blocked builtin: "{_name}()" is not allowed'
-
-if _blocked:
-    print(_marker + json.dumps({"success": False, "error": _blocked}))
-    sys.exit(0)
+${PYTHON_SECURITY_AND_SETUP}
 
 # --- Data injection ---
 _stdin_data = sys.stdin.read()
@@ -107,92 +62,9 @@ if _atlas_data:
     except ImportError:
         data = _atlas_data
 
-# Configure matplotlib for headless rendering
-try:
-    import matplotlib
-    matplotlib.use('Agg')
-except ImportError:
-    pass
-
-def chart_path(n=0):
-    return os.path.join(_chart_dir, f"chart_{n}.png")
-
-# --- Execute user code in isolated namespace ---
-_old_stdout = sys.stdout
-sys.stdout = _captured = io.StringIO()
-
-_user_ns = {"chart_path": chart_path, "data": data, "df": df}
-_atlas_error = None
-try:
-    exec(_user_code, _user_ns)
-except Exception as e:
-    _atlas_error = f"{type(e).__name__}: {e}"
-
-_output = _captured.getvalue()
-sys.stdout = _old_stdout
-
-# --- Collect results ---
-_charts = []
-for f in sorted(glob.glob(os.path.join(_chart_dir, "chart_*.png"))):
-    with open(f, "rb") as fh:
-        _charts.append({"base64": base64.b64encode(fh.read()).decode(), "mimeType": "image/png"})
-
-_result = {"success": _atlas_error is None}
-if _output.strip():
-    _result["output"] = _output.strip()
-if _atlas_error:
-    _result["error"] = _atlas_error
-
-if "_atlas_table" in _user_ns:
-    _result["table"] = _user_ns["_atlas_table"]
-
-if "_atlas_chart" in _user_ns:
-    _ac = _user_ns["_atlas_chart"]
-    if isinstance(_ac, dict):
-        _result["rechartsCharts"] = [_ac]
-    elif isinstance(_ac, list):
-        _result["rechartsCharts"] = _ac
-
-if _charts:
-    _result["charts"] = _charts
-
-print(_marker + json.dumps(_result), file=_old_stdout)
+${PYTHON_EXEC_AND_COLLECT}
 `;
 
-/** Read up to `max` bytes from a stream. */
-async function readLimited(stream: ReadableStream, max: number): Promise<string> {
-  const reader = stream.getReader();
-  const chunks: Uint8Array[] = [];
-  let total = 0;
-  try {
-    while (true) {
-      const { done, value } = await reader.read();
-      if (done) break;
-      total += value.byteLength;
-      if (total > max) {
-        chunks.push(value.slice(0, max - (total - value.byteLength)));
-        break;
-      }
-      chunks.push(value);
-    }
-  } finally {
-    await reader.cancel().catch(() => {});
-  }
-  return new TextDecoder().decode(Buffer.concat(chunks));
-}
-
-/** Parse a positive integer from an env var, returning defaultValue on invalid input. */
-function parsePositiveInt(envVar: string, defaultValue: number, name: string): number {
-  const raw = process.env[envVar];
-  if (raw === undefined) return defaultValue;
-  const parsed = parseInt(raw, 10);
-  if (isNaN(parsed) || parsed <= 0) {
-    log.warn({ envVar, raw, default: defaultValue }, `Invalid ${envVar} for ${name}, using default`);
-    return defaultValue;
-  }
-  return parsed;
-}
-
 /** Build nsjail args for Python execution. */
 export function buildPythonNsjailArgs(
   nsjailPath: string,
@@ -202,8 +74,8 @@ export function buildPythonNsjailArgs(
   chartDir: string,
   _resultMarker: string,
 ): string[] {
-  const timeLimit = parsePositiveInt("ATLAS_NSJAIL_TIME_LIMIT", DEFAULT_TIME_LIMIT, "time limit");
-  const memoryLimit = parsePositiveInt("ATLAS_NSJAIL_MEMORY_LIMIT", DEFAULT_MEMORY_LIMIT, "memory limit");
+  const timeLimit = parsePositiveInt("ATLAS_NSJAIL_TIME_LIMIT", DEFAULT_TIME_LIMIT, "time limit", log);
+  const memoryLimit = parsePositiveInt("ATLAS_NSJAIL_MEMORY_LIMIT", DEFAULT_MEMORY_LIMIT, "memory limit", log);
   const nproc = DEFAULT_NPROC;
 
   return [