@mmmbuto/nexuscli 0.9.10 → 0.9.12

package/CHANGELOG.md

@@ -0,0 +1,80 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+## [0.9.12] - 2026-01-09
+### Fixed
+- Guard PTY utils loading to avoid hard crash when dependency is broken or missing
+- Safer fallback adapter when native PTY stack is unavailable
+- Updated @mmmbuto/pty-termux-utils to ^1.1.3
+
+## [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.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.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

@@ -1,23 +1,9 @@
-# NexusCLI — AI Terminal Cockpit
-
-<p align="center">
-  <img src=".github/header/header.png" width="900" />
-</p>
-
----
-
 ## 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
 
 <p align="center">
@@ -27,18 +13,6 @@ NexusCLI is a lightweight, Termux-first AI cockpit that orchestrates Claude Code
 
 ---
 
-## 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 +26,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
 
@@ -69,7 +45,7 @@ NexusCLI is a lightweight, Termux-first AI cockpit that orchestrates Claude Code
 
 ```bash
 # From npm
-npm install -g @mmmbuto/nexuscli
+npm install -g @mmmbuto/nexuscli@0.9.12
 
 # From GitHub
 npm install -g github:DioNanos/nexuscli
@@ -79,7 +55,7 @@ npm install -g github:DioNanos/nexuscli
 
 ```bash
 # Latest (default)
-npm install -g @mmmbuto/nexuscli
+npm install -g @mmmbuto/nexuscli@0.9.12
 
 # Stable channel (pinned)
 npm install -g @mmmbuto/nexuscli@stable
@@ -128,8 +104,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 +169,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,11 +214,6 @@ npm run dev
 
 ---
 
-## License
-
-MIT License.
-See `LICENSE` for details.
-
 ## PTY Support (Shared Library)
 
 NexusCLI uses `@mmmbuto/pty-termux-utils` as a shared library for PTY
@@ -260,3 +229,16 @@ management across all Termux CLI projects (Gemini, Qwen, Nexus).
 # Enable PTY debug logging
 PTY_DEBUG=1 nexuscli start
 ```
+
+---
+
+## Changelog
+
+See [CHANGELOG.md](CHANGELOG.md) for version history.
+
+---
+
+## License
+
+MIT License.
+See `LICENSE` for details.

package/lib/server/lib/getPty.js

@@ -10,7 +10,10 @@
  * @version 1.1.0
  */
 
-const { getPty: getSharedPty, logDebug } = require('@mmmbuto/pty-termux-utils');
+const { getPtyFn, getLogDebugFn } = require('./pty-utils-loader');
+
+const getSharedPty = getPtyFn();
+const logDebug = getLogDebugFn();
 const tryRequire = (moduleName) => {
   try {
     require(moduleName);

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

@@ -6,7 +6,9 @@
  * @version 1.0.0
  */
 
-const { createFallbackAdapter } = require('@mmmbuto/pty-termux-utils');
+const { getPtyFn, getFallbackAdapter } = require('./pty-utils-loader');
+
+const getSharedPty = getPtyFn();
 const tryRequire = (moduleName) => {
   try {
     require(moduleName);
@@ -17,7 +19,7 @@ const tryRequire = (moduleName) => {
 };
 
 // Create shared fallback adapter (always uses child_process)
-const fallbackAdapter = createFallbackAdapter();
+const fallbackAdapter = getFallbackAdapter();
 
 // Cache for native PTY (sync access)
 let cachedNativePty = null;
@@ -31,8 +33,7 @@ async function initNativePty() {
   }
   
   try {
-    const { getPty } = require('@mmmbuto/pty-termux-utils');
-    cachedNativePty = await getPty();
+    cachedNativePty = await getSharedPty();
     return cachedNativePty;
   } catch (e) {
     cachedNativePty = false; // Error loading

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

@@ -6,7 +6,14 @@
  * @version 1.0.0
  */
 
-const { getPty: getSharedPty, createFallbackAdapter } = require('@mmmbuto/pty-termux-utils');
+const {
+  getPtyFn,
+  getSpawnPtyFn,
+  getFallbackAdapter: getSafeFallbackAdapter
+} = require('./pty-utils-loader');
+
+const getSharedPty = getPtyFn();
+const spawnPty = getSpawnPtyFn();
 const tryRequire = (moduleName) => {
   try {
     require(moduleName);
@@ -33,7 +40,7 @@ async function getPty() {
  * @returns {Object} Adapter with spawn method
  */
 function getFallbackAdapter() {
-  return createFallbackAdapter();
+  return getSafeFallbackAdapter();
 }
 
 /**
@@ -52,5 +59,5 @@ module.exports = {
   getFallbackAdapter,
   isPtyAvailable,
   // Re-export from shared library
-  spawnPty: require('@mmmbuto/pty-termux-utils').spawnPty,
+  spawnPty,
 };

package/lib/server/lib/pty-utils-loader.js

@@ -0,0 +1,136 @@
+/**
+ * Safe loader for @mmmbuto/pty-termux-utils with fallback adapter.
+ * Prevents hard crashes if the dependency is missing or broken.
+ */
+
+const { spawn } = require('child_process');
+
+let cachedUtils;
+let warned = false;
+
+function warnOnce(error) {
+  if (warned) return;
+  warned = true;
+  const message = error && error.message ? error.message : String(error);
+  console.warn('[PTY] Failed to load @mmmbuto/pty-termux-utils. Using fallback adapter.');
+  console.warn(`[PTY] Reason: ${message}`);
+}
+
+function loadPtyUtils() {
+  if (cachedUtils !== undefined) return cachedUtils;
+  try {
+    cachedUtils = require('@mmmbuto/pty-termux-utils');
+  } catch (err) {
+    warnOnce(err);
+    cachedUtils = null;
+  }
+  return cachedUtils;
+}
+
+function ensurePtyInterface(proc) {
+  if (!proc) return proc;
+  if (typeof proc.onData === 'function' && typeof proc.onExit === 'function') {
+    return proc;
+  }
+
+  const hasChildStd = !!(proc.stdout || proc.stderr);
+  const dataHandlers = [];
+  const exitHandlers = [];
+
+  if (typeof proc.on === 'function' && !hasChildStd) {
+    proc.on('data', (data) => {
+      dataHandlers.forEach((fn) => fn(data));
+    });
+    proc.on('exit', (code, signal) => {
+      exitHandlers.forEach((fn) => fn({ exitCode: code, signal }));
+    });
+  } else {
+    proc.stdout?.on('data', (data) => {
+      dataHandlers.forEach((fn) => fn(data.toString()));
+    });
+    proc.stderr?.on('data', (data) => {
+      dataHandlers.forEach((fn) => fn(data.toString()));
+    });
+    proc.on?.('exit', (code, signal) => {
+      exitHandlers.forEach((fn) => fn({ exitCode: code ?? -1, signal }));
+    });
+  }
+
+  proc.onData = (fn) => dataHandlers.push(fn);
+  proc.onExit = (fn) => exitHandlers.push(fn);
+
+  if (typeof proc.onError !== 'function' && typeof proc.on === 'function') {
+    proc.onError = (fn) => proc.on('error', fn);
+  }
+  if (typeof proc.write !== 'function') {
+    proc.write = (data) => proc.stdin?.write(data);
+  }
+  if (typeof proc.sendEsc !== 'function') {
+    proc.sendEsc = () => {
+      if (proc.stdin?.writable) {
+        proc.stdin.write('\x1B');
+        return true;
+      }
+      return false;
+    };
+  }
+  if (typeof proc.resize !== 'function') {
+    proc.resize = () => {};
+  }
+  if (typeof proc.kill !== 'function' && proc.process?.kill) {
+    proc.kill = (signal = 'SIGTERM') => proc.process.kill(signal);
+  }
+  if (proc.pid == null && proc.process?.pid != null) {
+    proc.pid = proc.process.pid;
+  }
+
+  return proc;
+}
+
+function createLocalFallbackAdapter() {
+  return {
+    spawn: (file, args, options = {}) => {
+      const child = spawn(file, args, {
+        cwd: options.cwd,
+        env: options.env ? { ...process.env, ...options.env } : undefined,
+      });
+      return ensurePtyInterface(child);
+    }
+  };
+}
+
+function getPtyFn() {
+  const utils = loadPtyUtils();
+  return utils?.getPty ? utils.getPty : async () => null;
+}
+
+function getSpawnPtyFn() {
+  const utils = loadPtyUtils();
+  return utils?.spawnPty
+    ? utils.spawnPty
+    : async () => { throw new Error('Native PTY utilities unavailable'); };
+}
+
+function getLogDebugFn() {
+  const utils = loadPtyUtils();
+  return utils?.logDebug ? utils.logDebug : () => {};
+}
+
+function getFallbackAdapter() {
+  const utils = loadPtyUtils();
+  if (utils?.createFallbackAdapter) {
+    const base = utils.createFallbackAdapter();
+    return {
+      spawn: (...args) => ensurePtyInterface(base.spawn(...args))
+    };
+  }
+  return createLocalFallbackAdapter();
+}
+
+module.exports = {
+  getPtyFn,
+  getSpawnPtyFn,
+  getLogDebugFn,
+  getFallbackAdapter,
+  ensurePtyInterface
+};

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.10",
+  "version": "0.9.12",
   "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,7 +59,7 @@
     "x64"
   ],
   "dependencies": {
-    "@mmmbuto/pty-termux-utils": "^1.1.0",
+    "@mmmbuto/pty-termux-utils": "^1.1.3",
     "bcryptjs": "^3.0.3",
     "chalk": "^4.1.2",
     "commander": "^12.1.0",