@mmmbuto/nexuscrew 0.2.1 → 0.2.2

package/lib/server/routes/auth.js

@@ -1,168 +0,0 @@
-const express = require('express');
-const rateLimit = require('express-rate-limit');
-const bcrypt = require('bcryptjs');
-const User = require('../models/User');
-const { generateToken, authMiddleware } = require('../middleware/auth');
-const { getConfig } = require('../../config/manager');
-
-const router = express.Router();
-
-/**
- * Check config user (admin from init)
- * Returns user object compatible with DB user structure
- */
-function findConfigUser(username) {
-  const config = getConfig();
-  if (config.auth && config.auth.user === username && config.auth.pass_hash) {
-    return {
-      id: 'config-admin',
-      username: config.auth.user,
-      password_hash: config.auth.pass_hash,
-      role: 'admin',
-      is_locked: false,
-      failed_attempts: 0,
-      created_at: Date.now()
-    };
-  }
-  return null;
-}
-
-/**
- * Verify password for config user
- */
-function verifyConfigPassword(passHash, password) {
-  return bcrypt.compareSync(password, passHash);
-}
-
-// Rate limiter: max 5 login attempts per 15 minutes per IP
-const loginLimiter = rateLimit({
-  windowMs: 15 * 60 * 1000, // 15 minutes
-  max: 10,
-  message: {
-    error: 'Too many login attempts, please try again later',
-    retry_after: 15 * 60
-  },
-  standardHeaders: true,
-  legacyHeaders: false
-});
-
-// POST /api/v1/auth/login
-router.post('/login', loginLimiter, async (req, res) => {
-  try {
-    const { username, password } = req.body;
-    const ipAddress = req.ip || req.connection.remoteAddress;
-
-    if (!username || !password) {
-      return res.status(400).json({ error: 'Username and password required' });
-    }
-
-    // Check IP rate limiting (additional layer)
-    const recentAttempts = User.getRecentLoginAttempts(ipAddress);
-    if (recentAttempts > 20) {
-      return res.status(429).json({
-        error: 'Too many failed attempts from this IP',
-        retry_after: 15 * 60
-      });
-    }
-
-    // First check config user (admin from init)
-    let user = findConfigUser(username);
-    let isConfigUser = !!user;
-
-    // If not config user, check database
-    if (!user) {
-      user = User.findByUsername(username);
-    }
-
-    if (!user) {
-      // Log failed attempt even for non-existent user
-      User.logLoginAttempt(ipAddress, username, false);
-      return res.status(401).json({ error: 'Invalid credentials' });
-    }
-
-    // Check if account is locked (only for DB users)
-    if (!isConfigUser && User.isAccountLocked(user)) {
-      User.logLoginAttempt(ipAddress, username, false);
-      const remainingMs = user.locked_until - Date.now();
-      return res.status(403).json({
-        error: 'Account locked due to failed login attempts',
-        locked_until: user.locked_until,
-        retry_after: Math.ceil(remainingMs / 1000)
-      });
-    }
-
-    // Verify password
-    let isValid;
-    if (isConfigUser) {
-      isValid = verifyConfigPassword(user.password_hash, password);
-    } else {
-      isValid = User.verifyPassword(user, password);
-    }
-
-    if (!isValid) {
-      User.logLoginAttempt(ipAddress, username, false);
-      if (!isConfigUser) {
-        User.incrementFailedAttempts(user.id);
-      }
-      return res.status(401).json({ error: 'Invalid credentials' });
-    }
-
-    // Success
-    User.logLoginAttempt(ipAddress, username, true);
-    if (!isConfigUser) {
-      User.resetFailedAttempts(user.id);
-      User.updateLastLogin(user.id);
-    }
-
-    const token = generateToken(user);
-
-    res.json({
-      token,
-      user: {
-        id: user.id,
-        username: user.username,
-        role: user.role
-      }
-    });
-  } catch (error) {
-    console.error('Login error:', error);
-    res.status(500).json({ error: 'Internal server error' });
-  }
-});
-
-// GET /api/v1/auth/me
-router.get('/me', authMiddleware, (req, res) => {
-  // Config user is already validated by authMiddleware
-  // Just return the user info from req.user
-  if (req.user.id === 'config-admin') {
-    const config = getConfig();
-    return res.json({
-      id: req.user.id,
-      username: req.user.username,
-      role: req.user.role,
-      created_at: Date.now(),
-      last_login: null
-    });
-  }
-
-  const user = User.findById(req.user.id);
-  if (!user) {
-    return res.status(404).json({ error: 'User not found' });
-  }
-
-  res.json({
-    id: user.id,
-    username: user.username,
-    role: user.role,
-    created_at: user.created_at,
-    last_login: user.last_login
-  });
-});
-
-// POST /api/v1/auth/logout
-router.post('/logout', authMiddleware, (req, res) => {
-  // With JWT, logout is handled client-side by removing token
-  res.json({ message: 'Logged out successfully' });
-});
-
-module.exports = router;

package/lib/server/routes/keys.js

@@ -1,28 +0,0 @@
-const express = require('express');
-const router = express.Router();
-const { getApiKey } = require('../db/adapter');
-
-/**
- * GET /api/v1/keys/check/:provider
- * Check if an API key is configured for a provider
- * Returns: { configured: boolean }
- */
-router.get('/check/:provider', (req, res) => {
-  if (req.params.provider === 'stt') {
-    const speech = req.speech || req.app?.locals?.speech;
-    if (!speech) {
-      return res.json({ configured: false, provider: 'unknown' });
-    }
-    const status = speech.getStatus();
-    return res.json({
-      configured: Boolean(status.whisper?.configured && status.whisper?.available),
-      provider: status.provider,
-      fallback: status.fallback
-    });
-  }
-
-  const key = getApiKey(req.params.provider);
-  res.json({ configured: !!key });
-});
-
-module.exports = router;

package/lib/server/routes/runtimes.js

@@ -1,34 +0,0 @@
-const express = require('express');
-const RuntimeManager = require('../services/runtime-manager');
-
-const router = express.Router();
-const runtimeManager = new RuntimeManager();
-
-router.get('/', async (_req, res) => {
-  try {
-    const inventory = await runtimeManager.getRuntimeInventory();
-    res.json({
-      platform: runtimeManager.platformId,
-      runtimes: inventory,
-    });
-  } catch (error) {
-    console.error('[Runtimes] Inventory error:', error);
-    res.status(500).json({ error: 'Failed to fetch runtime inventory' });
-  }
-});
-
-router.post('/check', async (_req, res) => {
-  try {
-    const inventory = await runtimeManager.getRuntimeInventory();
-    res.json({
-      platform: runtimeManager.platformId,
-      runtimes: inventory,
-      checkedAt: new Date().toISOString(),
-    });
-  } catch (error) {
-    console.error('[Runtimes] Check error:', error);
-    res.status(500).json({ error: 'Failed to check runtimes' });
-  }
-});
-
-module.exports = router;

package/lib/server/routes/speech.js

@@ -1,46 +0,0 @@
-const express = require('express');
-const router = express.Router();
-const multer = require('multer');
-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 }
-});
-
-router.get('/status', (req, res) => {
-  res.json(req.speech.getStatus());
-});
-
-router.post('/transcribe', upload.single('audio'), async (req, res) => {
-  let tempPath = null;
-
-  try {
-    if (!req.file) {
-      return res.status(400).json({ error: 'No audio file provided' });
-    }
-
-    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);
-
-    const result = await req.speech.transcribe({
-      audioPath: tempPath,
-      language: req.body.language
-    });
-
-    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);
-    }
-  }
-});
-
-module.exports = router;

package/lib/server/routes/upload.js

@@ -1,135 +0,0 @@
-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

@@ -1,95 +0,0 @@
-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

@@ -1,101 +0,0 @@
-/**
- * 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/services/attachment-manager.js

@@ -1,57 +0,0 @@
-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;