@mmmbuto/nexuscrew 0.1.0-beta.1 → 0.2.1

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

@@ -0,0 +1,124 @@
+/**
+ * Standard Paths for NexusCrew
+ * Termux Mobile First - all paths relative to $HOME
+ */
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const HOME = process.env.HOME || os.homedir();
+
+/**
+ * NexusCrew standard paths
+ */
+const PATHS = {
+  // Main config directory
+  CONFIG_DIR: path.join(HOME, '.nexuscrew'),
+
+  // Config file
+  CONFIG_FILE: path.join(HOME, '.nexuscrew', 'config.json'),
+
+  // Data directory (database, cache)
+  DATA_DIR: path.join(HOME, '.nexuscrew', 'data'),
+
+  // Database file
+  DATABASE: path.join(HOME, '.nexuscrew', 'data', 'nexuscrew.db'),
+
+  // Logs directory
+  LOGS_DIR: path.join(HOME, '.nexuscrew', 'logs'),
+
+  // Server log
+  SERVER_LOG: path.join(HOME, '.nexuscrew', 'logs', 'server.log'),
+
+  // PID file for daemon
+  PID_FILE: path.join(HOME, '.nexuscrew', 'nexuscrew.pid'),
+
+  // 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'),
+
+  // Default workspace
+  DEFAULT_WORKSPACE: path.join(HOME, 'Dev')
+};
+
+/**
+ * Ensure all required directories exist
+ */
+function ensureDirectories() {
+  const dirs = [
+    PATHS.CONFIG_DIR,
+    PATHS.DATA_DIR,
+    PATHS.LOGS_DIR,
+    PATHS.ENGINES_DIR,
+    PATHS.ATTACHMENTS_DIR,
+    PATHS.BIN_DIR
+  ];
+
+  for (const dir of dirs) {
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+  }
+}
+
+/**
+ * Ensure Termux boot directory exists
+ */
+function ensureBootDirectory() {
+  const bootDir = path.join(HOME, '.termux', 'boot');
+  if (!fs.existsSync(bootDir)) {
+    fs.mkdirSync(bootDir, { recursive: true });
+  }
+  return bootDir;
+}
+
+/**
+ * Get path resolving ~ to HOME
+ */
+function resolvePath(p) {
+  if (p.startsWith('~')) {
+    return path.join(HOME, p.slice(1));
+  }
+  return path.resolve(p);
+}
+
+/**
+ * Get relative path from HOME (for display)
+ */
+function toDisplayPath(p) {
+  if (p.startsWith(HOME)) {
+    return '~' + p.slice(HOME.length);
+  }
+  return p;
+}
+
+module.exports = {
+  PATHS,
+  HOME,
+  ensureDirectories,
+  ensureBootDirectory,
+  resolvePath,
+  toDisplayPath
+};