@mmmbuto/nexuscli 0.9.9 → 0.9.11

package/CHANGELOG.md

@@ -0,0 +1,74 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+## [0.9.10] - 2026-01-09
+### Fixed
+- Added PTY dependency check in postinstall to verify node-pty installation
+- Added pty-termux-utils verification to ensure .cjs files are built
+- Platform detection now installs correct PTY provider:
+  - `@mmmbuto/node-pty-android-arm64` for Termux
+  - `@lydell/node-pty-linux-arm64` for Linux ARM64
+- Provides helpful error messages when PTY dependencies are missing
+## [0.9.11] - 2026-01-09
+### Fixed
+- Added PTY dependency verification in postinstall
+- Added platform-specific PTY provider installation
+- Added @mmmbuto/pty-termux-utils installation check
+- All PTY dependencies now verified during npm install
+- Updated @mmmbuto/pty-termux-utils to ^1.1.2
+
+
+
+## [0.9.9] - 2026-01-01
+### Added
+- Auto-update check on `nexuscli start` (npm + GitHub) with interactive prompt.
+- `nexuscli update` / `nexuscli upgrade` command to update and restart server.
+- Warnings when changing config while server is running.
+- Live refresh of default model in UI (periodic + on focus).
+
+## [0.9.8] - 2025-12-30
+### Changed
+- Update GLM routing to GLM-4.7 for Z.ai in Claude wrapper and model catalog.
+### Docs
+- README updated for GLM-4.7 and release version.
+
+## [0.9.7004-termux] - 2025-12-28
+### Fixed
+- Force Qwen model selection so `vision-model` is honored for image prompts.
+- Parse Qwen stream-json tool events to keep statusbar live.
+- Improve light theme contrast and update mobile statusbar theme colors.
+
+## [0.9.7-termux] - 2025-12-28
+### Added
+- QWEN engine integration (Qwen Code CLI) with SSE streaming.
+- QWEN models in catalog: `coder-model`, `vision-model`.
+- QWEN session import + resume support.
+### Changed
+- Statusbar now reflects QWEN tool activity in real time (stream-json parsing).
+
+## [0.9.6] - 2025-12-26
+### Fixed
+- Restore Jobs CLI wrapper and Termux PTY adapter removed during cleanup.
+- Use Termux-safe shell/runtime resolution for job execution (no hardcoded /bin or /usr/bin paths).
+- Surface job stream errors correctly in the UI.
+
+## [0.9.5] - 2025-12-25
+### Added
+- GPT-5.2 Codex set as default Codex model.
+### Changed
+- Updated Codex model catalog to match OpenAI CLI.
+### Fixed
+- i18n import after cleanup.
+
+## [0.9.4] - 2025-12-25
+### Added
+- Dark/Light theme toggle with CSS variables and localStorage persistence.
+- Rate limiting on chat endpoints (10 req/min per user).
+- Architecture documentation (`docs/ARCHITECTURE.md`).
+
+## [0.9.3] - 2025-12-19
+### Fixed
+- Normalize Termux workspace paths (auto-correct `/data/data/com/termux/...`) to prevent Claude spawn ENOENT and stalled GLM-4.6/DeepSeek runs.
+- Workspaces API now filters and merges invalid paths to keep the UI dropdown clean.
+- Session importer reads `cwd` from Claude session files when available for accurate workspace mapping.

package/README.md

@@ -6,39 +6,18 @@
 
 ---
 
-## Overview
-
-NexusCLI is a lightweight, Termux-first AI cockpit that orchestrates Claude Code, Codex CLI, Gemini CLI, and Qwen Code CLI from a single web/terminal UI. It supports live streaming, interrupts, session resume, workspace isolation, and remote voice input with auto HTTPS setup.
-
----
-
 [![npm](https://img.shields.io/npm/v/@mmmbuto/nexuscli?style=flat-square&logo=npm)](https://www.npmjs.com/package/@mmmbuto/nexuscli)
 [![downloads](https://img.shields.io/npm/dt/@mmmbuto/nexuscli?style=flat-square)](https://www.npmjs.com/package/@mmmbuto/nexuscli)
 [![ko-fi](https://img.shields.io/badge/☕_Support-Ko--fi-FF5E5B?style=flat-square&logo=ko-fi)](https://ko-fi.com/dionanos)
 
 ---
 
-## Screenshots
+## Overview
 
-<p align="center">
-  <img src="docs/assets/screenshots/nexuscli-multilang-preview.png" width="45%" />
-  <img src="docs/assets/screenshots/nexuscli-mobile-glm.png" width="45%" />
-</p>
+NexusCLI is a lightweight, Termux-first AI cockpit that orchestrates Claude Code, Codex CLI, Gemini CLI, and Qwen Code CLI from a single web/terminal UI. It supports live streaming, interrupts, session resume, workspace isolation, and remote voice input with auto HTTPS setup.
 
 ---
 
-## Highlights (v0.9.9)
-
-- **Auto-update**: Update check on start (npm + GitHub) with interactive prompt
-- **Update command**: `nexuscli update` / `nexuscli upgrade` (stop → update → restart)
-- **Live default model**: UI refreshes config on focus/interval without restart
-- **Restart warnings**: CLI warns when changes require stop/start
-
-### Stable (v0.9.9)
-
-- Update check is cached and non-blocking for normal startup
-- GitHub-only releases show a notice without prompting
-
 ## Features
 
 - Multi-engine orchestration (Claude, Codex, Gemini, Qwen)
@@ -52,6 +31,8 @@ NexusCLI is a lightweight, Termux-first AI cockpit that orchestrates Claude Code
 - Conversation search + pin/bookmark
 - Built-in jobs runner API for shell tasks
 - Config API + rate limiting on chat endpoints
+- Auto-update check on start with interactive prompt
+- `nexuscli update` command to update and restart server
 
 ## Supported Engines
 
@@ -65,6 +46,15 @@ NexusCLI is a lightweight, Termux-first AI cockpit that orchestrates Claude Code
 
 ---
 
+## Screenshots
+
+<p align="center">
+  <img src="docs/assets/screenshots/nexuscli-multilang-preview.png" width="45%" />
+  <img src="docs/assets/screenshots/nexuscli-mobile-glm.png" width="45%" />
+</p>
+
+---
+
 ## Install
 
 ```bash
@@ -128,8 +118,6 @@ nexuscli start
 | `nexuscli upgrade` | Alias for update |
 | `nexuscli uninstall` | Remove NexusCLI |
 
----
-
 > **Note**: On `nexuscli start`, an update check runs (cached) and will prompt in interactive shells.
 
 ## API Keys
@@ -195,8 +183,8 @@ engine CLIs alive in background; it spawns them on demand and resumes sessions.
 - Install Termux:Boot to auto-restart after reboot or app kill.
 - Keep a persistent notification (Termux:API helps prevent background kill).
 
-**Reduce battery usage (when you don’t need it always-on):**
-- Stop the server when idle: `nexuscli stop`.
+**Reduce battery usage (when you don't need it always-on):**
+- Stop server when idle: `nexuscli stop`.
 - Disable wake-lock and notifications when not needed.
 - Prefer lighter models and lower reasoning settings.
 
@@ -240,6 +228,30 @@ npm run dev
 
 ---
 
+## 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
+```
+
+---
+
+## Changelog
+
+See [CHANGELOG.md](CHANGELOG.md) for version history.
+
+---
+
 ## License
 
 MIT License.

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/lib/setup/postinstall-pty-check.js

@@ -0,0 +1,183 @@
+/**
+ * PTY Dependency Check for NexusCLI Post-Install
+ * Detects platform and installs appropriate PTY provider
+ */
+
+const { execSync } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+
+const colors = {
+  green: (s) => `\x1b[32m${s}\x1b[0m`,
+  yellow: (s) => `\x1b[33m${s}\x1b[0m`,
+  red: (s) => `\x1b[31m${s}\x1b[0m`,
+  cyan: (s) => `\x1b[36m${s}\x1b[0m`,
+  gray: (s) => `\x1b[90m${s}\x1b[0m`
+};
+
+function log(msg) { console.log(msg); }
+function success(msg) { console.log(colors.green(`  ✓ ${msg}`)); }
+function warn(msg) { console.log(colors.yellow(`  ⚠ ${msg}`)); }
+function error(msg) { console.log(colors.red(`  ✗ ${msg}`)); }
+
+/**
+ * Detect platform
+ */
+function detectPlatform() {
+  const isTermux =
+    process.env.PREFIX?.includes('com.termux') ||
+    fs.existsSync('/data/data/com.termux') ||
+    process.env.TERMUX_VERSION !== undefined;
+  
+  const isLinuxArm64 = process.platform === 'linux' && process.arch === 'arm64';
+  
+  if (isTermux) return 'termux';
+  if (isLinuxArm64) return 'linux-arm64';
+  return 'other';
+}
+
+/**
+ * Check if npm package is installed
+ */
+function isNpmPackageInstalled(packageName) {
+  try {
+    const nodeModulesPath = path.join(__dirname, '..', '..', 'node_modules', packageName);
+    return fs.existsSync(nodeModulesPath);
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Check if pty.node exists (native module)
+ */
+function checkPtyNode() {
+  try {
+    const nodeModulesPath = path.join(__dirname, '..', '..', 'node_modules');
+    
+    // Check @mmmbuto/node-pty-android-arm64
+    const androidPtyPath = path.join(nodeModulesPath, '@mmmbuto', 'node-pty-android-arm64', 'build', 'Release', 'pty.node');
+    if (fs.existsSync(androidPtyPath)) {
+      return { found: true, provider: '@mmmbuto/node-pty-android-arm64', path: androidPtyPath };
+    }
+    
+    // Check @lydell/node-pty-linux-arm64
+    const linuxPtyPath = path.join(nodeModulesPath, '@lydell', 'node-pty-linux-arm64', 'build', 'Release', 'pty.node');
+    if (fs.existsSync(linuxPtyPath)) {
+      return { found: true, provider: '@lydell/node-pty-linux-arm64', path: linuxPtyPath };
+    }
+    
+    return { found: false };
+  } catch {
+    return { found: false };
+  }
+}
+
+/**
+ * Install PTY provider
+ */
+function installPtyProvider(provider) {
+  try {
+    log(`  Installing ${provider}...`);
+    
+    const npmCmd = process.env.npm_execpath || 'npm';
+    execSync(`${npmCmd} install ${provider}`, { 
+      stdio: 'inherit',
+      cwd: path.join(__dirname, '..', '..')
+    });
+    
+    success(`${provider} installed`);
+    return true;
+  } catch (err) {
+    warn(`${provider} installation failed: ${err.message}`);
+    return false;
+  }
+}
+
+/**
+ * Main PTY check function
+ */
+function checkPtyDependencies() {
+  console.log('');
+  console.log(colors.cyan('Checking PTY dependencies:'));
+  
+  const platform = detectPlatform();
+  let targetProvider = null;
+  
+  // Determine target provider based on platform
+  if (platform === 'termux') {
+    targetProvider = '@mmmbuto/node-pty-android-arm64';
+  } else if (platform === 'linux-arm64') {
+    targetProvider = '@lydell/node-pty-linux-arm64';
+  } else {
+    log(colors.gray('  Skipped: Unsupported platform for PTY (not Termux/Linux ARM64)'));
+    log(colors.gray('  PTY will use fallback adapter (child_process)'));
+    return;
+  }
+  
+  // Check if PTY native module exists
+  const ptyCheck = checkPtyNode();
+  
+  if (ptyCheck.found) {
+    success(`Native PTY found: ${ptyCheck.provider}`);
+  } else {
+    // Check if package is installed but pty.node is missing
+    if (isNpmPackageInstalled(targetProvider)) {
+      warn(`${targetProvider} installed but pty.node missing - may need rebuild`);
+      warn(`  Run: npm rebuild ${targetProvider}`);
+    } else {
+      warn(`${targetProvider} not installed`);
+    }
+    
+    // Try to install
+    const installed = installPtyProvider(targetProvider);
+    if (installed) {
+      // Verify installation
+      const verify = checkPtyNode();
+      if (verify.found) {
+        success(`Native PTY verified: ${verify.provider}`);
+      } else {
+        warn(`PTY package installed but pty.node not found`);
+        warn(`  You may need to rebuild: npm rebuild ${targetProvider}`);
+      }
+    } else {
+      warn(`Cannot install ${targetProvider} - PTY will use fallback`);
+    }
+  }
+  
+  console.log('');
+}
+
+
+/**
+ * Check if pty-termux-utils is installed and has .cjs files
+ */
+function checkPtyTermuxUtils() {
+  try {
+    const ptyUtilsPath = path.join(__dirname, '..', '..', 'node_modules', '@mmmbuto', 'pty-termux-utils');
+    
+    if (!fs.existsSync(ptyUtilsPath)) {
+      warn('@mmmbuto/pty-termux-utils not installed');
+      warn('  This is required for PTY support');
+      warn('  Run: npm install @mmmbuto/pty-termux-utils');
+      return false;
+    }
+    
+    const indexCjsPath = path.join(ptyUtilsPath, 'dist', 'index.cjs');
+    if (fs.existsSync(indexCjsPath)) {
+      success('@mmmbuto/pty-termux-utils installed with CJS support');
+      return true;
+    } else {
+      warn('@mmmbuto/pty-termux-utils installed but .cjs files missing');
+      warn('  Run: cd node_modules/@mmmbuto/pty-termux-utils && npm run build:cjs');
+      return false;
+    }
+  } catch (err) {
+    warn('Error checking @mmmbuto/pty-termux-utils: ' + err.message);
+    return false;
+  }
+}
+
+module.exports = { checkPtyDependencies ,
+  checkPtyTermuxUtils
+};

package/lib/setup/postinstall.js

@@ -4,6 +4,8 @@
  * Termux-only: auto-run wizard if not configured
  */
 
+
+const { checkPtyDependencies, checkPtyTermuxUtils } = require('./postinstall-pty-check');
 const { execSync, spawn } = require('child_process');
 const fs = require('fs');
 const path = require('path');
@@ -22,7 +24,6 @@ const colors = {
   red: (s) => `\x1b[31m${s}\x1b[0m`,
   cyan: (s) => `\x1b[36m${s}\x1b[0m`,
   bold: (s) => `\x1b[1m${s}\x1b[0m`,
-  gray: (s) => `\x1b[90m${s}\x1b[0m`
 };
 
 function log(msg) {
@@ -144,6 +145,15 @@ async function main() {
   for (const pkg of packages) {
     installPackage(pkg);
   }
+
+  // Check PTY dependencies
+  checkPtyDependencies();
+
+  // Check pty-termux-utils
+  checkPtyTermuxUtils();
+
+  // Check pty-termux-utils
+  checkPtyTermuxUtils();
   console.log('');
 
   // Create directories

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mmmbuto/nexuscli",
-  "version": "0.9.9",
+  "version": "0.9.11",
   "description": "NexusCLI - TRI CLI Control Plane (Claude/Codex/Gemini/Qwen)",
   "main": "lib/server/server.js",
   "bin": {
@@ -44,6 +44,7 @@
     "frontend/dist/",
     "package.json",
     "README.md",
+    "CHANGELOG.md",
     "LICENSE"
   ],
   "engines": {
@@ -58,6 +59,7 @@
     "x64"
   ],
   "dependencies": {
+    "@mmmbuto/pty-termux-utils": "^1.1.2",
     "bcryptjs": "^3.0.3",
     "chalk": "^4.1.2",
     "commander": "^12.1.0",
@@ -75,5 +77,8 @@
   },
   "devDependencies": {
     "jest": "^30.2.0"
+  },
+  "optionalDependencies": {
+    "@mmmbuto/node-pty-android-arm64": "~1.1.0"
   }
-}
+}