@mmmbuto/nexuscli 0.9.9 → 0.9.10

package/README.md

@@ -244,3 +244,19 @@ npm run dev
 
 MIT License.
 See `LICENSE` for details.
+
+## PTY Support (Shared Library)
+
+NexusCLI uses `@mmmbuto/pty-termux-utils` as a shared library for PTY
+management across all Termux CLI projects (Gemini, Qwen, Nexus).
+
+- **Native PTY:** Uses `@mmmbuto/node-pty-android-arm64@~1.1.0` when available
+- **Linux ARM64:** Uses `@lydell/node-pty-linux-arm64@~1.2.0-beta.2` when available
+- **Fallback:** Gracefully degrades to `child_process` adapter
+- **Debug Logging:** Enable with `PTY_DEBUG=1` environment variable
+- **Architecture:** See `@mmmbuto/pty-termux-utils` documentation
+
+```bash
+# Enable PTY debug logging
+PTY_DEBUG=1 nexuscli start
+```

package/lib/server/lib/getPty.js

@@ -0,0 +1,48 @@
+/**
+ * PTY Loader for NexusCLI (legacy compatibility wrapper)
+ * Delegates to @mmmbuto/pty-termux-utils multi-provider strategy.
+ *
+ * Provider priority:
+ * 1. Termux: @mmmbuto/node-pty-android-arm64
+ * 2. Linux ARM64: @lydell/node-pty-linux-arm64
+ * 3. Fallback: child_process adapter (pty-adapter.js)
+ *
+ * @version 1.1.0
+ */
+
+const { getPty: getSharedPty, logDebug } = require('@mmmbuto/pty-termux-utils');
+const tryRequire = (moduleName) => {
+  try {
+    require(moduleName);
+    return true;
+  } catch (_) {
+    return false;
+  }
+};
+
+module.exports = {
+  /**
+   * Get PTY implementation with fallback
+   * @returns {Promise<{module: any, name: string}|null>}
+   */
+  async getPty() {
+    const pty = await getSharedPty();
+    if (pty) {
+      logDebug(`Using native PTY provider: ${pty.name}`);
+      return pty;
+    }
+    logDebug('Native PTY not available, using fallback adapter');
+    return null;
+  },
+
+  /**
+   * Synchronous check if PTY is available
+   * @returns {boolean}
+   */
+  isPtyAvailable() {
+    return (
+      tryRequire('@mmmbuto/node-pty-android-arm64') ||
+      tryRequire('@lydell/node-pty-linux-arm64')
+    );
+  }
+};

package/lib/server/lib/pty-adapter.js

@@ -1,81 +1,124 @@
 /**
- * PTY Adapter for NexusCLI (Termux)
- * Provides node-pty-like interface using child_process.spawn
- * Termux-only: no native node-pty compilation needed
+ * PTY Adapter for NexusCLI (Termux + Linux ARM64)
+ * Wrapper around @mmmbuto/pty-termux-utils shared library
+ * Provides node-pty-like interface with graceful fallback
  *
- * @version 0.5.0 - Added stdin support for interrupt (ESC key)
+ * @version 1.0.0
  */
 
-const { spawn: cpSpawn } = require('child_process');
+const { createFallbackAdapter } = require('@mmmbuto/pty-termux-utils');
+const tryRequire = (moduleName) => {
+  try {
+    require(moduleName);
+    return true;
+  } catch (_) {
+    return false;
+  }
+};
+
+// Create shared fallback adapter (always uses child_process)
+const fallbackAdapter = createFallbackAdapter();
+
+// Cache for native PTY (sync access)
+let cachedNativePty = null;
 
 /**
- * Spawn a process with node-pty-like interface
+ * Initialize native PTY (called at startup)
+ */
+async function initNativePty() {
+  if (cachedNativePty !== null) {
+    return cachedNativePty;
+  }
+  
+  try {
+    const { getPty } = require('@mmmbuto/pty-termux-utils');
+    cachedNativePty = await getPty();
+    return cachedNativePty;
+  } catch (e) {
+    cachedNativePty = false; // Error loading
+    return null;
+  }
+}
+
+/**
+ * Synchronous spawn (for compatibility with existing wrapper code)
+ * Uses fallback adapter for simplicity (no native PTY in sync mode)
  * @param {string} command - Command to spawn
  * @param {string[]} args - Arguments
  * @param {Object} options - Spawn options (cwd, env)
- * @returns {Object} PTY-like interface with onData, onExit, kill
+ * @returns {Object} PTY-like interface
  */
 function spawn(command, args, options = {}) {
-  const proc = cpSpawn(command, args, {
-    cwd: options.cwd,
-    env: options.env,
-    shell: false,
-    stdio: ['pipe', 'pipe', 'pipe'],  // stdin enabled for interrupt support
-  });
-
-  const dataHandlers = [];
-  const exitHandlers = [];
-  const errorHandlers = [];
+  return fallbackAdapter.spawn(command, args, options);
+}
 
-  proc.stdout.on('data', (buf) => {
-    const data = buf.toString();
-    console.log('[PTY-Adapter] stdout:', data.substring(0, 200));
-    dataHandlers.forEach((fn) => fn(data));
-  });
+/**
+ * Async spawn with native PTY support
+ * @param {string} command - Command to spawn
+ * @param {string[]} args - Arguments
+ * @param {Object} options - Spawn options (cwd, env)
+ * @returns {Promise<Object>} PTY-like interface
+ */
+async function spawnAsync(command, args, options = {}) {
+  const pty = await initNativePty();
+  
+  if (pty) {
+    // Use native PTY
+    const proc = pty.module.spawn(command, args, {
+      cols: options.cols || 80,
+      rows: options.rows || 24,
+      cwd: options.cwd,
+      env: options.env,
+    });
 
-  proc.stderr.on('data', (buf) => {
-    const data = buf.toString();
-    console.log('[PTY-Adapter] stderr:', data.substring(0, 200));
-    dataHandlers.forEach((fn) => fn(data));
-  });
+    const dataHandlers = [];
+    const exitHandlers = [];
 
-  proc.on('close', (code) => {
-    exitHandlers.forEach((fn) => fn({ exitCode: code ?? 0 }));
-  });
+    proc.on('data', (data) => {
+      dataHandlers.forEach((fn) => fn(data));
+    });
 
-  proc.on('error', (err) => {
-    console.error('[PTY-Adapter] Error:', err.message);
-    errorHandlers.forEach((fn) => fn(err));
-  });
+    proc.on('exit', (code, signal) => {
+      exitHandlers.forEach((fn) => fn({ exitCode: code, signal }));
+    });
 
-  return {
-    onData: (fn) => dataHandlers.push(fn),
-    onExit: (fn) => exitHandlers.push(fn),
-    onError: (fn) => errorHandlers.push(fn),
-    write: (data) => proc.stdin?.writable && proc.stdin.write(data),
-    /**
-     * Send ESC key (0x1B) to interrupt CLI
-     * Used to gracefully stop Claude/Gemini CLI execution
-     * @returns {boolean} true if ESC was sent successfully
-     */
-    sendEsc: () => {
-      if (proc.stdin?.writable) {
-        proc.stdin.write('\x1B');
+    return {
+      onData: (fn) => dataHandlers.push(fn),
+      onExit: (fn) => exitHandlers.push(fn),
+      onError: (fn) => {}, // No error event in native PTY
+      write: (data) => proc.write(data),
+      sendEsc: () => {
+        proc.write('\x1B');
         return true;
-      }
-      return false;
-    },
-    kill: (signal = 'SIGTERM') => proc.kill(signal),
-    pid: proc.pid,
-  };
+      },
+      resize: (cols, rows) => proc.resize(cols, rows),
+      kill: (signal = 'SIGTERM') => proc.kill(signal),
+      pid: proc.pid,
+    };
+  } else {
+    // Use fallback adapter
+    return fallbackAdapter.spawn(command, args, options);
+  }
 }
 
 /**
- * Check if native PTY is available
- * Always returns false on Termux (we use spawn adapter)
+ * Synchronous check if PTY is available
+ * @returns {boolean}
  */
 function isPtyAvailable() {
-  return false;
+  return (
+    tryRequire('@mmmbuto/node-pty-android-arm64') ||
+    tryRequire('@lydell/node-pty-linux-arm64')
+  );
 }
 
-module.exports = { spawn, isPtyAvailable };
+// Initialize native PTY in background (non-blocking)
+initNativePty().catch(() => {
+  // Silently ignore initialization errors
+});
+
+module.exports = {
+  spawn,           // Sync spawn (uses fallback)
+  spawnAsync,      // Async spawn (uses native PTY if available)
+  isPtyAvailable,
+};

package/lib/server/lib/pty-provider.js

@@ -0,0 +1,56 @@
+/**
+ * PTY Provider for NexusCLI (Termux + Linux ARM64)
+ * Provides PTY detection with fallback to child_process adapter
+ * Uses @mmmbuto/pty-termux-utils shared library
+ *
+ * @version 1.0.0
+ */
+
+const { getPty: getSharedPty, createFallbackAdapter } = require('@mmmbuto/pty-termux-utils');
+const tryRequire = (moduleName) => {
+  try {
+    require(moduleName);
+    return true;
+  } catch (_) {
+    return false;
+  }
+};
+
+/**
+ * Get PTY implementation with fallback
+ * @returns {Promise<{module: any, name: string}|null>}
+ */
+async function getPty() {
+  const pty = await getSharedPty();
+  if (pty) {
+    return pty;
+  }
+  return null;
+}
+
+/**
+ * Get fallback adapter (child_process)
+ * @returns {Object} Adapter with spawn method
+ */
+function getFallbackAdapter() {
+  return createFallbackAdapter();
+}
+
+/**
+ * Synchronous check if PTY is available
+ * @returns {boolean}
+ */
+function isPtyAvailable() {
+  return (
+    tryRequire('@mmmbuto/node-pty-android-arm64') ||
+    tryRequire('@lydell/node-pty-linux-arm64')
+  );
+}
+
+module.exports = {
+  getPty,
+  getFallbackAdapter,
+  isPtyAvailable,
+  // Re-export from shared library
+  spawnPty: require('@mmmbuto/pty-termux-utils').spawnPty,
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mmmbuto/nexuscli",
-  "version": "0.9.9",
+  "version": "0.9.10",
   "description": "NexusCLI - TRI CLI Control Plane (Claude/Codex/Gemini/Qwen)",
   "main": "lib/server/server.js",
   "bin": {
@@ -58,6 +58,7 @@
     "x64"
   ],
   "dependencies": {
+    "@mmmbuto/pty-termux-utils": "^1.1.0",
     "bcryptjs": "^3.0.3",
     "chalk": "^4.1.2",
     "commander": "^12.1.0",
@@ -75,5 +76,8 @@
   },
   "devDependencies": {
     "jest": "^30.2.0"
+  },
+  "optionalDependencies": {
+    "@mmmbuto/node-pty-android-arm64": "~1.1.0"
   }
 }