@doccident/doccident 0.0.3 → 0.0.5

package/dist/languages/fortran.js

@@ -0,0 +1,165 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fortranHandler = void 0;
+const child_process_1 = require("child_process");
+const fs_1 = require("fs");
+const path_1 = require("path");
+const os_1 = require("os");
+const fortranHandler = (code, _snippet, config, sandbox, isSharedSandbox) => {
+    let success = false;
+    let stack = "";
+    const context = sandbox;
+    let fortranCode = code;
+    // Handle shared state
+    if (isSharedSandbox) {
+        if (!context._fortranCode) {
+            context._fortranCode = "";
+        }
+        context._fortranCode += code + "\n";
+        fortranCode = context._fortranCode;
+    }
+    let finalSource = "";
+    // Parse modules vs program
+    // We want to lift modules to the top, before the program block
+    if (!isSharedSandbox) {
+        // Legacy/Single snippet mode
+        if (!fortranCode.toLowerCase().includes('program ')) {
+            finalSource = `program main
+${fortranCode}
+end program main`;
+        }
+        else {
+            finalSource = fortranCode;
+        }
+    }
+    else {
+        // Shared state mode
+        // We need to separate modules, subroutines/functions (external), and the main program body.
+        // However, standard Fortran requires:
+        // MODULES
+        // PROGRAM
+        // 
+        // If the user provides snippets that are just code (print *, ...), they belong in PROGRAM.
+        // If they provide MODULE ..., it belongs at top level.
+        // If they provide SUBROUTINE ... inside a module or program? 
+        // 
+        // Strategy:
+        // 1. Extract MODULE blocks.
+        // 2. Extract SUBROUTINE/FUNCTION blocks that are top-level? Or assume they are contained?
+        //    Actually, simple subroutines can be outside/after program if using CONTAINS? 
+        //    No, simplest structure is:
+        //    MODULES...
+        //    PROGRAM main
+        //      USE modules...
+        //      IMPLICIT NONE
+        //      ... statements ...
+        //    END PROGRAM main
+        // Let's implement a simple parser that looks for MODULE ... END MODULE blocks.
+        const lines = fortranCode.split('\n');
+        const modules = [];
+        const programBody = [];
+        let inModule = false;
+        let moduleBuffer = [];
+        for (const line of lines) {
+            const trimmed = line.trim().toLowerCase();
+            if (trimmed.startsWith('module ') && !trimmed.startsWith('module procedure') && !inModule) {
+                inModule = true;
+                moduleBuffer.push(line);
+            }
+            else if (inModule) {
+                moduleBuffer.push(line);
+                if (trimmed.startsWith('end module')) {
+                    inModule = false;
+                    modules.push(moduleBuffer.join('\n'));
+                    moduleBuffer = [];
+                }
+            }
+            else {
+                // If it's a "use" statement, it should be at the top of program?
+                // Or "implicit none"?
+                // We'll just dump everything else into the program body for now.
+                // NOTE: If users provide a full PROGRAM block in shared mode, this breaks.
+                // We assume shared mode = snippets building up a program.
+                if (!trimmed.startsWith('program ') && !trimmed.startsWith('end program')) {
+                    programBody.push(line);
+                }
+            }
+        }
+        // If we have open module buffer (unclosed), dump it to body? Or fail? 
+        // Or assume it's just code.
+        if (inModule) {
+            // Fallback
+            programBody.push(...moduleBuffer);
+        }
+        // Detect dependencies (USE statements)
+        // Move USE statements to the top of the program body
+        const useStatements = [];
+        const otherStatements = [];
+        for (const line of programBody) {
+            const trimmed = line.trim().toLowerCase();
+            if (trimmed.startsWith('use ')) {
+                useStatements.push(line);
+            }
+            else {
+                otherStatements.push(line);
+            }
+        }
+        finalSource = `${modules.join('\n\n')}
+
+program main
+${useStatements.join('\n')}
+implicit none
+${otherStatements.join('\n')}
+end program main`;
+    }
+    const uniqueId = `${Date.now()}_${Math.random().toString(36).substring(7)}`;
+    const tempSourceFile = (0, path_1.join)((0, os_1.tmpdir)(), `doccident_fortran_${uniqueId}.f90`);
+    const tempExeFile = (0, path_1.join)((0, os_1.tmpdir)(), `doccident_fortran_${uniqueId}`);
+    const timeout = config.timeout || 30000;
+    try {
+        (0, fs_1.writeFileSync)(tempSourceFile, finalSource);
+        // Compile with gfortran
+        const compileResult = (0, child_process_1.spawnSync)('gfortran', [tempSourceFile, '-o', tempExeFile], { encoding: 'utf-8', timeout });
+        if (compileResult.status !== 0) {
+            stack = compileResult.stderr || "Fortran compilation failed";
+            if (isSharedSandbox) {
+                stack += `\n\nGenerated Source:\n${finalSource}`;
+            }
+        }
+        else {
+            // Run
+            const runResult = (0, child_process_1.spawnSync)(tempExeFile, [], { encoding: 'utf-8', timeout });
+            if (runResult.error && runResult.error.code === 'ETIMEDOUT') {
+                return { success: false, stack: `Execution timed out after ${timeout}ms` };
+            }
+            if (runResult.status === 0) {
+                success = true;
+            }
+            else {
+                stack = runResult.stderr || "Fortran execution failed with non-zero exit code";
+            }
+            return { success, stack, output: runResult.stdout };
+        }
+    }
+    catch (e) {
+        stack = e.message || "Failed to execute gfortran or run binary";
+    }
+    finally {
+        try {
+            if ((0, fs_1.existsSync)(tempSourceFile))
+                (0, fs_1.unlinkSync)(tempSourceFile);
+            if ((0, fs_1.existsSync)(tempExeFile))
+                (0, fs_1.unlinkSync)(tempExeFile);
+            // Cleanup .mod files generated by modules
+            // They are usually in the cwd (tmpdir)
+            // We can try to clean them up if we know the module names, or just ignore for now as tmpdir is cleaned by OS eventually?
+            // Actually, we are running in tmpdir, so .mod files will pollute it? 
+            // Better to run in a specific subdir like other handlers to avoid collisions.
+        }
+        catch {
+            // Ignore cleanup error
+        }
+    }
+    return { success, stack };
+};
+exports.fortranHandler = fortranHandler;

package/dist/languages/go.js

@@ -0,0 +1,159 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.goHandler = void 0;
+const child_process_1 = require("child_process");
+const fs_1 = require("fs");
+const path_1 = require("path");
+const os_1 = require("os");
+// Helper to parse Go code into imports, top-level decls, and main body
+function parseGoCode(fullCode) {
+    const lines = fullCode.split('\n');
+    const imports = [];
+    let topLevel = "";
+    let mainBody = "";
+    let state = 'NORMAL';
+    let braceCount = 0;
+    for (const line of lines) {
+        const trimmed = line.trim();
+        // Skip package main lines in shared snippets
+        if (trimmed.startsWith('package main'))
+            continue;
+        if (state === 'NORMAL') {
+            if (trimmed.startsWith('import')) {
+                if (trimmed.includes('(')) {
+                    state = 'IN_IMPORT_BLOCK';
+                    imports.push(line);
+                }
+                else {
+                    imports.push(line);
+                }
+            }
+            else if (trimmed.startsWith('func ') ||
+                trimmed.startsWith('type ') ||
+                trimmed.startsWith('const ') ||
+                trimmed.startsWith('var ')) {
+                // Heuristic: Top level declaration
+                topLevel += line + "\n";
+                // Count braces
+                const open = (line.match(/\{/g) || []).length;
+                const close = (line.match(/\}/g) || []).length;
+                braceCount = open - close;
+                if (braceCount > 0) {
+                    state = 'IN_BRACE_BLOCK';
+                }
+            }
+            else {
+                mainBody += line + "\n";
+            }
+        }
+        else if (state === 'IN_IMPORT_BLOCK') {
+            imports.push(line);
+            if (trimmed.includes(')')) {
+                state = 'NORMAL';
+            }
+        }
+        else if (state === 'IN_BRACE_BLOCK') {
+            topLevel += line + "\n";
+            const open = (line.match(/\{/g) || []).length;
+            const close = (line.match(/\}/g) || []).length;
+            braceCount += open - close;
+            if (braceCount <= 0) {
+                state = 'NORMAL';
+                braceCount = 0;
+            }
+        }
+    }
+    return { imports, topLevel, mainBody };
+}
+const goHandler = (code, _snippet, config, sandbox, isSharedSandbox) => {
+    let success = false;
+    let stack = "";
+    const context = sandbox;
+    let fullCode = code;
+    // Handle shared state
+    if (isSharedSandbox) {
+        if (!context._goCode) {
+            context._goCode = "";
+        }
+        context._goCode += code + "\n";
+        fullCode = context._goCode;
+    }
+    let finalSource = "";
+    // If explicit package main is present, use as is (unless shared?)
+    if (fullCode.includes('package main') && !isSharedSandbox) {
+        finalSource = fullCode;
+    }
+    else {
+        const { imports, topLevel, mainBody } = parseGoCode(fullCode);
+        // Auto-add fmt if used but not imported
+        const importsStr = imports.join('\n');
+        let autoImports = "";
+        if (!importsStr.includes('"fmt"') && (topLevel.includes('fmt.') || mainBody.includes('fmt.'))) {
+            autoImports = 'import "fmt"';
+        }
+        finalSource = `package main
+${autoImports}
+${importsStr}
+
+${topLevel}
+
+func main() {
+${mainBody}
+}`;
+    }
+    const tempFile = (0, path_1.join)((0, os_1.tmpdir)(), `doccident_go_${Date.now()}_${Math.random().toString(36).substring(7)}.go`);
+    const timeout = config.timeout || 30000;
+    try {
+        (0, fs_1.writeFileSync)(tempFile, finalSource);
+        let result = (0, child_process_1.spawnSync)('go', ['run', tempFile], { encoding: 'utf-8', timeout });
+        // Retry logic for unused imports
+        if (result.status !== 0 && result.stderr && result.stderr.includes("imported and not used")) {
+            const lines = finalSource.split('\n');
+            const errorLines = result.stderr.split('\n');
+            let modified = false;
+            errorLines.forEach(err => {
+                const match = err.match(/:(\d+):\d+: "(.+)" imported and not used/);
+                if (match) {
+                    const lineNum = parseInt(match[1], 10);
+                    // Comment out the unused import line (using 1-based index from error)
+                    if (lines[lineNum - 1]) {
+                        lines[lineNum - 1] = "// " + lines[lineNum - 1];
+                        modified = true;
+                    }
+                }
+            });
+            if (modified) {
+                const retriedSource = lines.join('\n');
+                (0, fs_1.writeFileSync)(tempFile, retriedSource);
+                result = (0, child_process_1.spawnSync)('go', ['run', tempFile], { encoding: 'utf-8', timeout });
+            }
+        }
+        if (result.error && result.error.code === 'ETIMEDOUT') {
+            return { success: false, stack: `Execution timed out after ${timeout}ms` };
+        }
+        if (result.status === 0) {
+            success = true;
+        }
+        else {
+            stack = result.stderr || "Go execution failed with non-zero exit code";
+            // Debug output for shared state issues
+            if (isSharedSandbox) {
+                stack += `\n\nGenerated Source:\n${finalSource}`;
+            }
+        }
+        return { success, stack, output: result.stdout };
+    }
+    catch (e) {
+        stack = e.message || "Failed to execute go run";
+    }
+    finally {
+        try {
+            (0, fs_1.unlinkSync)(tempFile);
+        }
+        catch {
+            // Ignore cleanup error
+        }
+    }
+    return { success, stack };
+};
+exports.goHandler = goHandler;

package/dist/languages/interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/languages/java.js

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.javaHandler = void 0;
+const child_process_1 = require("child_process");
+const fs_1 = require("fs");
+const path_1 = require("path");
+const os_1 = require("os");
+const javaHandler = (code, _snippet, config, _sandbox, _isSharedSandbox) => {
+    let success = false;
+    let stack = "";
+    // Java execution logic
+    // Auto-wrap in class Main and main method if not present
+    let javaCode = code;
+    let className = "Main";
+    // Simple heuristic to detect if class is provided or just snippet
+    if (!javaCode.includes("class ")) {
+        javaCode = `public class ${className} {
+    public static void main(String[] args) {
+        ${javaCode}
+    }
+}`;
+    }
+    else {
+        // Try to extract class name if provided
+        const classMatch = javaCode.match(/class\s+(\w+)/);
+        if (classMatch) {
+            className = classMatch[1];
+        }
+        else {
+            // Fallback or error? For now assume user knows what they are doing if they write "class" 
+            // but maybe we should ensure file name matches public class
+        }
+    }
+    const uniqueId = `${Date.now()}_${Math.random().toString(36).substring(7)}`;
+    // Create a unique directory for this execution to avoid class name collisions
+    // if running parallel or multiple Main classes
+    const tempDir = (0, path_1.join)((0, os_1.tmpdir)(), `doccident_java_${uniqueId}`);
+    const timeout = config.timeout || 30000;
+    // We need to make the directory
+    try {
+        if (!(0, fs_1.existsSync)(tempDir)) {
+            (0, fs_1.mkdirSync)(tempDir);
+        }
+        const tempSourceFile = (0, path_1.join)(tempDir, `${className}.java`);
+        (0, fs_1.writeFileSync)(tempSourceFile, javaCode);
+        // Compile with javac
+        const compileResult = (0, child_process_1.spawnSync)('javac', [tempSourceFile], { encoding: 'utf-8', cwd: tempDir, timeout });
+        if (compileResult.status !== 0) {
+            stack = compileResult.stderr || "Java compilation failed";
+        }
+        else {
+            // Run
+            const runResult = (0, child_process_1.spawnSync)('java', ['-cp', tempDir, className], { encoding: 'utf-8', cwd: tempDir, timeout });
+            if (runResult.error && runResult.error.code === 'ETIMEDOUT') {
+                return { success: false, stack: `Execution timed out after ${timeout}ms` };
+            }
+            if (runResult.status === 0) {
+                success = true;
+            }
+            else {
+                stack = runResult.stderr || "Java execution failed with non-zero exit code";
+            }
+            return { success, stack, output: runResult.stdout };
+        }
+    }
+    catch (e) {
+        stack = e.message || "Failed to execute javac or java";
+    }
+    finally {
+        try {
+            // Cleanup: remove file and directory
+            // This is a bit manual, but fs.rmSync is available in node 14+
+            if (fs_1.rmSync) {
+                (0, fs_1.rmSync)(tempDir, { recursive: true, force: true });
+            }
+            else {
+                // Fallback for older nodes if necessary, but we are on node 22 in CI
+                if ((0, fs_1.existsSync)((0, path_1.join)(tempDir, `${className}.java`)))
+                    (0, fs_1.unlinkSync)((0, path_1.join)(tempDir, `${className}.java`));
+                if ((0, fs_1.existsSync)((0, path_1.join)(tempDir, `${className}.class`)))
+                    (0, fs_1.unlinkSync)((0, path_1.join)(tempDir, `${className}.class`));
+                if ((0, fs_1.existsSync)(tempDir))
+                    (0, fs_1.rmdirSync)(tempDir);
+            }
+        }
+        catch {
+            // Ignore cleanup error
+        }
+    }
+    return { success, stack };
+};
+exports.javaHandler = javaHandler;

package/dist/languages/javascript.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.javascriptHandler = void 0;
+const vm_1 = require("vm");
+const esbuild_1 = require("esbuild");
+const javascriptHandler = (code, _snippet, config, sandbox, _isSharedSandbox) => {
+    let success = false;
+    let stack = "";
+    let output = "";
+    // Capture console.log
+    const originalLog = sandbox.console.log;
+    sandbox.console.log = (...args) => {
+        output += args.map(String).join(' ') + '\n';
+        if (originalLog)
+            originalLog(...args);
+    };
+    try {
+        const result = (0, esbuild_1.transformSync)(code, {
+            loader: 'ts',
+            format: 'cjs',
+            target: 'node12'
+        });
+        const compiledCode = result.code || "";
+        const timeout = config.timeout || 30000;
+        (0, vm_1.runInNewContext)(compiledCode, sandbox, { timeout });
+        success = true;
+    }
+    catch (e) {
+        if (e.code === 'ERR_SCRIPT_EXECUTION_TIMEOUT') {
+            stack = `Execution timed out after ${config.timeout || 30000}ms`;
+        }
+        else {
+            stack = e.stack || "";
+        }
+    }
+    finally {
+        // Restore console.log? Not strictly necessary as sandbox is recreated or dedicated
+        // But if shared sandbox, we might want to keep accumulating output?
+        // No, output capture is per-snippet usually.
+        // But if shared sandbox is reused, `output` variable here is local.
+        // We override sandbox.console.log every time.
+        // Ideally we should restore it to avoid nesting if we re-use the sandbox object in a way that stacks?
+        // But `makeTestSandbox` creates a fresh object or we reuse the same one.
+        // If we reuse, `sandbox.console.log` is overwritten.
+        // We should probably save the original log from the *very first* time?
+        // Actually, `makeTestSandbox` sets `console.log: () => null` or `console`.
+        // So we are wrapping that.
+    }
+    return { success, stack, output: output.trimEnd() }; // Trim trailing newline for easier comparison
+};
+exports.javascriptHandler = javascriptHandler;

package/dist/languages/pascal.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pascalHandler = void 0;
+const child_process_1 = require("child_process");
+const fs_1 = require("fs");
+const path_1 = require("path");
+const os_1 = require("os");
+const pascalHandler = (code, _snippet, config, _sandbox, _isSharedSandbox) => {
+    let success = false;
+    let stack = "";
+    // Pascal execution logic
+    // Auto-wrap in program block if not present
+    let pascalCode = code;
+    let programName = "TestProgram";
+    // Simple heuristic to detect if program is provided
+    if (!pascalCode.toLowerCase().includes("program ")) {
+        pascalCode = `program ${programName};
+begin
+    ${pascalCode}
+end.`;
+    }
+    else {
+        // Try to extract program name if provided
+        const match = pascalCode.match(/program\s+(\w+);/i);
+        if (match) {
+            programName = match[1];
+        }
+    }
+    const uniqueId = `${Date.now()}_${Math.random().toString(36).substring(7)}`;
+    const tempDir = (0, path_1.join)((0, os_1.tmpdir)(), `doccident_pascal_${uniqueId}`);
+    const timeout = config.timeout || 30000;
+    try {
+        if (!(0, fs_1.existsSync)(tempDir)) {
+            (0, fs_1.mkdirSync)(tempDir);
+        }
+        const tempSourceFile = (0, path_1.join)(tempDir, `${programName}.pas`);
+        const tempExeFile = (0, path_1.join)(tempDir, programName); // fpc creates executable with program name by default (or we specify -o)
+        (0, fs_1.writeFileSync)(tempSourceFile, pascalCode);
+        // Compile with fpc
+        // -o specifies output file name
+        const compileResult = (0, child_process_1.spawnSync)('fpc', [`-o${tempExeFile}`, tempSourceFile], { encoding: 'utf-8', cwd: tempDir, timeout });
+        if (compileResult.status !== 0) {
+            // Filter out the banner to just show the error if possible, or show all stderr/stdout
+            // fpc outputs errors to stdout often
+            stack = compileResult.stdout + "\n" + compileResult.stderr || "Pascal compilation failed";
+        }
+        else {
+            // Run
+            const runResult = (0, child_process_1.spawnSync)(tempExeFile, [], { encoding: 'utf-8', cwd: tempDir, timeout });
+            if (runResult.error && runResult.error.code === 'ETIMEDOUT') {
+                return { success: false, stack: `Execution timed out after ${timeout}ms` };
+            }
+            if (runResult.status === 0) {
+                success = true;
+            }
+            else {
+                stack = runResult.stderr || "Pascal execution failed with non-zero exit code";
+            }
+            return { success, stack, output: runResult.stdout };
+        }
+    }
+    catch (e) {
+        stack = e.message || "Failed to execute fpc";
+    }
+    finally {
+        try {
+            if (fs_1.rmSync) {
+                (0, fs_1.rmSync)(tempDir, { recursive: true, force: true });
+            }
+            else {
+                // Cleanup fallback
+                if ((0, fs_1.existsSync)((0, path_1.join)(tempDir, `${programName}.pas`)))
+                    (0, fs_1.unlinkSync)((0, path_1.join)(tempDir, `${programName}.pas`));
+                if ((0, fs_1.existsSync)((0, path_1.join)(tempDir, `${programName}.o`)))
+                    (0, fs_1.unlinkSync)((0, path_1.join)(tempDir, `${programName}.o`));
+                if ((0, fs_1.existsSync)((0, path_1.join)(tempDir, programName)))
+                    (0, fs_1.unlinkSync)((0, path_1.join)(tempDir, programName));
+                if ((0, fs_1.existsSync)(tempDir))
+                    (0, fs_1.rmdirSync)(tempDir);
+            }
+        }
+        catch {
+            // Ignore cleanup error
+        }
+    }
+    return { success, stack };
+};
+exports.pascalHandler = pascalHandler;

package/dist/languages/perl.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.perlHandler = void 0;
+const child_process_1 = require("child_process");
+const perlHandler = (code, _snippet, config, sandbox, isSharedSandbox) => {
+    let success = false;
+    let stack = "";
+    const context = sandbox;
+    // If sharing code, we need to accumulate previous perl snippets
+    if (isSharedSandbox) {
+        if (!context._perlContext) {
+            context._perlContext = "";
+        }
+        context._perlContext += code + "\n";
+        code = context._perlContext;
+    }
+    try {
+        const timeout = config.timeout || 30000;
+        const result = (0, child_process_1.spawnSync)('perl', [], { input: code, encoding: 'utf-8', timeout });
+        if (result.error && result.error.code === 'ETIMEDOUT') {
+            return { success: false, stack: `Execution timed out after ${timeout}ms` };
+        }
+        if (result.status === 0) {
+            success = true;
+        }
+        else {
+            stack = result.stderr || "Perl execution failed with non-zero exit code";
+        }
+        return { success, stack, output: result.stdout };
+    }
+    catch (e) {
+        stack = e.message || "Failed to spawn perl";
+    }
+    return { success, stack };
+};
+exports.perlHandler = perlHandler;

package/dist/languages/python.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pythonHandler = void 0;
+const child_process_1 = require("child_process");
+const pythonHandler = (code, snippet, config, sandbox, isSharedSandbox) => {
+    let success = false;
+    let stack = "";
+    const context = sandbox;
+    // If sharing code, we need to accumulate previous python snippets
+    if (isSharedSandbox) {
+        if (!context._pythonContext) {
+            context._pythonContext = "";
+        }
+        context._pythonContext += code + "\n";
+        code = context._pythonContext;
+    }
+    try {
+        const args = snippet.args || [];
+        const env = snippet.env ? { ...process.env, ...snippet.env } : undefined;
+        const timeout = config.timeout || 30000;
+        // For python, args usually go to the script or interpreter?
+        // If we want to pass args to the script, we might need to invoke differently if using stdin.
+        // `python3 - arg1 arg2` reads from stdin.
+        // Let's prepend '-' to args if not empty, so python knows to read script from stdin before args.
+        // But spawnSync args array includes 'python3' arguments.
+        // If user supplies `-v`, it should be `python3 -v`.
+        // If user supplies script args, they come after.
+        // This is tricky. Let's assume user provides INTERPRETER args for now, as typical.
+        // Or if they start with `-`, they are interpreter args.
+        const spawnArgs = [...args];
+        const result = (0, child_process_1.spawnSync)('python3', spawnArgs, { input: code, encoding: 'utf-8', env, timeout });
+        if (result.error && result.error.code === 'ETIMEDOUT') {
+            return { success: false, stack: `Execution timed out after ${timeout}ms` };
+        }
+        if (result.status === 0) {
+            success = true;
+        }
+        else {
+            stack = result.stderr || "Python execution failed with non-zero exit code";
+        }
+        return { success, stack, output: result.stdout };
+    }
+    catch (e) {
+        stack = e.message || "Failed to spawn python3";
+        return { success, stack };
+    }
+};
+exports.pythonHandler = pythonHandler;

package/dist/languages/r.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rHandler = void 0;
+const child_process_1 = require("child_process");
+const rHandler = (code, _snippet, config, sandbox, isSharedSandbox) => {
+    let success = false;
+    let stack = "";
+    const context = sandbox;
+    // If sharing code, we need to accumulate previous R snippets
+    if (isSharedSandbox) {
+        if (!context._rContext) {
+            context._rContext = "";
+        }
+        context._rContext += code + "\n";
+        code = context._rContext;
+    }
+    try {
+        // Rscript - runs R code from stdin
+        const timeout = config.timeout || 30000;
+        const result = (0, child_process_1.spawnSync)('Rscript', ['-'], { input: code, encoding: 'utf-8', timeout });
+        if (result.error && result.error.code === 'ETIMEDOUT') {
+            return { success: false, stack: `Execution timed out after ${timeout}ms` };
+        }
+        if (result.status === 0) {
+            success = true;
+        }
+        else {
+            stack = result.stderr || "R execution failed with non-zero exit code";
+        }
+        return { success, stack, output: result.stdout };
+    }
+    catch (e) {
+        stack = e.message || "Failed to spawn Rscript";
+        return { success, stack };
+    }
+};
+exports.rHandler = rHandler;