@mmmbuto/nexuscrew 0.2.1 → 0.2.2

package/lib/server/routes/tmux.js

@@ -0,0 +1,88 @@
+const { Router } = require('express');
+
+const router = Router();
+
+router.get('/sessions', (req, res) => {
+  const { tmux, store } = req;
+  const sessions = tmux.listSessions().map((session) => {
+    const conversation = store.findByTmuxSession(session.sessionName);
+    return {
+      ...session,
+      host: conversation?.host || 'local',
+      workspace: conversation?.workspace || '',
+      conversationId: conversation?.id || null,
+      launcherId: conversation?.launcher_id || null,
+      engine: conversation?.engine || null,
+      status: conversation?.status || 'external'
+    };
+  });
+
+  res.json({ sessions });
+});
+
+router.post('/sessions', (req, res) => {
+  const { tmux, store, engines } = req;
+  const {
+    sessionName,
+    launcherId,
+    workspace,
+    host
+  } = req.body;
+
+  if (!sessionName || !sessionName.trim()) {
+    return res.status(400).json({ error: 'sessionName is required' });
+  }
+  if (!launcherId) {
+    return res.status(400).json({ error: 'launcherId is required' });
+  }
+
+  const launcher = engines.getLauncher(launcherId);
+  if (!launcher) {
+    return res.status(404).json({ error: `Launcher "${launcherId}" not found` });
+  }
+  if (!launcher.runnable) {
+    return res.status(409).json({
+      error: `Launcher "${launcher.label}" was detected from config but is not verified runnable in the current shell`
+    });
+  }
+
+  const targetHost = host || 'local';
+  if (tmux.hasSession(sessionName.trim(), targetHost)) {
+    return res.status(409).json({ error: `tmux session "${sessionName.trim()}" already exists` });
+  }
+
+  const runtime = engines.getRuntimeInfo();
+  const createResult = tmux.createSession({
+    sessionName: sessionName.trim(),
+    cwd: (workspace || runtime.homeDir || '').trim() || runtime.homeDir,
+    host: targetHost,
+    shell: runtime.shell,
+    launcherCommand: launcher.command
+  });
+
+  const conversation = store.createConversation({
+    title: sessionName.trim(),
+    engine: launcher.family,
+    workspace: (workspace || runtime.homeDir || '').trim() || runtime.homeDir,
+    host: targetHost,
+    tmuxSession: createResult.sessionName,
+    logPath: createResult.logPath,
+    launcherId: launcher.id
+  });
+  store.updateConversation(conversation.id, { title: sessionName.trim() });
+
+  res.status(201).json({
+    session: {
+      sessionName: createResult.sessionName,
+      logPath: createResult.logPath,
+      host: targetHost,
+      workspace: conversation.workspace,
+      conversationId: conversation.id,
+      launcherId: launcher.id,
+      engine: launcher.family,
+      runnable: true
+    }
+  });
+});
+
+module.exports = router;

package/lib/server/server.js

@@ -10,134 +10,117 @@ const cors = require('cors');
 const path = require('path');
 const fs = require('fs');
 const http = require('http');
+const os = require('os');
+const packageJson = require('../../package.json');
 
-const { initDb, saveDb } = require('./db/adapter');
 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 RemotePaneWatcher = require('../services/remote-pane-watcher');
-const AttachmentManager = require('./services/attachment-manager');
-const SpeechManager = require('./services/speech-manager');
-const { getConfig } = require('../config/manager');
 
-// Routes
 const sendRouter = require('./routes/send');
 const sessionsRouter = require('./routes/sessions');
 const modelsRouter = require('./routes/models');
-const runtimesRouter = require('./routes/runtimes');
 const statusRouter = require('./routes/status');
 const hostsRouter = require('./routes/hosts');
-const wakeLockRouter = require('./routes/wake-lock');
-const authRouter = require('./routes/auth');
-const speechRouter = require('./routes/speech');
-const keysRouter = require('./routes/keys');
-const uploadRouter = require('./routes/upload');
-const workspacesRouter = require('./routes/workspaces');
-
-// Middleware
-const { authMiddleware } = require('./middleware/auth');
+const tmuxRouter = require('./routes/tmux');
+const launchersRouter = require('./routes/launchers');
+const runtimeRouter = require('./routes/runtime');
 
 class NexusCrewServer {
   constructor(config = {}) {
-    this.configDir = config.configDir || path.join(process.env.HOME, '.nexuscrew');
+    this.port = config.port || process.env.PORT || 41820;
+    this.configDir = config.configDir || path.join(os.homedir(), '.nexuscrew');
     this.config = this._loadConfig();
-    this.port = config.port || process.env.PORT || this.config.server?.port || 41820;
     this.app = express();
     this.server = null;
   }
 
   _loadConfig() {
-    return getConfig();
+    const configPath = path.join(this.configDir, 'config.json');
+    if (fs.existsSync(configPath)) {
+      const loaded = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+      if (loaded.providersPath && !loaded.extraShellSources) {
+        loaded.extraShellSources = [loaded.providersPath].filter(Boolean);
+      }
+      return loaded;
+    }
+    return {
+      port: this.port,
+      autoDiscovery: true,
+      preferredShell: '',
+      extraShellSources: []
+    };
   }
 
-  async start() {
-    // 1. Init database
-    await initDb();
-
-    // 2. Seed admin user if no users exist
-    const User = require('./models/User');
-    if (User.count() === 0) {
-      User.create('admin', 'admin', 'admin');
-      console.log('  Created initial admin account from local defaults');
+  _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 }];
+  }
 
-    // 3. Init services
+  async start() {
+    const hosts = this._loadHosts();
     const tmuxManager = new TmuxManager({
-      tmuxSession: this.config.tmuxSession || 'nexuscrew',
-      logDir: this.config.logDir || path.join(this.configDir, 'logs')
+      logDir: this.config.logDir || path.join(this.configDir, 'logs'),
+      preferredShell: this.config.preferredShell || process.env.SHELL || '/bin/sh',
+      hosts
     });
 
-    const engineDiscovery = new EngineDiscovery(this.config.providersPath);
-    const sessionStore = new SessionStore();
-    await sessionStore.init();
+    const engineDiscovery = new EngineDiscovery({
+      preferredShell: this.config.preferredShell,
+      extraShellSources: this.config.extraShellSources || []
+    });
+    const sessionStore = new SessionStore(path.join(this.configDir, 'nexuscrew.db'));
     const logWatcher = new LogWatcher();
-    const remotePaneWatcher = new RemotePaneWatcher(tmuxManager);
-    const attachmentManager = new AttachmentManager(tmuxManager);
-    const speechManager = new SpeechManager();
-    this.app.locals.logWatcher = logWatcher;
-    this.app.locals.remotePaneWatcher = remotePaneWatcher;
 
-    // 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);
+        logWatcher.watch(conv.log_path, conv.engine || 'generic', conv.id);
       }
     }
 
-    // 4. Middleware
+    // Middleware
     this.app.use(cors());
     this.app.use(express.json({ limit: '10mb' }));
 
-    // 5. Health check (public)
+    // Health check
     this.app.get('/health', (req, res) => {
       res.json({
         status: 'ok',
         service: 'nexuscrew',
-        version: '0.2.1',
-        tmux: tmuxManager.hasSession(),
-        windows: tmuxManager.listWindows().length,
+        version: packageJson.version,
+        tmuxSessions: tmuxManager.listSessions().length,
         uptime: process.uptime()
       });
     });
 
-    // 6. Inject services into request
+    // Inject services into request
     this.app.use((req, res, next) => {
       req.tmux = tmuxManager;
       req.engines = engineDiscovery;
       req.store = sessionStore;
       req.logWatcher = logWatcher;
-      req.remotePaneWatcher = remotePaneWatcher;
-      req.attachments = attachmentManager;
-      req.speech = speechManager;
       req.config = this.config;
       next();
     });
 
-    // 7. Public routes
-    this.app.use('/api/v1/auth', authRouter);
-    this.app.use('/api/v1', wakeLockRouter);
-    this.app.use('/api/v1/runtimes', runtimesRouter); // public for login screen
+    // 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/keys', keysRouter); // public for STT key check
-
-    // 8. Protected routes
-    this.app.use('/api/v1/send', authMiddleware, sendRouter);
-    this.app.use('/api/v1/sessions', authMiddleware, sessionsRouter);
-    this.app.use('/api/v1/workspaces', authMiddleware, workspacesRouter);
-    this.app.use('/api/v1/status', authMiddleware, statusRouter);
-    this.app.use('/api/v1/hosts', authMiddleware, hostsRouter);
-    this.app.use('/api/v1/speech', authMiddleware, speechRouter);
-    this.app.use('/api/v1/upload', authMiddleware, uploadRouter);
-
-    // 9. Serve frontend
+    this.app.use('/api/v1/status', statusRouter);
+    this.app.use('/api/v1/hosts', hostsRouter);
+    this.app.use('/api/v1/tmux', tmuxRouter);
+    this.app.use('/api/v1/launchers', launchersRouter);
+    this.app.use('/api/v1/runtime', runtimeRouter);
+
+    // Serve frontend
     const frontendDist = path.join(__dirname, '../../frontend/dist');
     if (fs.existsSync(frontendDist)) {
       this.app.use(express.static(frontendDist));
@@ -148,13 +131,13 @@ class NexusCrewServer {
       });
     }
 
-    // 10. Error handler
+    // Error handler
     this.app.use((err, req, res, next) => {
       console.error('[Error]', err.message);
       res.status(500).json({ error: err.message });
     });
 
-    // 11. Start HTTP server
+    // Start HTTP server
     this.server = http.createServer(this.app);
 
     return new Promise((resolve) => {
@@ -165,13 +148,13 @@ class NexusCrewServer {
         console.log('╚══════════════════════════════════════════════╝');
         console.log('');
         console.log(`  HTTP:  http://localhost:${this.port}`);
-        console.log(`  tmux:  session "${tmuxManager.sessionName}" (${tmuxManager.listWindows().length} windows)`);
-        console.log(`  Hosts: ${tmuxManager.getAllHosts().map(h => h.name).join(', ')}`);
+        console.log(`  tmux:  ${tmuxManager.listSessions().length} active sessions`);
+        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)` : ''}`);
+        const discovery = engineDiscovery.discover();
+        for (const launcher of discovery.launchers) {
+          console.log(`  OK ${launcher.label} [${launcher.kind}]`);
         }
         console.log('');
 
@@ -182,10 +165,6 @@ class NexusCrewServer {
 
   stop() {
     if (this.server) {
-      const appLocals = this.app?.locals || {};
-      appLocals.logWatcher?.unwatchAll?.();
-      appLocals.remotePaneWatcher?.unwatchAll?.();
-      saveDb();
       this.server.close();
     }
   }