aiden-runtime 3.16.0

package/dist/core/sandboxRunner.js

@@ -0,0 +1,200 @@
+"use strict";
+// ============================================================
+// DevOS — Autonomous AI Execution System
+// Copyright (c) 2026 Shiva Deore. All rights reserved.
+// ============================================================
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkDockerAvailable = checkDockerAvailable;
+exports.resetDockerCache = resetDockerCache;
+exports.buildSandboxImage = buildSandboxImage;
+exports.runInDockerSandbox = runInDockerSandbox;
+exports.getSandboxStatus = getSandboxStatus;
+// core/sandboxRunner.ts — Opt-in Docker sandbox backend (N+34).
+// When AIDEN_SANDBOX_MODE is "auto" or "strict", dangerous tools
+// (shell_exec, run_python) execute inside short-lived Docker containers
+// instead of the host, providing network isolation and resource limits.
+const child_process_1 = require("child_process");
+const util_1 = require("util");
+const path_1 = __importDefault(require("path"));
+const execAsync = (0, util_1.promisify)(child_process_1.exec);
+// ── Constants ─────────────────────────────────────────────────
+const SANDBOX_IMAGE = 'aiden-sandbox:latest';
+const DOCKERFILE_CONTENT = `FROM node:20-alpine
+RUN apk add --no-cache python3 py3-pip bash curl git
+WORKDIR /workspace
+# Drop to non-root for safety
+RUN addgroup -S aiden && adduser -S aiden -G aiden && chown aiden:aiden /workspace
+USER aiden
+`;
+// ── Docker availability check ─────────────────────────────────
+let _dockerAvailableCache = null;
+async function checkDockerAvailable() {
+    if (_dockerAvailableCache !== null)
+        return _dockerAvailableCache;
+    try {
+        await execAsync('docker --version', { timeout: 5000 });
+        _dockerAvailableCache = true;
+        return true;
+    }
+    catch {
+        _dockerAvailableCache = false;
+        return false;
+    }
+}
+// Resets the cache — useful after Docker Desktop starts up
+function resetDockerCache() {
+    _dockerAvailableCache = null;
+}
+// ── Image build / cache ───────────────────────────────────────
+let _imageBuildPromise = null;
+async function buildSandboxImage() {
+    // Deduplicate concurrent build calls
+    if (_imageBuildPromise)
+        return _imageBuildPromise;
+    _imageBuildPromise = _doBuild().finally(() => {
+        _imageBuildPromise = null;
+    });
+    return _imageBuildPromise;
+}
+async function _doBuild() {
+    // Check if image already exists
+    try {
+        const { stdout } = await execAsync(`docker image inspect ${SANDBOX_IMAGE} --format "{{.Id}}"`, { timeout: 10000 });
+        if (stdout.trim()) {
+            console.log('[Sandbox] Image already present:', SANDBOX_IMAGE);
+            return;
+        }
+    }
+    catch {
+        // Image doesn't exist — build it
+    }
+    // Write Dockerfile to a temp dir and build
+    const { mkdtempSync, writeFileSync, rmSync } = await Promise.resolve().then(() => __importStar(require('fs')));
+    const os = await Promise.resolve().then(() => __importStar(require('os')));
+    const tmpDir = mkdtempSync(path_1.default.join(os.tmpdir(), 'aiden-sandbox-'));
+    try {
+        writeFileSync(path_1.default.join(tmpDir, 'Dockerfile'), DOCKERFILE_CONTENT);
+        console.log('[Sandbox] Building image', SANDBOX_IMAGE, '...');
+        const { stdout, stderr } = await execAsync(`docker build -t ${SANDBOX_IMAGE} "${tmpDir}"`, { timeout: 120000 });
+        console.log('[Sandbox] Build complete.', (stdout || stderr).slice(0, 200));
+    }
+    finally {
+        try {
+            rmSync(tmpDir, { recursive: true, force: true });
+        }
+        catch { }
+    }
+}
+// ── Core runner ───────────────────────────────────────────────
+/**
+ * Run a command or Python script inside a Docker container with:
+ *   --rm              auto-remove on exit
+ *   --network=none    no outbound traffic (unless args.network=true)
+ *   --memory=512m     RAM cap
+ *   --cpus=1          CPU cap
+ *   --read-only       immutable container FS
+ *   --tmpfs /tmp      writable temp space
+ *   -v workspace:/workspace  (optional) host workspace mount
+ */
+async function runInDockerSandbox(args) {
+    const available = await checkDockerAvailable();
+    if (!available)
+        throw new Error('Docker is not available on this system');
+    await buildSandboxImage();
+    const timeout = args.timeout ?? 30000;
+    const network = args.network ? 'bridge' : 'none';
+    const workspace = args.workspace ?? path_1.default.join(process.cwd(), 'workspace');
+    // Resolve the actual command to pass to docker
+    let dockerCmd;
+    if (args.type === 'python') {
+        // Inline the script via stdin-style echo pipe to python3
+        const escaped = args.command
+            .replace(/\\/g, '\\\\')
+            .replace(/"/g, '\\"')
+            .replace(/\$/g, '\\$')
+            .replace(/`/g, '\\`');
+        dockerCmd = `python3 -c "${escaped}"`;
+    }
+    else {
+        dockerCmd = args.command;
+    }
+    // Escape for outer shell
+    const innerEscaped = dockerCmd.replace(/"/g, '\\"');
+    const volumeFlag = `-v "${workspace}:/workspace"`;
+    const runCmd = [
+        'docker run',
+        '--rm',
+        `--network=${network}`,
+        '--memory=512m',
+        '--cpus=1',
+        '--read-only',
+        '--tmpfs /tmp',
+        volumeFlag,
+        SANDBOX_IMAGE,
+        `bash -c "${innerEscaped}"`,
+    ].join(' ');
+    try {
+        const { stdout, stderr } = await execAsync(runCmd, {
+            timeout,
+            cwd: process.cwd(),
+        });
+        return { stdout: stdout || '', stderr: stderr || '', exitCode: 0 };
+    }
+    catch (e) {
+        const exitCode = e.code ?? 1;
+        return {
+            stdout: e.stdout ?? '',
+            stderr: e.stderr ?? e.message ?? '',
+            exitCode: typeof exitCode === 'number' ? exitCode : 1,
+        };
+    }
+}
+async function getSandboxStatus() {
+    const mode = process.env.AIDEN_SANDBOX_MODE || 'off';
+    const dockerAvailable = await checkDockerAvailable();
+    let imageCached = false;
+    if (dockerAvailable) {
+        try {
+            const { stdout } = await execAsync(`docker image inspect ${SANDBOX_IMAGE} --format "{{.Id}}"`, { timeout: 5000 });
+            imageCached = Boolean(stdout.trim());
+        }
+        catch { }
+    }
+    return { mode, dockerAvailable, imageCached, imageTag: SANDBOX_IMAGE };
+}