@scelar/nodepod 1.0.0

package/src/sdk/nodepod-fs.ts

@@ -0,0 +1,93 @@
+// Async facade over MemoryVolume. Returns Promises even though the
+// underlying VFS is synchronous -- keeps the public API consistent.
+
+import type { MemoryVolume } from "../memory-volume";
+import type { StatResult } from "./types";
+
+export class NodepodFS {
+  constructor(private _vol: MemoryVolume) {}
+
+  // Auto-creates parent dirs on write
+  async writeFile(path: string, data: string | Uint8Array): Promise<void> {
+    const dir = path.substring(0, path.lastIndexOf("/")) || "/";
+    if (dir !== "/" && !this._vol.existsSync(dir)) {
+      this._vol.mkdirSync(dir, { recursive: true });
+    }
+    this._vol.writeFileSync(path, data as any);
+  }
+
+  async readFile(path: string, encoding?: "utf-8" | "utf8"): Promise<string>;
+  async readFile(path: string): Promise<Uint8Array>;
+  async readFile(
+    path: string,
+    encoding?: string,
+  ): Promise<string | Uint8Array> {
+    if (encoding) return this._vol.readFileSync(path, "utf8") as string;
+    return this._vol.readFileSync(path) as any;
+  }
+
+  async mkdir(path: string, opts?: { recursive?: boolean }): Promise<void> {
+    this._vol.mkdirSync(path, opts);
+  }
+
+  async readdir(path: string): Promise<string[]> {
+    return this._vol.readdirSync(path) as string[];
+  }
+
+  async exists(path: string): Promise<boolean> {
+    return this._vol.existsSync(path);
+  }
+
+  async stat(path: string): Promise<StatResult> {
+    const s = this._vol.statSync(path);
+    return {
+      isFile: s.isFile(),
+      isDirectory: s.isDirectory(),
+      size: s.size,
+      mtime: s.mtimeMs ?? Date.now(),
+    };
+  }
+
+  async unlink(path: string): Promise<void> {
+    this._vol.unlinkSync(path);
+  }
+
+  async rmdir(path: string, opts?: { recursive?: boolean }): Promise<void> {
+    if (opts?.recursive) {
+      this._removeRecursive(path);
+    } else {
+      this._vol.rmdirSync(path);
+    }
+  }
+
+  async rename(from: string, to: string): Promise<void> {
+    this._vol.renameSync(from, to);
+  }
+
+  watch(
+    path: string,
+    optionsOrCb?:
+      | { recursive?: boolean }
+      | ((event: string, filename: string | null) => void),
+    cb?: (event: string, filename: string | null) => void,
+  ): { close(): void } {
+    if (typeof optionsOrCb === "function") {
+      return this._vol.watch(path, optionsOrCb);
+    }
+    return this._vol.watch(path, optionsOrCb ?? {}, cb!);
+  }
+
+  get volume(): MemoryVolume {
+    return this._vol;
+  }
+
+  private _removeRecursive(dir: string): void {
+    for (const name of this._vol.readdirSync(dir) as string[]) {
+      const full = `${dir}/${name}`;
+      const st = this._vol.statSync(full);
+      if (st.isDirectory()) this._removeRecursive(full);
+      else this._vol.unlinkSync(full);
+    }
+    this._vol.rmdirSync(dir);
+  }
+}

package/src/sdk/nodepod-process.ts

@@ -0,0 +1,86 @@
+// Process handle returned by nodepod.spawn().
+// Emits 'output', 'error', 'exit'. Has write() for stdin and kill() to abort.
+
+import { EventEmitter } from "../polyfills/events";
+
+export class NodepodProcess extends EventEmitter {
+  private _abortController = new AbortController();
+  private _resolve!: (r: {
+    stdout: string;
+    stderr: string;
+    exitCode: number;
+  }) => void;
+  private _stdout = "";
+  private _stderr = "";
+  private _exitCode: number | null = null;
+  private _sendStdinFn: ((data: string) => void) | null = null;
+  private _killFn: (() => void) | null = null;
+
+  // Resolves when the process exits -- use `await proc.completion`
+  readonly completion: Promise<{
+    stdout: string;
+    stderr: string;
+    exitCode: number;
+  }>;
+
+  constructor() {
+    super();
+    this.completion = new Promise((resolve) => {
+      this._resolve = resolve;
+    });
+  }
+
+  _setSendStdin(fn: (data: string) => void): void {
+    this._sendStdinFn = fn;
+  }
+
+  _setKillFn(fn: () => void): void {
+    this._killFn = fn;
+  }
+
+  _pushStdout(chunk: string): void {
+    this._stdout += chunk;
+    this.emit("output", chunk);
+  }
+
+  _pushStderr(chunk: string): void {
+    this._stderr += chunk;
+    this.emit("error", chunk);
+  }
+
+  // Idempotent -- safe to call twice
+  _finish(exitCode: number): void {
+    if (this._exitCode !== null) return;
+    this._exitCode = exitCode;
+    this.emit("exit", exitCode);
+    this._resolve({
+      stdout: this._stdout,
+      stderr: this._stderr,
+      exitCode,
+    });
+  }
+
+  get signal(): AbortSignal {
+    return this._abortController.signal;
+  }
+
+  get exited(): boolean {
+    return this._exitCode !== null;
+  }
+
+  write(data: string): void {
+    if (this._sendStdinFn) this._sendStdinFn(data);
+  }
+
+  kill(): void {
+    this._abortController.abort();
+    if (this._killFn) this._killFn();
+  }
+
+  on(event: "output", handler: (chunk: string) => void): this;
+  on(event: "error", handler: (chunk: string) => void): this;
+  on(event: "exit", handler: (code: number) => void): this;
+  on(event: string, handler: (...args: any[]) => void): this {
+    return super.on(event, handler) as this;
+  }
+}

package/src/sdk/nodepod-terminal.ts

@@ -0,0 +1,350 @@
+// Interactive terminal with line editing, history, raw/cooked mode, etc.
+// xterm.js is a peer dep -- passed in via TerminalOptions, not imported here.
+
+import type { TerminalOptions, TerminalTheme } from "./types";
+import { DEFAULT_TERMINAL } from "../constants/config";
+
+// GitHub Dark theme
+const DEFAULT_THEME: TerminalTheme = {
+  background: "#0d1117",
+  foreground: "#c9d1d9",
+  cursor: "#58a6ff",
+  selectionBackground: "#264f78",
+  black: "#0d1117",
+  red: "#f85149",
+  green: "#3fb950",
+  yellow: "#d29922",
+  blue: "#58a6ff",
+  magenta: "#bc8cff",
+  cyan: "#39c5cf",
+  white: "#c9d1d9",
+  brightBlack: "#8b949e",
+  brightRed: "#f85149",
+  brightGreen: "#3fb950",
+  brightYellow: "#d29922",
+  brightBlue: "#58a6ff",
+  brightMagenta: "#bc8cff",
+  brightCyan: "#39c5cf",
+  brightWhite: "#ffffff",
+};
+
+const DEFAULT_PROMPT = (cwd: string) =>
+  `\x1b[36mnodepod\x1b[0m:\x1b[34m${cwd}\x1b[0m$ `;
+
+// Wired by Nodepod.createTerminal()
+export interface TerminalWiring {
+  onCommand: (cmd: string) => Promise<void>;
+  getSendStdin: () => ((data: string) => void) | null;
+  getIsStdinRaw: () => boolean;
+  getActiveAbort: () => AbortController | null;
+  setActiveAbort: (ac: AbortController | null) => void;
+}
+
+export class NodepodTerminal {
+  private _term: any = null;
+  private _fitAddon: any = null;
+  private _dataDisposable: any = null;
+  private _resizeHandler: (() => void) | null = null;
+
+  private _lineBuffer = "";
+  private _history: string[] = [];
+  private _historyIndex = -1;
+  private _savedLine = "";
+  private _running = false;
+  private _cwd = "/";
+
+  private _promptFn: (cwd: string) => string;
+  private _theme: TerminalTheme;
+  private _opts: TerminalOptions;
+  private _wiring: TerminalWiring | null = null;
+
+  constructor(opts: TerminalOptions) {
+    this._opts = opts;
+    this._theme = opts.theme ?? DEFAULT_THEME;
+    this._promptFn = opts.prompt ?? DEFAULT_PROMPT;
+  }
+
+  /* ---- Internal wiring ---- */
+
+  _wireExecution(wiring: TerminalWiring): void {
+    this._wiring = wiring;
+  }
+
+  _setRunning(running: boolean): void {
+    this._running = running;
+  }
+
+  _writePrompt(): void {
+    this._term?.write(this._promptFn(this._cwd));
+  }
+
+  _getCols(): number {
+    return this._term?.cols ?? 80;
+  }
+
+  _getRows(): number {
+    return this._term?.rows ?? 24;
+  }
+
+  _writeOutput(text: string, isError = false): void {
+    if (!this._term) return;
+    const escaped = text.replace(/\r?\n/g, "\r\n");
+    if (isError) {
+      this._term.write("\x1b[31m" + escaped + "\x1b[0m");
+    } else {
+      this._term.write(escaped);
+    }
+  }
+
+  /* ---- Public API ---- */
+
+  attach(target: HTMLElement | string): void {
+    const container =
+      typeof target === "string"
+        ? (document.querySelector(target) as HTMLElement)
+        : target;
+    if (!container) throw new Error(`Terminal target not found: ${target}`);
+
+    const TermCtor = this._opts.Terminal;
+
+    this._term = new TermCtor({
+      cursorBlink: true,
+      fontSize: this._opts.fontSize ?? DEFAULT_TERMINAL.FONT_SIZE,
+      fontFamily:
+        this._opts.fontFamily ??
+        '"Cascadia Code", "Fira Code", "Consolas", "Monaco", monospace',
+      theme: this._theme,
+    });
+
+    if (this._opts.FitAddon) {
+      this._fitAddon = new this._opts.FitAddon();
+      this._term.loadAddon(this._fitAddon);
+    }
+
+    this._term.open(container);
+
+    if (this._opts.WebglAddon) {
+      try {
+        this._term.loadAddon(new this._opts.WebglAddon());
+      } catch {
+        // canvas fallback is fine
+      }
+    }
+
+    if (this._fitAddon) {
+      // Defer fit() so the container has final layout dimensions,
+      // otherwise interactive CLIs get wrong cols/rows
+      const addon = this._fitAddon;
+      requestAnimationFrame(() => {
+        addon.fit();
+        setTimeout(() => addon.fit(), 100);
+      });
+      this._resizeHandler = () => this._fitAddon?.fit();
+      window.addEventListener("resize", this._resizeHandler);
+    }
+
+    this._dataDisposable = this._term.onData((data: string) =>
+      this._handleInput(data),
+    );
+
+    this._term.focus();
+  }
+
+  detach(): void {
+    if (this._dataDisposable) {
+      this._dataDisposable.dispose();
+      this._dataDisposable = null;
+    }
+    if (this._resizeHandler) {
+      window.removeEventListener("resize", this._resizeHandler);
+      this._resizeHandler = null;
+    }
+    if (this._term) {
+      this._term.dispose();
+      this._term = null;
+    }
+    this._fitAddon = null;
+  }
+
+  clear(): void {
+    if (!this._term) return;
+    this._term.clear();
+    if (!this._running) this._term.write(this._promptFn(this._cwd));
+  }
+
+  input(text: string): void {
+    if (!this._term) return;
+    for (const ch of text) {
+      this._handleInput(ch);
+    }
+  }
+
+  setTheme(theme: Partial<TerminalTheme>): void {
+    this._theme = { ...this._theme, ...theme };
+    if (this._term) this._term.options.theme = this._theme;
+  }
+
+  fit(): void {
+    this._fitAddon?.fit();
+  }
+
+  write(text: string): void {
+    this._term?.write(text);
+  }
+
+  writeln(text: string): void {
+    this._term?.writeln(text);
+  }
+
+  showPrompt(): void {
+    this._term?.write(this._promptFn(this._cwd));
+  }
+
+  setCwd(cwd: string): void {
+    this._cwd = cwd;
+  }
+
+  getCwd(): string {
+    return this._cwd;
+  }
+
+  get xterm(): any {
+    return this._term;
+  }
+
+  /* ---- Input handling ---- */
+
+  private _handleInput(data: string): void {
+    if (!this._term) return;
+
+    if (this._running) {
+      // Ctrl+C
+      if (data.includes("\x03")) {
+        const abort = this._wiring?.getActiveAbort();
+        if (abort) {
+          abort.abort();
+          // Don't clear activeAbort -- nodepod.ts checks it to skip duplicate prompt
+        }
+        this._term.write("^C\r\n");
+        this._running = false;
+        this._writePrompt();
+        return;
+      }
+
+      const isRaw = this._wiring?.getIsStdinRaw() ?? false;
+      const sendStdin = this._wiring?.getSendStdin();
+
+      if (isRaw && sendStdin) {
+        sendStdin(data);
+      } else if (sendStdin) {
+        // Cooked mode: local echo + line buffering
+        for (let i = 0; i < data.length; i++) {
+          const ch = data[i];
+          const code = ch.charCodeAt(0);
+          if (ch === "\r" || ch === "\n") {
+            this._term.write("\r\n");
+            sendStdin("\n");
+          } else if (code === 127 || code === 8) {
+            this._term.write("\b \b");
+            sendStdin("\x7f");
+          } else if (code >= 32) {
+            this._term.write(ch);
+            sendStdin(ch);
+          } else {
+            // Control chars -- send remainder as-is
+            sendStdin(data.slice(i));
+            break;
+          }
+        }
+      }
+      return;
+    }
+
+    // Line editing mode
+    for (let i = 0; i < data.length; i++) {
+      const ch = data[i];
+      const code = ch.charCodeAt(0);
+
+      if (ch === "\r" || ch === "\n") {
+        const cmd = this._lineBuffer;
+        this._lineBuffer = "";
+        this._historyIndex = -1;
+        this._executeCommand(cmd);
+      } else if (code === 127 || code === 8) {
+        if (this._lineBuffer.length > 0) {
+          this._lineBuffer = this._lineBuffer.slice(0, -1);
+          this._term.write("\b \b");
+        }
+      } else if (code === 3) {
+        this._lineBuffer = "";
+        this._term.write("^C");
+        this._writePrompt();
+      } else if (code === 12) {
+        this._term.clear();
+        this._term.write(this._promptFn(this._cwd) + this._lineBuffer);
+      } else if (ch === "\x1b" && i + 2 < data.length && data[i + 1] === "[") {
+        const arrow = data[i + 2];
+        i += 2;
+        if (arrow === "A") this._historyUp();
+        else if (arrow === "B") this._historyDown();
+      } else if (code >= 32) {
+        this._lineBuffer += ch;
+        this._term.write(ch);
+      }
+    }
+  }
+
+  /* ---- History navigation ---- */
+
+  private _historyUp(): void {
+    if (this._history.length === 0) return;
+    if (this._historyIndex === -1) {
+      this._savedLine = this._lineBuffer;
+      this._historyIndex = this._history.length - 1;
+    } else if (this._historyIndex > 0) {
+      this._historyIndex--;
+    } else {
+      return;
+    }
+    this._replaceLineWith(this._history[this._historyIndex]);
+  }
+
+  private _historyDown(): void {
+    if (this._historyIndex === -1) return;
+    if (this._historyIndex < this._history.length - 1) {
+      this._historyIndex++;
+      this._replaceLineWith(this._history[this._historyIndex]);
+    } else {
+      this._historyIndex = -1;
+      this._replaceLineWith(this._savedLine);
+    }
+  }
+
+  private _replaceLineWith(text: string): void {
+    const prompt = this._promptFn(this._cwd);
+    this._term.write(
+      "\r" + prompt + " ".repeat(this._lineBuffer.length) + "\r" + prompt,
+    );
+    this._lineBuffer = text;
+    this._term.write(text);
+  }
+
+  /* ---- Command execution ---- */
+
+  private async _executeCommand(cmd: string): Promise<void> {
+    if (!cmd.trim()) {
+      this._term?.write("\r\n" + this._promptFn(this._cwd));
+      return;
+    }
+    this._history.push(cmd);
+    this._historyIndex = -1;
+    this._running = true;
+
+    if (this._wiring?.onCommand) {
+      await this._wiring.onCommand(cmd);
+    } else {
+      this._running = false;
+      this._writePrompt();
+    }
+  }
+}