@mmmbuto/nexuscrew 0.1.0-beta.1 → 0.2.0

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,18 +10,29 @@ 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');
 
+// 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 = {}) {
@@ -49,7 +60,17 @@ class NexusCrewServer {
   }
 
   async start() {
-    // Init services
+    // 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 default admin user (admin/admin)');
+    }
+
+    // 3. Init services
     const hosts = this._loadHosts();
     const tmuxManager = new TmuxManager({
       tmuxSession: this.config.tmuxSession || 'nexuscrew',
@@ -58,7 +79,8 @@ class NexusCrewServer {
     });
 
     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();
 
     // Ensure tmux master session
@@ -75,23 +97,23 @@ 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.0',
         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;
@@ -101,14 +123,23 @@ class NexusCrewServer {
       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 +150,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) => {
@@ -153,6 +184,7 @@ class NexusCrewServer {
 
   stop() {
     if (this.server) {
+      saveDb();
       this.server.close();
     }
   }