@mmmbuto/nexuscrew 0.1.0-beta.1

package/lib/server/routes/status.js

@@ -0,0 +1,60 @@
+/**
+ * GET /api/v1/status — Tmux status (windows, hosts)
+ * GET /api/v1/status/tmux — Detailed tmux info
+ * GET /api/v1/status/pane/:window — Capture pane content
+ */
+
+const { Router } = require('express');
+const router = Router();
+
+// Overall status
+router.get('/', (req, res) => {
+  const { tmux, store } = req;
+  const windows = tmux.listWindows();
+  const hosts = tmux.getAllHosts();
+
+  res.json({
+    tmux: {
+      session: tmux.sessionName,
+      alive: tmux.hasSession(),
+      windowCount: windows.length,
+      windows
+    },
+    hosts: hosts.map(h => ({
+      ...h,
+      connected: tmux.testHost(h)
+    }))
+  });
+});
+
+// Detailed tmux windows
+router.get('/tmux', (req, res) => {
+  const { tmux, store } = req;
+  const windows = tmux.listWindows();
+
+  // Enrich with DB data
+  const enriched = windows.map(w => {
+    const conv = store.findByWindow(w.name);
+    return {
+      ...w,
+      conversationId: conv?.id || null,
+      engine: conv?.engine || null,
+      model: conv?.model || null,
+      host: conv?.host || 'local',
+      title: conv?.title || w.name
+    };
+  });
+
+  res.json({ windows: enriched });
+});
+
+// Capture pane content
+router.get('/pane/:window', (req, res) => {
+  const { tmux } = req;
+  const { host } = req.query;
+  const content = tmux.capturePane(req.params.window, host || null);
+
+  res.json({ window: req.params.window, content });
+});
+
+module.exports = router;

package/lib/server/server.js

@@ -0,0 +1,173 @@
+/**
+ * NexusCrew Server — tmux-based AI cockpit
+ *
+ * Unified endpoint: POST /api/v1/send
+ * All engines routed through tmux windows.
+ */
+
+const express = require('express');
+const cors = require('cors');
+const path = require('path');
+const fs = require('fs');
+const http = require('http');
+const https = require('https');
+
+const TmuxManager = require('../services/tmux-manager');
+const EngineDiscovery = require('../services/engine-discovery');
+const SessionStore = require('../services/session-store');
+const LogWatcher = require('../services/log-watcher');
+
+const sendRouter = require('./routes/send');
+const sessionsRouter = require('./routes/sessions');
+const modelsRouter = require('./routes/models');
+const statusRouter = require('./routes/status');
+const hostsRouter = require('./routes/hosts');
+
+class NexusCrewServer {
+  constructor(config = {}) {
+    this.port = config.port || process.env.PORT || 41820;
+    this.configDir = config.configDir || path.join(process.env.HOME, '.nexuscrew');
+    this.config = this._loadConfig();
+    this.app = express();
+    this.server = null;
+  }
+
+  _loadConfig() {
+    const configPath = path.join(this.configDir, 'config.json');
+    if (fs.existsSync(configPath)) {
+      return JSON.parse(fs.readFileSync(configPath, 'utf8'));
+    }
+    return { port: this.port, tmuxSession: 'nexuscrew', autoDiscovery: true };
+  }
+
+  _loadHosts() {
+    const hostsPath = path.join(this.configDir, 'hosts.json');
+    if (fs.existsSync(hostsPath)) {
+      return JSON.parse(fs.readFileSync(hostsPath, 'utf8'));
+    }
+    return [{ name: 'local', type: 'local', default: true }];
+  }
+
+  async start() {
+    // Init services
+    const hosts = this._loadHosts();
+    const tmuxManager = new TmuxManager({
+      tmuxSession: this.config.tmuxSession || 'nexuscrew',
+      logDir: this.config.logDir || path.join(this.configDir, 'logs'),
+      hosts
+    });
+
+    const engineDiscovery = new EngineDiscovery(this.config.providersPath);
+    const sessionStore = new SessionStore(path.join(this.configDir, 'nexuscrew.db'));
+    const logWatcher = new LogWatcher();
+
+    // Ensure tmux master session
+    tmuxManager.ensureSession();
+
+    // Sync DB with tmux reality
+    sessionStore.syncWithTmux(tmuxManager);
+
+    // Resume watching logs for active conversations
+    const active = sessionStore.listConversations({ status: 'active' });
+    for (const conv of active) {
+      if (conv.log_path && fs.existsSync(conv.log_path)) {
+        logWatcher.watch(conv.log_path, conv.engine, conv.id);
+      }
+    }
+
+    // Middleware
+    this.app.use(cors());
+    this.app.use(express.json({ limit: '10mb' }));
+
+    // Health check
+    this.app.get('/health', (req, res) => {
+      res.json({
+        status: 'ok',
+        service: 'nexuscrew',
+        version: '0.1.0',
+        tmux: tmuxManager.hasSession(),
+        windows: tmuxManager.listWindows().length,
+        uptime: process.uptime()
+      });
+    });
+
+    // Inject services into request
+    this.app.use((req, res, next) => {
+      req.tmux = tmuxManager;
+      req.engines = engineDiscovery;
+      req.store = sessionStore;
+      req.logWatcher = logWatcher;
+      req.config = this.config;
+      next();
+    });
+
+    // API routes
+    this.app.use('/api/v1/send', sendRouter);
+    this.app.use('/api/v1/sessions', sessionsRouter);
+    this.app.use('/api/v1/models', modelsRouter);
+    this.app.use('/api/v1/status', statusRouter);
+    this.app.use('/api/v1/hosts', hostsRouter);
+
+    // Serve frontend
+    const frontendDist = path.join(__dirname, '../../frontend/dist');
+    if (fs.existsSync(frontendDist)) {
+      this.app.use(express.static(frontendDist));
+      this.app.get('*', (req, res) => {
+        if (!req.path.startsWith('/api/')) {
+          res.sendFile(path.join(frontendDist, 'index.html'));
+        }
+      });
+    }
+
+    // Error handler
+    this.app.use((err, req, res, next) => {
+      console.error('[Error]', err.message);
+      res.status(500).json({ error: err.message });
+    });
+
+    // Start HTTP server
+    this.server = http.createServer(this.app);
+
+    return new Promise((resolve) => {
+      this.server.listen(this.port, () => {
+        console.log('');
+        console.log('╔══════════════════════════════════════════════╗');
+        console.log('║   NexusCrew — tmux AI cockpit               ║');
+        console.log('╚══════════════════════════════════════════════╝');
+        console.log('');
+        console.log(`  HTTP:  http://localhost:${this.port}`);
+        console.log(`  tmux:  session "${tmuxManager.sessionName}" (${tmuxManager.listWindows().length} windows)`);
+        console.log(`  Hosts: ${hosts.map(h => h.name).join(', ')}`);
+        console.log('');
+
+        const engines = engineDiscovery.discover();
+        for (const [name, info] of Object.entries(engines)) {
+          console.log(`  ${info.available ? 'OK' : '  '} ${name}${info.aliases.length ? ` (+${info.aliases.length} aliases)` : ''}`);
+        }
+        console.log('');
+
+        resolve();
+      });
+    });
+  }
+
+  stop() {
+    if (this.server) {
+      this.server.close();
+    }
+  }
+}
+
+// Run if called directly
+if (require.main === module) {
+  const server = new NexusCrewServer();
+  server.start().catch(err => {
+    console.error('Failed to start:', err);
+    process.exit(1);
+  });
+
+  process.on('SIGTERM', () => { server.stop(); process.exit(0); });
+  process.on('SIGINT', () => { console.log('\nShutting down...'); server.stop(); process.exit(0); });
+}
+
+module.exports = NexusCrewServer;

package/lib/services/engine-discovery.js

@@ -0,0 +1,320 @@
+/**
+ * EngineDiscovery — Auto-detect AI CLIs and parse providers.zsh aliases
+ *
+ * Discovers:
+ * - Standard CLIs: claude, codex, gemini, qwen (via PATH + common paths)
+ * - Custom aliases/functions from providers.zsh (e.g. claude-glm-a, codex-alibaba-qwen35)
+ * - Each engine gets: path, type, available, aliases[], models[]
+ */
+
+const { execSync } = require('child_process');
+const path = require('path');
+const fs = require('fs');
+
+const CLI_SEARCH_PATHS = {
+  claude: [
+    '${HOME}/.local/bin/claude',
+    '${HOME}/.claude/local/claude',
+    '/usr/local/bin/claude',
+    '/usr/bin/claude',
+    '${PREFIX}/bin/claude'
+  ],
+  codex: [
+    '${HOME}/.local/codex-lts/bin/codex',
+    '${HOME}/.local/codex-lts/node_modules/.bin/codex',
+    '${HOME}/.local/codex-lts/package/bin/android-arm64/codex',
+    '/usr/local/bin/codex'
+  ],
+  gemini: [
+    '${HOME}/.local/bin/gemini',
+    '${HOME}/.gemini/bin/gemini',
+    '/usr/local/bin/gemini'
+  ],
+  qwen: [
+    '${HOME}/.local/bin/qwen',
+    '${HOME}/.qwen/bin/qwen',
+    '/usr/local/bin/qwen'
+  ]
+};
+
+/**
+ * Engine types:
+ * - interactive: runs as REPL, needs PTY-like handling (send text + Enter)
+ * - exec: runs one-shot commands, returns structured output
+ */
+const ENGINE_TYPES = {
+  claude: 'interactive',
+  codex: 'exec',
+  gemini: 'interactive',
+  qwen: 'interactive'
+};
+
+/**
+ * Build command templates for each engine
+ */
+const ENGINE_COMMANDS = {
+  claude: {
+    new: (bin, opts) => `${bin} --output-format json${opts.model ? ` --model ${opts.model}` : ''}`,
+    resume: (bin, opts) => `${bin} --output-format json -r ${opts.sessionId}${opts.model ? ` --model ${opts.model}` : ''}`,
+    interactive: (bin) => `${bin} --output-format json`
+  },
+  codex: {
+    new: (bin, opts) => `${bin} exec --json${opts.model ? ` -m ${opts.model}` : ''}${opts.reasoningEffort ? ` --reasoning ${opts.reasoningEffort}` : ''}`,
+    resume: (bin, opts) => `${bin} exec --json resume ${opts.threadId}`,
+    interactive: (bin) => bin
+  },
+  gemini: {
+    new: (bin, opts) => `${bin}${opts.model ? ` -m ${opts.model}` : ''}`,
+    resume: (bin, opts) => `${bin} --resume ${opts.threadId}${opts.model ? ` -m ${opts.model}` : ''}`,
+    interactive: (bin) => bin
+  },
+  qwen: {
+    new: (bin, opts) => `${bin}${opts.model ? ` -m ${opts.model}` : ''}`,
+    resume: (bin, opts) => `${bin} --resume ${opts.threadId}${opts.model ? ` -m ${opts.model}` : ''}`,
+    interactive: (bin) => bin
+  }
+};
+
+class EngineDiscovery {
+  constructor(providersPath) {
+    this.providersPath = providersPath || '';
+    this._cache = null;
+  }
+
+  /**
+   * Discover all available engines, aliases, and models
+   * @returns {Object} engines map
+   */
+  discover() {
+    if (this._cache) return this._cache;
+
+    const engines = {};
+
+    // 1. Discover standard CLIs
+    for (const [name, searchPaths] of Object.entries(CLI_SEARCH_PATHS)) {
+      engines[name] = this._discoverCli(name, searchPaths);
+    }
+
+    // 2. Parse providers.zsh for aliases/functions
+    const aliases = this._parseProviders();
+    for (const alias of aliases) {
+      const baseEngine = this._detectBaseEngine(alias.name);
+      if (baseEngine && engines[baseEngine]) {
+        engines[baseEngine].aliases.push({
+          name: alias.name,
+          command: alias.command,
+          description: this._describeAlias(alias.name),
+          modelHint: this._extractModelHint(alias.command)
+        });
+      }
+    }
+
+    // 3. Build model lists for each engine
+    for (const [name, engine] of Object.entries(engines)) {
+      engine.models = this._buildModels(name, engine);
+    }
+
+    this._cache = engines;
+    return engines;
+  }
+
+  /**
+   * Get flat list of all available models across all engines
+   * @returns {Array<{id, name, engine, type, alias?}>}
+   */
+  getAllModels() {
+    const engines = this.discover();
+    const models = [];
+    for (const [engineName, engine] of Object.entries(engines)) {
+      for (const model of engine.models) {
+        models.push({ ...model, engine: engineName });
+      }
+    }
+    return models;
+  }
+
+  /**
+   * Get engines formatted for the frontend model selector
+   */
+  getForFrontend() {
+    const engines = this.discover();
+    const result = {};
+    for (const [name, engine] of Object.entries(engines)) {
+      result[name] = {
+        available: engine.available,
+        type: engine.type,
+        path: engine.path,
+        models: engine.models,
+        aliases: engine.aliases,
+        endpoint: '/api/v1/send' // Single unified endpoint
+      };
+    }
+    return result;
+  }
+
+  // --- Internal ---
+
+  _discoverCli(name, searchPaths) {
+    const resolved = searchPaths.map(p =>
+      p.replace(/\$\{HOME\}/g, process.env.HOME || '')
+       .replace(/\$\{PREFIX\}/g, process.env.PREFIX || '')
+    );
+
+    let foundPath = null;
+    for (const p of resolved) {
+      try {
+        if (fs.existsSync(p) && fs.statSync(p).mode & 0o111) {
+          foundPath = p;
+          break;
+        }
+      } catch {}
+    }
+
+    // Fallback: which
+    if (!foundPath) {
+      try {
+        foundPath = execSync(`which ${name} 2>/dev/null`).toString().trim();
+      } catch {}
+    }
+
+    return {
+      available: !!foundPath,
+      path: foundPath,
+      type: ENGINE_TYPES[name] || 'interactive',
+      aliases: [],
+      models: []
+    };
+  }
+
+  _parseProviders() {
+    if (!fs.existsSync(this.providersPath)) return [];
+
+    const content = fs.readFileSync(this.providersPath, 'utf8');
+    const aliases = [];
+
+    // Match function definitions: name() { ... }
+    const funcRegex = /^(claude-[a-z0-9][a-z0-9-]*|codex-[a-z0-9][a-z0-9-]*|gemini-[a-z0-9][a-z0-9-]*|qwen-[a-z0-9][a-z0-9-]*)\(\)\s*\{([^}]*(?:\{[^}]*\}[^}]*)*)\}/gm;
+
+    let match;
+    while ((match = funcRegex.exec(content)) !== null) {
+      aliases.push({
+        name: match[1],
+        command: match[2].trim()
+      });
+    }
+
+    return aliases;
+  }
+
+  _detectBaseEngine(name) {
+    if (name.startsWith('claude')) return 'claude';
+    if (name.startsWith('codex')) return 'codex';
+    if (name.startsWith('gemini')) return 'gemini';
+    if (name.startsWith('qwen')) return 'qwen';
+    return null;
+  }
+
+  _describeAlias(name) {
+    // Human-readable description from function name
+    const parts = name.split('-');
+    const engine = parts[0];
+    const rest = parts.slice(1);
+
+    const providerMap = {
+      'glm': 'Z.ai GLM',
+      'zai': 'Z.ai',
+      'alibaba': 'Alibaba',
+      'chutes': 'Chutes',
+      'minimax': 'MiniMax',
+      'minimax27': 'MiniMax M2.7'
+    };
+
+    const modelMap = {
+      'a': '(Key A)',
+      'p': '(Key P)',
+      'qwen35': 'Qwen 3.5',
+      'qwen3max': 'Qwen 3 Max',
+      'glm5': 'GLM-5',
+      'glm5ist': 'GLM-5 Turbo',
+      'kimi': 'Kimi K2.5',
+      'minimax': 'MiniMax',
+      'minimax27': 'MiniMax M2.7',
+      'qwencodex': 'Qwen Coder',
+      'qwennext': 'Qwen Coder Next',
+      'qwen3next': 'Qwen 3 Next',
+      'glm5turbo': 'GLM-5 Turbo',
+      'deepseek': 'DeepSeek V3.2'
+    };
+
+    const descriptions = [];
+    for (const part of rest) {
+      if (providerMap[part]) descriptions.push(providerMap[part]);
+      else if (modelMap[part]) descriptions.push(modelMap[part]);
+      else descriptions.push(part);
+    }
+
+    return `${engine} → ${descriptions.join(' / ')}`;
+  }
+
+  _extractModelHint(command) {
+    // Try to extract model name from the command
+    const modelMatch = command.match(/"([^"]+)"/);
+    return modelMatch ? modelMatch[1] : null;
+  }
+
+  _buildModels(engineName, engine) {
+    const models = [];
+
+    if (!engine.available) return models;
+
+    // Native models per engine
+    const nativeModels = {
+      claude: [
+        { id: 'sonnet', name: 'Claude Sonnet', lane: 'native' },
+        { id: 'opus', name: 'Claude Opus', lane: 'native' },
+        { id: 'haiku', name: 'Claude Haiku', lane: 'native' }
+      ],
+      codex: [
+        { id: 'gpt-5.4', name: 'GPT-5.4', lane: 'native' },
+        { id: 'gpt-5.3-codex', name: 'GPT-5.3 Codex', lane: 'native' },
+        { id: 'codex-mini-latest', name: 'Codex Mini', lane: 'native' }
+      ],
+      gemini: [
+        { id: 'gemini-3-pro-preview', name: 'Gemini 3 Pro', lane: 'native' },
+        { id: 'gemini-3-flash-preview', name: 'Gemini 3 Flash', lane: 'native' },
+        { id: 'gemini-2.5-pro', name: 'Gemini 2.5 Pro', lane: 'native' }
+      ],
+      qwen: [
+        { id: 'qwen3-coder-plus', name: 'Qwen 3 Coder Plus', lane: 'native' },
+        { id: 'qwen3.5-plus', name: 'Qwen 3.5 Plus', lane: 'native' },
+        { id: 'qwen3-max', name: 'Qwen 3 Max', lane: 'native' }
+      ]
+    };
+
+    models.push(...(nativeModels[engineName] || []));
+
+    // Alias-based custom models
+    for (const alias of engine.aliases) {
+      if (alias.modelHint) {
+        models.push({
+          id: `${engineName}-${alias.name}`,
+          name: alias.description || alias.name,
+          lane: 'custom',
+          alias: alias.name,
+          modelHint: alias.modelHint
+        });
+      } else {
+        models.push({
+          id: `${engineName}-${alias.name}`,
+          name: alias.description || alias.name,
+          lane: 'custom',
+          alias: alias.name
+        });
+      }
+    }
+
+    return models;
+  }
+}
+
+module.exports = EngineDiscovery;