@mmmbuto/nexuscrew 0.2.0 → 0.2.2

package/README.md

@@ -1,34 +1,71 @@
-# NexusCrew — tmux AI Cockpit
+## Overview
 
-**Mobile-first** web cockpit for AI CLI tools. Persistent sessions via tmux.
+NexusCrew is a **tmux-based** AI cockpit that orchestrates Claude Code, Codex CLI, Gemini CLI, and Qwen Code through persistent tmux sessions.
+
+This is a **study project** exploring an alternative approach to AI CLI orchestration, based on experience with [NexusCLI](https://www.npmjs.com/package/@mmmbuto/nexuscli). Instead of managing PTY processes in-memory, NexusCrew delegates session lifecycle to **tmux** so sessions survive server restarts and can be accessed directly from the terminal.
+
+> **Status**: Beta — experimental, API may change
+
+> **Disclaimer**: This project is experimental. The automation pipeline is fast enough that it may be generated, tested, and published before I finish thinking about it. Expect incomplete features, mistakes, and breaking changes.
+
+---
+
+## Why tmux?
+
+| Problem | NexusCLI (PTY) | NexusCrew (tmux) |
+|---------|---------------|-------------------|
+| Server crash | All sessions die | Sessions survive |
+| Direct access | Web UI only | Web UI + `tmux attach` |
+| Remote machines | Not supported | Experimental host registry |
+| Native deps | node-pty required | SQLite native addon |
+| Session recovery | Manual | Automatic |
+
+---
 
 ## Features
 
-- **Persistent sessions** — tmux windows survive server restarts
-- **4 engines** — Claude Code, Codex CLI, Gemini CLI, Qwen Code
-- **Mobile-first** — Termux (Android) primary target, then Linux/Mac
-- **Zero native deps** — sql.js (WASM SQLite), no compilation needed
-- **Auth** — JWT with localhost auto-bypass
-- **Dark/Light theme** — CSS variables, instant toggle
-- **i18n** — 6 languages (en, it, es, ja, ru, zh)
-- **STT/TTS** — Speech-to-text (Web Speech API + OpenAI Whisper) + Read aloud
-- **File upload** — 50MB attachments
-- **Session dots** — Green (alive), Yellow (idle), Red (dead) tmux state
-- **Lane-aware models** — Native + Custom per engine
-- **Shell discovery** — Scans .zshrc, .bashrc, providers.zsh for aliases
-- **Remote hosts** — SSH to any machine
-- **SSE streaming** — Real-time AI output
-- **6 languages UI** — Auto-detects browser language
+- **Persistent sessions** — standalone tmux sessions survive server restarts
+- **Multi-engine** — Claude Code, Codex CLI, Gemini CLI, Qwen Code
+- **Auto-discovery** — detects installed CLIs plus live shell aliases/functions and generic shell config fallbacks
+- **Explicit tmux creation** — create a new tmux session only from a detected runnable launcher
+- **Unified web UI** — attach chat to real active tmux sessions
+- **SSE streaming** — real-time output from tmux sessions
+- **Cross-platform** — Linux, macOS, Termux (Android)
+
+---
+
+## Engine Discovery
+
+NexusCrew automatically detects:
+
+1. **PATH binaries** — `claude`, `codex`, `gemini`, `qwen` when present in the runtime PATH
+2. **Live shell wrappers** — aliases/functions available in the current login shell
+3. **Shell-file fallbacks** — wrappers detected from `.zshrc`, `.bashrc`, `.profile`, and optional extra shell sources
+
+Launchers detected only from shell files are shown as detected metadata but are not treated as runnable until they are verified in the active shell context.
+
+---
 
 ## Install
 
 ```bash
 npm install -g @mmmbuto/nexuscrew
+```
+
+Then initialize:
+
+```bash
 nexuscrew init
+```
+
+And start:
+
+```bash
 nexuscrew start
-# Open http://localhost:41820
 ```
 
+Open `http://localhost:41820` in your browser.
+
 ### Termux (Android)
 
 ```bash
@@ -38,72 +75,103 @@ nexuscrew init
 nexuscrew start
 ```
 
-## Quick Start
+---
+
+## Hosts Registry
+
+You can store SSH host definitions for later work:
 
 ```bash
-nexuscrew init      # First-time setup
-nexuscrew start     # Start server + tmux
-nexuscrew status    # Check server + sessions
-nexuscrew attach    # Attach to tmux directly
-nexuscrew engines   # Discover AI CLIs
+nexuscrew hosts add --name vps1 --host example.com --user user
+nexuscrew hosts add --name vps2 --host 192.168.1.10 --user admin --port 2222
 ```
 
-## Architecture
+Host storage and connectivity tests are available, but the current UI and default session flow are local tmux-first. Treat remote execution as experimental until it is revalidated end-to-end.
 
-```
-Browser/WebView ←SSE/REST→ Express :41820 ←tmux→ CLI AI processes
-                                    |
-                                sql.js DB (WASM)
-                                JWT Auth
-```
+---
+
+## Commands
 
-Each AI session = one tmux window. Output captured via `tee`, streamed to UI via SSE.
+| Command | Description |
+|---------|-------------|
+| `nexuscrew init` | First-time setup (config, hosts, tmux check) |
+| `nexuscrew start` | Start server |
+| `nexuscrew stop` | Stop server |
+| `nexuscrew status` | Server + tmux + hosts status |
+| `nexuscrew engines` | Discover available AI CLIs and aliases |
+| `nexuscrew sessions` | List tmux sessions |
+| `nexuscrew attach` | Attach to tmux session directly |
+| `nexuscrew config` | View/edit configuration |
+| `nexuscrew hosts list` | List configured hosts |
+| `nexuscrew hosts add` | Add remote SSH host |
+| `nexuscrew hosts remove` | Remove a host |
+
+---
 
 ## Configuration
 
-`~/.nexuscrew/config.json`:
+Config stored in `~/.nexuscrew/config.json`:
+
 ```json
 {
   "port": 41820,
-  "tmuxSession": "nexuscrew",
-  "autoDiscovery": true
+  "logDir": "~/.nexuscrew/logs",
+  "autoDiscovery": true,
+  "preferredShell": "",
+  "extraShellSources": []
 }
 ```
 
-## Commands
+Hosts stored in `~/.nexuscrew/hosts.json`:
 
-| Command | Description |
-|---------|-------------|
-| `nexuscrew init` | First-time setup |
-| `nexuscrew start` | Start server + tmux |
-| `nexuscrew stop` | Stop server |
-| `nexuscrew status` | Server + tmux + hosts |
-| `nexuscrew engines` | Discover CLIs + aliases |
-| `nexuscrew sessions` | List tmux windows |
-| `nexuscrew attach` | Attach to tmux |
-| `nexuscrew config` | View/edit config |
-| `nexuscrew hosts add` | Add SSH host |
+```json
+[
+  { "name": "local", "type": "local", "default": true },
+  { "name": "vps1", "type": "ssh", "host": "example.com", "user": "user", "port": "22" }
+]
+```
+
+---
+
+## Network
+
+| Protocol | Default Port | Use Case |
+|----------|--------------|----------|
+| HTTP | `41820` | Local access |
+
+---
 
-## API
+## Architecture
+
+```
+Browser ←SSE→ Express Server ←tmux→ active tmux sessions
+                                      ├─ session: claude-work
+                                      ├─ session: codex-debug
+                                      └─ session: qwen-sandbox
+```
 
-Public: `/health`, `/api/v1/auth/login`, `/api/v1/models`, `/api/v1/runtimes`
-Protected (JWT/localhost): `/api/v1/send`, `/api/v1/sessions`, `/api/v1/upload`, `/api/v1/workspaces`
+Each AI session = one standalone tmux session. Output is piped to log files, parsed by the watcher, and streamed to the UI via SSE.
 
-Default login: `admin` / `admin` (change after first login)
+---
 
 ## Development
 
 ```bash
-git clone https://github.com/DioNanos/nexuscrew
-cd nexuscrew && npm install
+git clone https://github.com/dionanos/nexuscrew
+cd nexuscrew
+npm install
 cd frontend && npm install && npm run build && cd ..
 npm run dev
 ```
 
-## Related
+---
+
+## Relation to NexusCLI
+
+NexusCrew is a **study branch** inspired by [NexusCLI](https://www.npmjs.com/package/@mmmbuto/nexuscli). It shares the same web UI direction but replaces PTY-based process management with tmux-based persistent sessions. The goal is to explore whether tmux provides a simpler, more robust foundation for local AI CLI orchestration and crash recovery.
 
-- [NexusCLI](https://www.npmjs.com/package/@mmmbuto/nexuscli) — PTY-based variant
+---
 
 ## License
 
-MIT
+MIT License. See [LICENSE](LICENSE).

package/bin/nexuscrew.js

@@ -4,86 +4,83 @@
 const { Command } = require('commander');
 const path = require('path');
 const fs = require('fs');
-const { execSync } = require('child_process');
+const os = require('os');
+const { execSync, spawn } = require('child_process');
 
-const CONFIG_DIR = path.join(process.env.HOME || '', '.nexuscrew');
-const DB_PATH = path.join(CONFIG_DIR, 'nexuscrew.db');
+const EngineDiscovery = require('../lib/services/engine-discovery');
+const packageJson = require('../package.json');
+
+const CONFIG_DIR = path.join(os.homedir(), '.nexuscrew');
 const CONFIG_PATH = path.join(CONFIG_DIR, 'config.json');
 const HOSTS_PATH = path.join(CONFIG_DIR, 'hosts.json');
-const TMUX_SESSION = 'nexuscrew';
+
+const DEFAULT_PORT = '41820';
 
 const program = new Command();
 program
   .name('nexuscrew')
   .description('tmux-based AI cockpit')
-  .version('0.2.0');
+  .version(packageJson.version);
 
-// --- init ---
 program.command('init')
   .description('First-time setup')
-  .option('-s, --silent', 'Silent mode (no output)')
+  .option('--silent', 'Suppress setup output')
   .action((opts) => {
+    const log = (...args) => {
+      if (!opts.silent) console.log(...args);
+    };
+    const error = (...args) => {
+      if (!opts.silent) console.error(...args);
+    };
+
     if (!fs.existsSync(CONFIG_DIR)) {
       fs.mkdirSync(CONFIG_DIR, { recursive: true });
-      if (!opts.silent) console.log('Created ~/.nexuscrew/');
+      log('Created ~/.nexuscrew/');
     }
 
-    // Default config
     if (!fs.existsSync(CONFIG_PATH)) {
       fs.writeFileSync(CONFIG_PATH, JSON.stringify({
-        port: 41820,
-        tmuxSession: TMUX_SESSION,
+        port: Number(DEFAULT_PORT),
         logDir: path.join(CONFIG_DIR, 'logs'),
         autoDiscovery: true,
-        providersPath: ''
+        preferredShell: '',
+        extraShellSources: []
       }, null, 2));
-      if (!opts.silent) console.log('Created config.json');
+      log('Created config.json');
     }
 
-    // Default hosts
     if (!fs.existsSync(HOSTS_PATH)) {
       fs.writeFileSync(HOSTS_PATH, JSON.stringify([
         { name: 'local', type: 'local', default: true }
       ], null, 2));
-      if (!opts.silent) console.log('Created hosts.json');
+      log('Created hosts.json');
     }
 
-    // Log dir
     const logDir = path.join(CONFIG_DIR, 'logs');
     if (!fs.existsSync(logDir)) {
       fs.mkdirSync(logDir, { recursive: true });
     }
 
-    // Check tmux
     try {
-      execSync('which tmux', { stdio: 'pipe' });
-      if (!opts.silent) console.log('tmux: OK');
+      execSync('command -v tmux >/dev/null 2>&1', { stdio: 'pipe' });
+      log('tmux: OK');
     } catch {
-      if (!opts.silent) console.error('tmux not found! Install: apt install tmux (or pkg install tmux)');
+      error('tmux not found! Install: apt install tmux (or pkg install tmux)');
     }
 
-    if (!opts.silent) console.log('\nDone! Run: nexuscrew start');
+    log('\nDone! Run: nexuscrew start');
   });
 
-// --- start ---
 program.command('start')
   .description('Start the server')
-  .option('-p, --port <port>', 'Port', '41820')
+  .option('-p, --port <port>', 'Port', DEFAULT_PORT)
   .option('-d, --dev', 'Dev mode (no frontend)')
   .action((opts) => {
-    // Ensure tmux master session exists
-    try {
-      execSync(`tmux has-session -t ${TMUX_SESSION} 2>/dev/null`);
-    } catch {
-      execSync(`tmux new-session -d -s ${TMUX_SESSION} -x 200 -y 50`);
-      console.log(`Created tmux session: ${TMUX_SESSION}`);
-    }
-
     const env = { ...process.env, PORT: opts.port };
     if (opts.dev) env.NEXUSCREW_DEV = '1';
 
     const args = [path.join(__dirname, '..', 'lib', 'server', 'server.js')];
-    const child = require('child_process').spawn('node', args, {
+    const child = spawn('node', args, {
       env,
       stdio: 'inherit',
       detached: false
@@ -91,12 +88,11 @@ program.command('start')
     child.on('exit', (code) => process.exit(code || 0));
   });
 
-// --- stop ---
 program.command('stop')
   .description('Stop the server')
   .action(() => {
     try {
-      const pid = execSync(`lsof -ti :41820 2>/dev/null`).toString().trim();
+      const pid = execSync(`lsof -ti :${DEFAULT_PORT} 2>/dev/null`).toString().trim();
       if (pid) {
         execSync(`kill ${pid}`);
         console.log('Server stopped');
@@ -108,72 +104,64 @@ program.command('stop')
     }
   });
 
-// --- status ---
 program.command('status')
   .description('Show server and tmux status')
   .action(() => {
     console.log('=== NexusCrew Status ===\n');
 
-    // Server
     try {
-      const pid = execSync(`lsof -ti :41820 2>/dev/null`).toString().trim();
+      const pid = execSync(`lsof -ti :${DEFAULT_PORT} 2>/dev/null`).toString().trim();
       console.log(`Server: RUNNING (pid ${pid})`);
     } catch {
       console.log('Server: STOPPED');
     }
 
-    // tmux
     try {
-      const windows = execSync(`tmux list-windows -t ${TMUX_SESSION} -F '#{window_name} #{?window_active,*, }' 2>/dev/null`).toString().trim();
-      console.log(`\ntmux session "${TMUX_SESSION}":`);
-      windows.split('\n').forEach(w => console.log(`  ${w}`));
+      const sessions = execSync("tmux list-sessions -F '#{session_name} #{?session_attached,*, }' 2>/dev/null").toString().trim();
+      console.log('\nActive tmux sessions:');
+      sessions.split('\n').filter(Boolean).forEach((session) => console.log(`  ${session}`));
     } catch {
-      console.log(`\ntmux session "${TMUX_SESSION}": NOT FOUND`);
+      console.log('\nActive tmux sessions: none');
     }
 
-    // Hosts
     if (fs.existsSync(HOSTS_PATH)) {
       const hosts = JSON.parse(fs.readFileSync(HOSTS_PATH, 'utf8'));
       console.log('\nHosts:');
-      hosts.forEach(h => {
-        if (h.type === 'local') {
-          console.log(`  ${h.name}: local`);
+      hosts.forEach((host) => {
+        if (host.type === 'local') {
+          console.log(`  ${host.name}: local`);
         } else {
-          const status = testSSH(h) ? 'OK' : 'UNREACHABLE';
-          console.log(`  ${h.name}: ${h.user}@${h.host}${h.port ? ':' + h.port : ''} [${status}]`);
+          const status = testSSH(host) ? 'OK' : 'UNREACHABLE';
+          console.log(`  ${host.name}: ${host.user}@${host.host}${host.port ? ':' + host.port : ''} [${status}]`);
         }
       });
     }
   });
 
-// --- attach ---
 program.command('attach')
-  .description('Attach to tmux session')
-  .option('-w, --window <name>', 'Attach to specific window')
+  .description('Attach to a tmux session')
+  .requiredOption('-s, --session <name>', 'Session name')
   .action((opts) => {
-    const target = opts.window ? `${TMUX_SESSION}:${opts.window}` : TMUX_SESSION;
     try {
-      execSync(`tmux attach -t ${target}`, { stdio: 'inherit' });
+      execSync(`tmux attach -t ${shellQuote(opts.session)}`, { stdio: 'inherit' });
     } catch {
-      console.error(`Session/window not found: ${target}`);
+      console.error(`Session not found: ${opts.session}`);
     }
   });
 
-// --- sessions ---
 program.command('sessions')
-  .description('List tmux windows')
+  .description('List active tmux sessions')
   .action(() => {
     try {
       const out = execSync(
-        `tmux list-windows -t ${TMUX_SESSION} -F '#{window_index}: #{window_name} [#{window_width}x#{window_height}] #{?window_active,(active),}' 2>/dev/null`
+        "tmux list-sessions -F '#{session_name} [#{session_windows} windows] #{?session_attached,(attached),}' 2>/dev/null"
       ).toString().trim();
-      console.log(out);
+      console.log(out || 'No tmux sessions found');
     } catch {
-      console.log('No tmux session found');
+      console.log('No tmux sessions found');
     }
   });
 
-// --- config ---
 program.command('config')
   .description('View/edit configuration')
   .option('-l, --list', 'Show current config')
@@ -188,7 +176,11 @@ program.command('config')
     if (opts.set) {
       const [key, ...rest] = opts.set.split('=');
       const value = rest.join('=');
-      config[key] = isNaN(value) ? value : Number(value);
+      let parsedValue = value;
+      if (value === 'true') parsedValue = true;
+      if (value === 'false') parsedValue = false;
+      if (!Number.isNaN(Number(value)) && value.trim() !== '') parsedValue = Number(value);
+      config[key] = parsedValue;
       fs.writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2));
       console.log(`Set ${key} = ${value}`);
     } else {
@@ -196,7 +188,6 @@ program.command('config')
     }
   });
 
-// --- hosts ---
 const hostsCmd = program.command('hosts').description('Manage remote hosts');
 
 hostsCmd.command('list')
@@ -207,9 +198,9 @@ hostsCmd.command('list')
       return;
     }
     const hosts = JSON.parse(fs.readFileSync(HOSTS_PATH, 'utf8'));
-    hosts.forEach((h, i) => {
-      const status = h.type === 'local' ? 'local' : (testSSH(h) ? 'OK' : 'UNREACHABLE');
-      console.log(`[${i}] ${h.name} (${h.type}) ${h.host || ''} [${status}]${h.default ? ' *default*' : ''}`);
+    hosts.forEach((host, i) => {
+      const status = host.type === 'local' ? 'local' : (testSSH(host) ? 'OK' : 'UNREACHABLE');
+      console.log(`[${i}] ${host.name} (${host.type}) ${host.host || ''} [${status}]${host.default ? ' *default*' : ''}`);
     });
   });
 
@@ -217,7 +208,7 @@ hostsCmd.command('add')
   .description('Add a remote host')
   .requiredOption('-n, --name <name>', 'Host name')
   .requiredOption('-h, --host <host>', 'Hostname or IP')
-  .option('-u, --user <user>', 'SSH user', 'dag')
+  .option('-u, --user <user>', 'SSH user', os.userInfo().username)
   .option('-p, --port <port>', 'SSH port', '22')
   .option('-k, --key <path>', 'SSH key path')
   .action((opts) => {
@@ -243,31 +234,38 @@ hostsCmd.command('remove')
     let hosts = fs.existsSync(HOSTS_PATH)
       ? JSON.parse(fs.readFileSync(HOSTS_PATH, 'utf8'))
       : [];
-    hosts = hosts.filter(h => h.name !== opts.name);
+    hosts = hosts.filter((host) => host.name !== opts.name);
     fs.writeFileSync(HOSTS_PATH, JSON.stringify(hosts, null, 2));
     console.log(`Removed host: ${opts.name}`);
   });
 
-// --- engines ---
 program.command('engines')
-  .description('Discover available AI CLIs')
+  .description('Discover available launchers')
   .action(() => {
-    const engines = discoverEngines();
-    console.log('\nDiscovered Engines:\n');
-    for (const [name, info] of Object.entries(engines)) {
-      console.log(`  ${name}: ${info.available ? 'OK' : 'NOT FOUND'}`);
-      if (info.path) console.log(`    path: ${info.path}`);
-      if (info.aliases.length) {
-        console.log(`    aliases: ${info.aliases.join(', ')}`);
-      }
+    const launchers = new EngineDiscovery(readConfig()).getLaunchers();
+    console.log('\nDiscovered Launchers:\n');
+    for (const launcher of launchers) {
+      console.log(`  ${launcher.label}: ${launcher.kind} [${launcher.family}]${launcher.runnable ? '' : ' (detected only)'}`);
+      console.log(`    command: ${launcher.commandPreview}`);
+      console.log(`    source:  ${launcher.source}`);
     }
     console.log('');
   });
 
-// --- helpers ---
+function readConfig() {
+  if (!fs.existsSync(CONFIG_PATH)) {
+    return { preferredShell: '', extraShellSources: [] };
+  }
+  const config = JSON.parse(fs.readFileSync(CONFIG_PATH, 'utf8'));
+  if (config.providersPath && !config.extraShellSources) {
+    config.extraShellSources = [config.providersPath].filter(Boolean);
+  }
+  return config;
+}
+
 function testSSH(host) {
   try {
-    const keyOpt = host.key ? `-i ${host.key}` : '';
+    const keyOpt = host.key ? `-i ${shellQuote(host.key)}` : '';
     const portOpt = host.port && host.port !== '22' ? `-p ${host.port}` : '';
     execSync(`ssh -o ConnectTimeout=3 -o BatchMode=yes ${keyOpt} ${portOpt} ${host.user}@${host.host} echo ok`, { stdio: 'pipe' });
     return true;
@@ -276,79 +274,8 @@ function testSSH(host) {
   }
 }
 
-function discoverEngines() {
-  const engines = {
-    claude: { available: false, path: null, aliases: [], type: 'interactive' },
-    codex: { available: false, path: null, aliases: [], type: 'exec' },
-    gemini: { available: false, path: null, aliases: [], type: 'interactive' },
-    qwen: { available: false, path: null, aliases: [], type: 'interactive' }
-  };
-
-  // Direct CLI discovery
-  const cliPaths = {
-    claude: [
-      path.join(process.env.HOME, '.local/bin/claude'),
-      path.join(process.env.HOME, '.claude/local/claude'),
-      '/usr/local/bin/claude'
-    ],
-    codex: [
-      path.join(process.env.HOME, '.local/codex-lts/bin/codex'),
-      path.join(process.env.HOME, '.local/codex-lts/node_modules/.bin/codex')
-    ],
-    gemini: [
-      path.join(process.env.HOME, '.local/bin/gemini'),
-      path.join(process.env.HOME, '.gemini/bin/gemini')
-    ],
-    qwen: [
-      path.join(process.env.HOME, '.local/bin/qwen'),
-      path.join(process.env.HOME, '.qwen/bin/qwen')
-    ]
-  };
-
-  for (const [engine, paths] of Object.entries(cliPaths)) {
-    for (const p of paths) {
-      try {
-        if (fs.existsSync(p) && fs.statSync(p).mode & 0o111) {
-          engines[engine].available = true;
-          engines[engine].path = p;
-          break;
-        }
-      } catch {}
-    }
-    // Fallback: check PATH
-    if (!engines[engine].available) {
-      try {
-        const which = execSync(`which ${engine} 2>/dev/null`).toString().trim();
-        if (which) {
-          engines[engine].available = true;
-          engines[engine].path = which;
-        }
-      } catch {}
-    }
-  }
-
-  // Parse providers file for aliases (if configured)
-  const configPath = path.join(process.env.HOME || '', '.nexuscrew', 'config.json');
-  let providersPath = '';
-  try {
-    const cfg = JSON.parse(fs.readFileSync(configPath, 'utf8'));
-    providersPath = cfg.providersPath || '';
-  } catch {}
-  if (providersPath && fs.existsSync(providersPath)) {
-    const content = fs.readFileSync(providersPath, 'utf8');
-    const funcRegex = /^(codex-[a-z0-9-]+|claude-[a-z0-9-]+|gemini-[a-z0-9-]+|qwen-[a-z0-9-]+)\(\)/gm;
-    let match;
-    while ((match = funcRegex.exec(content)) !== null) {
-      const alias = match[1];
-      const baseEngine = alias.split('-')[0];
-      const engine = baseEngine === 'codex' ? 'codex' : baseEngine === 'claude' ? 'claude' : baseEngine === 'gemini' ? 'gemini' : 'qwen';
-      if (engines[engine]) {
-        engines[engine].aliases.push(alias);
-      }
-    }
-  }
-
-  return engines;
+function shellQuote(value) {
+  return `'${String(value).replace(/'/g, `'\\''`)}'`;
 }
 
 program.parse();