@mmmbuto/nexuscrew 0.2.2 → 0.2.4

package/lib/server/routes/send.js

@@ -10,6 +10,23 @@ const os = require('os');
 
 const router = Router();
 
+function buildPanePoller(tmux, sessionName, hostName, onChunk) {
+  let lastSnapshot = '';
+  return setInterval(() => {
+    const snapshot = tmux.capturePane(sessionName, hostName) || '';
+    if (!snapshot || snapshot === lastSnapshot) return;
+
+    const chunk = snapshot.startsWith(lastSnapshot)
+      ? snapshot.slice(lastSnapshot.length)
+      : snapshot;
+
+    lastSnapshot = snapshot;
+    if (chunk.trim()) {
+      onChunk(chunk.trimEnd());
+    }
+  }, 700);
+}
+
 router.post('/', async (req, res) => {
   const { tmux, store, logWatcher } = req;
   const {
@@ -50,11 +67,12 @@ router.post('/', async (req, res) => {
     }
 
     if (!conversation) {
-      const existing = store.findByTmuxSession(resolvedSession);
+      const existing = store.listConversations({ host: resolvedHost, limit: 500 })
+        .find((item) => item.tmux_session === resolvedSession);
       conversation = existing || store.createConversation({
         title: resolvedSession,
         engine: null,
-        workspace: (workspace || os.homedir()).trim() || os.homedir(),
+        workspace: (workspace || tmux.getRuntimeInfo(resolvedHost).homeDir || os.homedir()).trim() || os.homedir(),
         host: resolvedHost,
         tmuxSession: resolvedSession,
         logPath: null
@@ -67,11 +85,15 @@ router.post('/', async (req, res) => {
     }
 
     let logPath = conversation.log_path;
+    let panePoller = null;
+    let maxTimer = null;
+    let idleTimer = null;
+    let closed = false;
     if (!logPath) {
       logPath = tmux.ensureSessionLogging(resolvedSession, resolvedHost);
       store.updateConversation(conversation.id, {
         tmux_session: resolvedSession,
-        workspace: conversation.workspace || (workspace || os.homedir()),
+        workspace: conversation.workspace || (workspace || tmux.getRuntimeInfo(resolvedHost).homeDir || os.homedir()),
         log_path: logPath,
         status: 'active'
       });
@@ -94,15 +116,28 @@ router.post('/', async (req, res) => {
     let responseBuffer = '';
     let finished = false;
     let activitySeen = false;
+    let lastMessageDone = '';
 
-    const finishResponse = (content, usage) => {
-      if (finished) return;
-      finished = true;
+    const cleanup = () => {
+      if (closed) return;
+      closed = true;
       clearTimeout(maxTimer);
       clearTimeout(idleTimer);
+      if (panePoller) clearInterval(panePoller);
       logWatcher.off('data', onData);
+    };
 
-      const finalContent = content || responseBuffer || tmux.capturePane(resolvedSession, resolvedHost) || '(no output captured)';
+    const finishResponse = (content, usage) => {
+      if (finished) return;
+      finished = true;
+      cleanup();
+
+      const finalContent =
+        content ||
+        lastMessageDone ||
+        responseBuffer ||
+        tmux.capturePane(resolvedSession, resolvedHost) ||
+        '(no output captured)';
       store.addMessage({
         conversationId: conversation.id,
         role: 'assistant',
@@ -127,7 +162,7 @@ router.post('/', async (req, res) => {
       clearTimeout(idleTimer);
       idleTimer = setTimeout(() => {
         finishResponse(responseBuffer);
-      }, activitySeen ? 15000 : 20000);
+      }, activitySeen ? 25000 : 30000);
     };
 
     const onData = (data) => {
@@ -140,8 +175,9 @@ router.post('/', async (req, res) => {
         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);
+        lastMessageDone = data.content || '';
+        if (lastMessageDone) responseBuffer = lastMessageDone;
+        return finishResponse(lastMessageDone || responseBuffer, data.usage);
       } else if (data.type === 'done') {
         return finishResponse(responseBuffer);
       }
@@ -151,10 +187,25 @@ router.post('/', async (req, res) => {
 
     logWatcher.on('data', onData);
 
-    const maxTimer = setTimeout(() => {
+    if (logPath) {
+      logWatcher.watch(logPath, conversation.engine || 'generic', conversation.id);
+    } else {
+      panePoller = buildPanePoller(tmux, resolvedSession, resolvedHost, (content) => {
+        activitySeen = true;
+        responseBuffer = content;
+        sendSSE('chunk', { content });
+        bumpIdleTimer();
+      });
+    }
+
+    maxTimer = setTimeout(() => {
       finishResponse(responseBuffer || '(timeout — check tmux session directly)');
-    }, 120000);
-    let idleTimer = setTimeout(() => finishResponse(responseBuffer), 20000);
+    }, 180000);
+    idleTimer = setTimeout(() => finishResponse(responseBuffer), 30000);
+
+    req.on('close', () => {
+      cleanup();
+    });
 
     tmux.sendKeys(resolvedSession, message, { enter: true, host: resolvedHost });
   } catch (err) {
@@ -166,15 +217,20 @@ router.post('/', async (req, res) => {
 
 router.post('/interrupt', (req, res) => {
   const { tmux, store } = req;
-  const { conversationId } = req.body;
+  const { conversationId, host: requestedHost } = req.body;
   const conversation = conversationId ? store.getConversation(conversationId) : null;
 
   if (!conversation?.tmux_session) {
     return res.status(404).json({ error: 'Conversation has no active tmux session' });
   }
 
-  tmux.interrupt(conversation.tmux_session, conversation.host || 'local');
-  res.json({ success: true });
+  const host = requestedHost || conversation.host || 'local';
+  if (!tmux.hasSession(conversation.tmux_session, host)) {
+    return res.status(409).json({ error: `tmux session "${conversation.tmux_session}" is not active on host "${host}"` });
+  }
+
+  tmux.interrupt(conversation.tmux_session, host);
+  res.json({ success: true, host, tmuxSession: conversation.tmux_session });
 });
 
 module.exports = router;

package/lib/server/routes/status.js

@@ -9,11 +9,13 @@ const router = Router();
 
 // Overall status
 router.get('/', (req, res) => {
-  const { tmux, store } = req;
-  const sessions = tmux.listSessions();
+  const { tmux } = req;
+  const host = req.query.host || 'local';
+  const sessions = tmux.listSessions(host === 'local' ? null : host);
   const hosts = tmux.getAllHosts();
 
   res.json({
+    host,
     tmux: {
       sessionCount: sessions.length,
       sessions
@@ -28,22 +30,24 @@ router.get('/', (req, res) => {
 // Detailed tmux windows
 router.get('/tmux', (req, res) => {
   const { tmux, store } = req;
-  const sessions = tmux.listSessions();
+  const host = req.query.host || 'local';
+  const sessions = tmux.listSessions(host === 'local' ? null : host);
+  const conversations = store.listConversations({ host, limit: 500 });
 
   const enriched = sessions.map((session) => {
-    const conv = store.findByTmuxSession(session.sessionName);
+    const conv = conversations.find((item) => item.tmux_session === session.sessionName);
     return {
       ...session,
       conversationId: conv?.id || null,
       engine: conv?.engine || null,
       model: conv?.model || null,
-      host: conv?.host || 'local',
+      host,
       title: conv?.title || session.sessionName,
       workspace: conv?.workspace || ''
     };
   });
 
-  res.json({ sessions: enriched });
+  res.json({ host, sessions: enriched });
 });
 
 // Capture pane content

package/lib/server/routes/tmux.js

@@ -4,11 +4,14 @@ const router = Router();
 
 router.get('/sessions', (req, res) => {
   const { tmux, store } = req;
-  const sessions = tmux.listSessions().map((session) => {
-    const conversation = store.findByTmuxSession(session.sessionName);
+  const host = req.query.host || 'local';
+  const resolvedHost = host === 'local' ? null : host;
+  const sessions = tmux.listSessions(resolvedHost).map((session) => {
+    const conversation = store.listConversations({ host, limit: 500 })
+      .find((item) => item.tmux_session === session.sessionName);
     return {
       ...session,
-      host: conversation?.host || 'local',
+      host,
       workspace: conversation?.workspace || '',
       conversationId: conversation?.id || null,
       launcherId: conversation?.launcher_id || null,
@@ -36,11 +39,11 @@ router.post('/sessions', (req, res) => {
     return res.status(400).json({ error: 'launcherId is required' });
   }
 
-  const launcher = engines.getLauncher(launcherId);
+  const launcher = engines.getLauncher(launcherId, host || 'local');
   if (!launcher) {
     return res.status(404).json({ error: `Launcher "${launcherId}" not found` });
   }
-  if (!launcher.runnable) {
+  if (!launcher.runnable || launcher.bucket !== 'runnable') {
     return res.status(409).json({
       error: `Launcher "${launcher.label}" was detected from config but is not verified runnable in the current shell`
     });

package/lib/server/server.js

@@ -12,6 +12,7 @@ const fs = require('fs');
 const http = require('http');
 const os = require('os');
 const packageJson = require('../../package.json');
+const { getConfigDir, getDefaultLogDir } = require('../config/paths');
 
 const TmuxManager = require('../services/tmux-manager');
 const EngineDiscovery = require('../services/engine-discovery');
@@ -30,7 +31,7 @@ const runtimeRouter = require('./routes/runtime');
 class NexusCrewServer {
   constructor(config = {}) {
     this.port = config.port || process.env.PORT || 41820;
-    this.configDir = config.configDir || path.join(os.homedir(), '.nexuscrew');
+    this.configDir = config.configDir || getConfigDir();
     this.config = this._loadConfig();
     this.app = express();
     this.server = null;
@@ -45,11 +46,11 @@ class NexusCrewServer {
       }
       return loaded;
     }
-    return {
-      port: this.port,
-      autoDiscovery: true,
-      preferredShell: '',
-      extraShellSources: []
+      return {
+        port: this.port,
+        autoDiscovery: true,
+        preferredShell: '',
+        extraShellSources: []
     };
   }
 
@@ -64,12 +65,14 @@ class NexusCrewServer {
   async start() {
     const hosts = this._loadHosts();
     const tmuxManager = new TmuxManager({
-      logDir: this.config.logDir || path.join(this.configDir, 'logs'),
+      logDir: this.config.logDir || getDefaultLogDir(),
+      configDir: this.configDir,
       preferredShell: this.config.preferredShell || process.env.SHELL || '/bin/sh',
       hosts
     });
 
     const engineDiscovery = new EngineDiscovery({
+      tmux: tmuxManager,
       preferredShell: this.config.preferredShell,
       extraShellSources: this.config.extraShellSources || []
     });
@@ -80,7 +83,7 @@ class NexusCrewServer {
 
     const active = sessionStore.listConversations({ status: 'active' });
     for (const conv of active) {
-      if (conv.log_path && fs.existsSync(conv.log_path)) {
+      if ((conv.host || 'local') === 'local' && conv.log_path && fs.existsSync(conv.log_path)) {
         logWatcher.watch(conv.log_path, conv.engine || 'generic', conv.id);
       }
     }
@@ -107,6 +110,7 @@ class NexusCrewServer {
       req.store = sessionStore;
       req.logWatcher = logWatcher;
       req.config = this.config;
+      req.configDir = this.configDir;
       next();
     });
 

package/lib/services/engine-discovery.js

@@ -9,7 +9,6 @@
  * No user-specific config is assumed and no model catalog is hardcoded.
  */
 
-const { execFileSync, execSync } = require('child_process');
 const path = require('path');
 const fs = require('fs');
 const os = require('os');
@@ -20,14 +19,17 @@ class EngineDiscovery {
   constructor(config = {}) {
     this.preferredShell = config.preferredShell || '';
     this.extraShellSources = Array.isArray(config.extraShellSources) ? config.extraShellSources : [];
-    this._cache = null;
+    this.tmux = config.tmux || null;
+    this._cache = new Map();
   }
 
-  discover() {
-    if (this._cache) return this._cache;
+  discover(host = null) {
+    const hostKey = this._hostKey(host);
+    if (this._cache.has(hostKey)) return this._cache.get(hostKey);
 
-    const shellPath = this.getShellPath();
-    const shellName = path.basename(shellPath);
+    const runtime = this.getRuntimeInfo(host);
+    const shellPath = runtime.shell || this.getShellPath();
+    const shellName = path.basename(shellPath || '/bin/sh');
     const launchers = [];
     const seen = new Set();
 
@@ -45,50 +47,63 @@ class EngineDiscovery {
         source: launcher.source,
         shell: launcher.shell || shellName,
         available: launcher.available !== false,
-        runnable: launcher.runnable !== false
+        runnable: launcher.runnable !== false,
+        bucket: launcher.bucket || this._classifyBucket(launcher)
       });
     };
 
-    this._discoverPathBinaries().forEach(addLauncher);
-    this._discoverLiveShell(shellPath).forEach(addLauncher);
-    this._discoverShellFiles(shellName).forEach(addLauncher);
+    this._discoverPathBinaries(host).forEach(addLauncher);
+    this._discoverLiveShell(shellPath, host).forEach(addLauncher);
+    this._discoverShellFiles(shellName, host).forEach(addLauncher);
 
     launchers.sort((a, b) => a.label.localeCompare(b.label));
-    this._cache = {
+    const discovery = {
       shell: shellPath,
-      homeDir: os.homedir(),
-      launchers
+      homeDir: runtime.homeDir,
+      platform: runtime.platform,
+      host: hostKey,
+      launchers,
+      buckets: this._bucketize(launchers)
     };
-    return this._cache;
+    this._cache.set(hostKey, discovery);
+    return discovery;
+  }
+
+  getLaunchers(host = null) {
+    return this.discover(host).launchers;
   }
 
-  getLaunchers() {
-    return this.discover().launchers;
+  getBuckets(host = null) {
+    return this.discover(host).buckets;
   }
 
-  getLauncher(id) {
-    return this.getLaunchers().find((launcher) => launcher.id === id) || null;
+  getLauncher(id, host = null) {
+    return this.getLaunchers(host).find((launcher) => launcher.id === id) || null;
   }
 
   getShellPath() {
     return this.preferredShell || process.env.SHELL || '/bin/sh';
   }
 
-  getRuntimeInfo() {
+  getRuntimeInfo(host = null) {
+    if (this.tmux) {
+      return this.tmux.getRuntimeInfo(host);
+    }
     return {
       homeDir: os.homedir(),
       shell: this.getShellPath(),
-      platform: process.platform
+      platform: process.platform,
+      host: this._hostKey(host)
     };
   }
 
   clearCache() {
-    this._cache = null;
+    this._cache.clear();
   }
 
-  _discoverPathBinaries() {
+  _discoverPathBinaries(host = null) {
     return KNOWN_FAMILIES.flatMap((family) => {
-      const binPath = this._resolveCommand(family);
+      const binPath = this._resolveCommand(family, host);
       if (!binPath) return [];
       return [{
         id: `binary:${family}`,
@@ -103,9 +118,9 @@ class EngineDiscovery {
     });
   }
 
-  _discoverLiveShell(shellPath) {
+  _discoverLiveShell(shellPath, host = null) {
     const shellName = path.basename(shellPath);
-    if (!fs.existsSync(shellPath)) return [];
+    if (!this._fileExists(shellPath, host)) return [];
 
     try {
       const script = [
@@ -114,18 +129,15 @@ class EngineDiscovery {
         'typeset -f 2>/dev/null || declare -f 2>/dev/null || true'
       ].join('; ');
 
-      const output = execFileSync(shellPath, this._shellArgs(shellName, script), {
-        encoding: 'utf8',
-        stdio: ['ignore', 'pipe', 'pipe']
-      });
+      const output = this._runInteractiveShell(shellPath, shellName, script, host);
       return this._parseShellDump(output, shellName, 'live-shell');
     } catch {
       return [];
     }
   }
 
-  _discoverShellFiles(shellName) {
-    const homeDir = os.homedir();
+  _discoverShellFiles(shellName, host = null) {
+    const homeDir = this.getRuntimeInfo(host).homeDir || os.homedir();
     const shellFiles = new Set();
 
     for (const candidate of this._defaultShellFiles(shellName)) {
@@ -137,9 +149,9 @@ class EngineDiscovery {
 
     const discovered = [];
     for (const filePath of shellFiles) {
-      if (!fs.existsSync(filePath)) continue;
+      if (!this._fileExists(filePath, host)) continue;
       try {
-        const content = fs.readFileSync(filePath, 'utf8');
+        const content = this._readFile(filePath, host);
         discovered.push(...this._parseShellFile(content, shellName, filePath));
       } catch {}
     }
@@ -218,8 +230,12 @@ class EngineDiscovery {
     return KNOWN_FAMILIES.find((family) => haystack.includes(family)) || 'custom';
   }
 
-  _resolveCommand(command) {
+  _resolveCommand(command, host = null) {
+    if (this.tmux) {
+      return this.tmux.resolveCommand(command, host);
+    }
     try {
+      const { execSync } = require('child_process');
       const resolved = execSync(`command -v ${command} 2>/dev/null`, {
         encoding: 'utf8',
         stdio: ['ignore', 'pipe', 'ignore']
@@ -247,6 +263,55 @@ class EngineDiscovery {
     }
     return ['-lc', script];
   }
+
+  _runInteractiveShell(shellPath, shellName, script, host = null) {
+    if (this.tmux) {
+      return this.tmux.runInteractiveShell(shellPath, script, host);
+    }
+    const { execFileSync } = require('child_process');
+    return execFileSync(shellPath, this._shellArgs(shellName, script), {
+      encoding: 'utf8',
+      stdio: ['ignore', 'pipe', 'pipe']
+    });
+  }
+
+  _fileExists(filePath, host = null) {
+    if (this.tmux) {
+      return this.tmux.fileExists(filePath, host);
+    }
+    return fs.existsSync(filePath);
+  }
+
+  _readFile(filePath, host = null) {
+    if (this.tmux) {
+      return this.tmux.readFile(filePath, host);
+    }
+    return fs.readFileSync(filePath, 'utf8');
+  }
+
+  _hostKey(host) {
+    if (!host || host === 'local') return 'local';
+    if (typeof host === 'string') return host;
+    return host.name || 'remote';
+  }
+
+  _classifyBucket(launcher) {
+    const name = String(launcher.label || launcher.name || launcher.command || '').trim();
+    if (name.startsWith('_')) return 'internal';
+    if (launcher.kind === 'function' && /(^_|_bin$|_run$|_cmd$|_provider_|_chutes$)/.test(name)) {
+      return 'internal';
+    }
+    if (launcher.runnable === false) return 'detectedOnly';
+    return 'runnable';
+  }
+
+  _bucketize(launchers) {
+    return {
+      runnable: launchers.filter((launcher) => launcher.bucket === 'runnable'),
+      detectedOnly: launchers.filter((launcher) => launcher.bucket === 'detectedOnly'),
+      internal: launchers.filter((launcher) => launcher.bucket === 'internal')
+    };
+  }
 }
 
 module.exports = EngineDiscovery;

package/lib/services/tmux-manager.js

@@ -13,6 +13,7 @@ const os = require('os');
 class TmuxManager {
   constructor(config = {}) {
     this.logDir = config.logDir || path.join(os.homedir(), '.nexuscrew', 'logs');
+    this.configDir = config.configDir || path.dirname(this.logDir);
     this.hosts = config.hosts || [{ name: 'local', type: 'local' }];
     this.shell = config.preferredShell || process.env.SHELL || '/bin/sh';
 
@@ -54,8 +55,9 @@ class TmuxManager {
 
   createSession({ sessionName, cwd, host = null, launcherCommand = '', shell = null }) {
     const effectiveHost = this._resolveHost(host);
-    const effectiveShell = shell || this.shell;
-    const workingDir = cwd || os.homedir();
+    const runtime = this.getRuntimeInfo(effectiveHost);
+    const effectiveShell = shell || runtime.shell || this.shell;
+    const workingDir = cwd || runtime.homeDir || os.homedir();
 
     if (this.hasSession(sessionName, effectiveHost)) {
       throw new Error(`tmux session "${sessionName}" already exists`);
@@ -78,6 +80,9 @@ class TmuxManager {
 
   ensureSessionLogging(sessionName, host = null) {
     const effectiveHost = this._resolveHost(host);
+    if (effectiveHost && effectiveHost.type !== 'local') {
+      return null;
+    }
     const logPath = path.join(this.logDir, `${sessionName}.log`);
     const pipeCmd = this._cmd(
       `tmux pipe-pane -o -t ${this._quote(sessionName)} ${this._quote(`cat >> ${logPath}`)}`,
@@ -163,6 +168,77 @@ class TmuxManager {
     return host;
   }
 
+  getRuntimeInfo(host = null) {
+    const effectiveHost = this._resolveHost(host);
+    if (!effectiveHost || effectiveHost.type === 'local') {
+      return {
+        homeDir: os.homedir(),
+        shell: this.shell,
+        platform: process.platform,
+        host: 'local'
+      };
+    }
+
+    try {
+      const output = this.execCommand(
+        "printf '__NEXUSCREW_HOME__%s\\n' \"$HOME\"; printf '__NEXUSCREW_SHELL__%s\\n' \"${SHELL:-/bin/sh}\"; uname -s",
+        effectiveHost,
+        5000
+      );
+      const lines = output.trim().split('\n');
+      const homeDir = lines.find((line) => line.startsWith('__NEXUSCREW_HOME__'))?.replace('__NEXUSCREW_HOME__', '') || '';
+      const shell = lines.find((line) => line.startsWith('__NEXUSCREW_SHELL__'))?.replace('__NEXUSCREW_SHELL__', '') || '/bin/sh';
+      const uname = lines[lines.length - 1] || '';
+      return {
+        homeDir: homeDir || '',
+        shell: shell || '/bin/sh',
+        platform: this._mapPlatform(uname),
+        host: effectiveHost.name || 'remote'
+      };
+    } catch {
+      return {
+        homeDir: '',
+        shell: '/bin/sh',
+        platform: 'unknown',
+        host: effectiveHost.name || 'remote'
+      };
+    }
+  }
+
+  execCommand(cmd, host = null, timeout = 10000) {
+    return this._exec(this._cmd(cmd, host), timeout);
+  }
+
+  resolveCommand(command, host = null) {
+    try {
+      const output = this.execCommand(`command -v ${command} 2>/dev/null`, host, 5000).trim();
+      return output || null;
+    } catch {
+      return null;
+    }
+  }
+
+  fileExists(filePath, host = null) {
+    try {
+      this.execCommand(`test -f ${this._quote(filePath)}`, host, 5000);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  readFile(filePath, host = null) {
+    return this.execCommand(`cat ${this._quote(filePath)}`, host, 5000);
+  }
+
+  runInteractiveShell(shellPath, script, host = null) {
+    const shellName = path.basename(shellPath || '/bin/sh');
+    const shellArgs = this._shellArgs(shellName, script)
+      .map((arg) => this._quote(arg))
+      .join(' ');
+    return this.execCommand(`${this._quote(shellPath)} ${shellArgs}`, host, 10000);
+  }
+
   _interactiveShellCommand(shellPath) {
     const shellName = path.basename(shellPath || '/bin/sh');
     if (shellName === 'bash' || shellName === 'zsh') {
@@ -193,6 +269,13 @@ class TmuxManager {
     return `'${String(value).replace(/'/g, `'\\''`)}'`;
   }
 
+  _mapPlatform(uname) {
+    const value = String(uname || '').trim().toLowerCase();
+    if (value === 'darwin') return 'darwin';
+    if (value === 'linux') return 'linux';
+    return value || 'unknown';
+  }
+
   _exec(cmd, timeout = 10000) {
     return execSync(cmd, {
       encoding: 'utf8',