@mmmbuto/nexuscrew 0.2.0 → 0.2.1

package/lib/server/routes/sessions.js

@@ -13,17 +13,16 @@ const router = Router();
 // List conversations (optionally grouped by date)
 router.get('/', (req, res) => {
   const { store, tmux } = req;
-  const { workspace, groupBy } = req.query;
+  const { workspace, groupBy, host } = req.query;
 
   if (groupBy === 'date') {
-    const grouped = store.listGroupedByDate({ workspace });
+    const grouped = store.listGroupedByDate({ workspace, host });
 
     // 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);
+          conv.tmux_alive = tmux.hasWindow(conv.tmux_window, conv.host || 'local');
         } else {
           conv.tmux_alive = false;
         }
@@ -33,13 +32,12 @@ router.get('/', (req, res) => {
     return res.json(grouped);
   }
 
-  const convs = store.listConversations({ workspace });
+  const convs = store.listConversations({ workspace, host });
 
   // 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);
+      conv.tmux_alive = tmux.hasWindow(conv.tmux_window, conv.host || 'local');
     } else {
       conv.tmux_alive = false;
     }
@@ -58,8 +56,7 @@ 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 alive = conv.tmux_window ? tmux.hasWindow(conv.tmux_window, conv.host || 'local') : false;
 
   res.json({
     session: {
@@ -113,21 +110,21 @@ router.post('/:id/pin', (req, res) => {
 
 // Delete conversation (kills tmux window too)
 router.delete('/:id', (req, res) => {
-  const { store, tmux, logWatcher } = req;
+  const { store, tmux, logWatcher, remotePaneWatcher } = 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) {
-    const host = conv.host !== 'local' ? conv.host : null;
-    tmux.killWindow(conv.tmux_window, host);
+    tmux.killWindow(conv.tmux_window, conv.host || 'local');
   }
 
   // Stop log watcher
   if (conv.log_path) {
     logWatcher.unwatch(conv.log_path);
   }
+  remotePaneWatcher?.unwatchByConversation?.(req.params.id);
 
   store.deleteConversation(req.params.id);
   res.json({ success: true });

package/lib/server/routes/speech.js

@@ -1,74 +1,45 @@
 const express = require('express');
 const router = express.Router();
 const multer = require('multer');
-const { getApiKey } = require('../db/adapter');
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const { PATHS } = require('../../utils/paths');
 
 const upload = multer({
   storage: multer.memoryStorage(),
-  limits: { fileSize: 25 * 1024 * 1024 } // 25MB max (Whisper limit)
+  limits: { fileSize: 25 * 1024 * 1024 }
+});
+
+router.get('/status', (req, res) => {
+  res.json(req.speech.getStatus());
 });
 
-/**
- * POST /api/v1/speech/transcribe
- * Transcribe audio using OpenAI Whisper API
- * Body: multipart/form-data with 'audio' file and 'language' (optional)
- * Returns: { text: string }
- *
- * Supported languages (aligned with UI): it, en, es, ja, ru, zh
- */
 router.post('/transcribe', upload.single('audio'), async (req, res) => {
-  try {
-    const apiKey = getApiKey('openai');
-    if (!apiKey) {
-      return res.status(400).json({ error: 'OpenAI API key not configured' });
-    }
+  let tempPath = null;
 
+  try {
     if (!req.file) {
       return res.status(400).json({ error: 'No audio file provided' });
     }
 
-    // Build FormData using native Node.js 22+ FormData and File
-    const formData = new FormData();
-    const audioFile = new File([req.file.buffer], 'audio.webm', {
-      type: req.file.mimetype || 'audio/webm'
-    });
-    formData.append('file', audioFile);
-    formData.append('model', 'whisper-1');
-
-    // Use language from request - extract base language (it-IT -> it)
-    if (req.body.language) {
-      const lang = req.body.language.split('-')[0]; // it-IT -> it
-      formData.append('language', lang);
-    }
-
-    console.log('[Speech] Transcribing audio:', {
-      size: req.file.size,
-      mimetype: req.file.mimetype,
-      language: req.body.language || 'auto-detect'
-    });
+    fs.mkdirSync(PATHS.DATA_DIR, { recursive: true });
+    tempPath = path.join(PATHS.DATA_DIR, `stt-${Date.now()}-${Math.random().toString(16).slice(2)}.webm`);
+    fs.writeFileSync(tempPath, req.file.buffer);
 
-    // Use native fetch (Node.js 22+)
-    const response = await fetch('https://api.openai.com/v1/audio/transcriptions', {
-      method: 'POST',
-      headers: {
-        'Authorization': `Bearer ${apiKey}`
-      },
-      body: formData
+    const result = await req.speech.transcribe({
+      audioPath: tempPath,
+      language: req.body.language
     });
 
-    if (!response.ok) {
-      const error = await response.json();
-      console.error('[Speech] OpenAI error:', error);
-      return res.status(response.status).json(error);
-    }
-
-    const data = await response.json();
-    console.log('[Speech] Transcription success:', data.text?.substring(0, 50) + '...');
-    res.json(data);
-
+    res.json(result);
   } catch (error) {
     console.error('[Speech] Transcription error:', error);
     res.status(500).json({ error: error.message });
+  } finally {
+    if (tempPath && fs.existsSync(tempPath)) {
+      fs.unlinkSync(tempPath);
+    }
   }
 });
 

package/lib/server/routes/status.js

@@ -10,13 +10,14 @@ const router = Router();
 // Overall status
 router.get('/', (req, res) => {
   const { tmux, store } = req;
-  const windows = tmux.listWindows();
+  const { host = 'local' } = req.query;
+  const windows = tmux.listWindows(host);
   const hosts = tmux.getAllHosts();
 
   res.json({
     tmux: {
       session: tmux.sessionName,
-      alive: tmux.hasSession(),
+      alive: tmux.hasSession(host),
       windowCount: windows.length,
       windows
     },
@@ -30,7 +31,8 @@ router.get('/', (req, res) => {
 // Detailed tmux windows
 router.get('/tmux', (req, res) => {
   const { tmux, store } = req;
-  const windows = tmux.listWindows();
+  const { host = 'local' } = req.query;
+  const windows = tmux.listWindows(host);
 
   // Enrich with DB data
   const enriched = windows.map(w => {
@@ -40,7 +42,7 @@ router.get('/tmux', (req, res) => {
       conversationId: conv?.id || null,
       engine: conv?.engine || null,
       model: conv?.model || null,
-      host: conv?.host || 'local',
+      host: conv?.host || host || 'local',
       title: conv?.title || w.name
     };
   });
@@ -51,8 +53,8 @@ router.get('/tmux', (req, res) => {
 // Capture pane content
 router.get('/pane/:window', (req, res) => {
   const { tmux } = req;
-  const { host } = req.query;
-  const content = tmux.capturePane(req.params.window, host || null);
+  const { host = 'local' } = req.query;
+  const content = tmux.capturePane(req.params.window, host);
 
   res.json({ window: req.params.window, content });
 });

package/lib/server/routes/upload.js

@@ -2,11 +2,12 @@ const express = require('express');
 const multer = require('multer');
 const path = require('path');
 const fs = require('fs');
+const { PATHS } = require('../../utils/paths');
 
 const router = express.Router();
 
 // NexusCrew: attachments in ~/.nexuscrew/attachments
-const ATTACHMENTS_DIR = path.join(process.env.HOME, '.nexuscrew', 'attachments');
+const ATTACHMENTS_DIR = path.join(PATHS.ATTACHMENTS_DIR, 'incoming');
 
 // Ensure directory exists
 if (!fs.existsSync(ATTACHMENTS_DIR)) {

package/lib/server/server.js

@@ -16,6 +16,10 @@ 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');
@@ -36,27 +40,15 @@ const { authMiddleware } = require('./middleware/auth');
 
 class NexusCrewServer {
   constructor(config = {}) {
-    this.port = config.port || process.env.PORT || 41820;
     this.configDir = config.configDir || path.join(process.env.HOME, '.nexuscrew');
     this.config = this._loadConfig();
+    this.port = config.port || process.env.PORT || this.config.server?.port || 41820;
     this.app = express();
     this.server = null;
   }
 
   _loadConfig() {
-    const configPath = path.join(this.configDir, 'config.json');
-    if (fs.existsSync(configPath)) {
-      return JSON.parse(fs.readFileSync(configPath, 'utf8'));
-    }
-    return { port: this.port, tmuxSession: 'nexuscrew', autoDiscovery: true };
-  }
-
-  _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 }];
+    return getConfig();
   }
 
   async start() {
@@ -67,21 +59,24 @@ class NexusCrewServer {
     const User = require('./models/User');
     if (User.count() === 0) {
       User.create('admin', 'admin', 'admin');
-      console.log('  Created default admin user (admin/admin)');
+      console.log('  Created initial admin account from local defaults');
     }
 
     // 3. Init services
-    const hosts = this._loadHosts();
     const tmuxManager = new TmuxManager({
       tmuxSession: this.config.tmuxSession || 'nexuscrew',
-      logDir: this.config.logDir || path.join(this.configDir, 'logs'),
-      hosts
+      logDir: this.config.logDir || path.join(this.configDir, 'logs')
     });
 
     const engineDiscovery = new EngineDiscovery(this.config.providersPath);
     const sessionStore = new SessionStore();
     await sessionStore.init();
     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();
@@ -106,7 +101,7 @@ class NexusCrewServer {
       res.json({
         status: 'ok',
         service: 'nexuscrew',
-        version: '0.2.0',
+        version: '0.2.1',
         tmux: tmuxManager.hasSession(),
         windows: tmuxManager.listWindows().length,
         uptime: process.uptime()
@@ -119,6 +114,9 @@ class NexusCrewServer {
       req.engines = engineDiscovery;
       req.store = sessionStore;
       req.logWatcher = logWatcher;
+      req.remotePaneWatcher = remotePaneWatcher;
+      req.attachments = attachmentManager;
+      req.speech = speechManager;
       req.config = this.config;
       next();
     });
@@ -168,7 +166,7 @@ class NexusCrewServer {
         console.log('');
         console.log(`  HTTP:  http://localhost:${this.port}`);
         console.log(`  tmux:  session "${tmuxManager.sessionName}" (${tmuxManager.listWindows().length} windows)`);
-        console.log(`  Hosts: ${hosts.map(h => h.name).join(', ')}`);
+        console.log(`  Hosts: ${tmuxManager.getAllHosts().map(h => h.name).join(', ')}`);
         console.log('');
 
         const engines = engineDiscovery.discover();
@@ -184,6 +182,9 @@ class NexusCrewServer {
 
   stop() {
     if (this.server) {
+      const appLocals = this.app?.locals || {};
+      appLocals.logWatcher?.unwatchAll?.();
+      appLocals.remotePaneWatcher?.unwatchAll?.();
       saveDb();
       this.server.close();
     }

package/lib/server/services/attachment-manager.js

@@ -0,0 +1,57 @@
+const fs = require('fs');
+const path = require('path');
+const { PATHS } = require('../../utils/paths');
+
+class AttachmentManager {
+  constructor(tmux) {
+    this.tmux = tmux;
+  }
+
+  getLocalAttachmentDir(conversationId = 'shared') {
+    return path.join(PATHS.ATTACHMENTS_DIR, 'local', conversationId);
+  }
+
+  getRemoteAttachmentDir(conversationId = 'shared') {
+    return path.posix.join('.nexuscrew', 'attachments', conversationId);
+  }
+
+  stageForConversation(file, conversationId, hostRef) {
+    if (!file?.path) {
+      throw new Error('Attachment path is required');
+    }
+
+    const host = this.tmux.resolveHost(hostRef);
+    const baseName = path.basename(file.path);
+
+    if (!host || host.type === 'local') {
+      const localDir = this.getLocalAttachmentDir(conversationId);
+      fs.mkdirSync(localDir, { recursive: true });
+      const localPath = path.join(localDir, baseName);
+      if (file.path !== localPath) {
+        fs.copyFileSync(file.path, localPath);
+      }
+      return {
+        ...file,
+        host: 'local',
+        localPath,
+        promptPath: localPath,
+        ready: true
+      };
+    }
+
+    const remoteDir = this.getRemoteAttachmentDir(conversationId);
+    const remotePath = path.posix.join(remoteDir, baseName);
+    this.tmux.copyToHost(file.path, remotePath, host);
+
+    return {
+      ...file,
+      host: host.name,
+      localPath: file.path,
+      remotePath,
+      promptPath: `~/${remotePath}`,
+      ready: true
+    };
+  }
+}
+
+module.exports = AttachmentManager;

package/lib/server/services/speech-manager.js

@@ -0,0 +1,76 @@
+const fs = require('fs');
+const path = require('path');
+const { execFile } = require('child_process');
+const { promisify } = require('util');
+const { getConfig } = require('../../config/manager');
+const { PATHS } = require('../../utils/paths');
+
+const execFileAsync = promisify(execFile);
+
+function resolveBundledWhisper() {
+  const candidates = [
+    path.join(PATHS.BIN_DIR, 'whisper-cli'),
+    path.join(__dirname, '../../../bin/android-arm64/whisper-cli'),
+    path.join(__dirname, '../../../bin/linux-x64/whisper-cli')
+  ];
+  return candidates.find((candidate) => fs.existsSync(candidate)) || 'whisper-cli';
+}
+
+class SpeechManager {
+  getStatus() {
+    const config = getConfig();
+    const whisperBin = config.stt?.whisper?.bin || resolveBundledWhisper();
+    const whisperModel = config.stt?.whisper?.model || '';
+
+    return {
+      provider: config.stt?.provider || 'whispercpp',
+      fallback: config.stt?.fallback || 'browser',
+      whisper: {
+        bin: whisperBin,
+        model: whisperModel,
+        configured: Boolean(whisperModel),
+        available: this.checkBinary(whisperBin)
+      },
+      tts: {
+        provider: config.tts?.provider || 'system'
+      }
+    };
+  }
+
+  checkBinary(binPath) {
+    if (!binPath) return false;
+    if (binPath === 'whisper-cli') return true;
+    return fs.existsSync(binPath);
+  }
+
+  async transcribe({ audioPath, language }) {
+    const config = getConfig();
+    const bin = config.stt?.whisper?.bin || resolveBundledWhisper();
+    const model = config.stt?.whisper?.model;
+    const threads = String(config.stt?.whisper?.threads || 2);
+    const lang = language || config.stt?.whisper?.language || 'it';
+
+    if (!model) {
+      throw new Error('whisper.cpp model not configured');
+    }
+
+    const args = ['-m', model, '-f', audioPath, '-l', lang, '-t', threads, '--no-timestamps'];
+    const { stdout, stderr } = await execFileAsync(bin, args, {
+      timeout: 120000,
+      maxBuffer: 8 * 1024 * 1024
+    });
+
+    const text = [stdout, stderr]
+      .filter(Boolean)
+      .join('\n')
+      .split('\n')
+      .map((line) => line.trim())
+      .filter((line) => line && !line.startsWith('['))
+      .join(' ')
+      .trim();
+
+    return { text };
+  }
+}
+
+module.exports = SpeechManager;

package/lib/services/log-watcher.js

@@ -27,10 +27,7 @@ class LogWatcher extends EventEmitter {
 
     const state = {
       offset: 0,
-      engine,
-      conversationId,
-      buffer: '',
-      parser: this._getParser(engine)
+      ...this.createParserState(engine, conversationId)
     };
 
     // Read existing content (in case log already has data)
@@ -98,39 +95,60 @@ class LogWatcher extends EventEmitter {
 
       state.offset = stat.size;
       const chunk = buf.toString('utf8');
-      state.buffer += chunk;
-
-      // Process complete lines
-      this._processBuffer(state);
+      this.processTextChunk(chunk, state);
     } catch (err) {
       // File might be temporarily unavailable
     }
   }
 
+  createParserState(engine, conversationId) {
+    return {
+      engine,
+      conversationId,
+      buffer: '',
+      parser: this._getParser(engine)
+    };
+  }
+
+  processTextChunk(chunk, state) {
+    state.buffer += chunk;
+    this._processBuffer(state);
+  }
+
+  flushState(state) {
+    if (!state.buffer?.trim()) return;
+    const line = state.buffer;
+    state.buffer = '';
+    this._emitParsedLine(line, state);
+  }
+
   _processBuffer(state) {
     const lines = state.buffer.split('\n');
     state.buffer = lines.pop() || ''; // Keep incomplete line in buffer
 
     for (const line of lines) {
-      if (!line.trim()) continue;
-      try {
-        const events = state.parser(line, state);
-        for (const event of events) {
-          this.emit('data', {
-            ...event,
-            conversationId: state.conversationId,
-            engine: state.engine
-          });
-        }
-      } catch {
-        // Emit raw text if parser fails
+      this._emitParsedLine(line, state);
+    }
+  }
+
+  _emitParsedLine(line, state) {
+    if (!line.trim()) return;
+    try {
+      const events = state.parser(line, state);
+      for (const event of events) {
         this.emit('data', {
-          type: 'raw',
-          content: line,
+          ...event,
           conversationId: state.conversationId,
           engine: state.engine
         });
       }
+    } catch {
+      this.emit('data', {
+        type: 'raw',
+        content: line,
+        conversationId: state.conversationId,
+        engine: state.engine
+      });
     }
   }