almostnode 0.1.0

package/src/shims/child_process.ts

@@ -0,0 +1,463 @@
+/**
+ * Node.js child_process module shim
+ * Uses just-bash for command execution in browser with VirtualFS adapter
+ */
+
+// Polyfill process for just-bash (it expects Node.js environment)
+if (typeof globalThis.process === 'undefined') {
+  (globalThis as any).process = {
+    env: {
+      HOME: '/home/user',
+      USER: 'user',
+      PATH: '/usr/local/bin:/usr/bin:/bin',
+      NODE_ENV: 'development',
+    },
+    cwd: () => '/',
+    platform: 'linux',
+    version: 'v18.0.0',
+    versions: { node: '18.0.0' },
+    stdout: { write: () => {} },
+    stderr: { write: () => {} },
+  };
+}
+
+import { Bash, defineCommand } from 'just-bash';
+import { EventEmitter } from './events';
+import { Readable, Writable, Buffer } from './stream';
+import type { VirtualFS } from '../virtual-fs';
+import { VirtualFSAdapter } from './vfs-adapter';
+import { Runtime } from '../runtime';
+
+// Singleton bash instance - uses VFS adapter for two-way file sync
+let bashInstance: Bash | null = null;
+let vfsAdapter: VirtualFSAdapter | null = null;
+let currentVfs: VirtualFS | null = null;
+
+/**
+ * Initialize the child_process shim with a VirtualFS instance
+ * Creates a single Bash instance with VirtualFSAdapter for efficient file access
+ */
+export function initChildProcess(vfs: VirtualFS): void {
+  currentVfs = vfs;
+  vfsAdapter = new VirtualFSAdapter(vfs);
+
+  // Create custom 'node' command that runs JS files using the Runtime
+  const nodeCommand = defineCommand('node', async (args, ctx) => {
+    if (!currentVfs) {
+      return { stdout: '', stderr: 'VFS not initialized\n', exitCode: 1 };
+    }
+
+    const scriptPath = args[0];
+    if (!scriptPath) {
+      return { stdout: '', stderr: 'Usage: node <script.js> [args...]\n', exitCode: 1 };
+    }
+
+    // Resolve the script path
+    const resolvedPath = scriptPath.startsWith('/')
+      ? scriptPath
+      : `${ctx.cwd}/${scriptPath}`.replace(/\/+/g, '/');
+
+    try {
+      // Check if file exists
+      if (!currentVfs.existsSync(resolvedPath)) {
+        return { stdout: '', stderr: `Error: Cannot find module '${resolvedPath}'\n`, exitCode: 1 };
+      }
+
+      let stdout = '';
+      let stderr = '';
+
+      // Create a runtime with the current environment
+      const runtime = new Runtime(currentVfs, {
+        cwd: ctx.cwd,
+        env: ctx.env,
+        onConsole: (method, consoleArgs) => {
+          const msg = consoleArgs.map(a => String(a)).join(' ') + '\n';
+          if (method === 'error') {
+            stderr += msg;
+          } else {
+            stdout += msg;
+          }
+        },
+      });
+
+      // Set up process.argv for the script
+      const processShim = (globalThis as any).process || {};
+      const originalArgv = processShim.argv;
+      processShim.argv = ['node', resolvedPath, ...args.slice(1)];
+      (globalThis as any).process = processShim;
+
+      try {
+        // Run the script
+        runtime.runFile(resolvedPath);
+        return { stdout, stderr, exitCode: 0 };
+      } finally {
+        // Restore original argv
+        processShim.argv = originalArgv;
+      }
+    } catch (error) {
+      const errorMsg = error instanceof Error ? error.message : String(error);
+      return { stdout: '', stderr: `Error: ${errorMsg}\n`, exitCode: 1 };
+    }
+  });
+
+  // Create custom 'convex' command that runs the Convex CLI
+  const convexCommand = defineCommand('convex', async (args, ctx) => {
+    if (!currentVfs) {
+      return { stdout: '', stderr: 'VFS not initialized\n', exitCode: 1 };
+    }
+
+    // Find the Convex CLI bundle
+    const cliBundlePath = '/node_modules/convex/dist/cli.bundle.cjs';
+    if (!currentVfs.existsSync(cliBundlePath)) {
+      return { stdout: '', stderr: 'Convex CLI not found. Run: npm install convex\n', exitCode: 1 };
+    }
+
+    let stdout = '';
+    let stderr = '';
+
+    try {
+      // Create a runtime with the current environment
+      const runtime = new Runtime(currentVfs, {
+        cwd: ctx.cwd,
+        env: ctx.env,
+        onConsole: (method, consoleArgs) => {
+          const msg = consoleArgs.map(a => String(a)).join(' ') + '\n';
+          if (method === 'error') {
+            stderr += msg;
+          } else {
+            stdout += msg;
+          }
+        },
+      });
+
+      // Set up process.argv for the CLI
+      const processShim = (globalThis as any).process || {};
+      const originalArgv = processShim.argv;
+      const originalEnv = { ...processShim.env };
+
+      processShim.argv = ['node', 'convex', ...args];
+      processShim.env = { ...processShim.env, ...ctx.env };
+      (globalThis as any).process = processShim;
+
+      try {
+        // Run the CLI bundle
+        runtime.runFile(cliBundlePath);
+        return { stdout, stderr, exitCode: 0 };
+      } finally {
+        // Restore original state
+        processShim.argv = originalArgv;
+        processShim.env = originalEnv;
+      }
+    } catch (error) {
+      const errorMsg = error instanceof Error ? error.message : String(error);
+      return { stdout, stderr: stderr + `Error: ${errorMsg}\n`, exitCode: 1 };
+    }
+  });
+
+  bashInstance = new Bash({
+    fs: vfsAdapter,
+    cwd: '/',
+    env: {
+      HOME: '/home/user',
+      USER: 'user',
+      PATH: '/usr/local/bin:/usr/bin:/bin:/node_modules/.bin',
+      NODE_ENV: 'development',
+    },
+    customCommands: [nodeCommand, convexCommand],
+  });
+}
+
+export interface ExecOptions {
+  cwd?: string;
+  env?: Record<string, string>;
+  encoding?: BufferEncoding | 'buffer';
+  timeout?: number;
+  maxBuffer?: number;
+  shell?: string | boolean;
+}
+
+export interface ExecResult {
+  stdout: string | Buffer;
+  stderr: string | Buffer;
+}
+
+export type ExecCallback = (
+  error: Error | null,
+  stdout: string | Buffer,
+  stderr: string | Buffer
+) => void;
+
+/**
+ * Execute a command in a shell
+ */
+export function exec(
+  command: string,
+  optionsOrCallback?: ExecOptions | ExecCallback,
+  callback?: ExecCallback
+): ChildProcess {
+  let options: ExecOptions = {};
+  let cb: ExecCallback | undefined;
+
+  if (typeof optionsOrCallback === 'function') {
+    cb = optionsOrCallback;
+  } else if (optionsOrCallback) {
+    options = optionsOrCallback;
+    cb = callback;
+  }
+
+  const child = new ChildProcess();
+
+  // Execute asynchronously
+  (async () => {
+    if (!bashInstance) {
+      const error = new Error('child_process not initialized');
+      child.emit('error', error);
+      if (cb) cb(error, '', '');
+      return;
+    }
+
+    try {
+      const result = await bashInstance!.exec(command, {
+        cwd: options.cwd,
+        env: options.env,
+      });
+
+      const stdout = result.stdout || '';
+      const stderr = result.stderr || '';
+
+      // Emit data events
+      if (stdout) {
+        child.stdout?.push(Buffer.from(stdout));
+      }
+      child.stdout?.push(null);
+
+      if (stderr) {
+        child.stderr?.push(Buffer.from(stderr));
+      }
+      child.stderr?.push(null);
+
+      // Emit close/exit
+      child.emit('close', result.exitCode, null);
+      child.emit('exit', result.exitCode, null);
+
+      if (cb) {
+        if (result.exitCode !== 0) {
+          const error = new Error(`Command failed: ${command}`);
+          (error as any).code = result.exitCode;
+          cb(error, stdout, stderr);
+        } else {
+          cb(null, stdout, stderr);
+        }
+      }
+    } catch (error) {
+      child.emit('error', error);
+      if (cb) cb(error as Error, '', '');
+    }
+  })();
+
+  return child;
+}
+
+/**
+ * Execute a command synchronously
+ */
+export function execSync(
+  command: string,
+  options?: ExecOptions
+): string | Buffer {
+  if (!bashInstance) {
+    throw new Error('child_process not initialized');
+  }
+
+  // Note: just-bash exec is async, so we can't truly do sync execution
+  // This is a limitation of the browser environment
+  // For now, throw an error suggesting to use exec() instead
+  throw new Error(
+    'execSync is not supported in browser environment. Use exec() with async/await or callbacks instead.'
+  );
+}
+
+export interface SpawnOptions {
+  cwd?: string;
+  env?: Record<string, string>;
+  shell?: boolean | string;
+  stdio?: 'pipe' | 'inherit' | 'ignore' | Array<'pipe' | 'inherit' | 'ignore'>;
+}
+
+/**
+ * Spawn a new process
+ */
+export function spawn(
+  command: string,
+  args?: string[] | SpawnOptions,
+  options?: SpawnOptions
+): ChildProcess {
+  let spawnArgs: string[] = [];
+  let spawnOptions: SpawnOptions = {};
+
+  if (Array.isArray(args)) {
+    spawnArgs = args;
+    spawnOptions = options || {};
+  } else if (args) {
+    spawnOptions = args;
+  }
+
+  const child = new ChildProcess();
+
+  // Build the full command
+  const fullCommand = spawnArgs.length > 0
+    ? `${command} ${spawnArgs.map(arg =>
+        arg.includes(' ') ? `"${arg}"` : arg
+      ).join(' ')}`
+    : command;
+
+  // Execute asynchronously
+  (async () => {
+    if (!bashInstance) {
+      const error = new Error('child_process not initialized');
+      child.emit('error', error);
+      return;
+    }
+
+    try {
+      const result = await bashInstance!.exec(fullCommand, {
+        cwd: spawnOptions.cwd,
+        env: spawnOptions.env,
+      });
+
+      const stdout = result.stdout || '';
+      const stderr = result.stderr || '';
+
+      // Emit data events
+      if (stdout) {
+        child.stdout?.push(Buffer.from(stdout));
+      }
+      child.stdout?.push(null);
+
+      if (stderr) {
+        child.stderr?.push(Buffer.from(stderr));
+      }
+      child.stderr?.push(null);
+
+      // Emit close/exit
+      child.emit('close', result.exitCode, null);
+      child.emit('exit', result.exitCode, null);
+    } catch (error) {
+      child.emit('error', error);
+    }
+  })();
+
+  return child;
+}
+
+/**
+ * Spawn a new process synchronously
+ */
+export function spawnSync(
+  command: string,
+  args?: string[],
+  options?: SpawnOptions
+): { stdout: Buffer; stderr: Buffer; status: number; error?: Error } {
+  throw new Error(
+    'spawnSync is not supported in browser environment. Use spawn() instead.'
+  );
+}
+
+/**
+ * Execute a file
+ */
+export function execFile(
+  file: string,
+  args?: string[] | ExecOptions | ExecCallback,
+  options?: ExecOptions | ExecCallback,
+  callback?: ExecCallback
+): ChildProcess {
+  let execArgs: string[] = [];
+  let execOptions: ExecOptions = {};
+  let cb: ExecCallback | undefined;
+
+  if (Array.isArray(args)) {
+    execArgs = args;
+    if (typeof options === 'function') {
+      cb = options;
+    } else if (options) {
+      execOptions = options;
+      cb = callback;
+    }
+  } else if (typeof args === 'function') {
+    cb = args;
+  } else if (args) {
+    execOptions = args;
+    cb = options as ExecCallback;
+  }
+
+  const command = execArgs.length > 0 ? `${file} ${execArgs.join(' ')}` : file;
+  return exec(command, execOptions, cb);
+}
+
+/**
+ * Fork is not supported in browser
+ */
+export function fork(): never {
+  throw new Error('fork is not supported in browser environment');
+}
+
+/**
+ * ChildProcess class
+ */
+export class ChildProcess extends EventEmitter {
+  pid: number;
+  connected: boolean = false;
+  killed: boolean = false;
+  exitCode: number | null = null;
+  signalCode: string | null = null;
+  spawnargs: string[] = [];
+  spawnfile: string = '';
+
+  stdin: Writable | null;
+  stdout: Readable | null;
+  stderr: Readable | null;
+
+  constructor() {
+    super();
+    this.pid = Math.floor(Math.random() * 10000) + 1000;
+    this.stdin = new Writable();
+    this.stdout = new Readable();
+    this.stderr = new Readable();
+  }
+
+  kill(signal?: string): boolean {
+    this.killed = true;
+    this.emit('exit', null, signal || 'SIGTERM');
+    return true;
+  }
+
+  disconnect(): void {
+    this.connected = false;
+  }
+
+  send(message: unknown, callback?: (error: Error | null) => void): boolean {
+    // IPC not supported
+    if (callback) callback(new Error('IPC not supported'));
+    return false;
+  }
+
+  ref(): this {
+    return this;
+  }
+
+  unref(): this {
+    return this;
+  }
+}
+
+export default {
+  exec,
+  execSync,
+  execFile,
+  spawn,
+  spawnSync,
+  fork,
+  ChildProcess,
+  initChildProcess,
+};