context-mode 0.4.0

package/build/executor.js

@@ -0,0 +1,255 @@
+var _a;
+import { spawn, execSync } from "node:child_process";
+import { mkdtempSync, writeFileSync, rmSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { tmpdir } from "node:os";
+import { detectRuntimes, buildCommand, } from "./runtime.js";
+export class PolyglotExecutor {
+    #maxOutputBytes;
+    #projectRoot;
+    #runtimes;
+    constructor(opts) {
+        this.#maxOutputBytes = opts?.maxOutputBytes ?? 102_400;
+        this.#projectRoot = opts?.projectRoot ?? process.cwd();
+        this.#runtimes = opts?.runtimes ?? detectRuntimes();
+    }
+    get runtimes() {
+        return { ...this.#runtimes };
+    }
+    async execute(opts) {
+        const { language, code, timeout = 30_000 } = opts;
+        const tmpDir = mkdtempSync(join(tmpdir(), "ctx-mode-"));
+        try {
+            const filePath = this.#writeScript(tmpDir, code, language);
+            const cmd = buildCommand(this.#runtimes, language, filePath);
+            // Rust: compile then run
+            if (cmd[0] === "__rust_compile_run__") {
+                return await this.#compileAndRun(filePath, tmpDir, timeout);
+            }
+            return await this.#spawn(cmd, tmpDir, timeout);
+        }
+        finally {
+            rmSync(tmpDir, { recursive: true, force: true });
+        }
+    }
+    async executeFile(opts) {
+        const { path: filePath, language, code, timeout = 30_000 } = opts;
+        const absolutePath = resolve(this.#projectRoot, filePath);
+        const wrappedCode = this.#wrapWithFileContent(absolutePath, language, code);
+        return this.execute({ language, code: wrappedCode, timeout });
+    }
+    #writeScript(tmpDir, code, language) {
+        const extMap = {
+            javascript: "js",
+            typescript: "ts",
+            python: "py",
+            shell: "sh",
+            ruby: "rb",
+            go: "go",
+            rust: "rs",
+            php: "php",
+            perl: "pl",
+            r: "R",
+        };
+        // Go needs a main package wrapper if not present
+        if (language === "go" && !code.includes("package ")) {
+            code = `package main\n\nimport "fmt"\n\nfunc main() {\n${code}\n}\n`;
+        }
+        // PHP needs opening tag if not present
+        if (language === "php" && !code.trimStart().startsWith("<?")) {
+            code = `<?php\n${code}`;
+        }
+        const fp = join(tmpDir, `script.${extMap[language]}`);
+        if (language === "shell") {
+            writeFileSync(fp, code, { encoding: "utf-8", mode: 0o700 });
+        }
+        else {
+            writeFileSync(fp, code, "utf-8");
+        }
+        return fp;
+    }
+    async #compileAndRun(srcPath, cwd, timeout) {
+        const binPath = srcPath.replace(/\.rs$/, "");
+        // Compile
+        try {
+            execSync(`rustc ${srcPath} -o ${binPath} 2>&1`, {
+                cwd,
+                timeout: Math.min(timeout, 30_000),
+                encoding: "utf-8",
+            });
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.stderr || err.message : String(err);
+            return {
+                stdout: "",
+                stderr: `Compilation failed:\n${message}`,
+                exitCode: 1,
+                timedOut: false,
+            };
+        }
+        // Run
+        return this.#spawn([binPath], cwd, timeout);
+    }
+    /**
+     * Smart truncation: keeps head (60%) + tail (40%) of output,
+     * preserving both initial context and final error messages.
+     * Snaps to line boundaries and handles UTF-8 safely.
+     */
+    static #smartTruncate(raw, max) {
+        if (Buffer.byteLength(raw) <= max)
+            return raw;
+        const lines = raw.split("\n");
+        // Budget: 60% head, 40% tail (errors/results are usually at the end)
+        const headBudget = Math.floor(max * 0.6);
+        const tailBudget = max - headBudget;
+        // Collect head lines
+        const headLines = [];
+        let headBytes = 0;
+        for (const line of lines) {
+            const lineBytes = Buffer.byteLength(line) + 1; // +1 for \n
+            if (headBytes + lineBytes > headBudget)
+                break;
+            headLines.push(line);
+            headBytes += lineBytes;
+        }
+        // Collect tail lines (from end)
+        const tailLines = [];
+        let tailBytes = 0;
+        for (let i = lines.length - 1; i >= headLines.length; i--) {
+            const lineBytes = Buffer.byteLength(lines[i]) + 1;
+            if (tailBytes + lineBytes > tailBudget)
+                break;
+            tailLines.unshift(lines[i]);
+            tailBytes += lineBytes;
+        }
+        const skippedLines = lines.length - headLines.length - tailLines.length;
+        const skippedBytes = Buffer.byteLength(raw) - headBytes - tailBytes;
+        const separator = `\n\n... [${skippedLines} lines / ${(skippedBytes / 1024).toFixed(1)}KB truncated — showing first ${headLines.length} + last ${tailLines.length} lines] ...\n\n`;
+        return headLines.join("\n") + separator + tailLines.join("\n");
+    }
+    async #spawn(cmd, cwd, timeout) {
+        return new Promise((res) => {
+            const proc = spawn(cmd[0], cmd.slice(1), {
+                cwd,
+                stdio: ["ignore", "pipe", "pipe"],
+                env: this.#buildSafeEnv(cwd),
+            });
+            let timedOut = false;
+            const timer = setTimeout(() => {
+                timedOut = true;
+                proc.kill("SIGKILL");
+            }, timeout);
+            // Collect ALL output in full — smart truncation happens after
+            // process exits so we can keep head + tail.
+            // OOM is bounded by timeout (default 30s) and maxOutputBytes
+            // (used only for truncation threshold, not stream limiting).
+            const stdoutChunks = [];
+            const stderrChunks = [];
+            proc.stdout.on("data", (chunk) => {
+                stdoutChunks.push(chunk);
+            });
+            proc.stderr.on("data", (chunk) => {
+                stderrChunks.push(chunk);
+            });
+            proc.on("close", (exitCode) => {
+                clearTimeout(timer);
+                const rawStdout = Buffer.concat(stdoutChunks).toString("utf-8");
+                const rawStderr = Buffer.concat(stderrChunks).toString("utf-8");
+                const max = this.#maxOutputBytes;
+                const stdout = _a.#smartTruncate(rawStdout, max);
+                const stderr = _a.#smartTruncate(rawStderr, max);
+                res({
+                    stdout,
+                    stderr,
+                    exitCode: timedOut ? 1 : (exitCode ?? 1),
+                    timedOut,
+                });
+            });
+            proc.on("error", (err) => {
+                clearTimeout(timer);
+                res({
+                    stdout: "",
+                    stderr: err.message,
+                    exitCode: 1,
+                    timedOut: false,
+                });
+            });
+        });
+    }
+    #buildSafeEnv(tmpDir) {
+        const realHome = process.env.HOME ?? process.env.USERPROFILE ?? tmpDir;
+        // Pass through auth-related env vars so CLI tools (gh, aws, gcloud, etc.) work
+        const passthrough = [
+            // GitHub
+            "GH_TOKEN",
+            "GITHUB_TOKEN",
+            "GH_HOST",
+            // AWS
+            "AWS_ACCESS_KEY_ID",
+            "AWS_SECRET_ACCESS_KEY",
+            "AWS_SESSION_TOKEN",
+            "AWS_REGION",
+            "AWS_DEFAULT_REGION",
+            "AWS_PROFILE",
+            // Google Cloud
+            "GOOGLE_APPLICATION_CREDENTIALS",
+            "CLOUDSDK_CONFIG",
+            // Docker / K8s
+            "DOCKER_HOST",
+            "KUBECONFIG",
+            // Node / npm
+            "NPM_TOKEN",
+            "NODE_AUTH_TOKEN",
+            "npm_config_registry",
+            // General
+            "HTTP_PROXY",
+            "HTTPS_PROXY",
+            "NO_PROXY",
+            "SSL_CERT_FILE",
+            "CURL_CA_BUNDLE",
+            // XDG (config paths for gh, gcloud, etc.)
+            "XDG_CONFIG_HOME",
+            "XDG_DATA_HOME",
+        ];
+        const env = {
+            PATH: process.env.PATH ?? "/usr/local/bin:/usr/bin:/bin",
+            HOME: realHome,
+            TMPDIR: tmpDir,
+            LANG: "en_US.UTF-8",
+            PYTHONDONTWRITEBYTECODE: "1",
+            PYTHONUNBUFFERED: "1",
+            NO_COLOR: "1",
+        };
+        for (const key of passthrough) {
+            if (process.env[key]) {
+                env[key] = process.env[key];
+            }
+        }
+        return env;
+    }
+    #wrapWithFileContent(absolutePath, language, code) {
+        const escaped = JSON.stringify(absolutePath);
+        switch (language) {
+            case "javascript":
+            case "typescript":
+                return `const FILE_CONTENT = require("fs").readFileSync(${escaped}, "utf-8");\n${code}`;
+            case "python":
+                return `with open(${escaped}, "r") as _f:\n    FILE_CONTENT = _f.read()\n${code}`;
+            case "shell":
+                return `FILE_CONTENT=$(cat ${escaped})\n${code}`;
+            case "ruby":
+                return `FILE_CONTENT = File.read(${escaped})\n${code}`;
+            case "go":
+                return `package main\n\nimport (\n\t"fmt"\n\t"os"\n)\n\nfunc main() {\n\tb, _ := os.ReadFile(${escaped})\n\tFILE_CONTENT := string(b)\n\t_ = FILE_CONTENT\n${code}\n}\n`;
+            case "rust":
+                return `use std::fs;\n\nfn main() {\n    let file_content = fs::read_to_string(${escaped}).unwrap();\n${code}\n}\n`;
+            case "php":
+                return `<?php\n$FILE_CONTENT = file_get_contents(${escaped});\n${code}`;
+            case "perl":
+                return `open(my $fh, '<', ${escaped}) or die "Cannot open: $!";\nmy $FILE_CONTENT = do { local $/; <$fh> };\nclose($fh);\n${code}`;
+            case "r":
+                return `FILE_CONTENT <- readLines(${escaped}, warn=FALSE)\nFILE_CONTENT <- paste(FILE_CONTENT, collapse="\\n")\n${code}`;
+        }
+    }
+}
+_a = PolyglotExecutor;

package/build/runtime.d.ts

@@ -0,0 +1,24 @@
+export type Language = "javascript" | "typescript" | "python" | "shell" | "ruby" | "go" | "rust" | "php" | "perl" | "r";
+export interface RuntimeInfo {
+    command: string;
+    available: boolean;
+    version: string;
+    preferred: boolean;
+}
+export interface RuntimeMap {
+    javascript: string;
+    typescript: string | null;
+    python: string | null;
+    shell: string;
+    ruby: string | null;
+    go: string | null;
+    rust: string | null;
+    php: string | null;
+    perl: string | null;
+    r: string | null;
+}
+export declare function detectRuntimes(): RuntimeMap;
+export declare function hasBunRuntime(): boolean;
+export declare function getRuntimeSummary(runtimes: RuntimeMap): string;
+export declare function getAvailableLanguages(runtimes: RuntimeMap): Language[];
+export declare function buildCommand(runtimes: RuntimeMap, language: Language, filePath: string): string[];

package/build/runtime.js

@@ -0,0 +1,167 @@
+import { execSync } from "node:child_process";
+function commandExists(cmd) {
+    try {
+        execSync(`command -v ${cmd} 2>/dev/null`, { stdio: "pipe" });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function getVersion(cmd) {
+    try {
+        return execSync(`${cmd} --version 2>/dev/null`, {
+            encoding: "utf-8",
+            timeout: 5000,
+        })
+            .trim()
+            .split("\n")[0];
+    }
+    catch {
+        return "unknown";
+    }
+}
+export function detectRuntimes() {
+    const hasBun = commandExists("bun");
+    return {
+        javascript: hasBun ? "bun" : "node",
+        typescript: hasBun
+            ? "bun"
+            : commandExists("tsx")
+                ? "tsx"
+                : commandExists("ts-node")
+                    ? "ts-node"
+                    : null,
+        python: commandExists("python3")
+            ? "python3"
+            : commandExists("python")
+                ? "python"
+                : null,
+        shell: commandExists("bash") ? "bash" : "sh",
+        ruby: commandExists("ruby") ? "ruby" : null,
+        go: commandExists("go") ? "go" : null,
+        rust: commandExists("rustc") ? "rustc" : null,
+        php: commandExists("php") ? "php" : null,
+        perl: commandExists("perl") ? "perl" : null,
+        r: commandExists("Rscript")
+            ? "Rscript"
+            : commandExists("r")
+                ? "r"
+                : null,
+    };
+}
+export function hasBunRuntime() {
+    return commandExists("bun");
+}
+export function getRuntimeSummary(runtimes) {
+    const lines = [];
+    const bunPreferred = runtimes.javascript === "bun";
+    lines.push(`  JavaScript: ${runtimes.javascript} (${getVersion(runtimes.javascript)})${bunPreferred ? " ⚡" : ""}`);
+    if (runtimes.typescript) {
+        lines.push(`  TypeScript: ${runtimes.typescript} (${getVersion(runtimes.typescript)})`);
+    }
+    else {
+        lines.push(`  TypeScript: not available (install bun, tsx, or ts-node)`);
+    }
+    if (runtimes.python) {
+        lines.push(`  Python:     ${runtimes.python} (${getVersion(runtimes.python)})`);
+    }
+    else {
+        lines.push(`  Python:     not available`);
+    }
+    lines.push(`  Shell:      ${runtimes.shell} (${getVersion(runtimes.shell)})`);
+    // Optional runtimes — only show if available
+    if (runtimes.ruby)
+        lines.push(`  Ruby:       ${runtimes.ruby} (${getVersion(runtimes.ruby)})`);
+    if (runtimes.go)
+        lines.push(`  Go:         ${runtimes.go} (${getVersion(runtimes.go)})`);
+    if (runtimes.rust)
+        lines.push(`  Rust:       ${runtimes.rust} (${getVersion(runtimes.rust)})`);
+    if (runtimes.php)
+        lines.push(`  PHP:        ${runtimes.php} (${getVersion(runtimes.php)})`);
+    if (runtimes.perl)
+        lines.push(`  Perl:       ${runtimes.perl} (${getVersion(runtimes.perl)})`);
+    if (runtimes.r)
+        lines.push(`  R:          ${runtimes.r} (${getVersion(runtimes.r)})`);
+    if (!bunPreferred) {
+        lines.push("");
+        lines.push("  Tip: Install Bun for 3-5x faster JS/TS execution → https://bun.sh");
+    }
+    return lines.join("\n");
+}
+export function getAvailableLanguages(runtimes) {
+    const langs = ["javascript", "shell"];
+    if (runtimes.typescript)
+        langs.push("typescript");
+    if (runtimes.python)
+        langs.push("python");
+    if (runtimes.ruby)
+        langs.push("ruby");
+    if (runtimes.go)
+        langs.push("go");
+    if (runtimes.rust)
+        langs.push("rust");
+    if (runtimes.php)
+        langs.push("php");
+    if (runtimes.perl)
+        langs.push("perl");
+    if (runtimes.r)
+        langs.push("r");
+    return langs;
+}
+export function buildCommand(runtimes, language, filePath) {
+    switch (language) {
+        case "javascript":
+            return runtimes.javascript === "bun"
+                ? ["bun", "run", filePath]
+                : ["node", filePath];
+        case "typescript":
+            if (!runtimes.typescript) {
+                throw new Error("No TypeScript runtime available. Install one of: bun (recommended), tsx (npm i -g tsx), or ts-node.");
+            }
+            if (runtimes.typescript === "bun")
+                return ["bun", "run", filePath];
+            if (runtimes.typescript === "tsx")
+                return ["tsx", filePath];
+            return ["ts-node", filePath];
+        case "python":
+            if (!runtimes.python) {
+                throw new Error("No Python runtime available. Install python3 or python.");
+            }
+            return [runtimes.python, filePath];
+        case "shell":
+            return [runtimes.shell, filePath];
+        case "ruby":
+            if (!runtimes.ruby) {
+                throw new Error("Ruby not available. Install ruby.");
+            }
+            return [runtimes.ruby, filePath];
+        case "go":
+            if (!runtimes.go) {
+                throw new Error("Go not available. Install go.");
+            }
+            return ["go", "run", filePath];
+        case "rust": {
+            if (!runtimes.rust) {
+                throw new Error("Rust not available. Install rustc via https://rustup.rs");
+            }
+            // Rust needs compile + run — handled specially in executor
+            return ["__rust_compile_run__", filePath];
+        }
+        case "php":
+            if (!runtimes.php) {
+                throw new Error("PHP not available. Install php.");
+            }
+            return ["php", filePath];
+        case "perl":
+            if (!runtimes.perl) {
+                throw new Error("Perl not available. Install perl.");
+            }
+            return ["perl", filePath];
+        case "r":
+            if (!runtimes.r) {
+                throw new Error("R not available. Install R / Rscript.");
+            }
+            return [runtimes.r, filePath];
+    }
+}

package/build/server.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};