@naarang/ccc 2.0.0-alpha.5 → 2.0.0-alpha.6

package/scripts/build-binaries.ts

@@ -1,9 +1,10 @@
 /**
  * Build script for creating cross-platform binaries with embedded version
+ * and native library support (bun-pty)
  */
 
 import { $ } from 'bun';
-import { readFileSync, mkdirSync, existsSync } from 'fs';
+import { readFileSync, writeFileSync, mkdirSync, existsSync, unlinkSync } from 'fs';
 import { join } from 'path';
 
 // Read version from package.json
@@ -18,41 +19,296 @@ if (!existsSync(binariesDir)) {
   mkdirSync(binariesDir, { recursive: true });
 }
 
-// Define targets
+// Define targets with their native library paths
 const targets = [
-  { name: 'linux-x64', target: 'bun-linux-x64', outfile: 'ccc-linux-x64' },
-  { name: 'linux-arm64', target: 'bun-linux-arm64', outfile: 'ccc-linux-arm64' },
-  { name: 'darwin-x64', target: 'bun-darwin-x64', outfile: 'ccc-darwin-x64' },
-  { name: 'darwin-arm64', target: 'bun-darwin-arm64', outfile: 'ccc-darwin-arm64' },
-  { name: 'windows-x64', target: 'bun-windows-x64', outfile: 'ccc-windows-x64.exe' },
+  {
+    name: 'linux-x64',
+    target: 'bun-linux-x64',
+    outfile: 'ccc-linux-x64',
+    ptyLib: 'librust_pty.so',
+  },
+  {
+    name: 'linux-arm64',
+    target: 'bun-linux-arm64',
+    outfile: 'ccc-linux-arm64',
+    ptyLib: 'librust_pty_arm64.so',
+  },
+  {
+    name: 'darwin-x64',
+    target: 'bun-darwin-x64',
+    outfile: 'ccc-darwin-x64',
+    ptyLib: 'librust_pty.dylib',
+  },
+  {
+    name: 'darwin-arm64',
+    target: 'bun-darwin-arm64',
+    outfile: 'ccc-darwin-arm64',
+    ptyLib: 'librust_pty_arm64.dylib',
+  },
+  {
+    name: 'windows-x64',
+    target: 'bun-windows-x64',
+    outfile: 'ccc-windows-x64.exe',
+    ptyLib: 'rust_pty.dll',
+  },
 ];
 
 // Parse command line arguments
 const args = process.argv.slice(2);
-const targetArg = args.find(arg => !arg.startsWith('-'));
-const selectedTargets = targetArg
-  ? targets.filter(t => t.name === targetArg)
-  : targets;
+const targetArg = args.find((arg) => !arg.startsWith('-'));
+const selectedTargets = targetArg ? targets.filter((t) => t.name === targetArg) : targets;
 
 if (targetArg && selectedTargets.length === 0) {
   console.error(`Unknown target: ${targetArg}`);
-  console.error(`Available targets: ${targets.map(t => t.name).join(', ')}`);
+  console.error(`Available targets: ${targets.map((t) => t.name).join(', ')}`);
   process.exit(1);
 }
 
+// Path to the generated loader file
+const loaderDir = join(import.meta.dir, '..', 'src', 'lib');
+const loaderPath = join(loaderDir, 'bun-pty-loader.generated.ts');
+
+// Ensure the lib directory exists
+if (!existsSync(loaderDir)) {
+  mkdirSync(loaderDir, { recursive: true });
+}
+
+/**
+ * Generate a platform-specific bun-pty loader that embeds the native library
+ * This inlines the bun-pty implementation to ensure the library is extracted
+ * before dlopen is called (bun-pty calls dlopen at module load time)
+ */
+function generatePtyLoader(ptyLib: string): void {
+  const loaderContent = `/**
+ * Auto-generated bun-pty implementation with embedded native library
+ * DO NOT EDIT - This file is generated by build-binaries.ts
+ *
+ * This is a copy of bun-pty's implementation that uses an embedded native library.
+ * We can't just set BUN_PTY_LIB and import bun-pty because bun-pty calls dlopen
+ * at module load time, before our env var setup code runs.
+ */
+
+import { dlopen, FFIType, ptr } from 'bun:ffi';
+import { Buffer } from 'buffer';
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
+import { join } from 'path';
+import { tmpdir } from 'os';
+
+// Embed the native library file - Bun will include this in the binary
+// @ts-ignore - Bun's file embedding syntax
+import embeddedLibPath from '../../node_modules/bun-pty/rust-pty/target/release/${ptyLib}' with { type: 'file' };
+
+// Extract embedded library to temp directory
+const libName = '${ptyLib}';
+const tempDir = join(tmpdir(), 'ccc-pty-lib');
+const extractedLibPath = join(tempDir, libName);
+
+if (!existsSync(extractedLibPath)) {
+  if (!existsSync(tempDir)) {
+    mkdirSync(tempDir, { recursive: true });
+  }
+  const libData = readFileSync(embeddedLibPath);
+  writeFileSync(extractedLibPath, libData);
+}
+
+// Load the native library
+const lib = dlopen(extractedLibPath, {
+  bun_pty_spawn: {
+    args: [FFIType.cstring, FFIType.cstring, FFIType.cstring, FFIType.i32, FFIType.i32],
+    returns: FFIType.i32,
+  },
+  bun_pty_write: {
+    args: [FFIType.i32, FFIType.pointer, FFIType.i32],
+    returns: FFIType.i32,
+  },
+  bun_pty_read: {
+    args: [FFIType.i32, FFIType.pointer, FFIType.i32],
+    returns: FFIType.i32,
+  },
+  bun_pty_resize: {
+    args: [FFIType.i32, FFIType.i32, FFIType.i32],
+    returns: FFIType.i32,
+  },
+  bun_pty_kill: { args: [FFIType.i32], returns: FFIType.i32 },
+  bun_pty_get_pid: { args: [FFIType.i32], returns: FFIType.i32 },
+  bun_pty_get_exit_code: { args: [FFIType.i32], returns: FFIType.i32 },
+  bun_pty_close: { args: [FFIType.i32], returns: FFIType.void },
+});
+
+// EventEmitter for PTY events
+class EventEmitter<T> {
+  private listeners: ((data: T) => void)[] = [];
+
+  event = (listener: (data: T) => void) => {
+    this.listeners.push(listener);
+    return {
+      dispose: () => {
+        const i = this.listeners.indexOf(listener);
+        if (i !== -1) this.listeners.splice(i, 1);
+      },
+    };
+  };
+
+  fire(data: T) {
+    for (const listener of this.listeners) {
+      listener(data);
+    }
+  }
+}
+
+// Shell quote helper
+function shQuote(s: string): string {
+  if (s.length === 0) return "''";
+  return \`'\${s.replace(/'/g, \`'\\\\''\\'\`)}'\`;
+}
+
+const DEFAULT_COLS = 80;
+const DEFAULT_ROWS = 24;
+const DEFAULT_FILE = process.platform === 'win32' ? 'powershell.exe' : 'sh';
+
+export interface IPtyOptions {
+  name?: string;
+  cols?: number;
+  rows?: number;
+  cwd?: string;
+  env?: Record<string, string>;
+}
+
+export interface IPty {
+  pid: number;
+  cols: number;
+  rows: number;
+  process: string;
+  onData: (listener: (data: string) => void) => { dispose: () => void };
+  onExit: (listener: (data: { exitCode: number; signal?: string }) => void) => { dispose: () => void };
+  write(data: string): void;
+  resize(cols: number, rows: number): void;
+  kill(signal?: string): void;
+}
+
+export class Terminal implements IPty {
+  private handle = -1;
+  private _pid = -1;
+  private _cols = DEFAULT_COLS;
+  private _rows = DEFAULT_ROWS;
+  private _readLoop = false;
+  private _closing = false;
+  private _onData = new EventEmitter<string>();
+  private _onExit = new EventEmitter<{ exitCode: number; signal?: string }>();
+
+  constructor(file = DEFAULT_FILE, args: string[] = [], opts: IPtyOptions = {}) {
+    this._cols = opts.cols ?? DEFAULT_COLS;
+    this._rows = opts.rows ?? DEFAULT_ROWS;
+    const cwd = opts.cwd ?? process.cwd();
+    const cmdline = [file, ...args.map(shQuote)].join(' ');
+    let envStr = '';
+    if (opts.env) {
+      const envPairs = Object.entries(opts.env).map(([k, v]) => \`\${k}=\${v}\`);
+      envStr = envPairs.join('\\x00') + '\\x00';
+    }
+
+    this.handle = lib.symbols.bun_pty_spawn(
+      Buffer.from(\`\${cmdline}\\x00\`, 'utf8'),
+      Buffer.from(\`\${cwd}\\x00\`, 'utf8'),
+      Buffer.from(\`\${envStr}\\x00\`, 'utf8'),
+      this._cols,
+      this._rows
+    );
+
+    if (this.handle < 0) throw new Error('PTY spawn failed');
+    this._pid = lib.symbols.bun_pty_get_pid(this.handle);
+    this._startReadLoop();
+  }
+
+  get pid() { return this._pid; }
+  get cols() { return this._cols; }
+  get rows() { return this._rows; }
+  get process() { return 'shell'; }
+  get onData() { return this._onData.event; }
+  get onExit() { return this._onExit.event; }
+
+  write(data: string) {
+    if (this._closing) return;
+    const buf = Buffer.from(data, 'utf8');
+    lib.symbols.bun_pty_write(this.handle, ptr(buf), buf.length);
+  }
+
+  resize(cols: number, rows: number) {
+    if (this._closing) return;
+    this._cols = cols;
+    this._rows = rows;
+    lib.symbols.bun_pty_resize(this.handle, cols, rows);
+  }
+
+  kill(signal = 'SIGTERM') {
+    if (this._closing) return;
+    this._closing = true;
+    lib.symbols.bun_pty_kill(this.handle);
+    lib.symbols.bun_pty_close(this.handle);
+    this._onExit.fire({ exitCode: 0, signal });
+  }
+
+  private async _startReadLoop() {
+    if (this._readLoop) return;
+    this._readLoop = true;
+    const buf = Buffer.allocUnsafe(4096);
+
+    while (this._readLoop && !this._closing) {
+      const n = lib.symbols.bun_pty_read(this.handle, ptr(buf), buf.length);
+      if (n > 0) {
+        this._onData.fire(buf.subarray(0, n).toString('utf8'));
+      } else if (n === -2) {
+        const exitCode = lib.symbols.bun_pty_get_exit_code(this.handle);
+        this._onExit.fire({ exitCode });
+        break;
+      } else if (n < 0) {
+        break;
+      } else {
+        await new Promise((r) => setTimeout(r, 8));
+      }
+    }
+  }
+}
+
+export function spawn(file: string, args: string[], options: IPtyOptions): IPty {
+  return new Terminal(file, args, options);
+}
+`;
+
+  writeFileSync(loaderPath, loaderContent);
+  console.log(`  Generated bun-pty loader for ${ptyLib}`);
+}
+
+/**
+ * Clean up the generated loader file
+ */
+function cleanupLoader(): void {
+  if (existsSync(loaderPath)) {
+    unlinkSync(loaderPath);
+  }
+}
+
 // Build each target
-for (const { name, target, outfile } of selectedTargets) {
+for (const { name, target, outfile, ptyLib } of selectedTargets) {
   console.log(`\nBuilding ${name}...`);
 
   const outfilePath = join(binariesDir, outfile);
 
   try {
-    await $`bun build --compile --minify --bytecode --target=${target} --external bun-pty --external @ngrok/ngrok --external expo-server-sdk --define BUILD_VERSION='"${VERSION}"' src/index.ts --outfile ${outfilePath}`;
+    // Generate platform-specific bun-pty loader
+    generatePtyLoader(ptyLib);
+
+    // Build the binary (bun-pty is now bundled via the generated loader)
+    await $`bun build --compile --minify --bytecode --target=${target} --external @ngrok/ngrok --external expo-server-sdk --define BUILD_VERSION='"${VERSION}"' src/index.ts --outfile ${outfilePath}`;
     console.log(`  ✓ Built ${outfile}`);
   } catch (error) {
     console.error(`  ✗ Failed to build ${name}:`, error);
+    cleanupLoader();
     process.exit(1);
   }
 }
 
+// Clean up generated files
+cleanupLoader();
+
 console.log('\nBuild complete!');

package/scripts/postinstall.cjs

@@ -1,84 +1,84 @@
-#!/usr/bin/env node
-/**
- * Postinstall script (CommonJS version for npm compatibility)
- *
- * This script checks if bun-pty is working correctly.
- * bun-pty is a Bun-native PTY implementation that doesn't require node-gyp.
- */
-
-const { existsSync } = require('fs');
-const { join } = require('path');
-const { spawn } = require('child_process');
-
-const ROOT_PATH = join(__dirname, '..');
-
-/**
- * Check if Bun is available
- */
-function checkBun() {
-  return new Promise((resolve) => {
-    const result = spawn('bun', ['--version'], { stdio: 'pipe', shell: true });
-    result.on('close', (code) => resolve(code === 0));
-    result.on('error', () => resolve(false));
-  });
-}
-
-/**
- * Check if bun-pty works (requires Bun runtime)
- */
-async function checkBunPty() {
-  const hasBun = await checkBun();
-  if (!hasBun) {
-    console.log('[postinstall] Bun not found, skipping bun-pty check');
-    console.log('[postinstall] Install Bun for full functionality: https://bun.sh');
-    return false;
-  }
-
-  return new Promise((resolve) => {
-    // Run a simple Bun script to test bun-pty
-    const testScript = `
-      try {
-        const { spawn } = require('bun-pty');
-        const shell = process.platform === 'win32' ? 'cmd.exe' : 'sh';
-        const pty = spawn(shell, [], { cols: 80, rows: 24 });
-        pty.kill();
-        console.log('bun-pty is working correctly');
-        process.exit(0);
-      } catch (e) {
-        console.error('bun-pty check failed:', e.message);
-        process.exit(1);
-      }
-    `;
-
-    const testProcess = spawn('bun', ['-e', testScript], {
-      cwd: ROOT_PATH,
-      stdio: 'inherit',
-      shell: true,
-    });
-
-    testProcess.on('close', (code) => resolve(code === 0));
-    testProcess.on('error', () => resolve(false));
-  });
-}
-
-async function main() {
-  console.log('[postinstall] Code Chat Connect v2 - Post-installation check\n');
-
-  // Check bun-pty
-  const ptyWorks = await checkBunPty();
-
-  if (ptyWorks) {
-    console.log('\n[postinstall] All checks passed!');
-  } else {
-    console.log('\n[postinstall] Terminal functionality may be limited.');
-    console.log('[postinstall] Ensure Bun is installed: https://bun.sh');
-  }
-
-  console.log('\n[postinstall] Run "ccc" to start the server.\n');
-}
-
-main().catch((err) => {
-  console.error('[postinstall] Error:', err.message);
-  // Don't fail the install on postinstall errors
-  process.exit(0);
-});
+#!/usr/bin/env node
+/**
+ * Postinstall script (CommonJS version for npm compatibility)
+ *
+ * This script checks if bun-pty is working correctly.
+ * bun-pty is a Bun-native PTY implementation that doesn't require node-gyp.
+ */
+
+const { existsSync } = require('fs');
+const { join } = require('path');
+const { spawn } = require('child_process');
+
+const ROOT_PATH = join(__dirname, '..');
+
+/**
+ * Check if Bun is available
+ */
+function checkBun() {
+  return new Promise((resolve) => {
+    const result = spawn('bun', ['--version'], { stdio: 'pipe', shell: true });
+    result.on('close', (code) => resolve(code === 0));
+    result.on('error', () => resolve(false));
+  });
+}
+
+/**
+ * Check if bun-pty works (requires Bun runtime)
+ */
+async function checkBunPty() {
+  const hasBun = await checkBun();
+  if (!hasBun) {
+    console.log('[postinstall] Bun not found, skipping bun-pty check');
+    console.log('[postinstall] Install Bun for full functionality: https://bun.sh');
+    return false;
+  }
+
+  return new Promise((resolve) => {
+    // Run a simple Bun script to test bun-pty
+    const testScript = `
+      try {
+        const { spawn } = require('bun-pty');
+        const shell = process.platform === 'win32' ? 'cmd.exe' : 'sh';
+        const pty = spawn(shell, [], { cols: 80, rows: 24 });
+        pty.kill();
+        console.log('bun-pty is working correctly');
+        process.exit(0);
+      } catch (e) {
+        console.error('bun-pty check failed:', e.message);
+        process.exit(1);
+      }
+    `;
+
+    const testProcess = spawn('bun', ['-e', testScript], {
+      cwd: ROOT_PATH,
+      stdio: 'inherit',
+      shell: true,
+    });
+
+    testProcess.on('close', (code) => resolve(code === 0));
+    testProcess.on('error', () => resolve(false));
+  });
+}
+
+async function main() {
+  console.log('[postinstall] Code Chat Connect v2 - Post-installation check\n');
+
+  // Check bun-pty
+  const ptyWorks = await checkBunPty();
+
+  if (ptyWorks) {
+    console.log('\n[postinstall] All checks passed!');
+  } else {
+    console.log('\n[postinstall] Terminal functionality may be limited.');
+    console.log('[postinstall] Ensure Bun is installed: https://bun.sh');
+  }
+
+  console.log('\n[postinstall] Run "ccc" to start the server.\n');
+}
+
+main().catch((err) => {
+  console.error('[postinstall] Error:', err.message);
+  // Don't fail the install on postinstall errors
+  process.exit(0);
+});