@mmmbuto/nexuscli 0.9.7004-termux → 0.10.0

package/lib/server/db/migrations/006_runtime_lane_tracking.sql

@@ -0,0 +1,79 @@
+ALTER TABLE sessions ADD COLUMN lane TEXT;
+
+ALTER TABLE sessions ADD COLUMN runtime_id TEXT;
+
+ALTER TABLE sessions ADD COLUMN provider_id TEXT;
+
+ALTER TABLE sessions ADD COLUMN model_id TEXT;
+
+ALTER TABLE messages ADD COLUMN lane TEXT;
+
+ALTER TABLE messages ADD COLUMN runtime_id TEXT;
+
+ALTER TABLE messages ADD COLUMN provider_id TEXT;
+
+ALTER TABLE messages ADD COLUMN model_id TEXT;
+
+UPDATE sessions
+SET engine = 'claude'
+WHERE lower(engine) = 'claude-code';
+
+UPDATE messages
+SET engine = 'claude'
+WHERE lower(engine) = 'claude-code';
+
+UPDATE sessions
+SET
+  lane = COALESCE(lane, 'native'),
+  runtime_id = COALESCE(runtime_id,
+    CASE
+      WHEN lower(engine) LIKE '%codex%' OR lower(engine) LIKE '%openai%' THEN 'codex-native'
+      WHEN lower(engine) LIKE '%gemini%' OR lower(engine) LIKE '%google%' THEN 'gemini-native'
+      WHEN lower(engine) LIKE '%qwen%' THEN 'qwen-native'
+      ELSE 'claude-native'
+    END
+  ),
+  provider_id = COALESCE(provider_id,
+    CASE
+      WHEN lower(engine) LIKE '%codex%' OR lower(engine) LIKE '%openai%' THEN 'openai'
+      WHEN lower(engine) LIKE '%gemini%' OR lower(engine) LIKE '%google%' THEN 'google'
+      WHEN lower(engine) LIKE '%qwen%' THEN 'qwen'
+      ELSE 'anthropic'
+    END
+  ),
+  model_id = COALESCE(model_id,
+    CASE
+      WHEN lower(engine) LIKE '%codex%' OR lower(engine) LIKE '%openai%' THEN 'gpt-5.3-codex'
+      WHEN lower(engine) LIKE '%gemini%' OR lower(engine) LIKE '%google%' THEN 'gemini-3-pro-preview'
+      WHEN lower(engine) LIKE '%qwen%' THEN 'qwen3-coder-plus'
+      ELSE 'sonnet'
+    END
+  );
+
+UPDATE messages
+SET
+  lane = COALESCE(lane, 'native'),
+  runtime_id = COALESCE(runtime_id,
+    CASE
+      WHEN lower(engine) LIKE '%codex%' OR lower(engine) LIKE '%openai%' THEN 'codex-native'
+      WHEN lower(engine) LIKE '%gemini%' OR lower(engine) LIKE '%google%' THEN 'gemini-native'
+      WHEN lower(engine) LIKE '%qwen%' THEN 'qwen-native'
+      ELSE 'claude-native'
+    END
+  ),
+  provider_id = COALESCE(provider_id,
+    CASE
+      WHEN lower(engine) LIKE '%codex%' OR lower(engine) LIKE '%openai%' THEN 'openai'
+      WHEN lower(engine) LIKE '%gemini%' OR lower(engine) LIKE '%google%' THEN 'google'
+      WHEN lower(engine) LIKE '%qwen%' THEN 'qwen'
+      ELSE 'anthropic'
+    END
+  ),
+  model_id = COALESCE(model_id,
+    CASE
+      WHEN lower(engine) LIKE '%codex%' OR lower(engine) LIKE '%openai%' THEN 'gpt-5.3-codex'
+      WHEN lower(engine) LIKE '%gemini%' OR lower(engine) LIKE '%google%' THEN 'gemini-3-pro-preview'
+      WHEN lower(engine) LIKE '%qwen%' THEN 'qwen3-coder-plus'
+      ELSE 'sonnet'
+    END
+  );

package/lib/server/lib/getPty.js

@@ -0,0 +1,51 @@
+/**
+ * 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 { getPtyFn, getLogDebugFn } = require('./pty-utils-loader');
+
+const getSharedPty = getPtyFn();
+const logDebug = getLogDebugFn();
+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,125 @@
 /**
- * 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 { getPtyFn, getFallbackAdapter } = require('./pty-utils-loader');
+
+const getSharedPty = getPtyFn();
+const tryRequire = (moduleName) => {
+  try {
+    require(moduleName);
+    return true;
+  } catch (_) {
+    return false;
+  }
+};
+
+// Create shared fallback adapter (always uses child_process)
+const fallbackAdapter = getFallbackAdapter();
+
+// Cache for native PTY (sync access)
+let cachedNativePty = null;
+
+/**
+ * Initialize native PTY (called at startup)
+ */
+async function initNativePty() {
+  if (cachedNativePty !== null) {
+    return cachedNativePty;
+  }
+  
+  try {
+    cachedNativePty = await getSharedPty();
+    return cachedNativePty;
+  } catch (e) {
+    cachedNativePty = false; // Error loading
+    return null;
+  }
+}
 
 /**
- * Spawn a process with node-pty-like interface
+ * 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,63 @@
+/**
+ * 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 {
+  getPtyFn,
+  getSpawnPtyFn,
+  getFallbackAdapter: getSafeFallbackAdapter
+} = require('./pty-utils-loader');
+
+const getSharedPty = getPtyFn();
+const spawnPty = getSpawnPtyFn();
+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 getSafeFallbackAdapter();
+}
+
+/**
+ * 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,
+};

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/server/middleware/auth.js

@@ -1,8 +1,31 @@
+const crypto = require('crypto');
 const jwt = require('jsonwebtoken');
 const User = require('../models/User');
 const { getConfig } = require('../../config/manager');
 
-const JWT_SECRET = process.env.JWT_SECRET || 'nexuscli-secret-change-in-production';
+let warnedEphemeralSecret = false;
+
+function getJwtSecret() {
+  if (process.env.JWT_SECRET) {
+    return process.env.JWT_SECRET;
+  }
+
+  const config = getConfig();
+  if (config.auth?.jwt_secret) {
+    return config.auth.jwt_secret;
+  }
+
+  if (!global.__NEXUSCLI_EPHEMERAL_JWT_SECRET__) {
+    global.__NEXUSCLI_EPHEMERAL_JWT_SECRET__ = crypto.randomBytes(48).toString('hex');
+  }
+
+  if (!warnedEphemeralSecret) {
+    warnedEphemeralSecret = true;
+    console.warn('[Auth] JWT secret missing from env and config; using ephemeral in-memory secret for this process');
+  }
+
+  return global.__NEXUSCLI_EPHEMERAL_JWT_SECRET__;
+}
 
 /**
  * Get config user (admin from init) by id
@@ -31,14 +54,14 @@ function generateToken(user) {
       username: user.username,
       role: user.role
     },
-    JWT_SECRET,
+    getJwtSecret(),
     { expiresIn: JWT_EXPIRES_IN }
   );
 }
 
 function verifyToken(token) {
   try {
-    return jwt.verify(token, JWT_SECRET);
+    return jwt.verify(token, getJwtSecret());
   } catch (err) {
     return null;
   }
@@ -99,5 +122,5 @@ module.exports = {
   verifyToken,
   authMiddleware,
   adminOnly,
-  JWT_SECRET
+  getJwtSecret
 };

package/lib/server/models/Conversation.js

@@ -28,15 +28,19 @@ class Conversation {
 
     const sessionStmt = prepare(`
       INSERT INTO sessions (
-        id, engine, workspace_path, title,
+        id, engine, lane, runtime_id, provider_id, model_id, workspace_path, title,
         last_used_at, created_at, message_count
       )
-      VALUES (?, ?, ?, ?, ?, ?, ?)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
     `);
 
     sessionStmt.run(
       id,
-      'claude-code',
+      'claude',
+      'native',
+      'claude-native',
+      'anthropic',
+      'sonnet',
       workspace,
       title,
       now,

package/lib/server/models/Message.js

@@ -14,15 +14,31 @@ class Message {
    * @param {Object} metadata - Optional metadata
    * @param {number} createdAt - Optional timestamp override
    * @param {string} engine - Engine used ('claude' | 'codex' | 'gemini' | 'qwen')
+   * @param {Object} runtimeMeta - Optional runtime-aware metadata
    * @returns {Object} Created message
    */
-  static create(conversationId, role, content, metadata = null, createdAt = Date.now(), engine = 'claude') {
+  static create(
+    conversationId,
+    role,
+    content,
+    metadata = null,
+    createdAt = Date.now(),
+    engine = 'claude',
+    runtimeMeta = {}
+  ) {
     const id = uuidv4();
     const now = createdAt || Date.now();
+    const lane = runtimeMeta.lane || 'native';
+    const runtimeId = runtimeMeta.runtimeId || `${engine}-native`;
+    const providerId = runtimeMeta.providerId || null;
+    const modelId = runtimeMeta.modelId || null;
 
     const stmt = prepare(`
-      INSERT INTO messages (id, conversation_id, role, content, created_at, metadata, engine)
-      VALUES (?, ?, ?, ?, ?, ?, ?)
+      INSERT INTO messages (
+        id, conversation_id, role, content, created_at, metadata, engine,
+        lane, runtime_id, provider_id, model_id
+      )
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
     `);
 
     stmt.run(
@@ -32,7 +48,11 @@ class Message {
       content,
       now,
       metadata ? JSON.stringify(metadata) : null,
-      engine
+      engine,
+      lane,
+      runtimeId,
+      providerId,
+      modelId
     );
 
     // Touch conversation (update updated_at)
@@ -45,7 +65,11 @@ class Message {
       content,
       created_at: now,
       metadata,
-      engine
+      engine,
+      lane,
+      runtime_id: runtimeId,
+      provider_id: providerId,
+      model_id: modelId
     };
   }