@fastino-ai/pioneer-cli 0.1.0 → 0.2.0

package/src/tools/modal.ts

@@ -0,0 +1,269 @@
+/**
+ * Modal.com integration for serverless ML workloads
+ */
+
+import { spawn } from "child_process";
+import type { Tool, ToolResult } from "../agent/types.js";
+
+export interface ModalConfig {
+  tokenId?: string;
+  tokenSecret?: string;
+  timeout?: number;
+}
+
+// Check if Modal CLI is available
+export async function isModalAvailable(): Promise<boolean> {
+  return new Promise((resolve) => {
+    const proc = spawn("modal", ["--version"], { stdio: "pipe" });
+    proc.on("close", (code) => resolve(code === 0));
+    proc.on("error", () => resolve(false));
+  });
+}
+
+// Run a Modal function
+async function runModal(
+  args: string[],
+  options: ModalConfig = {}
+): Promise<{ stdout: string; stderr: string; exitCode: number }> {
+  const timeout = options.timeout || 300000; // 5 min default
+
+  return new Promise((resolve) => {
+    let stdout = "";
+    let stderr = "";
+    let timedOut = false;
+
+    const env: NodeJS.ProcessEnv = { ...process.env };
+    if (options.tokenId) env.MODAL_TOKEN_ID = options.tokenId;
+    if (options.tokenSecret) env.MODAL_TOKEN_SECRET = options.tokenSecret;
+
+    const proc = spawn("modal", args, {
+      stdio: ["pipe", "pipe", "pipe"],
+      env,
+    });
+
+    const timer = setTimeout(() => {
+      timedOut = true;
+      proc.kill("SIGTERM");
+    }, timeout);
+
+    proc.stdout.on("data", (data: Buffer) => {
+      stdout += data.toString();
+    });
+
+    proc.stderr.on("data", (data: Buffer) => {
+      stderr += data.toString();
+    });
+
+    proc.on("close", (code) => {
+      clearTimeout(timer);
+      resolve({
+        stdout,
+        stderr,
+        exitCode: timedOut ? -1 : (code ?? -1),
+      });
+    });
+
+    proc.on("error", (err) => {
+      clearTimeout(timer);
+      resolve({
+        stdout: "",
+        stderr: err.message,
+        exitCode: -1,
+      });
+    });
+  });
+}
+
+export function createModalRunTool(config: ModalConfig = {}): Tool {
+  return {
+    name: "modal_run",
+    description: "Run a Python function on Modal.com serverless GPU/CPU infrastructure. Useful for ML inference, training, and compute-intensive tasks.",
+    parameters: [
+      {
+        name: "code",
+        type: "string",
+        description: "Python code with Modal app definition. Must include @app.function decorator.",
+        required: true,
+      },
+      {
+        name: "function_name",
+        type: "string",
+        description: "Name of the Modal function to run (the one with @app.local_entrypoint or to call)",
+        required: true,
+      },
+      {
+        name: "args",
+        type: "string",
+        description: "Arguments to pass to the function (as JSON string)",
+        required: false,
+      },
+    ],
+
+    async execute(args: Record<string, unknown>): Promise<ToolResult> {
+      const code = args.code as string;
+      const functionName = args.function_name as string;
+      const funcArgs = args.args as string;
+
+      if (!code || !functionName) {
+        return {
+          toolCallId: "",
+          output: "",
+          success: false,
+          error: "code and function_name are required",
+        };
+      }
+
+      // Check if Modal is available
+      const available = await isModalAvailable();
+      if (!available) {
+        return {
+          toolCallId: "",
+          output: "",
+          success: false,
+          error: "Modal CLI not installed. Run: pip install modal",
+        };
+      }
+
+      // Create temp file with the code
+      const fs = await import("fs");
+      const path = await import("path");
+      const os = await import("os");
+
+      const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "modal-"));
+      const tempFile = path.join(tempDir, "app.py");
+      
+      // Ensure the code has proper Modal imports
+      let fullCode = code;
+      if (!code.includes("import modal")) {
+        fullCode = "import modal\n\n" + code;
+      }
+      
+      fs.writeFileSync(tempFile, fullCode);
+
+      try {
+        // Run the Modal function
+        const runArgs = ["run", tempFile];
+        if (functionName) {
+          runArgs.push("::" + functionName);
+        }
+        if (funcArgs) {
+          try {
+            const parsed = JSON.parse(funcArgs);
+            for (const [key, value] of Object.entries(parsed)) {
+              runArgs.push(`--${key}`, String(value));
+            }
+          } catch {
+            // Ignore JSON parse errors
+          }
+        }
+
+        const result = await runModal(runArgs, config);
+
+        let output = result.stdout;
+        if (result.stderr) {
+          output += (output ? "\n\nStderr:\n" : "") + result.stderr;
+        }
+
+        return {
+          toolCallId: "",
+          output: output || "(no output)",
+          success: result.exitCode === 0,
+          error: result.exitCode !== 0 ? `Exit code: ${result.exitCode}` : undefined,
+        };
+      } finally {
+        // Cleanup
+        try {
+          fs.rmSync(tempDir, { recursive: true, force: true });
+        } catch {
+          // Ignore cleanup errors
+        }
+      }
+    },
+  };
+}
+
+export function createModalDeployTool(config: ModalConfig = {}): Tool {
+  return {
+    name: "modal_deploy",
+    description: "Deploy a Modal app for persistent endpoints or scheduled jobs.",
+    parameters: [
+      {
+        name: "code",
+        type: "string",
+        description: "Python code with Modal app definition",
+        required: true,
+      },
+      {
+        name: "app_name",
+        type: "string",
+        description: "Name for the deployed app",
+        required: true,
+      },
+    ],
+
+    async execute(args: Record<string, unknown>): Promise<ToolResult> {
+      const code = args.code as string;
+      const appName = args.app_name as string;
+
+      if (!code || !appName) {
+        return {
+          toolCallId: "",
+          output: "",
+          success: false,
+          error: "code and app_name are required",
+        };
+      }
+
+      const available = await isModalAvailable();
+      if (!available) {
+        return {
+          toolCallId: "",
+          output: "",
+          success: false,
+          error: "Modal CLI not installed. Run: pip install modal",
+        };
+      }
+
+      const fs = await import("fs");
+      const path = await import("path");
+      const os = await import("os");
+
+      const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "modal-deploy-"));
+      const tempFile = path.join(tempDir, "app.py");
+
+      let fullCode = code;
+      if (!code.includes("import modal")) {
+        fullCode = "import modal\n\n" + code;
+      }
+      
+      fs.writeFileSync(tempFile, fullCode);
+
+      try {
+        const result = await runModal(["deploy", tempFile, "--name", appName], config);
+
+        let output = result.stdout;
+        if (result.stderr) {
+          output += (output ? "\n\nStderr:\n" : "") + result.stderr;
+        }
+
+        return {
+          toolCallId: "",
+          output: output || "(no output)",
+          success: result.exitCode === 0,
+          error: result.exitCode !== 0 ? `Exit code: ${result.exitCode}` : undefined,
+        };
+      } finally {
+        try {
+          fs.rmSync(tempDir, { recursive: true, force: true });
+        } catch {
+          // Ignore
+        }
+      }
+    },
+  };
+}
+
+export function createModalTools(config: ModalConfig = {}): Tool[] {
+  return [createModalRunTool(config), createModalDeployTool(config)];
+}
+

package/src/tools/sandbox.ts

@@ -0,0 +1,310 @@
+/**
+ * Code Sandbox - Isolated execution environments
+ * Uses temporary directories with timeout and resource limits
+ */
+
+import { spawn, execSync } from "child_process";
+import * as fs from "fs";
+import * as path from "path";
+import * as os from "os";
+import type { Tool, ToolResult } from "../agent/types.js";
+
+export interface SandboxOptions {
+  timeout?: number; // ms
+  memoryLimit?: string; // e.g., "512m"
+  cpuLimit?: number; // cores
+  useDocker?: boolean;
+  dockerImage?: string;
+}
+
+export interface SandboxResult {
+  stdout: string;
+  stderr: string;
+  exitCode: number;
+  timedOut: boolean;
+  duration: number;
+}
+
+// Language configurations
+const LANGUAGE_CONFIG: Record<
+  string,
+  { extension: string; command: (file: string) => string[]; setup?: string }
+> = {
+  python: {
+    extension: ".py",
+    command: (file) => ["python3", file],
+    setup: "pip install -q",
+  },
+  javascript: {
+    extension: ".js",
+    command: (file) => ["node", file],
+  },
+  typescript: {
+    extension: ".ts",
+    command: (file) => ["bun", file],
+  },
+  bash: {
+    extension: ".sh",
+    command: (file) => ["bash", file],
+  },
+  ruby: {
+    extension: ".rb",
+    command: (file) => ["ruby", file],
+  },
+  go: {
+    extension: ".go",
+    command: (file) => ["go", "run", file],
+  },
+};
+
+export class Sandbox {
+  private tempDir: string;
+  private options: SandboxOptions;
+
+  constructor(options: SandboxOptions = {}) {
+    this.options = {
+      timeout: options.timeout || 30000,
+      memoryLimit: options.memoryLimit || "512m",
+      cpuLimit: options.cpuLimit || 1,
+      useDocker: options.useDocker || false,
+      dockerImage: options.dockerImage || "python:3.11-slim",
+    };
+    this.tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "sandbox-"));
+  }
+
+  async execute(code: string, language: string): Promise<SandboxResult> {
+    const config = LANGUAGE_CONFIG[language];
+    if (!config) {
+      return {
+        stdout: "",
+        stderr: `Unsupported language: ${language}. Supported: ${Object.keys(LANGUAGE_CONFIG).join(", ")}`,
+        exitCode: 1,
+        timedOut: false,
+        duration: 0,
+      };
+    }
+
+    const filename = `code${config.extension}`;
+    const filepath = path.join(this.tempDir, filename);
+    fs.writeFileSync(filepath, code);
+
+    if (this.options.useDocker) {
+      return this.executeInDocker(filepath, config.command(filename));
+    } else {
+      return this.executeLocal(filepath, config.command(filepath));
+    }
+  }
+
+  private async executeLocal(
+    filepath: string,
+    command: string[]
+  ): Promise<SandboxResult> {
+    const startTime = Date.now();
+    let stdout = "";
+    let stderr = "";
+    let timedOut = false;
+
+    return new Promise((resolve) => {
+      const proc = spawn(command[0], command.slice(1), {
+        cwd: this.tempDir,
+        env: { ...process.env, PYTHONDONTWRITEBYTECODE: "1" },
+        stdio: ["pipe", "pipe", "pipe"],
+      });
+
+      const timer = setTimeout(() => {
+        timedOut = true;
+        proc.kill("SIGTERM");
+        setTimeout(() => proc.kill("SIGKILL"), 5000);
+      }, this.options.timeout);
+
+      proc.stdout.on("data", (data: Buffer) => {
+        stdout += data.toString();
+      });
+
+      proc.stderr.on("data", (data: Buffer) => {
+        stderr += data.toString();
+      });
+
+      proc.on("close", (code) => {
+        clearTimeout(timer);
+        const duration = Date.now() - startTime;
+
+        resolve({
+          stdout: stdout.slice(0, 50000), // Limit output
+          stderr: stderr.slice(0, 50000),
+          exitCode: timedOut ? -1 : (code ?? -1),
+          timedOut,
+          duration,
+        });
+      });
+
+      proc.on("error", (err) => {
+        clearTimeout(timer);
+        resolve({
+          stdout: "",
+          stderr: err.message,
+          exitCode: -1,
+          timedOut: false,
+          duration: Date.now() - startTime,
+        });
+      });
+    });
+  }
+
+  private async executeInDocker(
+    filepath: string,
+    command: string[]
+  ): Promise<SandboxResult> {
+    const startTime = Date.now();
+    const timeoutSeconds = Math.ceil((this.options.timeout || 30000) / 1000);
+
+    const dockerArgs = [
+      "run",
+      "--rm",
+      "-v",
+      `${this.tempDir}:/sandbox:ro`,
+      "-w",
+      "/sandbox",
+      "--memory",
+      this.options.memoryLimit || "512m",
+      "--cpus",
+      String(this.options.cpuLimit || 1),
+      "--network",
+      "none",
+      "--pids-limit",
+      "100",
+      this.options.dockerImage || "python:3.11-slim",
+      "timeout",
+      String(timeoutSeconds),
+      ...command,
+    ];
+
+    return new Promise((resolve) => {
+      const proc = spawn("docker", dockerArgs, {
+        stdio: ["pipe", "pipe", "pipe"],
+      });
+
+      let stdout = "";
+      let stderr = "";
+      let timedOut = false;
+
+      const timer = setTimeout(() => {
+        timedOut = true;
+        proc.kill("SIGTERM");
+      }, (this.options.timeout || 30000) + 5000);
+
+      proc.stdout.on("data", (data: Buffer) => {
+        stdout += data.toString();
+      });
+
+      proc.stderr.on("data", (data: Buffer) => {
+        stderr += data.toString();
+      });
+
+      proc.on("close", (code) => {
+        clearTimeout(timer);
+        const duration = Date.now() - startTime;
+
+        // Docker timeout returns code 124
+        if (code === 124) timedOut = true;
+
+        resolve({
+          stdout: stdout.slice(0, 50000),
+          stderr: stderr.slice(0, 50000),
+          exitCode: timedOut ? -1 : (code ?? -1),
+          timedOut,
+          duration,
+        });
+      });
+
+      proc.on("error", (err) => {
+        clearTimeout(timer);
+        resolve({
+          stdout: "",
+          stderr: `Docker error: ${err.message}`,
+          exitCode: -1,
+          timedOut: false,
+          duration: Date.now() - startTime,
+        });
+      });
+    });
+  }
+
+  cleanup(): void {
+    try {
+      fs.rmSync(this.tempDir, { recursive: true, force: true });
+    } catch {
+      // Ignore cleanup errors
+    }
+  }
+}
+
+export function createSandboxTool(options: SandboxOptions = {}): Tool {
+  return {
+    name: "execute_code",
+    description: "Execute code in an isolated sandbox environment. Supports Python, JavaScript, TypeScript, Bash, Ruby, and Go.",
+    parameters: [
+      {
+        name: "code",
+        type: "string",
+        description: "The code to execute",
+        required: true,
+      },
+      {
+        name: "language",
+        type: "string",
+        description: "Programming language: python, javascript, typescript, bash, ruby, go",
+        required: true,
+      },
+    ],
+
+    async execute(args: Record<string, unknown>): Promise<ToolResult> {
+      const code = args.code as string;
+      const language = (args.language as string)?.toLowerCase();
+
+      if (!code) {
+        return { toolCallId: "", output: "", success: false, error: "Code is required" };
+      }
+
+      if (!language || !LANGUAGE_CONFIG[language]) {
+        return {
+          toolCallId: "",
+          output: "",
+          success: false,
+          error: `Invalid language. Supported: ${Object.keys(LANGUAGE_CONFIG).join(", ")}`,
+        };
+      }
+
+      const sandbox = new Sandbox(options);
+
+      try {
+        const result = await sandbox.execute(code, language);
+        
+        let output = "";
+        if (result.stdout) output += result.stdout;
+        if (result.stderr) output += (output ? "\n\nStderr:\n" : "") + result.stderr;
+        if (result.timedOut) output += `\n\n(Execution timed out after ${options.timeout || 30000}ms)`;
+
+        return {
+          toolCallId: "",
+          output: output || "(no output)",
+          success: result.exitCode === 0 && !result.timedOut,
+          error: result.exitCode !== 0 ? `Exit code: ${result.exitCode}` : undefined,
+        };
+      } finally {
+        sandbox.cleanup();
+      }
+    },
+  };
+}
+
+// Check if Docker is available
+export function isDockerAvailable(): boolean {
+  try {
+    execSync("docker --version", { stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+