almostnode 0.1.0

package/src/shims/async_hooks.ts

@@ -0,0 +1,86 @@
+/**
+ * async_hooks shim - Async tracking is not available in browser
+ */
+
+export class AsyncResource {
+  constructor(_type: string, _options?: object) {}
+
+  runInAsyncScope<T>(fn: (...args: unknown[]) => T, thisArg?: unknown, ...args: unknown[]): T {
+    return fn.apply(thisArg, args);
+  }
+
+  emitDestroy(): this { return this; }
+  asyncId(): number { return 0; }
+  triggerAsyncId(): number { return 0; }
+
+  static bind<T extends (...args: unknown[]) => unknown>(fn: T, _type?: string): T {
+    return fn;
+  }
+}
+
+export class AsyncLocalStorage<T> {
+  private store: T | undefined;
+
+  disable(): void {}
+
+  getStore(): T | undefined {
+    return this.store;
+  }
+
+  run<R>(store: T, callback: () => R): R {
+    const prev = this.store;
+    this.store = store;
+    try {
+      return callback();
+    } finally {
+      this.store = prev;
+    }
+  }
+
+  exit<R>(callback: () => R): R {
+    const prev = this.store;
+    this.store = undefined;
+    try {
+      return callback();
+    } finally {
+      this.store = prev;
+    }
+  }
+
+  enterWith(store: T): void {
+    this.store = store;
+  }
+}
+
+export interface AsyncHook {
+  enable(): this;
+  disable(): this;
+}
+
+export function createHook(_callbacks: object): AsyncHook {
+  return {
+    enable(): AsyncHook { return this; },
+    disable(): AsyncHook { return this; },
+  };
+}
+
+export function executionAsyncId(): number {
+  return 0;
+}
+
+export function executionAsyncResource(): object {
+  return {};
+}
+
+export function triggerAsyncId(): number {
+  return 0;
+}
+
+export default {
+  AsyncResource,
+  AsyncLocalStorage,
+  createHook,
+  executionAsyncId,
+  executionAsyncResource,
+  triggerAsyncId,
+};

package/src/shims/buffer.ts

@@ -0,0 +1,75 @@
+/**
+ * Node.js buffer module shim
+ * Provides Buffer class for browser environment
+ */
+
+// Re-export Buffer from stream where it's defined
+import { Buffer as BufferClass } from './stream';
+
+// The buffer module exports Buffer as a named export
+export const Buffer = BufferClass;
+
+// SlowBuffer is deprecated but some packages still use it
+export const SlowBuffer = BufferClass;
+
+// kMaxLength is the maximum size of a Buffer
+export const kMaxLength = 2147483647;
+
+// INSPECT_MAX_BYTES controls how many bytes are shown when calling inspect()
+export const INSPECT_MAX_BYTES = 50;
+
+// Constants for Buffer pooling
+export const constants = {
+  MAX_LENGTH: kMaxLength,
+  MAX_STRING_LENGTH: 536870888,
+};
+
+// transcode function - simplified
+export function transcode(
+  source: Uint8Array,
+  _fromEnc: string,
+  _toEnc: string
+): InstanceType<typeof Buffer> {
+  // Simplified - just return a copy
+  return Buffer.from(source);
+}
+
+// resolveObjectURL - returns undefined (no blob support)
+export function resolveObjectURL(id: string): undefined {
+  return undefined;
+}
+
+// atob and btoa wrappers
+export function atob(data: string): string {
+  return globalThis.atob(data);
+}
+
+export function btoa(data: string): string {
+  return globalThis.btoa(data);
+}
+
+// Default export as a plain object with all exports
+// Using Object.create(null) and then assigning doesn't work well,
+// so we use a regular object that has hasOwnProperty
+const bufferModule: Record<string, unknown> = {
+  Buffer,
+  SlowBuffer,
+  kMaxLength,
+  INSPECT_MAX_BYTES,
+  constants,
+  transcode,
+  resolveObjectURL,
+  atob,
+  btoa,
+};
+
+// Ensure hasOwnProperty is accessible (should already be from Object.prototype)
+// but we make it explicit
+Object.defineProperty(bufferModule, 'hasOwnProperty', {
+  value: Object.prototype.hasOwnProperty,
+  enumerable: false,
+  configurable: true,
+  writable: true,
+});
+
+export default bufferModule;

package/src/shims/child_process-browser.ts

@@ -0,0 +1,217 @@
+/**
+ * Browser-compatible child_process shim
+ * This version doesn't use just-bash and throws errors for commands
+ * Most CLI tools (like Convex CLI) don't actually need shell execution
+ */
+
+import { EventEmitter } from './events';
+import { Readable, Writable, Buffer } from './stream';
+
+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;
+
+/**
+ * Initialize child_process - no-op in browser version
+ */
+export function initChildProcess(): void {
+  // No-op - just-bash not used in browser version
+}
+
+/**
+ * Execute a command in a shell
+ */
+export function exec(
+  command: string,
+  optionsOrCallback?: ExecOptions | ExecCallback,
+  callback?: ExecCallback
+): ChildProcess {
+  let cb: ExecCallback | undefined;
+
+  if (typeof optionsOrCallback === 'function') {
+    cb = optionsOrCallback;
+  } else {
+    cb = callback;
+  }
+
+  const child = new ChildProcess();
+
+  // Execute asynchronously - emit error
+  setTimeout(() => {
+    const error = new Error(
+      `exec is not supported in browser environment: ${command}`
+    );
+    child.emit('error', error);
+    if (cb) cb(error, '', '');
+  }, 0);
+
+  return child;
+}
+
+/**
+ * Execute a command synchronously
+ */
+export function execSync(
+  command: string,
+  options?: ExecOptions
+): string | Buffer {
+  throw new Error(
+    `execSync is not supported in browser environment: ${command}`
+  );
+}
+
+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 {
+  const child = new ChildProcess();
+
+  // Execute asynchronously - emit error
+  setTimeout(() => {
+    const error = new Error(
+      `spawn is not supported in browser environment: ${command}`
+    );
+    child.emit('error', error);
+  }, 0);
+
+  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: ${command}`
+  );
+}
+
+/**
+ * Execute a file
+ */
+export function execFile(
+  file: string,
+  args?: string[] | ExecOptions | ExecCallback,
+  options?: ExecOptions | ExecCallback,
+  callback?: ExecCallback
+): ChildProcess {
+  let cb: ExecCallback | undefined;
+
+  if (typeof args === 'function') {
+    cb = args;
+  } else if (typeof options === 'function') {
+    cb = options;
+  } else {
+    cb = callback;
+  }
+
+  const child = new ChildProcess();
+
+  setTimeout(() => {
+    const error = new Error(
+      `execFile is not supported in browser environment: ${file}`
+    );
+    child.emit('error', error);
+    if (cb) cb(error, '', '');
+  }, 0);
+
+  return child;
+}
+
+/**
+ * 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,
+};