@mmmbuto/nexuscrew 0.2.0 → 0.2.2

package/lib/server/routes/send.js

@@ -1,38 +1,33 @@
 /**
- * POST /api/v1/send — Unified send endpoint
+ * POST /api/v1/send — send a message to an existing tmux session
+ * POST /api/v1/send/interrupt — interrupt current generation
  *
- * Routes message to the correct tmux window.
- * Creates new window if needed, resumes existing.
+ * This route never creates tmux sessions implicitly.
  */
 
 const { Router } = require('express');
-const { v4: uuidv4 } = require('uuid');
-const path = require('path');
+const os = require('os');
 
 const router = Router();
 
 router.post('/', async (req, res) => {
-  const { tmux, engines, store, logWatcher, config } = req;
+  const { tmux, store, logWatcher } = req;
   const {
     conversationId,
     message,
-    model,
-    engine: engineOverride,
+    tmuxSession,
     workspace,
-    host: hostName,
-    alias,
-    resumeSession
+    host: hostName
   } = req.body;
 
   if (!message || !message.trim()) {
     return res.status(400).json({ error: 'Message is required' });
   }
 
-  // Set SSE headers
   res.writeHead(200, {
     'Content-Type': 'text/event-stream',
     'Cache-Control': 'no-cache',
-    'Connection': 'keep-alive',
+    Connection: 'keep-alive',
     'X-Accel-Buffering': 'no'
   });
 
@@ -41,192 +36,127 @@ router.post('/', async (req, res) => {
   };
 
   try {
-    // Resolve engine and model
-    const resolvedEngine = engineOverride || resolveEngine(model, engines);
-    const host = hostName || 'local';
-    const hostObj = host !== 'local' ? tmux.getHost(host) : null;
+    let conversation = conversationId ? store.getConversation(conversationId) : null;
+    const resolvedHost = hostName || conversation?.host || 'local';
+    const resolvedSession = (tmuxSession || conversation?.tmux_session || '').trim();
 
-    // Get or create conversation
-    let conversation;
-    let isNew = false;
-
-    if (conversationId) {
-      conversation = store.getConversation(conversationId);
+    if (!resolvedSession) {
+      sendSSE('error', { error: 'tmuxSession is required' });
+      return res.end();
+    }
+    if (!tmux.hasSession(resolvedSession, resolvedHost)) {
+      sendSSE('error', { error: `tmux session "${resolvedSession}" is not active` });
+      return res.end();
     }
 
     if (!conversation) {
-      isNew = true;
-      conversation = store.createConversation({
-        engine: resolvedEngine,
-        model: model || null,
-        workspace: workspace || process.env.HOME,
-        host
+      const existing = store.findByTmuxSession(resolvedSession);
+      conversation = existing || store.createConversation({
+        title: resolvedSession,
+        engine: null,
+        workspace: (workspace || os.homedir()).trim() || os.homedir(),
+        host: resolvedHost,
+        tmuxSession: resolvedSession,
+        logPath: null
       });
+      store.updateConversation(conversation.id, { title: resolvedSession });
       sendSSE('session_created', {
         conversationId: conversation.id,
         sessionId: conversation.id
       });
     }
 
-    // Context Bridge: if engine changed, add context to message
-    let fullMessage = message;
-    if (!isNew && conversationId && conversation.engine && conversation.engine !== resolvedEngine) {
-      try {
-        const { default: ContextBridge } = require('../services/context-bridge');
-        const ctx = await ContextBridge.buildContext({
-          conversationId: conversation.id,
-          fromEngine: conversation.engine,
-          toEngine: resolvedEngine,
-          userMessage: message
-        });
-        if (ctx.prompt) {
-          fullMessage = ctx.prompt;
-          console.log(`[send] Applied context bridge: ${conversation.engine} -> ${resolvedEngine} (${ctx.contextTokens} tokens)`);
-        }
-      } catch (err) {
-        console.warn('[send] Context bridge failed, proceeding without context:', err.message);
-        // Continue without context - non-fatal
-      }
+    let logPath = conversation.log_path;
+    if (!logPath) {
+      logPath = tmux.ensureSessionLogging(resolvedSession, resolvedHost);
+      store.updateConversation(conversation.id, {
+        tmux_session: resolvedSession,
+        workspace: conversation.workspace || (workspace || os.homedir()),
+        log_path: logPath,
+        status: 'active'
+      });
+      conversation = store.getConversation(conversation.id);
     }
 
-    // Save user message
     store.addMessage({
       conversationId: conversation.id,
       role: 'user',
-      content: fullMessage,
-      engine: resolvedEngine,
-      model: model
+      content: message,
+      engine: conversation.engine,
+      model: conversation.model
     });
 
-    sendSSE('message_start', { role: 'user' });
-
-    // Determine tmux window name
-    const windowName = `nc-${conversation.id.substring(0, 8)}`;
-
-    // Build command for the engine
-    const engineInfo = engines.discover()[resolvedEngine];
-    let command;
-
-    if (alias) {
-      // Use a custom alias from providers.zsh
-      command = alias;
-    } else if (engineInfo?.available) {
-      command = buildEngineCommand(resolvedEngine, engineInfo, {
-        model,
-        message: fullMessage, // Pass fullMessage for codex exec mode
-        resume: resumeSession || (conversation.tmux_window ? conversation.id : null)
-      });
-    } else {
-      sendSSE('error', { error: `Engine "${resolvedEngine}" not available` });
-      res.end();
-      return;
-    }
-
-    // Create or reuse tmux window
-    let logPath;
-
-    if (conversation.tmux_window && tmux.hasWindow(conversation.tmux_window, hostObj)) {
-      // Resume existing window — send message directly
-      tmux.sendKeys(conversation.tmux_window, fullMessage, { enter: true, host: hostName });
-      logPath = conversation.log_path;
-    } else {
-      // Create new tmux window
-      const result = tmux.createWindow({
-        windowName,
-        command,
-        cwd: conversation.workspace || workspace || process.env.HOME,
-        host: hostName
-      });
-      logPath = result.logPath;
-
-      store.updateConversation(conversation.id, {
-        tmux_window: windowName,
-        log_path: logPath,
-        status: 'active'
-      });
+    logWatcher.watch(logPath, conversation.engine || 'generic', conversation.id);
 
-      // Wait a moment for the CLI to start, then send the message
-      if (resolvedEngine !== 'codex') {
-        // Interactive CLIs need a moment to start
-        await new Promise(r => setTimeout(r, 1500));
-        tmux.sendKeys(windowName, fullMessage, { enter: true, host: hostName });
-      }
-      // Codex exec mode gets the message via the command itself
-    }
-
-    // Start watching the log
-    if (logPath) {
-      logWatcher.watch(logPath, resolvedEngine, conversation.id);
-    }
-
-    sendSSE('status', { content: 'Sending to tmux...' });
+    sendSSE('message_start', { role: 'user' });
+    sendSSE('status', { content: `Sending to tmux session ${resolvedSession}...` });
 
-    // Collect response from log watcher
     let responseBuffer = '';
-    let doneFired = false;
-    const timeout = setTimeout(() => {
-      if (!doneFired) {
-        doneFired = true;
-        finishResponse(responseBuffer || '(timeout — check tmux window directly)');
-      }
-    }, 120000); // 2 min timeout
-
-    const onData = (data) => {
-      if (data.conversationId !== conversation.id) return;
-
-      switch (data.type) {
-        case 'status':
-          sendSSE('status', { content: data.content });
-          break;
-        case 'chunk':
-          responseBuffer += data.content;
-          sendSSE('chunk', { content: data.content });
-          break;
-        case 'message_done':
-          if (!doneFired) {
-            doneFired = true;
-            clearTimeout(timeout);
-            finishResponse(data.content || responseBuffer, data.usage);
-          }
-          break;
-        case 'done':
-          if (!doneFired) {
-            doneFired = true;
-            clearTimeout(timeout);
-            finishResponse(responseBuffer || '(completed)');
-          }
-          break;
-      }
-    };
-
-    logWatcher.on('data', onData);
-
-    function finishResponse(content, usage) {
+    let finished = false;
+    let activitySeen = false;
+
+    const finishResponse = (content, usage) => {
+      if (finished) return;
+      finished = true;
+      clearTimeout(maxTimer);
+      clearTimeout(idleTimer);
       logWatcher.off('data', onData);
-      clearTimeout(timeout);
 
-      // Save assistant message
+      const finalContent = content || responseBuffer || tmux.capturePane(resolvedSession, resolvedHost) || '(no output captured)';
       store.addMessage({
         conversationId: conversation.id,
         role: 'assistant',
-        content,
-        engine: resolvedEngine,
-        model: model,
+        content: finalContent,
+        engine: conversation.engine,
+        model: conversation.model,
         tokensIn: usage?.input_tokens || 0,
         tokensOut: usage?.output_tokens || 0
       });
 
       sendSSE('message_done', {
-        content,
+        content: finalContent,
         usage,
         conversationId: conversation.id,
-        engine: resolvedEngine,
-        model: model
+        tmuxSession: resolvedSession
       });
 
       res.end();
-    }
+    };
+
+    const bumpIdleTimer = () => {
+      clearTimeout(idleTimer);
+      idleTimer = setTimeout(() => {
+        finishResponse(responseBuffer);
+      }, activitySeen ? 15000 : 20000);
+    };
+
+    const onData = (data) => {
+      if (data.conversationId !== conversation.id) return;
+      activitySeen = true;
+
+      if (data.type === 'status') {
+        sendSSE('status', { content: data.content });
+      } else if (data.type === 'chunk' || data.type === 'raw') {
+        responseBuffer += `${data.content}\n`;
+        sendSSE('chunk', { content: data.content });
+      } else if (data.type === 'message_done') {
+        responseBuffer += data.content || '';
+        return finishResponse(data.content || responseBuffer, data.usage);
+      } else if (data.type === 'done') {
+        return finishResponse(responseBuffer);
+      }
+
+      bumpIdleTimer();
+    };
+
+    logWatcher.on('data', onData);
+
+    const maxTimer = setTimeout(() => {
+      finishResponse(responseBuffer || '(timeout — check tmux session directly)');
+    }, 120000);
+    let idleTimer = setTimeout(() => finishResponse(responseBuffer), 20000);
 
+    tmux.sendKeys(resolvedSession, message, { enter: true, host: resolvedHost });
   } catch (err) {
     console.error('[send] Error:', err);
     sendSSE('error', { error: err.message });
@@ -234,68 +164,17 @@ router.post('/', async (req, res) => {
   }
 });
 
-/**
- * POST /api/v1/send/interrupt — Interrupt current generation
- */
 router.post('/interrupt', (req, res) => {
   const { tmux, store } = req;
   const { conversationId } = req.body;
+  const conversation = conversationId ? store.getConversation(conversationId) : null;
 
-  if (!conversationId) {
-    return res.status(400).json({ error: 'conversationId required' });
+  if (!conversation?.tmux_session) {
+    return res.status(404).json({ error: 'Conversation has no active tmux session' });
   }
 
-  const conversation = store.getConversation(conversationId);
-  if (!conversation || !conversation.tmux_window) {
-    return res.json({ success: false, reason: 'No active tmux window' });
-  }
-
-  const host = conversation.host !== 'local' ? conversation.host : null;
-  tmux.interrupt(conversation.tmux_window, host);
-
-  res.json({ success: true, method: 'tmux interrupt' });
+  tmux.interrupt(conversation.tmux_session, conversation.host || 'local');
+  res.json({ success: true });
 });
 
-// --- Helpers ---
-
-function resolveEngine(model, engineDiscovery) {
-  if (!model) return 'claude';
-  const allModels = engineDiscovery.getAllModels();
-  const found = allModels.find(m => m.id === model);
-  return found ? found.engine : 'claude';
-}
-
-function buildEngineCommand(engine, engineInfo, opts = {}) {
-  const bin = engineInfo.path;
-  if (!bin) return engine;
-
-  switch (engine) {
-    case 'claude':
-      if (opts.resume) {
-        return `${bin} --output-format json -r ${opts.resume}${opts.model ? ` --model ${opts.model}` : ''}`;
-      }
-      return `${bin} --output-format json${opts.model ? ` --model ${opts.model}` : ''}`;
-
-    case 'codex':
-      // For codex, message is passed via --prompt flag in exec mode
-      const prompt = opts.message ? ` --prompt "${opts.message.replace(/"/g, '\\"')}"` : '';
-      return `${bin} exec --json${opts.model ? ` -m ${opts.model}` : ''}${opts.reasoningEffort ? ` --reasoning ${opts.reasoningEffort}` : ''}${prompt}`;
-
-    case 'gemini':
-      if (opts.resume) {
-        return `${bin} --resume ${opts.resume}${opts.model ? ` -m ${opts.model}` : ''}`;
-      }
-      return `${bin}${opts.model ? ` -m ${opts.model}` : ''}`;
-
-    case 'qwen':
-      if (opts.resume) {
-        return `${bin} --resume ${opts.resume}${opts.model ? ` -m ${opts.model}` : ''}`;
-      }
-      return `${bin}${opts.model ? ` -m ${opts.model}` : ''}`;
-
-    default:
-      return bin;
-  }
-}
-
 module.exports = router;

package/lib/server/routes/sessions.js

@@ -1,9 +1,8 @@
 /**
- * GET /api/v1/sessions — List/load sessions (with tmux_alive status)
+ * GET /api/v1/sessions — List/load sessions
  * GET /api/v1/sessions/:id/messages — Get session messages
  * GET /api/v1/sessions/:id/summary — Get session summary
  * POST /api/v1/sessions/:id/rename — Rename session
- * POST /api/v1/sessions/:id/pin — Pin/unpin session
  * DELETE /api/v1/sessions/:id — Delete session
  */
 
@@ -12,39 +11,15 @@ const router = Router();
 
 // List conversations (optionally grouped by date)
 router.get('/', (req, res) => {
-  const { store, tmux } = req;
+  const { store } = req;
   const { workspace, groupBy } = req.query;
 
   if (groupBy === 'date') {
     const grouped = store.listGroupedByDate({ workspace });
-
-    // Enrich with tmux_alive status
-    Object.keys(grouped).forEach(dateGroup => {
-      grouped[dateGroup].forEach(conv => {
-        if (conv.tmux_window) {
-          const host = conv.host !== 'local' ? conv.host : null;
-          conv.tmux_alive = tmux.hasWindow(conv.tmux_window, host);
-        } else {
-          conv.tmux_alive = false;
-        }
-      });
-    });
-
     return res.json(grouped);
   }
 
   const convs = store.listConversations({ workspace });
-
-  // Enrich with tmux_alive status
-  convs.forEach(conv => {
-    if (conv.tmux_window) {
-      const host = conv.host !== 'local' ? conv.host : null;
-      conv.tmux_alive = tmux.hasWindow(conv.tmux_window, host);
-    } else {
-      conv.tmux_alive = false;
-    }
-  });
-
   res.json({ conversations: convs });
 });
 
@@ -59,7 +34,8 @@ router.get('/:id', (req, res) => {
 
   // Check tmux window status
   const host = conv.host !== 'local' ? conv.host : null;
-  const alive = conv.tmux_window ? tmux.hasWindow(conv.tmux_window, host) : false;
+  const target = conv.tmux_session || conv.tmux_window;
+  const alive = target ? tmux.hasSession(target, host) : false;
 
   res.json({
     session: {
@@ -104,24 +80,16 @@ router.post('/:id/rename', (req, res) => {
   res.json({ success: true, title });
 });
 
-// Pin/unpin conversation
-router.post('/:id/pin', (req, res) => {
-  const { store } = req;
-  const result = store.pinConversation(req.params.id);
-  res.json({ pinned: result });
-});
-
-// Delete conversation (kills tmux window too)
+// Delete conversation (kills tmux session too)
 router.delete('/:id', (req, res) => {
   const { store, tmux, logWatcher } = req;
   const conv = store.getConversation(req.params.id);
 
   if (!conv) return res.status(404).json({ error: 'Not found' });
 
-  // Kill tmux window if active
-  if (conv.tmux_window) {
+  if (conv.tmux_session) {
     const host = conv.host !== 'local' ? conv.host : null;
-    tmux.killWindow(conv.tmux_window, host);
+    tmux.killSession(conv.tmux_session, host);
   }
 
   // Stop log watcher

package/lib/server/routes/status.js

@@ -1,7 +1,7 @@
 /**
- * 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
+ * GET /api/v1/status — tmux status
+ * GET /api/v1/status/tmux — Detailed tmux session info
+ * GET /api/v1/status/pane/:session — Capture pane content
  */
 
 const { Router } = require('express');
@@ -10,15 +10,13 @@ const router = Router();
 // Overall status
 router.get('/', (req, res) => {
   const { tmux, store } = req;
-  const windows = tmux.listWindows();
+  const sessions = tmux.listSessions();
   const hosts = tmux.getAllHosts();
 
   res.json({
     tmux: {
-      session: tmux.sessionName,
-      alive: tmux.hasSession(),
-      windowCount: windows.length,
-      windows
+      sessionCount: sessions.length,
+      sessions
     },
     hosts: hosts.map(h => ({
       ...h,
@@ -30,31 +28,31 @@ router.get('/', (req, res) => {
 // Detailed tmux windows
 router.get('/tmux', (req, res) => {
   const { tmux, store } = req;
-  const windows = tmux.listWindows();
+  const sessions = tmux.listSessions();
 
-  // Enrich with DB data
-  const enriched = windows.map(w => {
-    const conv = store.findByWindow(w.name);
+  const enriched = sessions.map((session) => {
+    const conv = store.findByTmuxSession(session.sessionName);
     return {
-      ...w,
+      ...session,
       conversationId: conv?.id || null,
       engine: conv?.engine || null,
       model: conv?.model || null,
       host: conv?.host || 'local',
-      title: conv?.title || w.name
+      title: conv?.title || session.sessionName,
+      workspace: conv?.workspace || ''
     };
   });
 
-  res.json({ windows: enriched });
+  res.json({ sessions: enriched });
 });
 
 // Capture pane content
-router.get('/pane/:window', (req, res) => {
+router.get('/pane/:session', (req, res) => {
   const { tmux } = req;
   const { host } = req.query;
-  const content = tmux.capturePane(req.params.window, host || null);
+  const content = tmux.capturePane(req.params.session, host || null);
 
-  res.json({ window: req.params.window, content });
+  res.json({ session: req.params.session, content });
 });
 
 module.exports = router;

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;