Complete Node.js migration with custom ESM loader

- Created custom ESM loader (loader.mjs) to handle:
  - Asset files (.txt, .scm, .md, .wasm, .dylib, etc.)
  - bun: protocol imports (redirects to compat layers)
  - TypeScript files in node_modules (prevents CJS transformation)

- Extended Bun compatibility layer (src/util/bun-compat.ts):
  - Added Bun.Glob (using minimatch)
  - Added Bun.which (executable finder)
  - Added Bun.stderr (stderr writer)
  - Added Bun.color (ANSI color codes)

- Created bun:ffi stub (src/util/bun-ffi-compat.ts)
  - Provides minimal stubs to prevent import errors
  - Logs warnings when FFI functions are called

- Created global Bun shim (global-bun-shim.mjs)
  - Injects Bun into global scope for third-party libraries

- Converted text file imports to fs.readFileSync:
  - Fixed 20+ files that imported .txt files
  - Added necessary fs, path, and fileURLToPath imports

- Fixed compatibility issues:
  - Replaced fs.exists with fs.access (deprecated API)
  - Fixed duplicate fs imports
  - Added Bun imports where needed

- Created launcher scripts:
  - opencode-node.mjs (Unix/macOS)
  - opencode-node.bat (Windows CMD)
  - opencode-node.ps1 (Windows PowerShell)

- Added comprehensive documentation (NODE_MIGRATION.md)

Successfully tested on macOS with Node.js v25.2.1

Author: mattbaylor

fix-txt-imports.mjs

@@ -0,0 +1,93 @@
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+// Find all .ts files in packages/opencode/src
+function findTsFiles(dir, files = []) {
+  const entries = fs.readdirSync(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = path.join(dir, entry.name);
+    if (entry.isDirectory() && entry.name !== 'node_modules') {
+      findTsFiles(fullPath, files);
+    } else if (entry.isFile() && (entry.name.endsWith('.ts') || entry.name.endsWith('.tsx'))) {
+      files.push(fullPath);
+    }
+  }
+  return files;
+}
+
+const files = findTsFiles(path.join(__dirname, 'packages/opencode/src'));
+
+for (const file of files) {
+  let content = fs.readFileSync(file, 'utf-8');
+  const originalContent = content;
+  
+  // Match: import SOMETHING from "./path/to/file.txt"
+  const importRegex = /import\s+(\w+)\s+from\s+["']([^"']+\.txt)["']/g;
+  
+  const matches = [...content.matchAll(importRegex)];
+  if (matches.length === 0) continue;
+  
+  console.log(`Processing ${file}...`);
+  
+  // Check if already has needed imports
+  const hasFs = /import.*fs.*from\s+["']fs["']/.test(content);
+  const hasPath = /import.*path.*from\s+["']path["']/.test(content);
+  const hasFileURLToPath = /import.*fileURLToPath.*from\s+["']url["']/.test(content);
+  
+  // Remove the txt imports
+  content = content.replace(importRegex, '');
+  
+  // Add necessary imports if not present
+  let importsToAdd = [];
+  if (!hasFs) importsToAdd.push(`import fs from "fs"`);
+  if (!hasPath) importsToAdd.push(`import path from "path"`);
+  if (!hasFileURLToPath) importsToAdd.push(`import { fileURLToPath } from "url"`);
+  
+  if (importsToAdd.length > 0) {
+    // Find the first import statement
+    const firstImportMatch = content.match(/^import\s+/m);
+    if (firstImportMatch) {
+      const insertPos = firstImportMatch.index;
+      content = content.slice(0, insertPos) + importsToAdd.join('\n') + '\n' + content.slice(insertPos);
+    }
+  }
+  
+  // Add __dirname setup if not present
+  if (!/__dirname/.test(content)) {
+    const firstNonImportLine = content.search(/\n\n[^import]/);
+    if (firstNonImportLine !== -1) {
+      const setup = `\nconst __filename = fileURLToPath(import.meta.url)\nconst __dirname = path.dirname(__filename)\n`;
+      content = content.slice(0, firstNonImportLine) + setup + content.slice(firstNonImportLine);
+    }
+  }
+  
+  // Add const declarations for each txt file
+  for (const match of matches) {
+    const [, varName, txtPath] = match;
+    const constDecl = `const ${varName} = fs.readFileSync(path.join(__dirname, "${txtPath}"), "utf-8")\n`;
+    
+    // Find a good place to insert (after imports and __dirname setup)
+    const lastImport = content.lastIndexOf('import ');
+    if (lastImport !== -1) {
+      const afterLastImport = content.indexOf('\n', lastImport) + 1;
+      const afterDirname = content.indexOf('const __dirname', afterLastImport);
+      if (afterDirname !== -1) {
+        const insertPos = content.indexOf('\n', afterDirname) + 1;
+        content = content.slice(0, insertPos) + constDecl + content.slice(insertPos);
+      } else {
+        content = content.slice(0, afterLastImport) + '\n' + constDecl + content.slice(afterLastImport);
+      }
+    }
+  }
+  
+  if (content !== originalContent) {
+    fs.writeFileSync(file, content);
+    console.log(`Updated ${file}`);
+  }
+}
+
+console.log('Done!');

package.json

@@ -25,6 +25,7 @@
     "husky": "9.1.7",
     "prettier": "3.6.2",
     "sst": "3.17.23",
+    "ts-node": "^10.9.2",
     "turbo": "2.5.6"
   },
   "dependencies": {

packages/opencode/NODE_MIGRATION.md

@@ -0,0 +1,131 @@
+# OpenCode Node.js Migration
+
+This directory contains the Node.js-compatible version of OpenCode, migrated from Bun.
+
+## Running OpenCode with Node.js
+
+### Prerequisites
+
+- Node.js v22+ (tested with v25.2.1)
+- pnpm (for package management)
+
+### Installation
+
+```bash
+cd /Users/matt/repo/opencode
+pnpm install
+```
+
+### Running
+
+**Unix/Linux/macOS:**
+```bash
+cd packages/opencode
+./opencode-node.mjs [arguments]
+```
+
+**Windows (PowerShell):**
+```powershell
+cd packages\opencode
+.\opencode-node.ps1 [arguments]
+```
+
+**Windows (Command Prompt):**
+```cmd
+cd packages\opencode
+opencode-node.bat [arguments]
+```
+
+**Direct Node.js command (all platforms):**
+```bash
+node --loader ./loader.mjs --conditions=browser --import ./global-bun-shim.mjs --import tsx/esm ./src/index.ts [arguments]
+```
+
+### Examples
+
+```bash
+# Show help
+./opencode-node.mjs --help
+
+# Show version
+./opencode-node.mjs --version
+
+# Run OpenCode
+./opencode-node.mjs
+```
+
+## Migration Details
+
+### Key Changes
+
+1. **Bun Compatibility Layer** (`src/util/bun-compat.ts`)
+   - Implements Bun APIs using Node.js equivalents
+   - Provides: `Bun.$`, `Bun.file`, `Bun.write`, `Bun.spawn`, `Bun.Glob`, `Bun.which`, `Bun.stderr`, `Bun.color`
+
+2. **Custom ESM Loader** (`loader.mjs`)
+   - Handles asset file imports (.txt, .scm, .md, .wasm, etc.)
+   - Resolves `bun:` protocol imports to compatibility layers
+   - Prevents tsx from transforming TypeScript files in node_modules to CJS
+
+3. **Global Bun Shim** (`global-bun-shim.mjs`)
+   - Injects Bun compatibility layer into global scope
+   - Allows third-party libraries expecting `Bun` to work
+
+4. **Text File Import Conversion**
+   - Converted all `.txt` file imports to use `fs.readFileSync()`
+   - Added necessary imports (`fs`, `path`, `fileURLToPath`)
+
+5. **Package Updates**
+   - Changed package manager from `bun` to `pnpm`
+   - Replaced `bun-pty` with `node-pty`
+   - Updated tsconfig to use `@tsconfig/node22`
+   - Added path mapping for `bun` → `./src/util/bun-compat.ts`
+
+### Known Limitations
+
+1. **bun:ffi Stub**: The `bun:ffi` module is stubbed out, so native FFI functionality from `@opentui/core` may be limited
+2. **Experimental Loader Warning**: Node.js shows a warning about the experimental loader API (can be suppressed with `NODE_NO_WARNINGS=1`)
+3. **Performance**: May be slightly slower than Bun due to different runtime optimizations
+
+### Files Modified
+
+**Core Compatibility:**
+- `src/util/bun-compat.ts` - Bun API compatibility layer
+- `src/util/bun-ffi-compat.ts` - Bun FFI stub
+- `loader.mjs` - Custom ESM loader
+- `global-bun-shim.mjs` - Global Bun injection
+
+**Import Fixes:**
+- `src/provider/models-macro.ts` - Removed macro, added Bun compat import
+- `src/provider/models.ts` - Removed macro import, added Bun compat
+- `src/util/filesystem.ts` - Added Bun import, fixed `fs.exists`
+- `src/util/log.ts` - Added Bun import
+- `src/file/ignore.ts` - Added Bun import
+- `src/file/ripgrep.ts` - Added Bun import
+- `src/cli/ui.ts` - Added Bun import
+- `src/session/prompt.ts` - Fixed duplicate fs imports
+- 20+ files - Converted .txt imports to fs.readFileSync
+
+**Configuration:**
+- `package.json` - Updated package manager and dependencies
+- `tsconfig.json` - Added bun path mapping
+- `pnpm-workspace.yaml` - Created for pnpm
+- `packages/sdk/js/package.json` - Added src to files array
+
+**Launchers:**
+- `opencode-node.mjs` - Unix/macOS launcher
+- `opencode-node.bat` - Windows batch launcher
+- `opencode-node.ps1` - Windows PowerShell launcher
+
+## Testing
+
+Tested on:
+- ✅ macOS (darwin-arm64) with Node.js v25.2.1
+- ⏳ Windows Server 2022 (pending)
+
+## Future Work
+
+- Package as standalone executable using `pkg`, `nexe`, or `caxa`
+- Implement full `bun:ffi` support using node-ffi-napi
+- Add CI/CD for automated testing
+- Create installers for Windows, macOS, Linux

packages/opencode/global-bun-shim.mjs

@@ -0,0 +1,8 @@
+/**
+ * Global Bun shim for Node.js
+ * This makes Bun APIs available globally for libraries that expect them
+ */
+import { Bun } from './src/util/bun-compat.ts'
+
+// Inject Bun into global scope
+globalThis.Bun = Bun

packages/opencode/loader.mjs

@@ -0,0 +1,119 @@
+/**
+ * Custom Node.js loader for asset files
+ * Handles .txt, .scm, .md, WASM, and other text-based asset files
+ */
+import { readFile } from 'fs/promises';
+import { fileURLToPath } from 'url';
+
+const TEXT_ASSET_EXTENSIONS = [
+  '.txt',
+  '.scm',
+  '.md',
+  '.css',
+  '.html',
+  '.xml',
+  '.json',
+  '.yaml',
+  '.yml',
+  '.toml',
+];
+
+const BINARY_ASSET_EXTENSIONS = [
+  '.wasm',
+  '.dylib',
+  '.so',
+  '.dll',
+  '.node',
+];
+
+export async function resolve(specifier, context, nextResolve) {
+  // Handle bun: protocol imports by redirecting to our compat layer
+  if (specifier.startsWith('bun:')) {
+    // Map bun: imports to specific modules
+    const bunModule = specifier.replace('bun:', '');
+    
+    // Handle specific bun modules
+    if (bunModule === 'ffi') {
+      return {
+        url: new URL('./src/util/bun-ffi-compat.ts', import.meta.url).href,
+        shortCircuit: true,
+      };
+    }
+    
+    // For other bun: imports, redirect to our general compat layer
+    return {
+      url: new URL('./src/util/bun-compat.ts', import.meta.url).href,
+      shortCircuit: true,
+    };
+  }
+  
+  // Let the default resolver handle the resolution
+  return nextResolve(specifier, context);
+}
+
+export async function load(url, context, nextLoad) {
+  // Only handle file:// URLs
+  if (!url.startsWith('file://')) {
+    return nextLoad(url, context);
+  }
+  
+  const filePath = fileURLToPath(url);
+  
+  // Skip transformation of TypeScript files in node_modules
+  // This prevents tsx from trying to transform native modules with top-level await
+  if (filePath.includes('node_modules') && filePath.endsWith('.ts')) {
+    // Let Node.js handle it - it will likely error, but that's better than tsx transforming it to CJS
+    // Actually, we should read and return as ESM module
+    try {
+      const content = await readFile(filePath, 'utf-8');
+      return {
+        format: 'module',
+        source: content,
+        shortCircuit: true,
+      };
+    } catch (error) {
+      console.error(`Failed to load TS file ${filePath}:`, error);
+      throw error;
+    }
+  }
+  
+  // Check if this is a text asset file
+  const isTextAsset = TEXT_ASSET_EXTENSIONS.some(ext => filePath.endsWith(ext));
+  
+  if (isTextAsset) {
+    try {
+      const content = await readFile(filePath, 'utf-8');
+      
+      // Return the content as a default export
+      return {
+        format: 'module',
+        source: `export default ${JSON.stringify(content)};`,
+        shortCircuit: true,
+      };
+    } catch (error) {
+      console.error(`Failed to load text asset file ${filePath}:`, error);
+      throw error;
+    }
+  }
+  
+  // Check if this is a WASM file
+  const isWasm = BINARY_ASSET_EXTENSIONS.some(ext => filePath.endsWith(ext));
+  
+  if (isWasm) {
+    try {
+      // For WASM files with type: "file", just return the file path
+      // The code expects a file path, not the actual content
+      return {
+        format: 'module',
+        source: `export default ${JSON.stringify(filePath)};`,
+        shortCircuit: true,
+      };
+    } catch (error) {
+      console.error(`Failed to load WASM file ${filePath}:`, error);
+      throw error;
+    }
+  }
+  
+  // Let the default loader handle everything else
+  return nextLoad(url, context);
+}

packages/opencode/opencode-node.bat

@@ -0,0 +1,12 @@
+@echo off
+REM OpenCode launcher for Node.js on Windows
+
+setlocal
+
+REM Get the directory where this script is located
+set SCRIPT_DIR=%~dp0
+
+REM Build the node command with all arguments
+node --loader "%SCRIPT_DIR%loader.mjs" --conditions=browser --import "%SCRIPT_DIR%global-bun-shim.mjs" --import tsx/esm "%SCRIPT_DIR%src\index.ts" %*
+
+endlocal