@mmmbuto/nexuscli 0.5.0

package/lib/server/routes/workspaces.js

@@ -0,0 +1,142 @@
+const express = require('express');
+const WorkspaceManager = require('../services/workspace-manager');
+const { prepare } = require('../db');
+
+const router = express.Router();
+const workspaceManager = new WorkspaceManager();
+
+/**
+ * GET /api/v1/workspaces
+ * List all unique workspaces from sessions
+ */
+router.get('/', async (req, res) => {
+  try {
+    const stmt = prepare(`
+      SELECT
+        workspace_path,
+        COUNT(*) as session_count,
+        MAX(last_used_at) as last_activity
+      FROM sessions
+      GROUP BY workspace_path
+      ORDER BY last_activity DESC
+    `);
+
+    const workspaces = stmt.all();
+
+    res.json({ workspaces });
+  } catch (error) {
+    console.error('[Workspaces] Error listing workspaces:', error);
+    res.status(500).json({ error: error.message });
+  }
+});
+
+/**
+ * POST /api/v1/workspaces/:path/mount
+ * Mount workspace (validate + index sessions)
+ */
+router.post('/:path(*)/mount', async (req, res) => {
+  try {
+    // Replace __ back to / (avoid Apache encoding issues with slashes in paths)
+    let workspacePath = req.params.path.replace(/__/g, '/');
+    workspacePath = decodeURIComponent(workspacePath);
+
+    const result = await workspaceManager.mountWorkspace(workspacePath);
+
+    res.json(result);
+  } catch (error) {
+    console.error('[Workspaces] Mount error:', error);
+    res.status(400).json({ error: error.message });
+  }
+});
+
+/**
+ * GET /api/v1/workspaces/:path/sessions
+ * Get sessions in workspace (lightweight)
+ */
+router.get('/:path(*)/sessions', async (req, res) => {
+  try {
+    // Replace __ back to / (avoid Apache encoding issues with slashes in paths)
+    let workspacePath = req.params.path.replace(/__/g, '/');
+    workspacePath = decodeURIComponent(workspacePath);
+    const { groupBy = 'date' } = req.query;
+
+    // Get sessions from DB
+    const stmt = prepare(`
+      SELECT
+        s.*,
+        ss.summary_short,
+        ss.updated_at as summary_updated_at
+      FROM sessions s
+      LEFT JOIN session_summaries ss ON s.id = ss.session_id
+      WHERE s.workspace_path = ?
+      ORDER BY s.last_used_at DESC
+    `);
+
+    const sessions = stmt.all(workspacePath);
+
+    // Parse metadata JSON and ensure title is not empty
+    sessions.forEach(session => {
+      if (session.metadata) {
+        try {
+          session.metadata = JSON.parse(session.metadata);
+        } catch (e) {
+          session.metadata = {};
+        }
+      }
+
+      // Ensure title is not empty (fallback to default if missing)
+      if (!session.title || session.title.trim() === '') {
+        console.warn(`[Workspaces] Session ${session.id} has empty title, using default`);
+        session.title = 'Untitled Session';
+      }
+    });
+
+    // Group by date if requested
+    if (groupBy === 'date') {
+      const grouped = groupSessionsByDate(sessions);
+      return res.json(grouped);
+    }
+
+    res.json({ sessions });
+  } catch (error) {
+    console.error('[Workspaces] Error getting sessions:', error);
+    res.status(500).json({ error: error.message });
+  }
+});
+
+/**
+ * Group sessions by date
+ */
+function groupSessionsByDate(sessions) {
+  const now = Date.now();
+  const oneDayMs = 24 * 60 * 60 * 1000;
+
+  const grouped = {
+    pinned: [],
+    today: [],
+    yesterday: [],
+    last7days: [],
+    last30days: [],
+    older: []
+  };
+
+  sessions.forEach(session => {
+    // Pinned sessions go to separate group
+    if (session.pinned) {
+      grouped.pinned.push(session);
+      return;
+    }
+
+    const age = now - session.last_used_at;
+
+    if (age < oneDayMs) grouped.today.push(session);
+    else if (age < 2 * oneDayMs) grouped.yesterday.push(session);
+    else if (age < 7 * oneDayMs) grouped.last7days.push(session);
+    else if (age < 30 * oneDayMs) grouped.last30days.push(session);
+    else grouped.older.push(session);
+  });
+
+  return grouped;
+}
+
+module.exports = router;

package/lib/server/scripts/cleanup-ghost-sessions.js

@@ -0,0 +1,71 @@
+#!/usr/bin/env node
+
+const { initDb, getDb } = require('../db');
+const Message = require('../models/Message');
+
+/**
+ * Identify and clean up "ghost" conversations
+ * Ghost = conversation with 0 messages OR only 1 user message (no assistant reply)
+ */
+async function cleanupGhostSessions() {
+  await initDb();
+  const db = getDb();
+
+  console.log('[Cleanup] Starting ghost session cleanup...');
+
+  const conversations = db.prepare('SELECT id, title, created_at FROM conversations').all();
+  console.log(`[Cleanup] Total conversations: ${conversations.length}`);
+
+  const ghosts = [];
+
+  for (const conv of conversations) {
+    // Only need first two messages to detect ghosts
+    const messages = Message.getByConversation(conv.id, 2);
+
+    if (messages.length === 0) {
+      ghosts.push({ ...conv, reason: 'NO_MESSAGES' });
+    } else if (messages.length === 1 && messages[0].role === 'user') {
+      ghosts.push({ ...conv, reason: 'NO_REPLY' });
+    }
+  }
+
+  console.log(`[Cleanup] Found ${ghosts.length} ghost conversations`);
+
+  if (ghosts.length === 0) {
+    console.log('[Cleanup] No ghosts found - database is clean!');
+    return;
+  }
+
+  console.log('\n[Cleanup] Ghost conversations:');
+  ghosts.forEach(g => {
+    console.log(`  - ${g.id.substring(0, 8)}: "${g.title}" (${g.reason})`);
+  });
+
+  const shouldDelete = process.argv.includes('--force');
+
+  if (!shouldDelete) {
+    console.log('\n[Cleanup] Dry run complete. Use --force to delete.');
+    return;
+  }
+
+  const deleteConvo = db.prepare('DELETE FROM conversations WHERE id = ?');
+  const deleteMessages = db.prepare('DELETE FROM messages WHERE conversation_id = ?');
+
+  for (const ghost of ghosts) {
+    deleteMessages.run(ghost.id);
+    deleteConvo.run(ghost.id);
+  }
+
+  console.log(`\n[Cleanup] Deleted ${ghosts.length} ghost conversations`);
+}
+
+if (require.main === module) {
+  cleanupGhostSessions()
+    .then(() => process.exit(0))
+    .catch(err => {
+      console.error('[Cleanup] Error:', err);
+      process.exit(1);
+    });
+}
+
+module.exports = { cleanupGhostSessions };

package/lib/server/scripts/seed-users.js

@@ -0,0 +1,37 @@
+#!/usr/bin/env node
+
+const { initDb } = require('../db');
+const User = require('../models/User');
+
+async function seed() {
+  console.log('🌱 Seeding users...');
+
+  try {
+    // Initialize database first
+    await initDb();
+
+    // Check if user dag already exists
+    const existing = User.findByUsername('dag');
+
+    if (existing) {
+      console.log('✅ User "dag" already exists');
+      process.exit(0);
+    }
+
+    // Create admin user dag
+    const user = User.create('dag', 'myj0b1s', 'admin');
+
+    console.log('✅ Created admin user:');
+    console.log(`   Username: ${user.username}`);
+    console.log(`   Role: ${user.role}`);
+    console.log(`   ID: ${user.id}`);
+
+    process.exit(0);
+  } catch (error) {
+    console.error('❌ Error seeding users:', error.message);
+    console.error(error.stack);
+    process.exit(1);
+  }
+}
+
+seed();

package/lib/server/scripts/test-history-access.js

@@ -0,0 +1,50 @@
+#!/usr/bin/env node
+
+const fs = require('fs');
+const path = require('path');
+
+function testHistoryAccess() {
+  const historyPath = path.join(process.env.HOME || '', '.claude', 'history.jsonl');
+
+  console.log(`[Test] Checking access to: ${historyPath}`);
+  console.log(`[Test] HOME env: ${process.env.HOME}`);
+  console.log(`[Test] USER env: ${process.env.USER}`);
+
+  if (!fs.existsSync(historyPath)) {
+    console.error('[Test] ❌ history.jsonl NOT FOUND');
+    process.exit(1);
+  }
+
+  console.log('[Test] ✅ history.jsonl exists');
+
+  try {
+    fs.accessSync(historyPath, fs.constants.R_OK);
+    console.log('[Test] ✅ Read permission OK');
+  } catch (err) {
+    console.error('[Test] ❌ No read permission:', err.message);
+    process.exit(1);
+  }
+
+  try {
+    const content = fs.readFileSync(historyPath, 'utf8');
+    const lines = content.split('\n').filter(l => l.trim()).slice(0, 10);
+
+    console.log(`[Test] ✅ Read ${lines.length} lines successfully`);
+
+    if (lines.length > 0) {
+      const firstEntry = JSON.parse(lines[0]);
+      console.log('[Test] Sample entry:', {
+        sessionId: firstEntry.sessionId ? firstEntry.sessionId.substring(0, 8) : null,
+        project: firstEntry.project,
+        timestamp: firstEntry.timestamp ? new Date(firstEntry.timestamp).toISOString() : null
+      });
+    }
+  } catch (err) {
+    console.error('[Test] ❌ Failed to read/parse:', err.message);
+    process.exit(1);
+  }
+
+  console.log('\n[Test] ✅ All checks passed!');
+}
+
+testHistoryAccess();

package/lib/server/server.js

@@ -0,0 +1,227 @@
+const express = require('express');
+const cors = require('cors');
+const path = require('path');
+const fs = require('fs');
+const https = require('https');
+const http = require('http');
+const { initDb, prepare } = require('./db');
+const User = require('./models/User');
+const WorkspaceManager = require('./services/workspace-manager');
+const pkg = require('../../package.json');
+
+// Import middleware
+const { authMiddleware } = require('./middleware/auth');
+
+// Import routes
+const authRouter = require('./routes/auth');
+const conversationsRouter = require('./routes/conversations');
+const messagesRouter = require('./routes/messages');
+const jobsRouter = require('./routes/jobs');
+const chatRouter = require('./routes/chat');
+const codexRouter = require('./routes/codex');
+const geminiRouter = require('./routes/gemini');
+const modelsRouter = require('./routes/models');
+const workspaceRouter = require('./routes/workspace');
+const workspacesRouter = require('./routes/workspaces');
+const sessionsRouter = require('./routes/sessions');
+const wakeLockRouter = require('./routes/wake-lock');
+const uploadRouter = require('./routes/upload');
+
+const app = express();
+const PORT = process.env.PORT || 41800;
+
+// Middleware
+app.use(cors());
+app.use(express.json());
+
+// Request logging
+app.use((req, res, next) => {
+  console.log(`${req.method} ${req.path} (URL: ${req.url}, original: ${req.originalUrl})`);
+  next();
+});
+
+// Health check (public)
+app.get('/health', (req, res) => {
+  res.json({
+    status: 'ok',
+    service: 'nexuscli-backend',
+    version: pkg.version,
+    engines: ['claude', 'codex', 'gemini'],
+    port: PORT,
+    timestamp: new Date().toISOString()
+  });
+});
+
+// Serve frontend static files (production)
+// Path: lib/server -> ../../frontend/dist
+const frontendDist = path.join(__dirname, '../../frontend/dist');
+app.use(express.static(frontendDist));
+
+// Public routes
+app.use('/api/v1/auth', authRouter);
+app.use('/api/v1/models', modelsRouter);
+app.use('/api/v1/workspace', workspaceRouter);
+app.use('/api/v1', wakeLockRouter); // Wake lock endpoints (public for app visibility handling)
+app.use('/api/v1/workspaces', authMiddleware, workspacesRouter);
+app.use('/api/v1/sessions', authMiddleware, sessionsRouter);
+
+// Protected routes (require authentication)
+app.use('/api/v1/conversations', authMiddleware, conversationsRouter);
+app.use('/api/v1/conversations', authMiddleware, messagesRouter);
+app.use('/api/v1/jobs', authMiddleware, jobsRouter);
+app.use('/api/v1/chat', authMiddleware, chatRouter);
+app.use('/api/v1/codex', authMiddleware, codexRouter);
+app.use('/api/v1/gemini', authMiddleware, geminiRouter);
+app.use('/api/v1/upload', authMiddleware, uploadRouter); // File upload
+
+// Root endpoint
+app.get('/', (req, res) => {
+  res.json({
+    service: 'NexusCLI Backend',
+    version: pkg.version,
+    engines: ['claude', 'codex', 'gemini'],
+    endpoints: {
+      health: '/health',
+      models: '/api/v1/models',
+      chat: '/api/v1/chat (Claude)',
+      codex: '/api/v1/codex (OpenAI)',
+      gemini: '/api/v1/gemini (Google)',
+      conversations: '/api/v1/conversations',
+      jobs: '/api/v1/jobs'
+    }
+  });
+});
+
+// SPA catch-all route (serve index.html for all non-API routes)
+app.get('*', (req, res) => {
+  res.sendFile(path.join(frontendDist, 'index.html'));
+});
+
+// 404 handler (for API routes)
+app.use((req, res) => {
+  res.status(404).json({
+    error: 'Not Found',
+    path: req.path
+  });
+});
+
+// Error handler
+app.use((err, req, res, next) => {
+  console.error('Error:', err);
+  res.status(500).json({
+    error: 'Internal Server Error',
+    message: err.message
+  });
+});
+
+// Start server
+async function start() {
+  // Initialize database first
+  await initDb();
+
+  // ⚡ SYNC DATABASE WITH FILESYSTEM (CRITICAL!)
+  // Database is only a CACHE - real truth is on disk
+  // Discover and index ALL workspaces from .claude/projects/
+  console.log('[Startup] Discovering and syncing all workspaces...');
+  const workspaceManager = new WorkspaceManager();
+  try {
+    const workspaces = await workspaceManager.discoverWorkspaces();
+    console.log(`[Startup] Found ${workspaces.length} workspaces with sessions`);
+
+    // Mount each workspace to index its sessions
+    for (const ws of workspaces) {
+      try {
+        await workspaceManager.mountWorkspace(ws.workspace_path);
+        console.log(`[Startup] ✅ Mounted ${ws.workspace_path} (${ws.session_count} sessions)`);
+      } catch (error) {
+        console.error(`[Startup] ⚠️  Failed to mount ${ws.workspace_path}:`, error.message);
+      }
+    }
+
+    console.log('[Startup] ✅ All workspaces synced to database');
+  } catch (error) {
+    console.error('[Startup] ⚠️  Failed to discover workspaces:', error.message);
+    // Continue anyway - database will sync on first workspace mount
+  }
+
+  // Auto-seed dev user on demand (Termux/local) if no users exist
+  const autoSeed = process.env.NEXUSCLI_AUTO_SEED === '1';
+  if (autoSeed) {
+    const countStmt = prepare('SELECT COUNT(*) as count FROM users');
+    const { count } = countStmt.get();
+    if (count === 0) {
+      const username = process.env.NEXUSCLI_SEED_USER || 'tux';
+      const password = process.env.NEXUSCLI_SEED_PASS || 'tux';
+      const role = 'admin';
+
+      const user = User.create(username, password, role);
+      console.log(`[AutoSeed] Created default user ${user.username} (${user.role})`);
+    }
+  }
+
+  // Check for HTTPS certificates
+  const certDir = path.join(process.env.HOME || '', '.nexuscli', 'certs');
+  const certPath = path.join(certDir, 'cert.pem');
+  const keyPath = path.join(certDir, 'key.pem');
+  const useHttps = fs.existsSync(certPath) && fs.existsSync(keyPath);
+
+  let server;
+  let protocol = 'http';
+
+  if (useHttps) {
+    try {
+      const httpsOptions = {
+        key: fs.readFileSync(keyPath),
+        cert: fs.readFileSync(certPath)
+      };
+      server = https.createServer(httpsOptions, app);
+      protocol = 'https';
+      console.log('[Startup] HTTPS enabled - certificates found');
+    } catch (err) {
+      console.warn('[Startup] Failed to load certificates, falling back to HTTP:', err.message);
+      server = http.createServer(app);
+    }
+  } else {
+    server = http.createServer(app);
+    console.log('[Startup] HTTP mode - no certificates found');
+    console.log('[Startup] Run: ./scripts/setup-https.sh to enable HTTPS');
+  }
+
+  server.listen(PORT, () => {
+    console.log('');
+    console.log('╔══════════════════════════════════════════════╗');
+    console.log('║   🚀 NexusCLI Backend                       ║');
+    console.log('╚══════════════════════════════════════════════╝');
+    console.log('');
+    console.log(`✅ Server running on ${protocol}://localhost:${PORT}`);
+    if (useHttps) {
+      console.log(`🔒 HTTPS enabled - secure connection`);
+    }
+    console.log('');
+    console.log('Endpoints:');
+    console.log(`   GET  /health (public)`);
+    console.log(`   POST /api/v1/auth/login (public)`);
+    console.log(`   GET  /api/v1/auth/me (protected)`);
+    console.log(`   GET  /api/v1/conversations (protected)`);
+    console.log(`   POST /api/v1/conversations (protected)`);
+    console.log(`   POST /api/v1/jobs (protected)`);
+    console.log(`   GET  /api/v1/jobs/:id/stream (protected, SSE)`);
+    console.log('');
+  });
+}
+
+start().catch(err => {
+  console.error('Failed to start server:', err);
+  process.exit(1);
+});
+
+// Graceful shutdown
+process.on('SIGTERM', () => {
+  console.log('SIGTERM signal received: closing HTTP server');
+  process.exit(0);
+});
+
+process.on('SIGINT', () => {
+  console.log('\nSIGINT signal received: closing HTTP server');
+  process.exit(0);
+});

package/lib/server/services/cache.js

@@ -0,0 +1,85 @@
+/**
+ * Cache Service - In-memory caching with TTL
+ *
+ * Uses node-cache for lightweight, Redis-free caching.
+ * Perfect for Termux environments with limited resources.
+ */
+
+const NodeCache = require('node-cache');
+
+// Cache configuration
+const cache = new NodeCache({
+  stdTTL: 30,          // Default 30 seconds TTL
+  checkperiod: 60,     // Check for expired keys every 60 seconds
+  useClones: false,    // Don't clone objects (faster for read-heavy workloads)
+  deleteOnExpire: true
+});
+
+// Cache keys
+const KEYS = {
+  CONVERSATIONS_GROUPED: 'conversations:grouped',
+  CONVERSATIONS_WORKSPACE: (ws) => `conversations:workspace:${ws}`,
+  CONVERSATION: (id) => `conversation:${id}`,
+};
+
+/**
+ * Get cached value or execute callback and cache result
+ * @param {string} key - Cache key
+ * @param {Function} callback - Async function to get data if not cached
+ * @param {number} ttl - TTL in seconds (default: 30)
+ * @returns {Promise<any>}
+ */
+async function getOrSet(key, callback, ttl = 30) {
+  let value = cache.get(key);
+
+  if (value !== undefined) {
+    return value;
+  }
+
+  // Execute callback and cache result
+  value = await callback();
+  cache.set(key, value, ttl);
+
+  return value;
+}
+
+/**
+ * Invalidate specific key
+ * @param {string} key
+ */
+function invalidate(key) {
+  cache.del(key);
+}
+
+/**
+ * Invalidate all conversation-related caches
+ * Called when conversation is created, updated, or deleted
+ */
+function invalidateConversations() {
+  // Get all keys and delete conversation-related ones
+  const keys = cache.keys();
+  const toDelete = keys.filter(k => k.startsWith('conversations:') || k.startsWith('conversation:'));
+  cache.del(toDelete);
+  console.log(`[Cache] Invalidated ${toDelete.length} conversation cache entries`);
+}
+
+/**
+ * Get cache statistics
+ */
+function getStats() {
+  return {
+    keys: cache.keys().length,
+    hits: cache.getStats().hits,
+    misses: cache.getStats().misses,
+    hitRate: cache.getStats().hits / (cache.getStats().hits + cache.getStats().misses) || 0
+  };
+}
+
+module.exports = {
+  cache,
+  KEYS,
+  getOrSet,
+  invalidate,
+  invalidateConversations,
+  getStats
+};