@scelar/nodepod 1.0.0

package/src/threading/worker-protocol.ts

@@ -0,0 +1,358 @@
+// Worker Protocol — typed messages for main<->worker communication.
+// Flows via postMessage. Binary data (VFS snapshots) transferred zero-copy.
+
+// --- VFS snapshot (binary transfer) ---
+
+export interface VFSBinarySnapshot {
+  manifest: VFSSnapshotEntry[];
+  data: ArrayBuffer;
+}
+
+export interface VFSSnapshotEntry {
+  path: string;
+  offset: number;
+  length: number;
+  isDirectory: boolean;
+}
+
+// --- Main -> Worker messages ---
+
+export interface MainToWorker_Init {
+  type: "init";
+  pid: number;
+  cwd: string;
+  env: Record<string, string>;
+  snapshot: VFSBinarySnapshot;
+  sharedBuffer?: SharedArrayBuffer;
+  syncBuffer?: SharedArrayBuffer;
+}
+
+export interface MainToWorker_Exec {
+  type: "exec";
+  filePath: string;
+  args: string[];
+  cwd?: string;
+  env?: Record<string, string>;
+  isShell?: boolean;
+  shellCommand?: string;
+  isFork?: boolean;
+  // If true, worker sends "shell-done" instead of "exit" and stays alive
+  persistent?: boolean;
+  isWorkerThread?: boolean;
+  workerData?: unknown;
+  threadId?: number;
+}
+
+export interface MainToWorker_Stdin {
+  type: "stdin";
+  data: string;
+}
+
+export interface MainToWorker_Signal {
+  type: "signal";
+  signal: string;
+}
+
+export interface MainToWorker_Resize {
+  type: "resize";
+  cols: number;
+  rows: number;
+}
+
+export interface MainToWorker_VFSSync {
+  type: "vfs-sync";
+  path: string;
+  content: ArrayBuffer | null; // null = deleted
+  isDirectory: boolean;
+}
+
+export interface MainToWorker_VFSChunk {
+  type: "vfs-chunk";
+  chunkIndex: number;
+  totalChunks: number;
+  data: ArrayBuffer;
+  manifest: VFSSnapshotEntry[];
+}
+
+export interface MainToWorker_SpawnResult {
+  type: "spawn-result";
+  requestId: number;
+  pid: number;
+  error?: string;
+}
+
+export interface MainToWorker_ChildOutput {
+  type: "child-output";
+  requestId: number;
+  stream: "stdout" | "stderr";
+  data: string;
+}
+
+export interface MainToWorker_ChildExit {
+  type: "child-exit";
+  requestId: number;
+  exitCode: number;
+  stdout: string;
+  stderr: string;
+}
+
+export interface MainToWorker_HttpRequest {
+  type: "http-request";
+  requestId: number;
+  port: number;
+  method: string;
+  path: string;
+  headers: Record<string, string>;
+  body: string | null;
+}
+
+export interface MainToWorker_IPC {
+  type: "ipc-message";
+  data: unknown;
+  // Routes to a specific fork callback when sent to a parent worker
+  targetRequestId?: number;
+}
+
+export interface MainToWorker_WsUpgrade {
+  type: "ws-upgrade";
+  uid: string;
+  port: number;
+  path: string;
+  headers: Record<string, string>;
+}
+
+export interface MainToWorker_WsData {
+  type: "ws-data";
+  uid: string;
+  frame: number[]; // encoded WS frame bytes (number[] for postMessage)
+}
+
+export interface MainToWorker_WsClose {
+  type: "ws-close";
+  uid: string;
+  code: number;
+}
+
+export type MainToWorkerMessage =
+  | MainToWorker_Init
+  | MainToWorker_Exec
+  | MainToWorker_Stdin
+  | MainToWorker_Signal
+  | MainToWorker_Resize
+  | MainToWorker_VFSSync
+  | MainToWorker_VFSChunk
+  | MainToWorker_SpawnResult
+  | MainToWorker_ChildOutput
+  | MainToWorker_ChildExit
+  | MainToWorker_HttpRequest
+  | MainToWorker_IPC
+  | MainToWorker_WsUpgrade
+  | MainToWorker_WsData
+  | MainToWorker_WsClose;
+
+// --- Worker -> Main messages ---
+
+export interface WorkerToMain_Ready {
+  type: "ready";
+  pid: number;
+}
+
+export interface WorkerToMain_Stdout {
+  type: "stdout";
+  data: string;
+}
+
+export interface WorkerToMain_Stderr {
+  type: "stderr";
+  data: string;
+}
+
+export interface WorkerToMain_Exit {
+  type: "exit";
+  exitCode: number;
+  stdout: string;
+  stderr: string;
+}
+
+export interface WorkerToMain_Console {
+  type: "console";
+  method: string;
+  args: string[];
+}
+
+export interface WorkerToMain_VFSWrite {
+  type: "vfs-write";
+  path: string;
+  content: ArrayBuffer;
+  isDirectory: boolean;
+}
+
+export interface WorkerToMain_VFSDelete {
+  type: "vfs-delete";
+  path: string;
+}
+
+export interface WorkerToMain_VFSRead {
+  type: "vfs-read";
+  requestId: number;
+  path: string;
+}
+
+export interface WorkerToMain_SpawnRequest {
+  type: "spawn-request";
+  requestId: number;
+  command: string;
+  args: string[];
+  cwd: string;
+  env: Record<string, string>;
+  stdio: "pipe" | "inherit";
+}
+
+export interface WorkerToMain_ForkRequest {
+  type: "fork-request";
+  requestId: number;
+  modulePath: string;
+  args: string[];
+  cwd: string;
+  env: Record<string, string>;
+}
+
+export interface WorkerToMain_WorkerThreadRequest {
+  type: "workerthread-request";
+  requestId: number;
+  modulePath: string; // absolute path, or inline code if isEval
+  isEval?: boolean;
+  args: string[];
+  cwd: string;
+  env: Record<string, string>;
+  workerData: unknown;
+  threadId: number;
+}
+
+export interface WorkerToMain_SpawnSync {
+  type: "spawn-sync";
+  requestId: number;
+  command: string;
+  args: string[];
+  cwd: string;
+  env: Record<string, string>;
+  syncSlot: number; // index in the sync SAB for Atomics.wait/notify
+  shellCommand?: string;
+}
+
+export interface WorkerToMain_ServerListen {
+  type: "server-listen";
+  port: number;
+  hostname: string;
+}
+
+export interface WorkerToMain_ServerClose {
+  type: "server-close";
+  port: number;
+}
+
+export interface WorkerToMain_HttpRequest {
+  type: "http-request";
+  requestId: number;
+  port: number;
+  method: string;
+  path: string;
+  headers: Record<string, string>;
+  body: string | null;
+}
+
+export interface WorkerToMain_CwdChange {
+  type: "cwd-change";
+  cwd: string;
+}
+
+export interface WorkerToMain_StdinRawStatus {
+  type: "stdin-raw-status";
+  isRaw: boolean;
+}
+
+export interface WorkerToMain_HttpResponse {
+  type: "http-response";
+  requestId: number;
+  statusCode: number;
+  statusMessage: string;
+  headers: Record<string, string>;
+  body: string;
+}
+
+export interface WorkerToMain_IPC {
+  type: "ipc-message";
+  data: unknown;
+  targetRequestId?: number;
+}
+
+export interface WorkerToMain_ShellDone {
+  type: "shell-done";
+  exitCode: number;
+  stdout: string;
+  stderr: string;
+}
+
+export interface WorkerToMain_Error {
+  type: "error";
+  message: string;
+  stack?: string;
+}
+
+export interface WorkerToMain_WsFrame {
+  type: "ws-frame";
+  uid: string;
+  kind: string; // "open" | "text" | "binary" | "close" | "error"
+  data?: string;
+  bytes?: number[];
+  code?: number;
+  message?: string;
+}
+
+export type WorkerToMainMessage =
+  | WorkerToMain_Ready
+  | WorkerToMain_Stdout
+  | WorkerToMain_Stderr
+  | WorkerToMain_Exit
+  | WorkerToMain_Console
+  | WorkerToMain_VFSWrite
+  | WorkerToMain_VFSDelete
+  | WorkerToMain_VFSRead
+  | WorkerToMain_SpawnRequest
+  | WorkerToMain_ForkRequest
+  | WorkerToMain_WorkerThreadRequest
+  | WorkerToMain_SpawnSync
+  | WorkerToMain_ServerListen
+  | WorkerToMain_ServerClose
+  | WorkerToMain_HttpRequest
+  | WorkerToMain_CwdChange
+  | WorkerToMain_StdinRawStatus
+  | WorkerToMain_HttpResponse
+  | WorkerToMain_IPC
+  | WorkerToMain_ShellDone
+  | WorkerToMain_Error
+  | WorkerToMain_WsFrame;
+
+// --- Spawn config ---
+
+export interface SpawnConfig {
+  command: string;
+  args: string[];
+  cwd: string;
+  env: Record<string, string>;
+  snapshot: VFSBinarySnapshot;
+  sharedBuffer?: SharedArrayBuffer;
+  syncBuffer?: SharedArrayBuffer;
+  parentPid?: number;
+}
+
+// --- Process info ---
+
+export interface ProcessInfo {
+  pid: number;
+  command: string;
+  args: string[];
+  state: "starting" | "running" | "exited";
+  exitCode?: number;
+  parentPid?: number;
+}

package/src/threading/worker-vfs.ts

@@ -0,0 +1,218 @@
+// WorkerVFS — worker-side filesystem proxy.
+// Reads are instant (local Map). Writes go to both local store + main thread.
+
+import type { VFSBinarySnapshot, VFSSnapshotEntry } from "./worker-protocol";
+
+export class WorkerVFS {
+  private _files = new Map<string, Uint8Array>();
+  private _dirs = new Set<string>();
+  private _onWrite: ((path: string, content: Uint8Array, isDir: boolean) => void) | null = null;
+  private _onDelete: ((path: string) => void) | null = null;
+  private _decoder = new TextDecoder();
+  private _encoder = new TextEncoder();
+
+  constructor() {
+    this._dirs.add("/");
+  }
+
+  initFromSnapshot(snapshot: VFSBinarySnapshot): void {
+    const data = new Uint8Array(snapshot.data);
+
+    for (const entry of snapshot.manifest) {
+      if (entry.isDirectory) {
+        this._dirs.add(entry.path);
+      } else {
+        this._files.set(entry.path, data.slice(entry.offset, entry.offset + entry.length));
+        this._ensureParentDirs(entry.path);
+      }
+    }
+  }
+
+  setWriteCallback(cb: (path: string, content: Uint8Array, isDir: boolean) => void): void {
+    this._onWrite = cb;
+  }
+
+  setDeleteCallback(cb: (path: string) => void): void {
+    this._onDelete = cb;
+  }
+
+  readFileSync(path: string, encoding?: string): string | Uint8Array {
+    const data = this._files.get(path);
+    if (!data) {
+      const err = new Error(`ENOENT: no such file or directory, open '${path}'`) as Error & { code: string; errno: number };
+      err.code = "ENOENT";
+      err.errno = -2;
+      throw err;
+    }
+    if (encoding === "utf8" || encoding === "utf-8") {
+      return this._decoder.decode(data);
+    }
+    return new Uint8Array(data);
+  }
+
+  existsSync(path: string): boolean {
+    return this._files.has(path) || this._dirs.has(path);
+  }
+
+  statSync(path: string): { isFile: () => boolean; isDirectory: () => boolean; size: number } {
+    if (this._dirs.has(path)) {
+      return {
+        isFile: () => false,
+        isDirectory: () => true,
+        size: 0,
+      };
+    }
+    const data = this._files.get(path);
+    if (data) {
+      return {
+        isFile: () => true,
+        isDirectory: () => false,
+        size: data.byteLength,
+      };
+    }
+    const err = new Error(`ENOENT: no such file or directory, stat '${path}'`) as Error & { code: string; errno: number };
+    err.code = "ENOENT";
+    err.errno = -2;
+    throw err;
+  }
+
+  readdirSync(path: string): string[] {
+    if (!this._dirs.has(path)) {
+      const err = new Error(`ENOENT: no such file or directory, scandir '${path}'`) as Error & { code: string; errno: number };
+      err.code = "ENOENT";
+      err.errno = -2;
+      throw err;
+    }
+
+    const prefix = path === "/" ? "/" : path + "/";
+    const entries = new Set<string>();
+
+    for (const filePath of this._files.keys()) {
+      if (filePath.startsWith(prefix)) {
+        const rest = filePath.slice(prefix.length);
+        const slashIdx = rest.indexOf("/");
+        entries.add(slashIdx === -1 ? rest : rest.slice(0, slashIdx));
+      }
+    }
+
+    for (const dirPath of this._dirs) {
+      if (dirPath.startsWith(prefix) && dirPath !== path) {
+        const rest = dirPath.slice(prefix.length);
+        const slashIdx = rest.indexOf("/");
+        entries.add(slashIdx === -1 ? rest : rest.slice(0, slashIdx));
+      }
+    }
+
+    return Array.from(entries).filter(Boolean).sort();
+  }
+
+  writeFileSync(path: string, content: string | Uint8Array): void {
+    const bytes = typeof content === "string" ? this._encoder.encode(content) : new Uint8Array(content);
+    this._files.set(path, bytes);
+    this._ensureParentDirs(path);
+    if (this._onWrite) this._onWrite(path, bytes, false);
+  }
+
+  mkdirSync(path: string, opts?: { recursive?: boolean }): void {
+    if (this._dirs.has(path)) return;
+    if (opts?.recursive) {
+      const parts = path.split("/").filter(Boolean);
+      let current = "";
+      for (const part of parts) {
+        current += "/" + part;
+        if (!this._dirs.has(current)) {
+          this._dirs.add(current);
+          if (this._onWrite) this._onWrite(current, new Uint8Array(0), true);
+        }
+      }
+    } else {
+      this._dirs.add(path);
+      if (this._onWrite) this._onWrite(path, new Uint8Array(0), true);
+    }
+  }
+
+  unlinkSync(path: string): void {
+    if (!this._files.has(path)) {
+      const err = new Error(`ENOENT: no such file or directory, unlink '${path}'`) as Error & { code: string; errno: number };
+      err.code = "ENOENT";
+      err.errno = -2;
+      throw err;
+    }
+    this._files.delete(path);
+    if (this._onDelete) this._onDelete(path);
+  }
+
+  rmdirSync(path: string): void {
+    this._dirs.delete(path);
+    if (this._onDelete) this._onDelete(path);
+  }
+
+  renameSync(src: string, dest: string): void {
+    const data = this._files.get(src);
+    if (data) {
+      this._files.delete(src);
+      this._files.set(dest, data);
+      if (this._onDelete) this._onDelete(src);
+      if (this._onWrite) this._onWrite(dest, data, false);
+    } else if (this._dirs.has(src)) {
+      this._dirs.delete(src);
+      this._dirs.add(dest);
+      if (this._onDelete) this._onDelete(src);
+      if (this._onWrite) this._onWrite(dest, new Uint8Array(0), true);
+    }
+  }
+
+  appendFileSync(path: string, content: string | Uint8Array): void {
+    const existing = this._files.get(path) ?? new Uint8Array(0);
+    const bytes = typeof content === "string" ? this._encoder.encode(content) : new Uint8Array(content);
+    const merged = new Uint8Array(existing.byteLength + bytes.byteLength);
+    merged.set(existing, 0);
+    merged.set(bytes, existing.byteLength);
+    this._files.set(path, merged);
+    this._ensureParentDirs(path);
+    if (this._onWrite) this._onWrite(path, merged, false);
+  }
+
+  copyFileSync(src: string, dest: string): void {
+    const data = this._files.get(src);
+    if (!data) {
+      const err = new Error(`ENOENT: no such file or directory, copyfile '${src}'`) as Error & { code: string; errno: number };
+      err.code = "ENOENT";
+      err.errno = -2;
+      throw err;
+    }
+    const copy = new Uint8Array(data);
+    this._files.set(dest, copy);
+    this._ensureParentDirs(dest);
+    if (this._onWrite) this._onWrite(dest, copy, false);
+  }
+
+  applySync(path: string, content: ArrayBuffer | null, isDirectory: boolean): void {
+    if (content === null) {
+      this._files.delete(path);
+      this._dirs.delete(path);
+    } else if (isDirectory) {
+      this._dirs.add(path);
+    } else {
+      this._files.set(path, new Uint8Array(content));
+      this._ensureParentDirs(path);
+    }
+  }
+
+  private _ensureParentDirs(path: string): void {
+    const parts = path.split("/").filter(Boolean);
+    let current = "";
+    for (let i = 0; i < parts.length - 1; i++) {
+      current += "/" + parts[i];
+      this._dirs.add(current);
+    }
+  }
+
+  get fileCount(): number {
+    return this._files.size;
+  }
+
+  get dirCount(): number {
+    return this._dirs.size;
+  }
+}

package/src/types/externals.d.ts

@@ -0,0 +1,38 @@
+interface EsbuildTransformConfig {
+  loader?: string;
+  jsx?: string;
+  jsxFactory?: string;
+  jsxFragment?: string;
+  jsxImportSource?: string;
+  sourcemap?: boolean | 'inline' | 'external' | 'both';
+  sourcefile?: string;
+  target?: string | string[];
+  format?: 'iife' | 'cjs' | 'esm';
+  minify?: boolean;
+  tsconfigRaw?: string | object;
+  platform?: 'browser' | 'node' | 'neutral';
+  define?: Record<string, string>;
+}
+
+interface EsbuildTransformOutput {
+  code: string;
+  map: string;
+  warnings: unknown[];
+}
+
+declare module 'esbuild-wasm' {
+  export function initialize(options?: { wasmURL?: string; worker?: boolean }): Promise<void>;
+  export function transform(input: string, options?: EsbuildTransformConfig): Promise<EsbuildTransformOutput>;
+  export function build(options: unknown): Promise<unknown>;
+  export function formatMessages(messages: unknown[], options: unknown): Promise<string[]>;
+  export const version: string;
+}
+
+interface Window {
+  __esbuildEngine?: typeof import('esbuild-wasm');
+  __esbuildReady?: Promise<void>;
+}
+
+declare module 'virtual:process-worker-bundle' {
+  export const PROCESS_WORKER_BUNDLE: string;
+}