@mmmbuto/nexuscli 0.5.0

package/lib/server/routes/sessions.js

@@ -0,0 +1,285 @@
+const express = require('express');
+const fs = require('fs');
+const path = require('path');
+const { prepare, saveDb } = require('../db');
+const CliLoader = require('../services/cli-loader');
+const SummaryGenerator = require('../services/summary-generator');
+
+const router = express.Router();
+const cliLoader = new CliLoader();
+const summaryGenerator = new SummaryGenerator();
+
+// Engine-specific session directories
+const SESSION_DIRS = {
+  claude: path.join(process.env.HOME || '', '.claude', 'projects'),
+  codex: path.join(process.env.HOME || '', '.codex', 'sessions'),
+  gemini: path.join(process.env.HOME || '', '.gemini', 'sessions'),
+};
+
+/**
+ * GET /api/v1/sessions/:id
+ * Return session metadata from DB (sessions table)
+ */
+router.get('/:id', async (req, res) => {
+  try {
+    const sessionId = req.params.id;
+    const stmt = prepare('SELECT * FROM sessions WHERE id = ?');
+    const session = stmt.get(sessionId);
+
+    if (!session) {
+      return res.status(404).json({ error: 'Session not found' });
+    }
+
+    if (session.metadata) {
+      try {
+        session.metadata = JSON.parse(session.metadata);
+      } catch (_) {
+        session.metadata = {};
+      }
+    }
+
+    res.json({ session });
+  } catch (error) {
+    console.error('[Sessions] Metadata fetch error:', error);
+    res.status(500).json({ error: error.message });
+  }
+});
+
+/**
+ * GET /api/v1/sessions/:id/messages
+ * Lazy load messages from CLI files (not from DB)
+ */
+router.get('/:id/messages', async (req, res) => {
+  try {
+    const sessionId = req.params.id;
+    const limit = Math.min(Number(req.query.limit) || 30, 200);
+    const before = req.query.before ? Number(req.query.before) : undefined;
+    const mode = req.query.mode === 'desc' ? 'desc' : 'asc';
+
+    // Fetch session to get workspace path & engine
+    const sessionStmt = prepare('SELECT * FROM sessions WHERE id = ?');
+    const session = sessionStmt.get(sessionId);
+
+    if (!session) {
+      return res.status(404).json({ error: 'Session not found' });
+    }
+
+    const { messages, pagination } = await cliLoader.loadMessagesFromCLI({
+      sessionId,
+      engine: session.engine || 'claude-code',
+      workspacePath: session.workspace_path,
+      limit,
+      before,
+      mode
+    });
+
+    res.json({
+      session: {
+        id: session.id,
+        workspace_path: session.workspace_path,
+        title: session.title,
+        engine: session.engine,
+        last_used_at: session.last_used_at,
+        created_at: session.created_at,
+        message_count: session.message_count
+      },
+      messages,
+      pagination
+    });
+  } catch (error) {
+    console.error('[Sessions] Messages fetch error:', error);
+    res.status(500).json({ error: error.message });
+  }
+});
+
+/**
+ * GET /api/v1/sessions/:id/summary
+ * Placeholder for Phase 4 (summary generation)
+ */
+router.get('/:id/summary', async (req, res) => {
+  try {
+    const sessionId = req.params.id;
+    const stmt = prepare(`
+      SELECT ss.*
+      FROM session_summaries ss
+      WHERE ss.session_id = ?
+    `);
+    const summaryRow = stmt.get(sessionId);
+
+    if (summaryRow) {
+      ['key_decisions', 'tools_used', 'files_modified'].forEach(key => {
+        if (summaryRow[key]) {
+          try {
+            summaryRow[key] = JSON.parse(summaryRow[key]);
+          } catch (_) {
+            summaryRow[key] = [];
+          }
+        } else {
+          summaryRow[key] = [];
+        }
+      });
+    }
+
+    res.json({ summary: summaryRow || null });
+  } catch (error) {
+    console.error('[Sessions] Summary fetch error:', error);
+    res.status(500).json({ error: error.message });
+  }
+});
+
+/**
+ * POST /api/v1/sessions/:id/summarize
+ * Generate or refresh summary using Claude Haiku
+ */
+router.post('/:id/summarize', async (req, res) => {
+  try {
+    const sessionId = req.params.id;
+    const limit = Math.min(Number(req.body?.limit) || 120, 300);
+    const before = req.body?.before ? Number(req.body.before) : undefined;
+
+    // Fetch session metadata
+    const sessionStmt = prepare('SELECT * FROM sessions WHERE id = ?');
+    const session = sessionStmt.get(sessionId);
+    if (!session) {
+      return res.status(404).json({ error: 'Session not found' });
+    }
+
+    // Load messages from CLI history
+    const { messages } = await cliLoader.loadMessagesFromCLI({
+      sessionId,
+      engine: session.engine || 'claude-code',
+      workspacePath: session.workspace_path,
+      limit,
+      before,
+      mode: 'asc'
+    });
+
+    // Pull existing summary (if any)
+    const existingStmt = prepare('SELECT * FROM session_summaries WHERE session_id = ?');
+    const existingSummary = existingStmt.get(sessionId);
+
+    const summary = await summaryGenerator.generateSummary({
+      sessionId,
+      messages,
+      existingSummary
+    });
+
+    const updatedAt = Date.now();
+
+    // Upsert summary table
+    const upsertStmt = prepare(`
+      INSERT INTO session_summaries (
+        session_id, summary_short, summary_long, key_decisions,
+        tools_used, files_modified, updated_at, version
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, 1)
+      ON CONFLICT(session_id) DO UPDATE SET
+        summary_short = excluded.summary_short,
+        summary_long = excluded.summary_long,
+        key_decisions = excluded.key_decisions,
+        tools_used = excluded.tools_used,
+        files_modified = excluded.files_modified,
+        updated_at = excluded.updated_at,
+        version = session_summaries.version + 1
+    `);
+
+    upsertStmt.run(
+      sessionId,
+      summary.summary_short || '',
+      summary.summary_long || '',
+      JSON.stringify(summary.key_decisions || []),
+      JSON.stringify(summary.tools_used || []),
+      JSON.stringify(summary.files_modified || []),
+      updatedAt
+    );
+
+    res.json({
+      summary: {
+        session_id: sessionId,
+        ...summary,
+        updated_at: updatedAt
+      }
+    });
+  } catch (error) {
+    console.error('[Sessions] Summarize error:', error);
+    res.status(500).json({ error: error.message });
+  }
+});
+
+/**
+ * DELETE /api/v1/sessions/:id
+ * Delete session from DB AND the original .jsonl file (SYNC DELETE)
+ */
+router.delete('/:id', async (req, res) => {
+  try {
+    const sessionId = req.params.id;
+    console.log(`[Sessions] Deleting session: ${sessionId}`);
+
+    // Fetch session to get workspace path & engine for file deletion
+    const sessionStmt = prepare('SELECT * FROM sessions WHERE id = ?');
+    const session = sessionStmt.get(sessionId);
+
+    if (!session) {
+      return res.status(404).json({ error: 'Session not found' });
+    }
+
+    // Delete the original .jsonl file (SYNC DELETE)
+    let fileDeleted = false;
+    const sessionFile = getSessionFilePath(sessionId, session.engine, session.workspace_path);
+    if (sessionFile && fs.existsSync(sessionFile)) {
+      try {
+        fs.unlinkSync(sessionFile);
+        fileDeleted = true;
+        console.log(`[Sessions] Deleted session file: ${sessionFile}`);
+      } catch (e) {
+        console.warn(`[Sessions] Failed to delete file ${sessionFile}: ${e.message}`);
+      }
+    }
+
+    // Delete from session_summaries (cascade should handle this, but be explicit)
+    const deleteSummaryStmt = prepare('DELETE FROM session_summaries WHERE session_id = ?');
+    deleteSummaryStmt.run(sessionId);
+
+    // Delete from sessions table
+    const deleteStmt = prepare('DELETE FROM sessions WHERE id = ?');
+    deleteStmt.run(sessionId);
+    saveDb();
+
+    console.log(`[Sessions] Session ${sessionId} deleted (file: ${fileDeleted})`);
+    res.json({ success: true, fileDeleted });
+  } catch (error) {
+    console.error('[Sessions] Delete error:', error);
+    res.status(500).json({ error: error.message });
+  }
+});
+
+/**
+ * Helper: Convert workspace path to slug (matches Claude Code behavior)
+ */
+function pathToSlug(workspacePath) {
+  if (!workspacePath) return '-default';
+  return workspacePath.replace(/[\/\.]/g, '-');
+}
+
+/**
+ * Helper: Get the filesystem path for a session file
+ */
+function getSessionFilePath(sessionId, engine, workspacePath) {
+  const normalizedEngine = engine?.toLowerCase().includes('claude') ? 'claude'
+    : engine?.toLowerCase().includes('codex') ? 'codex'
+    : engine?.toLowerCase().includes('gemini') ? 'gemini'
+    : 'claude';
+
+  switch (normalizedEngine) {
+    case 'claude':
+      const slug = pathToSlug(workspacePath);
+      return path.join(SESSION_DIRS.claude, slug, `${sessionId}.jsonl`);
+    case 'codex':
+      return path.join(SESSION_DIRS.codex, `${sessionId}.jsonl`);
+    case 'gemini':
+      return path.join(SESSION_DIRS.gemini, `${sessionId}.jsonl`);
+    default:
+      return null;
+  }
+}
+
+module.exports = router;

package/lib/server/routes/upload.js

@@ -0,0 +1,134 @@
+const express = require('express');
+const multer = require('multer');
+const path = require('path');
+const fs = require('fs');
+
+const router = express.Router();
+
+// Termux-only: attachments in ~/.nexuscli/attachments
+const ATTACHMENTS_DIR = path.join(process.env.HOME, '.nexuscli', 'attachments');
+
+// 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/workspace.js

@@ -0,0 +1,80 @@
+const express = require('express');
+const path = require('path');
+const os = require('os');
+const fs = require('fs');
+
+const router = express.Router();
+
+// Config file path (same as lib/config/manager.js)
+const CONFIG_DIR = path.join(os.homedir(), '.nexuscli');
+const CONFIG_FILE = path.join(CONFIG_DIR, 'config.json');
+
+/**
+ * Load config from file
+ */
+function loadConfig() {
+  try {
+    if (fs.existsSync(CONFIG_FILE)) {
+      return JSON.parse(fs.readFileSync(CONFIG_FILE, 'utf8'));
+    }
+  } catch (err) {
+    console.warn('[Workspace] Failed to load config:', err.message);
+  }
+  return null;
+}
+
+/**
+ * Expand ~ to home directory
+ */
+function expandPath(p) {
+  if (!p) return p;
+  if (p.startsWith('~/')) {
+    return path.join(os.homedir(), p.slice(2));
+  }
+  return p;
+}
+
+/**
+ * GET /api/v1/workspace
+ * Returns configured default workspace and environment info
+ */
+router.get('/', (req, res) => {
+  try {
+    const home = os.homedir();
+    const config = loadConfig();
+
+    // Get default workspace from config, fallback to ~/Dev or HOME
+    let defaultWorkspace = home;
+    if (config?.workspaces?.default) {
+      defaultWorkspace = expandPath(config.workspaces.default);
+    }
+
+    // CREATE the directory if it doesn't exist (user chose this path during init)
+    if (!fs.existsSync(defaultWorkspace)) {
+      try {
+        fs.mkdirSync(defaultWorkspace, { recursive: true });
+        console.log(`[Workspace] Created default workspace: ${defaultWorkspace}`);
+      } catch (err) {
+        console.warn(`[Workspace] Failed to create ${defaultWorkspace}: ${err.message}, using HOME`);
+        defaultWorkspace = home;
+      }
+    }
+
+    // Get configured workspace list
+    const configuredPaths = (config?.workspaces?.paths || []).map(expandPath);
+
+    res.json({
+      current: defaultWorkspace,
+      default: defaultWorkspace,
+      configured: configuredPaths,
+      home: home,
+      platform: process.platform,
+      user: process.env.USER || process.env.USERNAME || 'unknown'
+    });
+  } catch (error) {
+    console.error('[Workspace] Error fetching workspace info:', error);
+    res.status(500).json({ error: 'Failed to fetch workspace info' });
+  }
+});
+
+module.exports = router;