@mmmbuto/nexuscrew 0.1.0-beta.1 → 0.2.1

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

@@ -0,0 +1,135 @@
+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(PATHS.ATTACHMENTS_DIR, 'incoming');
+
+// Ensure directory exists
+if (!fs.existsSync(ATTACHMENTS_DIR)) {
+  fs.mkdirSync(ATTACHMENTS_DIR, { recursive: true });
+  console.log(`[Upload] Created attachments directory: ${ATTACHMENTS_DIR}`);
+}
+
+// Multer storage config
+const storage = multer.diskStorage({
+  destination: (req, file, cb) => {
+    cb(null, ATTACHMENTS_DIR);
+  },
+  filename: (req, file, cb) => {
+    // Unique filename: timestamp_originalname
+    const timestamp = Date.now();
+    const safeName = file.originalname.replace(/[^a-zA-Z0-9._-]/g, '_');
+    cb(null, `${timestamp}_${safeName}`);
+  }
+});
+
+// File filter - allow images and documents
+const fileFilter = (req, file, cb) => {
+  const allowedMimes = [
+    // Images
+    'image/jpeg', 'image/png', 'image/gif', 'image/webp', 'image/svg+xml',
+    // Documents
+    'text/plain', 'text/markdown', 'text/csv', 'text/html', 'text/css',
+    'application/json', 'application/xml', 'application/pdf',
+    'application/msword', 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+    'application/vnd.ms-excel', 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+    // Code files (often sent as octet-stream)
+    'application/octet-stream', 'text/x-python', 'text/javascript', 'application/javascript'
+  ];
+
+  // Also allow by extension for code files
+  const allowedExts = ['.js', '.ts', '.py', '.java', '.c', '.cpp', '.h', '.rb', '.php', '.go', '.rs', '.sh', '.bash', '.zsh', '.md', '.txt', '.json', '.yaml', '.yml', '.toml', '.xml', '.html', '.css', '.sql', '.log'];
+  const ext = path.extname(file.originalname).toLowerCase();
+
+  if (allowedMimes.includes(file.mimetype) || allowedExts.includes(ext)) {
+    cb(null, true);
+  } else {
+    cb(new Error(`File type not allowed: ${file.mimetype} (${ext})`), false);
+  }
+};
+
+// Multer config - 50MB limit
+const upload = multer({
+  storage,
+  fileFilter,
+  limits: { fileSize: 50 * 1024 * 1024 }
+});
+
+// POST /api/v1/upload - Single file upload
+router.post('/', upload.single('file'), (req, res) => {
+  try {
+    if (!req.file) {
+      return res.status(400).json({ error: 'No file uploaded' });
+    }
+
+    const filePath = req.file.path;
+    const fileName = req.file.filename;
+    const originalName = req.file.originalname;
+    const mimeType = req.file.mimetype;
+    const size = req.file.size;
+
+    console.log(`[Upload] File saved: ${filePath} (${size} bytes, ${mimeType})`);
+
+    res.json({
+      success: true,
+      file: {
+        path: filePath,
+        name: fileName,
+        originalName,
+        mimeType,
+        size
+      }
+    });
+  } catch (error) {
+    console.error('[Upload] Error:', error);
+    res.status(500).json({ error: error.message });
+  }
+});
+
+// POST /api/v1/upload/multiple - Multiple files upload
+router.post('/multiple', upload.array('files', 10), (req, res) => {
+  try {
+    if (!req.files || req.files.length === 0) {
+      return res.status(400).json({ error: 'No files uploaded' });
+    }
+
+    const files = req.files.map(f => ({
+      path: f.path,
+      name: f.filename,
+      originalName: f.originalname,
+      mimeType: f.mimetype,
+      size: f.size
+    }));
+
+    console.log(`[Upload] ${files.length} files saved`);
+
+    res.json({
+      success: true,
+      files
+    });
+  } catch (error) {
+    console.error('[Upload] Error:', error);
+    res.status(500).json({ error: error.message });
+  }
+});
+
+// Error handler for multer
+router.use((error, req, res, next) => {
+  if (error instanceof multer.MulterError) {
+    if (error.code === 'LIMIT_FILE_SIZE') {
+      return res.status(400).json({ error: 'File too large (max 50MB)' });
+    }
+    return res.status(400).json({ error: error.message });
+  }
+  if (error) {
+    return res.status(400).json({ error: error.message });
+  }
+  next();
+});
+
+module.exports = router;

package/lib/server/routes/wake-lock.js

@@ -0,0 +1,95 @@
+const express = require('express');
+const { execSync } = require('child_process');
+const router = express.Router();
+
+// State to track wake lock status
+let wakeLockAcquired = false;
+
+/**
+ * POST /api/v1/wake-lock
+ * Acquire wake lock (prevent Android from killing process)
+ * On non-Termux systems, this is a no-op but returns success to avoid errors
+ */
+router.post('/wake-lock', (req, res) => {
+  try {
+    console.log('[WakeLock] Acquiring wake lock...');
+
+    const isTermux = process.env.PREFIX?.includes('com.termux');
+
+    if (isTermux) {
+      // Only execute on Termux/Android
+      try {
+        execSync('termux-wake-lock', { stdio: 'ignore' });
+      } catch (e) {
+        console.warn('[WakeLock] termux-wake-lock command failed (may not be available)');
+      }
+    } else {
+      console.log('[WakeLock] Not on Termux - wake-lock is a no-op');
+    }
+
+    wakeLockAcquired = true;
+
+    console.log('[WakeLock] ✅ Wake lock acquired (or skipped on non-Termux)');
+
+    res.json({
+      status: 'ok',
+      message: 'Wake lock acquired',
+      acquired: wakeLockAcquired,
+      platform: isTermux ? 'termux' : 'linux'
+    });
+  } catch (err) {
+    console.error('[WakeLock] ❌ Unexpected error:', err.message);
+
+    // Still return success to avoid breaking the app
+    res.status(200).json({
+      status: 'ok',
+      message: 'Wake lock handler executed',
+      acquired: true,
+      error: err.message // Log the error but don't fail the request
+    });
+  }
+});
+
+/**
+ * DELETE /api/v1/wake-lock
+ * Release wake lock
+ */
+router.delete('/wake-lock', (req, res) => {
+  try {
+    console.log('[WakeLock] Releasing wake lock...');
+
+    // Execute termux-wake-unlock
+    execSync('termux-wake-unlock', { stdio: 'ignore' });
+
+    wakeLockAcquired = false;
+
+    console.log('[WakeLock] ✅ Wake lock released');
+
+    res.json({
+      status: 'ok',
+      message: 'Wake lock released',
+      acquired: wakeLockAcquired
+    });
+  } catch (err) {
+    console.error('[WakeLock] ❌ Failed to release wake lock:', err.message);
+
+    res.status(500).json({
+      status: 'error',
+      message: 'Failed to release wake lock',
+      error: err.message
+    });
+  }
+});
+
+/**
+ * GET /api/v1/wake-lock
+ * Get wake lock status
+ */
+router.get('/wake-lock', (req, res) => {
+  res.json({
+    status: 'ok',
+    acquired: wakeLockAcquired
+  });
+});
+
+module.exports = router;

package/lib/server/routes/workspaces.js

@@ -0,0 +1,101 @@
+/**
+ * Workspace Routes - Express router for workspace management
+ *
+ * Endpoints:
+ * - GET /api/v1/workspaces - List discovered workspaces
+ * - POST /api/v1/workspaces/mount - Validate and set active workspace
+ */
+
+const express = require('express');
+const router = express.Router();
+
+/**
+ * GET /api/v1/workspaces
+ * List all discovered workspaces from conversations table
+ */
+router.get('/', (req, res) => {
+  try {
+    const WorkspaceManager = require('../services/workspace-manager');
+    const wm = new WorkspaceManager();
+    const workspaces = wm.discoverWorkspaces();
+
+    res.json({
+      workspaces,
+      count: workspaces.length
+    });
+  } catch (error) {
+    console.error('[Workspaces] Error listing workspaces:', error);
+    res.status(500).json({ error: 'Failed to list workspaces' });
+  }
+});
+
+/**
+ * POST /api/v1/workspaces/mount
+ * Validate workspace path and optionally return workspace details
+ * Body: { path: string }
+ */
+router.post('/mount', (req, res) => {
+  try {
+    const { path: wsPath } = req.body;
+
+    if (!wsPath) {
+      return res.status(400).json({ error: 'Workspace path is required' });
+    }
+
+    const WorkspaceManager = require('../services/workspace-manager');
+    const wm = new WorkspaceManager();
+
+    // Validate workspace exists
+    const valid = wm.validateWorkspace(wsPath);
+
+    if (!valid) {
+      return res.status(400).json({ error: 'Invalid workspace path' });
+    }
+
+    // Get workspace details if it exists in conversations
+    const stats = wm.getWorkspaceStats(wsPath);
+    const conversations = wm.getWorkspaceConversations(wsPath);
+
+    res.json({
+      workspace: wsPath,
+      mounted: true,
+      stats,
+      conversations: conversations.slice(0, 10) // Return first 10
+    });
+  } catch (error) {
+    console.error('[Workspaces] Error mounting workspace:', error);
+    res.status(500).json({ error: 'Failed to mount workspace' });
+  }
+});
+
+/**
+ * GET /api/v1/workspaces/:path/stats
+ * Get statistics for a specific workspace
+ */
+router.get('/:path/stats', (req, res) => {
+  try {
+    const { path: wsPath } = req.params;
+
+    const WorkspaceManager = require('../services/workspace-manager');
+    const wm = new WorkspaceManager();
+
+    // Validate workspace exists
+    const valid = wm.validateWorkspace(wsPath);
+
+    if (!valid) {
+      return res.status(404).json({ error: 'Workspace not found' });
+    }
+
+    const stats = wm.getWorkspaceStats(wsPath);
+
+    res.json({
+      workspace: wsPath,
+      stats
+    });
+  } catch (error) {
+    console.error('[Workspaces] Error getting workspace stats:', error);
+    res.status(500).json({ error: 'Failed to get workspace stats' });
+  }
+});
+
+module.exports = router;

package/lib/server/server.js

@@ -10,56 +10,73 @@ const cors = require('cors');
 const path = require('path');
 const fs = require('fs');
 const http = require('http');
-const https = require('https');
 
+const { initDb, saveDb } = require('./db/adapter');
 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');
 const sessionsRouter = require('./routes/sessions');
 const modelsRouter = require('./routes/models');
+const runtimesRouter = require('./routes/runtimes');
 const statusRouter = require('./routes/status');
 const hostsRouter = require('./routes/hosts');
+const wakeLockRouter = require('./routes/wake-lock');
+const authRouter = require('./routes/auth');
+const speechRouter = require('./routes/speech');
+const keysRouter = require('./routes/keys');
+const uploadRouter = require('./routes/upload');
+const workspacesRouter = require('./routes/workspaces');
+
+// Middleware
+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 };
+    return getConfig();
   }
 
-  _loadHosts() {
-    const hostsPath = path.join(this.configDir, 'hosts.json');
-    if (fs.existsSync(hostsPath)) {
-      return JSON.parse(fs.readFileSync(hostsPath, 'utf8'));
+  async start() {
+    // 1. Init database
+    await initDb();
+
+    // 2. Seed admin user if no users exist
+    const User = require('./models/User');
+    if (User.count() === 0) {
+      User.create('admin', 'admin', 'admin');
+      console.log('  Created initial admin account from local defaults');
     }
-    return [{ name: 'local', type: 'local', default: true }];
-  }
 
-  async start() {
-    // Init services
-    const hosts = this._loadHosts();
+    // 3. Init services
     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(path.join(this.configDir, 'nexuscrew.db'));
+    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();
@@ -75,40 +92,52 @@ class NexusCrewServer {
       }
     }
 
-    // Middleware
+    // 4. Middleware
     this.app.use(cors());
     this.app.use(express.json({ limit: '10mb' }));
 
-    // Health check
+    // 5. Health check (public)
     this.app.get('/health', (req, res) => {
       res.json({
         status: 'ok',
         service: 'nexuscrew',
-        version: '0.1.0',
+        version: '0.2.1',
         tmux: tmuxManager.hasSession(),
         windows: tmuxManager.listWindows().length,
         uptime: process.uptime()
       });
     });
 
-    // Inject services into request
+    // 6. Inject services into request
     this.app.use((req, res, next) => {
       req.tmux = tmuxManager;
       req.engines = engineDiscovery;
       req.store = sessionStore;
       req.logWatcher = logWatcher;
+      req.remotePaneWatcher = remotePaneWatcher;
+      req.attachments = attachmentManager;
+      req.speech = speechManager;
       req.config = this.config;
       next();
     });
 
-    // API routes
-    this.app.use('/api/v1/send', sendRouter);
-    this.app.use('/api/v1/sessions', sessionsRouter);
+    // 7. Public routes
+    this.app.use('/api/v1/auth', authRouter);
+    this.app.use('/api/v1', wakeLockRouter);
+    this.app.use('/api/v1/runtimes', runtimesRouter); // public for login screen
     this.app.use('/api/v1/models', modelsRouter);
-    this.app.use('/api/v1/status', statusRouter);
-    this.app.use('/api/v1/hosts', hostsRouter);
-
-    // Serve frontend
+    this.app.use('/api/v1/keys', keysRouter); // public for STT key check
+
+    // 8. Protected routes
+    this.app.use('/api/v1/send', authMiddleware, sendRouter);
+    this.app.use('/api/v1/sessions', authMiddleware, sessionsRouter);
+    this.app.use('/api/v1/workspaces', authMiddleware, workspacesRouter);
+    this.app.use('/api/v1/status', authMiddleware, statusRouter);
+    this.app.use('/api/v1/hosts', authMiddleware, hostsRouter);
+    this.app.use('/api/v1/speech', authMiddleware, speechRouter);
+    this.app.use('/api/v1/upload', authMiddleware, uploadRouter);
+
+    // 9. Serve frontend
     const frontendDist = path.join(__dirname, '../../frontend/dist');
     if (fs.existsSync(frontendDist)) {
       this.app.use(express.static(frontendDist));
@@ -119,13 +148,13 @@ class NexusCrewServer {
       });
     }
 
-    // Error handler
+    // 10. Error handler
     this.app.use((err, req, res, next) => {
       console.error('[Error]', err.message);
       res.status(500).json({ error: err.message });
     });
 
-    // Start HTTP server
+    // 11. Start HTTP server
     this.server = http.createServer(this.app);
 
     return new Promise((resolve) => {
@@ -137,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();
@@ -153,6 +182,10 @@ 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;