@mmmbuto/nexuscrew 0.2.0 → 0.2.1

package/lib/services/remote-pane-watcher.js

@@ -0,0 +1,155 @@
+const { EventEmitter } = require('events');
+const LogWatcher = require('./log-watcher');
+
+function normalizeSnapshot(text = '') {
+  return String(text).replace(/\r\n/g, '\n').replace(/\r/g, '\n');
+}
+
+function commonPrefixLength(a = '', b = '') {
+  const max = Math.min(a.length, b.length);
+  let index = 0;
+  while (index < max && a[index] === b[index]) {
+    index += 1;
+  }
+  return index;
+}
+
+class RemotePaneWatcher extends EventEmitter {
+  constructor(tmux, options = {}) {
+    super();
+    this.tmux = tmux;
+    this.parserAdapter = new LogWatcher();
+    this.watchers = new Map();
+    this.pollMs = options.pollMs || 400;
+    this.idleMs = options.idleMs || 4500;
+    this.timeoutMs = options.timeoutMs || 120000;
+
+    this.parserAdapter.on('data', (event) => this.emit('data', event));
+  }
+
+  watch({ conversationId, engine, host, windowName, promptText = '', initialSnapshot = '' }) {
+    const key = `${host?.name || host || 'local'}:${windowName}:${conversationId}`;
+    if (this.watchers.has(key)) return key;
+
+    const parserState = this.parserAdapter.createParserState(engine, conversationId);
+    const state = {
+      key,
+      conversationId,
+      engine,
+      host,
+      windowName,
+      parserState,
+      promptText: String(promptText || ''),
+      lastSnapshot: normalizeSnapshot(initialSnapshot),
+      startedAt: Date.now(),
+      lastChangeAt: Date.now(),
+      lastEmitAt: 0,
+      stopped: false,
+      sawAnyOutput: false
+    };
+
+    const intervalId = setInterval(() => this._poll(state), this.pollMs);
+    state.intervalId = intervalId;
+    this.watchers.set(key, state);
+    return key;
+  }
+
+  unwatch(key) {
+    const state = this.watchers.get(key);
+    if (!state) return;
+    clearInterval(state.intervalId);
+    state.stopped = true;
+    this.watchers.delete(key);
+  }
+
+  unwatchByConversation(conversationId) {
+    for (const [key, state] of this.watchers.entries()) {
+      if (state.conversationId === conversationId) {
+        this.unwatch(key);
+      }
+    }
+  }
+
+  unwatchAll() {
+    for (const key of this.watchers.keys()) {
+      this.unwatch(key);
+    }
+  }
+
+  _poll(state) {
+    if (state.stopped) return;
+
+    if (Date.now() - state.startedAt > this.timeoutMs) {
+      this._finish(state, true);
+      return;
+    }
+
+    const snapshot = normalizeSnapshot(
+      this.tmux.capturePane(state.windowName, state.host, 250)
+    );
+
+    if (!snapshot) {
+      if (Date.now() - state.lastChangeAt > this.idleMs) {
+        this._finish(state, true);
+      }
+      return;
+    }
+
+    if (snapshot === state.lastSnapshot) {
+      if (state.sawAnyOutput && Date.now() - state.lastChangeAt > this.idleMs) {
+        this._finish(state, true);
+      }
+      return;
+    }
+
+    const prefixLength = commonPrefixLength(state.lastSnapshot, snapshot);
+    let delta = snapshot.slice(prefixLength);
+    state.lastSnapshot = snapshot;
+    state.lastChangeAt = Date.now();
+
+    if (!delta.trim()) {
+      return;
+    }
+
+    delta = this._stripPromptEcho(delta, state);
+    if (!delta.trim()) {
+      return;
+    }
+
+    state.sawAnyOutput = true;
+    this.parserAdapter.processTextChunk(delta, state.parserState);
+    state.lastEmitAt = Date.now();
+  }
+
+  _stripPromptEcho(delta, state) {
+    if (!state.promptText) return delta;
+
+    const prompt = state.promptText.trim();
+    if (!prompt) return delta;
+
+    if (delta.includes(prompt)) {
+      return delta.replace(prompt, '');
+    }
+
+    const compact = delta.trim();
+    if (prompt.startsWith(compact) && compact.length > 10) {
+      return '';
+    }
+
+    return delta;
+  }
+
+  _finish(state, emitDone = false) {
+    this.parserAdapter.flushState(state.parserState);
+    if (emitDone) {
+      this.emit('data', {
+        type: 'done',
+        conversationId: state.conversationId,
+        engine: state.engine
+      });
+    }
+    this.unwatch(state.key);
+  }
+}
+
+module.exports = RemotePaneWatcher;

package/lib/services/session-store.js

@@ -81,8 +81,8 @@ class SessionStore {
   }
 
   /** Get conversations grouped by date */
-  listGroupedByDate({ workspace, limit = 100 } = {}) {
-    const convs = this.listConversations({ workspace, limit });
+  listGroupedByDate({ workspace, host, limit = 100 } = {}) {
+    const convs = this.listConversations({ workspace, host, limit });
     const grouped = {};
     for (const c of convs) {
       const date = new Date(c.updated_at * 1000).toISOString().split('T')[0];
@@ -155,7 +155,7 @@ class SessionStore {
     const active = stmt.all();
     for (const conv of active) {
       if (conv.tmux_window) {
-        const exists = tmuxManager.hasWindow(conv.tmux_window, conv.host !== 'local' ? conv.host : null);
+        const exists = tmuxManager.hasWindow(conv.tmux_window, conv.host || 'local');
         if (!exists) {
           this.updateConversation(conv.id, { status: 'dead' });
         }

package/lib/services/tmux-manager.js

@@ -5,35 +5,67 @@
  * Every AI session = one tmux window inside the master session.
  */
 
-const { execSync, exec } = require('child_process');
+const { execSync } = require('child_process');
 const path = require('path');
 const fs = require('fs');
+const { readHosts, getHostByName } = require('../config/hosts');
+const { PATHS } = require('../utils/paths');
 
 const TMUX_SESSION = 'nexuscrew';
 
+function shellEscape(value) {
+  return `'${String(value).replace(/'/g, `'\\''`)}'`;
+}
+
 class TmuxManager {
   constructor(config = {}) {
     this.sessionName = config.tmuxSession || TMUX_SESSION;
-    this.logDir = config.logDir || path.join(process.env.HOME, '.nexuscrew', 'logs');
-    this.hosts = config.hosts || [{ name: 'local', type: 'local' }];
+    this.logDir = config.logDir || PATHS.LOGS_DIR;
 
-    // Ensure log dir
     if (!fs.existsSync(this.logDir)) {
       fs.mkdirSync(this.logDir, { recursive: true });
     }
   }
 
-  // --- Session management ---
+  getAllHosts() {
+    return readHosts();
+  }
+
+  getHost(name) {
+    return this.resolveHost(name);
+  }
 
-  /** Ensure master tmux session exists */
-  ensureSession(host = null) {
+  resolveHost(hostRef) {
+    if (!hostRef || hostRef === 'local') {
+      return getHostByName('local');
+    }
+
+    if (typeof hostRef === 'string') {
+      return getHostByName(hostRef);
+    }
+
+    if (typeof hostRef === 'object') {
+      if (hostRef.type === 'local' || hostRef.name === 'local') {
+        return getHostByName('local');
+      }
+      if (hostRef.name) {
+        return { ...getHostByName(hostRef.name), ...hostRef };
+      }
+      return hostRef;
+    }
+
+    return null;
+  }
+
+  ensureSession(hostRef = null) {
+    const host = this.resolveHost(hostRef);
     const cmd = this._cmd('tmux new-session -d -s ${SESSION} -x 200 -y 50 2>/dev/null || true', host);
     this._exec(cmd);
   }
 
-  /** Check if master session exists */
-  hasSession(host = null) {
+  hasSession(hostRef = null) {
     try {
+      const host = this.resolveHost(hostRef);
       this._exec(this._cmd('tmux has-session -t ${SESSION} 2>/dev/null', host));
       return true;
     } catch {
@@ -41,98 +73,68 @@ class TmuxManager {
     }
   }
 
-  // --- Window management ---
-
-  /**
-   * Create a new tmux window running a CLI command
-   * @param {Object} opts
-   * @param {string} opts.windowName - Unique window name (e.g. "claude-abc123")
-   * @param {string} opts.command - Full command to run
-   * @param {string} opts.cwd - Working directory
-   * @param {string} opts.host - Host name or null for local
-   * @returns {{ windowName, logPath }}
-   */
-  createWindow({ windowName, command, cwd, host = null }) {
+  createWindow({ windowName, command, cwd, host: hostRef = null }) {
+    const host = this.resolveHost(hostRef);
     this.ensureSession(host);
 
-    const logPath = path.join(this.logDir, `${windowName}.log`);
-    const logDir = path.dirname(logPath);
-
-    // For remote hosts, logs go to a local path
-    const fullCommand = cwd
-      ? `cd ${cwd} && ${command} 2>&1 | tee ${logPath}`
-      : `${command} 2>&1 | tee ${logPath}`;
+    const logPath = this.getLogPath(windowName);
+    const targetCwd = cwd || process.env.HOME || '.';
+    const fullCommand = `cd ${shellEscape(targetCwd)} && ${command} 2>&1 | tee ${shellEscape(logPath)}`;
 
     const cmd = this._cmd(
-      `tmux new-window -t \${SESSION} -n ${windowName} -c '${cwd || process.env.HOME}' "${fullCommand.replace(/"/g, '\\"')}"`,
+      `tmux new-window -t \${SESSION} -n ${shellEscape(windowName)} -c ${shellEscape(targetCwd)} ${shellEscape(fullCommand)}`,
       host
     );
 
-    this._exec(cmd);
-
+    this._exec(cmd, 20000);
     return { windowName, logPath };
   }
 
-  /**
-   * Send text to a tmux window (like typing)
-   * @param {string} windowName
-   * @param {string} text - Text to send
-   * @param {Object} opts
-   * @param {boolean} opts.enter - Press Enter after text
-   * @param {string} opts.host - Host name or null
-   */
   sendKeys(windowName, text, opts = {}) {
-    const enterSuffix = opts.enter ? ' Enter' : '';
-    const escapedText = text.replace(/'/g, "'\\''");
+    const host = this.resolveHost(opts.host);
     const cmd = this._cmd(
-      `tmux send-keys -t \${SESSION}:${windowName} '${escapedText}'${enterSuffix}`,
-      opts.host
+      `tmux send-keys -t \${SESSION}:${shellEscape(windowName)} -l ${shellEscape(text)}`,
+      host
     );
     this._exec(cmd);
+    if (opts.enter) {
+      this.sendSpecialKey(windowName, 'Enter', host);
+    }
   }
 
-  /**
-   * Send a special key (C-c, Escape, etc.)
-   */
-  sendSpecialKey(windowName, key, host = null) {
+  sendSpecialKey(windowName, key, hostRef = null) {
+    const host = this.resolveHost(hostRef);
     const cmd = this._cmd(
-      `tmux send-keys -t \${SESSION}:${windowName} ${key}`,
+      `tmux send-keys -t \${SESSION}:${shellEscape(windowName)} ${shellEscape(key)}`,
       host
     );
     this._exec(cmd);
   }
 
-  /** Interrupt: Escape then C-c (works for Claude/Codex/Gemini/Qwen) */
-  interrupt(windowName, host = null) {
+  interrupt(windowName, hostRef = null) {
+    const host = this.resolveHost(hostRef);
     this.sendSpecialKey(windowName, 'Escape', host);
-    setTimeout(() => {
-      this.sendSpecialKey(windowName, 'C-c', host);
-    }, 100);
+    this.sendSpecialKey(windowName, 'C-c', host);
   }
 
-  /**
-   * Capture current pane content
-   * @returns {string} visible text in the pane
-   */
-  capturePane(windowName, host = null) {
+  capturePane(windowName, hostRef = null, lines = 200) {
     try {
+      const host = this.resolveHost(hostRef);
       const cmd = this._cmd(
-        `tmux capture-pane -t \${SESSION}:${windowName} -p -S -100`,
+        `tmux capture-pane -t \${SESSION}:${shellEscape(windowName)} -p -S -${Math.max(50, lines)}`,
         host
       );
-      return this._exec(cmd);
+      return this._exec(cmd, 15000);
     } catch {
       return '';
     }
   }
 
-  /**
-   * Check if a window exists
-   */
-  hasWindow(windowName, host = null) {
+  hasWindow(windowName, hostRef = null) {
     try {
+      const host = this.resolveHost(hostRef);
       const cmd = this._cmd(
-        `tmux list-windows -t \${SESSION} -F '#{{window_name}}' 2>/dev/null | grep -qx '${windowName}'`,
+        `tmux list-windows -t \${SESSION} -F '#{window_name}' 2>/dev/null | grep -Fx -- ${shellEscape(windowName)}`,
         host
       );
       this._exec(cmd);
@@ -142,38 +144,35 @@ class TmuxManager {
     }
   }
 
-  /**
-   * Kill a window
-   */
-  killWindow(windowName, host = null) {
+  killWindow(windowName, hostRef = null) {
     try {
+      const host = this.resolveHost(hostRef);
       const cmd = this._cmd(
-        `tmux kill-window -t \${SESSION}:${windowName} 2>/dev/null`,
+        `tmux kill-window -t \${SESSION}:${shellEscape(windowName)} 2>/dev/null`,
         host
       );
       this._exec(cmd);
     } catch {}
   }
 
-  /**
-   * List all windows in the master session
-   * @returns {Array<{index, name, active, size}>}
-   */
-  listWindows(host = null) {
+  listWindows(hostRef = null) {
     try {
+      const host = this.resolveHost(hostRef);
       const cmd = this._cmd(
-        `tmux list-windows -t \${SESSION} -F '#{{window_index}}:#{{window_name}} #{{window_width}}x#{{window_height}} #{{?window_active,1,0}}' 2>/dev/null`,
+        `tmux list-windows -t \${SESSION} -F '#{window_index}\t#{window_name}\t#{window_width}x#{window_height}\t#{?window_active,1,0}' 2>/dev/null`,
         host
       );
-      const output = this._exec(cmd);
-      return output.trim().split('\n').filter(Boolean).map(line => {
-        const [idxName, size, active] = line.split(' ');
-        const [index, ...nameParts] = idxName.split(':');
+      const output = this._exec(cmd, 15000).trim();
+      if (!output) return [];
+
+      return output.split('\n').filter(Boolean).map((line) => {
+        const [index, name, size, active] = line.split('\t');
         return {
-          index: parseInt(index),
-          name: nameParts.join(':'),
+          index: Number(index),
+          name,
           size,
-          active: active === '1'
+          active: active === '1',
+          host: host?.name || 'local'
         };
       });
     } catch {
@@ -181,13 +180,11 @@ class TmuxManager {
     }
   }
 
-  /**
-   * Get process PID running in a window
-   */
-  getWindowPid(windowName, host = null) {
+  getWindowPid(windowName, hostRef = null) {
     try {
+      const host = this.resolveHost(hostRef);
       const cmd = this._cmd(
-        `tmux list-panes -t \${SESSION}:${windowName} -F '#{{pane_pid}}' 2>/dev/null`,
+        `tmux list-panes -t \${SESSION}:${shellEscape(windowName)} -F '#{pane_pid}' 2>/dev/null`,
         host
       );
       return this._exec(cmd).trim();
@@ -196,40 +193,51 @@ class TmuxManager {
     }
   }
 
-  // --- Host resolution ---
-
-  /** Get host config by name */
-  getHost(name) {
-    if (!name || name === 'local') return null;
-    return this.hosts.find(h => h.name === name) || null;
-  }
-
-  /** Get all configured hosts */
-  getAllHosts() {
-    return this.hosts;
-  }
-
-  /** Test SSH connectivity */
-  testHost(host) {
+  testHost(hostRef) {
+    const host = this.resolveHost(hostRef);
     if (!host || host.type === 'local') return true;
     try {
-      const sshCmd = this._sshCmd(host, 'echo ok');
-      this._exec(sshCmd, 5000);
+      this._exec(this._sshCmd(host, 'echo ok'), 5000);
       return true;
     } catch {
       return false;
     }
   }
 
-  // --- Internal ---
+  ensureRemoteDirectory(remotePath, hostRef) {
+    const host = this.resolveHost(hostRef);
+    if (!host || host.type === 'local') {
+      fs.mkdirSync(remotePath, { recursive: true });
+      return remotePath;
+    }
+    this._exec(this._sshCmd(host, `mkdir -p ${shellEscape(remotePath)}`), 10000);
+    return remotePath;
+  }
+
+  copyToHost(localPath, remotePath, hostRef) {
+    const host = this.resolveHost(hostRef);
+    if (!host || host.type === 'local') {
+      const targetDir = path.dirname(remotePath);
+      fs.mkdirSync(targetDir, { recursive: true });
+      fs.copyFileSync(localPath, remotePath);
+      return remotePath;
+    }
+
+    this.ensureRemoteDirectory(path.posix.dirname(remotePath), host);
+    const parts = ['scp', '-q', '-o', 'ConnectTimeout=5', '-o', 'BatchMode=yes'];
+    if (host.port && host.port !== '22') parts.push('-P', String(host.port));
+    if (host.key) parts.push('-i', host.key);
+    parts.push(localPath, `${host.user}@${host.host}:${remotePath}`);
+    this._exec(parts.map(shellEscape).join(' '), 30000);
+    return remotePath;
+  }
+
+  getLogPath(windowName) {
+    return path.join(this.logDir, `${windowName}.log`);
+  }
 
-  /**
-   * Build command with SESSION variable substitution
-   * @param {string} tmpl - Command template with ${SESSION}
-   * @param {Object|null} host - Host config
-   * @returns {string} final command
-   */
-  _cmd(tmpl, host) {
+  _cmd(tmpl, hostRef) {
+    const host = this.resolveHost(hostRef);
     const cmd = tmpl.replace(/\$\{SESSION\}/g, this.sessionName);
     if (!host || host.type === 'local') return cmd;
     return this._sshCmd(host, cmd);
@@ -237,11 +245,14 @@ class TmuxManager {
 
   _sshCmd(host, cmd) {
     const parts = ['ssh', '-o', 'ConnectTimeout=5', '-o', 'BatchMode=yes'];
-    if (host.port && host.port !== '22') parts.push('-p', host.port);
+    if (host.port && host.port !== '22') parts.push('-p', String(host.port));
     if (host.key) parts.push('-i', host.key);
     parts.push(`${host.user}@${host.host}`);
-    parts.push(cmd);
-    return parts.join(' ');
+    parts.push(shellEscape(cmd));
+    return parts.map((part, index) => {
+      if (index === parts.length - 1) return part;
+      return /\s/.test(part) ? shellEscape(part) : part;
+    }).join(' ');
   }
 
   _exec(cmd, timeout = 10000) {

package/lib/setup/postinstall.js

@@ -0,0 +1,38 @@
+#!/usr/bin/env node
+
+const { execSync } = require('child_process');
+const { ensureDirectories, PATHS } = require('../utils/paths');
+const { initializeConfig, isInitialized } = require('../config/manager');
+const { ensureHostsFile } = require('../config/hosts');
+const { isTermux } = require('../utils/termux');
+
+function has(command) {
+  try {
+    execSync(`which ${command}`, { stdio: 'ignore' });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+ensureDirectories();
+ensureHostsFile();
+
+if (!isInitialized()) {
+  initializeConfig({ workspaces: [`${process.env.HOME || ''}/Dev`] });
+}
+
+console.log('');
+console.log('NexusCrew postinstall');
+console.log(`  config: ${PATHS.CONFIG_FILE}`);
+console.log(`  hosts: ${PATHS.HOSTS_FILE}`);
+console.log(`  tmux: ${has('tmux') ? 'OK' : 'missing'}`);
+console.log(`  ssh: ${has('ssh') ? 'OK' : 'missing'}`);
+console.log(`  scp: ${has('scp') ? 'OK' : 'missing'}`);
+console.log(`  whisper-cli: ${has('whisper-cli') ? 'OK' : 'missing'}`);
+if (isTermux()) {
+  console.log('  platform: Termux');
+  console.log(`  termux-services: ${has('sv') ? 'OK' : 'missing'}`);
+}
+console.log('  next: run `nexuscrew setup` to configure workspace, SSH hosts, local STT, and optional Termux boot/runit');
+console.log('');

package/lib/utils/paths.js

@@ -37,9 +37,24 @@ const PATHS = {
   // Engines config directory
   ENGINES_DIR: path.join(HOME, '.nexuscrew', 'engines'),
 
+  // Attachments directory
+  ATTACHMENTS_DIR: path.join(HOME, '.nexuscrew', 'attachments'),
+
+  // Local helper binaries
+  BIN_DIR: path.join(HOME, '.nexuscrew', 'bin'),
+
+  // Hosts registry
+  HOSTS_FILE: path.join(HOME, '.nexuscrew', 'hosts.json'),
+
   // Termux boot script
   BOOT_SCRIPT: path.join(HOME, '.termux', 'boot', 'nexuscrew-start.sh'),
 
+  // Termux runit service directory
+  TERMUX_SERVICE_DIR: path.join(process.env.PREFIX || '/data/data/com.termux/files/usr', 'var', 'service', 'nexuscrew'),
+
+  // Termux runit logs
+  TERMUX_SERVICE_LOG_DIR: path.join(process.env.PREFIX || '/data/data/com.termux/files/usr', 'var', 'log', 'sv', 'nexuscrew'),
+
   // Claude CLI history (read-only)
   CLAUDE_HISTORY: path.join(HOME, '.claude', 'history.jsonl'),
   CLAUDE_PROJECTS: path.join(HOME, '.claude', 'projects'),
@@ -56,7 +71,9 @@ function ensureDirectories() {
     PATHS.CONFIG_DIR,
     PATHS.DATA_DIR,
     PATHS.LOGS_DIR,
-    PATHS.ENGINES_DIR
+    PATHS.ENGINES_DIR,
+    PATHS.ATTACHMENTS_DIR,
+    PATHS.BIN_DIR
   ];
 
   for (const dir of dirs) {

package/lib/utils/termux.js

@@ -24,6 +24,14 @@ function getPrefix() {
   return process.env.PREFIX || '/data/data/com.termux/files/usr';
 }
 
+function getServiceDir(serviceName = 'nexuscrew') {
+  return path.join(getPrefix(), 'var', 'service', serviceName);
+}
+
+function getStartServicesScript() {
+  return path.join(getPrefix(), 'etc', 'profile.d', 'start-services.sh');
+}
+
 /**
  * Check if a Termux package is installed
  */
@@ -68,6 +76,10 @@ function isTermuxBootAvailable() {
   return fs.existsSync(bootDir);
 }
 
+function isTermuxServicesAvailable() {
+  return fs.existsSync(getStartServicesScript()) && isPackageInstalled('sv');
+}
+
 /**
  * Acquire Termux wake lock
  */
@@ -130,16 +142,41 @@ function checkRequiredPackages() {
   return status;
 }
 
+function openUrl(url) {
+  try {
+    if (isTermux() && isPackageInstalled('termux-open-url')) {
+      spawn('termux-open-url', [url], { detached: true, stdio: 'ignore' }).unref();
+      return true;
+    }
+
+    if (process.platform === 'darwin') {
+      spawn('open', [url], { detached: true, stdio: 'ignore' }).unref();
+      return true;
+    }
+
+    if (isPackageInstalled('xdg-open')) {
+      spawn('xdg-open', [url], { detached: true, stdio: 'ignore' }).unref();
+      return true;
+    }
+  } catch {}
+
+  return false;
+}
+
 module.exports = {
   isTermux,
   getPrefix,
+  getServiceDir,
+  getStartServicesScript,
   isPackageInstalled,
   installPackage,
   isTermuxApiWorking,
   isTermuxBootAvailable,
+  isTermuxServicesAvailable,
   acquireWakeLock,
   releaseWakeLock,
   sendNotification,
   getRequiredPackages,
-  checkRequiredPackages
+  checkRequiredPackages,
+  openUrl
 };