sandlot 0.1.1 → 0.1.3

package/src/commands.ts

@@ -1,733 +0,0 @@
-/**
- * Command factories for sandbox bash environments.
- *
- * Pure factories that create commands for type checking and bundling.
- * No global state - all dependencies are passed in explicitly.
- */
-
-import { defineCommand, type CommandContext, type IFileSystem } from "just-bash/browser";
-import { typecheck, formatDiagnosticsForAgent, type TypecheckResult } from "./typechecker";
-import { bundle, type BundleResult } from "./bundler";
-import { installPackage, uninstallPackage, listPackages, type TypesCache } from "./packages";
-import { loadModule } from "./loader";
-
-/**
- * Dependencies required by command factories
- */
-export interface CommandDeps {
-  /**
-   * The virtual filesystem to operate on
-   */
-  fs: IFileSystem;
-
-  /**
-   * Pre-loaded TypeScript lib files for type checking
-   */
-  libFiles: Map<string, string>;
-
-  /**
-   * Path to tsconfig.json in the virtual filesystem
-   */
-  tsconfigPath: string;
-
-  /**
-   * Callback invoked when a build succeeds
-   */
-  onBuild?: (result: BundleResult) => void | Promise<void>;
-
-  /**
-   * Cache for package type definitions.
-   * When provided, avoids redundant network fetches for packages
-   * that have already been installed in other sandboxes.
-   */
-  typesCache?: TypesCache;
-
-  /**
-   * Options for the `run` command
-   */
-  runOptions?: RunOptions;
-
-  /**
-   * Module IDs that should be resolved from the host's SharedModuleRegistry
-   * instead of esm.sh CDN. The host must have registered these modules.
-   * 
-   * Example: ['react', 'react-dom/client']
-   */
-  sharedModules?: string[];
-}
-
-/**
- * Runtime context passed to the `main()` function when code is executed.
- * This provides sandboxed code with access to sandbox capabilities.
- */
-export interface RunContext {
-  /**
-   * The virtual filesystem - read/write files within the sandbox
-   */
-  fs: IFileSystem;
-
-  /**
-   * Environment variables (configurable per-sandbox)
-   */
-  env: Record<string, string>;
-
-  /**
-   * Command-line arguments passed to `run`
-   */
-  args: string[];
-
-  /**
-   * Explicit logging function (alternative to console.log)
-   */
-  log: (...args: unknown[]) => void;
-
-  /**
-   * Explicit error logging function (alternative to console.error)
-   */
-  error: (...args: unknown[]) => void;
-}
-
-/**
- * Options for configuring the `run` command behavior
- */
-export interface RunOptions {
-  /**
-   * Environment variables available via ctx.env
-   */
-  env?: Record<string, string>;
-
-  /**
-   * Maximum execution time in milliseconds (default: 30000 = 30s)
-   * Set to 0 to disable timeout.
-   */
-  timeout?: number;
-
-  /**
-   * Whether to skip type checking before running (default: false)
-   */
-  skipTypecheck?: boolean;
-}
-
-/**
- * Result of running code via the `run` command
- */
-export interface RunResult {
-  /**
-   * Captured console output (log, warn, error)
-   */
-  logs: string[];
-
-  /**
-   * Return value from main() if present
-   */
-  returnValue?: unknown;
-
-  /**
-   * Execution time in milliseconds
-   */
-  executionTimeMs: number;
-}
-
-/**
- * Format esbuild messages (warnings/errors) for display
- */
-export function formatEsbuildMessages(
-  messages: { text: string; location?: { file?: string; line?: number; column?: number } | null }[]
-): string {
-  if (messages.length === 0) return "";
-
-  return messages
-    .map((msg) => {
-      if (msg.location) {
-        const { file, line, column } = msg.location;
-        const loc = file ? `${file}${line ? `:${line}` : ""}${column ? `:${column}` : ""}` : "";
-        return loc ? `${loc}: ${msg.text}` : msg.text;
-      }
-      return msg.text;
-    })
-    .join("\n");
-}
-
-/**
- * Create the `tsc` command for type checking
- */
-export function createTscCommand(deps: CommandDeps) {
-  const { fs, libFiles, tsconfigPath } = deps;
-
-  return defineCommand("tsc", async (args, _ctx: CommandContext) => {
-    const entryPoint = args[0];
-    if (!entryPoint) {
-      return {
-        stdout: "",
-        stderr: `Usage: tsc <entry-point>\n\nExample: tsc /src/index.ts\n`,
-        exitCode: 1,
-      };
-    }
-
-    try {
-      // Check if entry point exists
-      if (!(await fs.exists(entryPoint))) {
-        return {
-          stdout: "",
-          stderr: `Error: Entry point not found: ${entryPoint}\n`,
-          exitCode: 1,
-        };
-      }
-
-      const result = await typecheck({
-        fs,
-        entryPoint,
-        tsconfigPath,
-        libFiles,
-      });
-
-      if (result.hasErrors) {
-        const formatted = formatDiagnosticsForAgent(result.diagnostics);
-        return {
-          stdout: "",
-          stderr: formatted + "\n",
-          exitCode: 1,
-        };
-      }
-
-      const checkedCount = result.checkedFiles.length;
-      const warningCount = result.diagnostics.filter((d) => d.category === "warning").length;
-
-      let output = `Type check passed. Checked ${checkedCount} file(s).\n`;
-      if (warningCount > 0) {
-        output += `\nWarnings:\n${formatDiagnosticsForAgent(result.diagnostics.filter((d) => d.category === "warning"))}\n`;
-      }
-
-      return {
-        stdout: output,
-        stderr: "",
-        exitCode: 0,
-      };
-    } catch (err) {
-      return {
-        stdout: "",
-        stderr: `Type check failed: ${err instanceof Error ? err.message : String(err)}\n`,
-        exitCode: 1,
-      };
-    }
-  });
-}
-
-/**
- * Create the `build` command for bundling (with automatic type checking)
- */
-export function createBuildCommand(deps: CommandDeps) {
-  const { fs, libFiles, tsconfigPath, onBuild, sharedModules } = deps;
-
-  return defineCommand("build", async (args, _ctx: CommandContext) => {
-    // Parse arguments
-    let entryPoint: string | null = null;
-    let skipTypecheck = false;
-    let minify = false;
-    let format: "esm" | "iife" | "cjs" = "esm";
-
-    for (let i = 0; i < args.length; i++) {
-      const arg = args[i];
-      if (arg === "--skip-typecheck" || arg === "-s") {
-        skipTypecheck = true;
-      } else if (arg === "--minify" || arg === "-m") {
-        minify = true;
-      } else if ((arg === "--format" || arg === "-f") && args[i + 1]) {
-        const f = args[++i]!.toLowerCase();
-        if (f === "esm" || f === "iife" || f === "cjs") {
-          format = f;
-        }
-      } else if (!arg!.startsWith("-")) {
-        entryPoint = arg!;
-      }
-    }
-
-    // Entry point is required
-    if (!entryPoint) {
-      return {
-        stdout: "",
-        stderr: `Usage: build <entry-point> [options]\n\nOptions:\n  --skip-typecheck, -s  Skip type checking\n  --minify, -m          Minify output\n  --format, -f <fmt>    Output format (esm|iife|cjs)\n\nExample: build /src/index.ts\n`,
-        exitCode: 1,
-      };
-    }
-
-    try {
-      // Check if entry point exists
-      if (!(await fs.exists(entryPoint))) {
-        return {
-          stdout: "",
-          stderr: `Error: Entry point not found: ${entryPoint}\n`,
-          exitCode: 1,
-        };
-      }
-
-      // Step 1: Type check (unless skipped)
-      let typecheckResult: TypecheckResult | null = null;
-      if (!skipTypecheck) {
-        typecheckResult = await typecheck({
-          fs,
-          entryPoint,
-          tsconfigPath,
-          libFiles,
-        });
-
-        if (typecheckResult.hasErrors) {
-          const formatted = formatDiagnosticsForAgent(typecheckResult.diagnostics);
-          return {
-            stdout: "",
-            stderr: `Build failed: Type errors found.\n\n${formatted}\n`,
-            exitCode: 1,
-          };
-        }
-      }
-
-      // Step 2: Bundle
-      const bundleResult = await bundle({
-        fs,
-        entryPoint,
-        format,
-        minify,
-        sharedModules,
-      });
-
-      // Invoke callback with bundle result (caller can dynamically import, halt agent, etc.)
-      if (onBuild) {
-        await onBuild(bundleResult);
-      }
-
-      // Build success message
-      let output = `Build successful!\n`;
-      output += `Entry: ${entryPoint}\n`;
-      output += `Format: ${format}\n`;
-      output += `Size: ${(bundleResult.code.length / 1024).toFixed(2)} KB\n`;
-
-      if (typecheckResult) {
-        output += `Type checked: ${typecheckResult.checkedFiles.length} file(s)\n`;
-      }
-
-      output += `Bundled: ${bundleResult.includedFiles.length} file(s)\n`;
-
-      // Include warnings if any
-      if (bundleResult.warnings.length > 0) {
-        output += `\nBuild warnings:\n${formatEsbuildMessages(bundleResult.warnings)}\n`;
-      }
-
-      if (typecheckResult) {
-        const warnings = typecheckResult.diagnostics.filter((d) => d.category === "warning");
-        if (warnings.length > 0) {
-          output += `\nType warnings:\n${formatDiagnosticsForAgent(warnings)}\n`;
-        }
-      }
-
-      return {
-        stdout: output,
-        stderr: "",
-        exitCode: 0,
-      };
-    } catch (err) {
-      const errorMessage = err instanceof Error ? err.message : String(err);
-      return {
-        stdout: "",
-        stderr: `Build failed: ${errorMessage}\n`,
-        exitCode: 1,
-      };
-    }
-  });
-}
-
-/**
- * Create the `install` command for adding packages from npm
- */
-export function createInstallCommand(deps: CommandDeps) {
-  const { fs, typesCache } = deps;
-
-  return defineCommand("install", async (args, _ctx: CommandContext) => {
-    if (args.length === 0) {
-      return {
-        stdout: "",
-        stderr: "Usage: install <package>[@version] [...packages]\n\nExamples:\n  install react\n  install lodash@4.17.21\n  install @tanstack/react-query@5\n",
-        exitCode: 1,
-      };
-    }
-
-    const results: string[] = [];
-    let hasError = false;
-
-    for (const packageSpec of args) {
-      try {
-        const result = await installPackage(fs, packageSpec!, { cache: typesCache });
-
-        let status = `+ ${result.name}@${result.version}`;
-        if (result.typesInstalled) {
-          status += ` (${result.typeFilesCount} type file${result.typeFilesCount !== 1 ? "s" : ""})`;
-          if (result.fromCache) {
-            status += " [cached]";
-          }
-        } else if (result.typesError) {
-          status += ` (no types: ${result.typesError})`;
-        }
-        results.push(status);
-      } catch (err) {
-        hasError = true;
-        const message = err instanceof Error ? err.message : String(err);
-        results.push(`x ${packageSpec}: ${message}`);
-      }
-    }
-
-    const output = results.join("\n") + "\n";
-
-    if (hasError) {
-      return {
-        stdout: "",
-        stderr: output,
-        exitCode: 1,
-      };
-    }
-
-    return {
-      stdout: output,
-      stderr: "",
-      exitCode: 0,
-    };
-  });
-}
-
-/**
- * Create the `uninstall` command for removing packages
- */
-export function createUninstallCommand(deps: CommandDeps) {
-  const { fs } = deps;
-
-  return defineCommand("uninstall", async (args, _ctx: CommandContext) => {
-    if (args.length === 0) {
-      return {
-        stdout: "",
-        stderr: "Usage: uninstall <package> [...packages]\n",
-        exitCode: 1,
-      };
-    }
-
-    const results: string[] = [];
-    let hasError = false;
-
-    for (const packageName of args) {
-      try {
-        const removed = await uninstallPackage(fs, packageName!);
-        if (removed) {
-          results.push(`- ${packageName}`);
-        } else {
-          results.push(`x ${packageName}: not installed`);
-          hasError = true;
-        }
-      } catch (err) {
-        hasError = true;
-        const message = err instanceof Error ? err.message : String(err);
-        results.push(`x ${packageName}: ${message}`);
-      }
-    }
-
-    const output = results.join("\n") + "\n";
-
-    if (hasError) {
-      return {
-        stdout: "",
-        stderr: output,
-        exitCode: 1,
-      };
-    }
-
-    return {
-      stdout: output,
-      stderr: "",
-      exitCode: 0,
-    };
-  });
-}
-
-/**
- * Create the `list` command (alias: `ls`) for showing installed packages
- */
-export function createListCommand(deps: CommandDeps) {
-  const { fs } = deps;
-
-  return defineCommand("list", async (_args, _ctx: CommandContext) => {
-    try {
-      const packages = await listPackages(fs);
-
-      if (packages.length === 0) {
-        return {
-          stdout: "No packages installed.\n",
-          stderr: "",
-          exitCode: 0,
-        };
-      }
-
-      const output = packages
-        .map((pkg) => `${pkg.name}@${pkg.version}`)
-        .join("\n") + "\n";
-
-      return {
-        stdout: output,
-        stderr: "",
-        exitCode: 0,
-      };
-    } catch (err) {
-      const message = err instanceof Error ? err.message : String(err);
-      return {
-        stdout: "",
-        stderr: `Failed to list packages: ${message}\n`,
-        exitCode: 1,
-      };
-    }
-  });
-}
-
-/**
- * Create the `run` command for executing code in the sandbox.
- *
- * The run command:
- * 1. Builds the entry point (with type checking by default)
- * 2. Dynamically imports the bundle
- * 3. If a `main` export exists, calls it with a RunContext
- * 4. Captures all console output (log, warn, error)
- * 5. Returns the captured output and any return value from main()
- *
- * Usage:
- *   run [entry] [--skip-typecheck|-s] [--timeout|-t <ms>] [-- args...]
- *
- * Code can be written in two styles:
- *
- * 1. Script style (top-level code, runs on import):
- *    ```ts
- *    console.log("Hello from script!");
- *    const result = 2 + 2;
- *    console.log("Result:", result);
- *    ```
- *
- * 2. Main function style (with context access):
- *    ```ts
- *    import type { RunContext } from "sandlot";
- *
- *    export async function main(ctx: RunContext) {
- *      ctx.log("Reading file...");
- *      const content = await ctx.fs.readFile("/data/input.txt");
- *      ctx.log("Content:", content);
- *      return { success: true };
- *    }
- *    ```
- */
-export function createRunCommand(deps: CommandDeps) {
-  const { fs, libFiles, tsconfigPath, runOptions = {}, sharedModules } = deps;
-
-  return defineCommand("run", async (args, _ctx: CommandContext) => {
-    // Parse arguments
-    let entryPoint: string | null = null;
-    let skipTypecheck = runOptions.skipTypecheck ?? false;
-    let timeout = runOptions.timeout ?? 30000;
-    const scriptArgs: string[] = [];
-    let collectingArgs = false;
-
-    for (let i = 0; i < args.length; i++) {
-      const arg = args[i];
-
-      if (collectingArgs) {
-        scriptArgs.push(arg!);
-        continue;
-      }
-
-      if (arg === "--") {
-        collectingArgs = true;
-      } else if (arg === "--skip-typecheck" || arg === "-s") {
-        skipTypecheck = true;
-      } else if ((arg === "--timeout" || arg === "-t") && args[i + 1]) {
-        timeout = parseInt(args[++i]!, 10);
-        if (isNaN(timeout)) timeout = 30000;
-      } else if (!arg!.startsWith("-")) {
-        entryPoint = arg!;
-      }
-    }
-
-    // Entry point is required
-    if (!entryPoint) {
-      return {
-        stdout: "",
-        stderr: `Usage: run <entry-point> [options] [-- args...]\n\nOptions:\n  --skip-typecheck, -s  Skip type checking\n  --timeout, -t <ms>    Execution timeout (default: 30000)\n\nExample: run /src/index.ts\n`,
-        exitCode: 1,
-      };
-    }
-
-    // Capture console output
-    const logs: string[] = [];
-    const originalConsole = {
-      log: console.log,
-      warn: console.warn,
-      error: console.error,
-      info: console.info,
-      debug: console.debug,
-    };
-
-    const formatArgs = (...a: unknown[]) =>
-      a.map((v) => (typeof v === "object" ? JSON.stringify(v) : String(v))).join(" ");
-
-    const captureLog = (...a: unknown[]) => {
-      logs.push(formatArgs(...a));
-      originalConsole.log.apply(console, a);
-    };
-    const captureWarn = (...a: unknown[]) => {
-      logs.push(`[warn] ${formatArgs(...a)}`);
-      originalConsole.warn.apply(console, a);
-    };
-    const captureError = (...a: unknown[]) => {
-      logs.push(`[error] ${formatArgs(...a)}`);
-      originalConsole.error.apply(console, a);
-    };
-    const captureInfo = (...a: unknown[]) => {
-      logs.push(`[info] ${formatArgs(...a)}`);
-      originalConsole.info.apply(console, a);
-    };
-    const captureDebug = (...a: unknown[]) => {
-      logs.push(`[debug] ${formatArgs(...a)}`);
-      originalConsole.debug.apply(console, a);
-    };
-
-    const restoreConsole = () => {
-      console.log = originalConsole.log;
-      console.warn = originalConsole.warn;
-      console.error = originalConsole.error;
-      console.info = originalConsole.info;
-      console.debug = originalConsole.debug;
-    };
-
-    try {
-      // Check if entry point exists
-      if (!(await fs.exists(entryPoint))) {
-        return {
-          stdout: "",
-          stderr: `Error: Entry point not found: ${entryPoint}\n`,
-          exitCode: 1,
-        };
-      }
-
-      // Type check (unless skipped)
-      if (!skipTypecheck) {
-        const typecheckResult = await typecheck({
-          fs,
-          entryPoint,
-          tsconfigPath,
-          libFiles,
-        });
-
-        if (typecheckResult.hasErrors) {
-          const formatted = formatDiagnosticsForAgent(typecheckResult.diagnostics);
-          return {
-            stdout: "",
-            stderr: `Type errors:\n${formatted}\n`,
-            exitCode: 1,
-          };
-        }
-      }
-
-      // Bundle the code
-      const bundleResult = await bundle({
-        fs,
-        entryPoint,
-        format: "esm",
-        sharedModules,
-      });
-
-      // Install console interceptors
-      console.log = captureLog;
-      console.warn = captureWarn;
-      console.error = captureError;
-      console.info = captureInfo;
-      console.debug = captureDebug;
-
-      // Create the run context
-      const context: RunContext = {
-        fs,
-        env: { ...runOptions.env },
-        args: scriptArgs,
-        log: captureLog,
-        error: captureError,
-      };
-
-      // Execute the code with optional timeout
-      const startTime = performance.now();
-      let returnValue: unknown;
-
-      const executeCode = async () => {
-        // Load the module (this executes top-level code)
-        const module = await loadModule<{ main?: (ctx: RunContext) => unknown }>(bundleResult);
-
-        // If there's a main export, call it with context
-        if (typeof module.main === "function") {
-          returnValue = await module.main(context);
-        }
-      };
-
-      if (timeout > 0) {
-        const timeoutPromise = new Promise<never>((_, reject) => {
-          setTimeout(() => reject(new Error(`Execution timed out after ${timeout}ms`)), timeout);
-        });
-        await Promise.race([executeCode(), timeoutPromise]);
-      } else {
-        await executeCode();
-      }
-
-      const executionTimeMs = performance.now() - startTime;
-
-      // Restore console before building output
-      restoreConsole();
-
-      // Build output
-      let output = "";
-      if (logs.length > 0) {
-        output = logs.join("\n") + "\n";
-      }
-      if (returnValue !== undefined) {
-        const returnStr =
-          typeof returnValue === "object"
-            ? JSON.stringify(returnValue, null, 2)
-            : String(returnValue);
-        output += `[return] ${returnStr}\n`;
-      }
-      output += `\nExecution completed in ${executionTimeMs.toFixed(2)}ms\n`;
-
-      return {
-        stdout: output,
-        stderr: "",
-        exitCode: 0,
-      };
-    } catch (err) {
-      restoreConsole();
-
-      const errorMessage = err instanceof Error ? err.message : String(err);
-      const errorStack = err instanceof Error && err.stack ? `\n${err.stack}` : "";
-
-      let output = "";
-      if (logs.length > 0) {
-        output = logs.join("\n") + "\n\n";
-      }
-
-      return {
-        stdout: output,
-        stderr: `Runtime error: ${errorMessage}${errorStack}\n`,
-        exitCode: 1,
-      };
-    }
-  });
-}
-
-/**
- * Create all default sandbox commands
- */
-export function createDefaultCommands(deps: CommandDeps) {
-  return [
-    createTscCommand(deps),
-    createBuildCommand(deps),
-    createRunCommand(deps),
-    createInstallCommand(deps),
-    createUninstallCommand(deps),
-    createListCommand(deps),
-  ];
-}