@mmmbuto/nexuscli 0.7.6 → 0.7.8

package/lib/server/routes/codex.js

@@ -9,6 +9,20 @@ const contextBridge = require('../services/context-bridge');
 const router = express.Router();
 const codexWrapper = new CodexWrapper();
 
+function ensureConversation(conversationId, workspacePath) {
+  try {
+    const stmt = prepare(`
+      INSERT OR IGNORE INTO conversations (id, title, created_at, updated_at, metadata)
+      VALUES (?, ?, ?, ?, ?)
+    `);
+    const now = Date.now();
+    const metadata = workspacePath ? JSON.stringify({ workspace: workspacePath }) : null;
+    stmt.run(conversationId, 'New Chat', now, now, metadata);
+  } catch (err) {
+    console.warn('[Codex] Failed to ensure conversation exists:', err.message);
+  }
+}
+
 /**
  * POST /api/v1/codex
  * Send message to Codex CLI with SSE streaming
@@ -61,6 +75,8 @@ router.post('/', async (req, res) => {
     // Use SessionManager for session sync pattern
     // conversationId → sessionId (per engine)
     const frontendConversationId = conversationId || uuidv4();
+    ensureConversation(frontendConversationId, workspacePath);
+
     const { sessionId, isNew: isNewSession } = await sessionManager.getOrCreateSession(
       frontendConversationId,
       'codex',
@@ -80,10 +96,10 @@ router.post('/', async (req, res) => {
     res.setHeader('Connection', 'keep-alive');
 
     // Send initial event
-    res.write(`data: ${JSON.stringify({ type: 'message_start', messageId: `user-${Date.now()}`, sessionId })}\n\n`);
+    res.write(`data: ${JSON.stringify({ type: 'message_start', messageId: `user-${Date.now()}`, sessionId, conversationId: frontendConversationId })}\n\n`);
 
     // Check if this is an engine switch (requires context bridging)
-    const lastEngine = Message.getLastEngine(sessionId);
+    const lastEngine = Message.getLastEngine(frontendConversationId);
     const isEngineBridge = lastEngine && lastEngine !== 'codex';
 
     // IMPORTANT: Skip contextBridge for Codex native resume!
@@ -94,6 +110,7 @@ router.post('/', async (req, res) => {
     if (isEngineBridge) {
       // Engine switch: need context from previous engine
       const contextResult = await contextBridge.buildContext({
+        conversationId: frontendConversationId,
         sessionId,
         fromEngine: lastEngine,
         toEngine: 'codex',
@@ -119,7 +136,7 @@ router.post('/', async (req, res) => {
       // Save user message to database with engine tracking
       try {
         const userMessage = Message.create(
-          sessionId,
+          frontendConversationId,
           'user',
           message,
           { workspace: workspacePath },
@@ -127,6 +144,7 @@ router.post('/', async (req, res) => {
           'codex'  // Engine tracking for context bridging
         );
         console.log(`[Codex] Saved user message: ${userMessage.id} (engine: codex)`);
+        sessionManager.bumpSessionActivity(sessionId, 1);
       } catch (msgErr) {
         console.warn('[Codex] Failed to save user message:', msgErr.message);
       }
@@ -138,21 +156,28 @@ router.post('/', async (req, res) => {
         threadId: nativeThreadId, // Native Codex thread ID for resume
         reasoningEffort,
         workspacePath,
+        processId: sessionId, // Use Nexus sessionId for interrupt tracking
         onStatus: (event) => {
           // Stream status events to client
           res.write(`data: ${JSON.stringify(event)}\n\n`);
         }
       });
 
-      // Save native threadId for future resume (if new)
-      if (result.threadId && result.threadId !== nativeThreadId) {
+      // Persist native threadId for future resume (always, even if unchanged)
+      if (result.threadId) {
         sessionManager.setNativeThreadId(sessionId, result.threadId);
+        const unchanged = nativeThreadId && nativeThreadId === result.threadId ? ' (unchanged)' : '';
+        console.log(`[Codex] Saved native threadId: ${result.threadId}${unchanged}`);
+      } else if (nativeThreadId) {
+        console.log(`[Codex] Reused existing native threadId: ${nativeThreadId}`);
+      } else {
+        console.warn('[Codex] No threadId returned; resume may not work for next turn');
       }
 
       // Save assistant response to database with engine tracking
       try {
         const assistantMessage = Message.create(
-          sessionId,
+          frontendConversationId,
           'assistant',
           result.text,
           { usage: result.usage, model },
@@ -160,13 +185,14 @@ router.post('/', async (req, res) => {
           'codex'  // Engine tracking for context bridging
         );
         console.log(`[Codex] Saved assistant message: ${assistantMessage.id} (engine: codex)`);
+        sessionManager.bumpSessionActivity(sessionId, 1);
       } catch (msgErr) {
         console.warn('[Codex] Failed to save assistant message:', msgErr.message);
       }
 
       // Smart auto-summary: trigger based on message count and engine bridging
-      if (contextBridge.shouldTriggerSummary(sessionId, isEngineBridge)) {
-        contextBridge.triggerSummaryGeneration(sessionId, '[Codex]');
+      if (contextBridge.shouldTriggerSummary(frontendConversationId, isEngineBridge)) {
+        contextBridge.triggerSummaryGeneration(frontendConversationId, '[Codex]');
       }
 
       // Send completion event
@@ -175,7 +201,8 @@ router.post('/', async (req, res) => {
         messageId: `assistant-${Date.now()}`,
         content: result.text,
         usage: result.usage,
-        sessionId
+        sessionId,
+        conversationId: frontendConversationId
       })}\n\n`);
 
       res.end();
@@ -220,4 +247,38 @@ router.get('/status', async (req, res) => {
   }
 });
 
+/**
+ * POST /api/v1/codex/interrupt
+ * Interrupt running Codex CLI process
+ *
+ * Request body:
+ * {
+ *   "sessionId": "uuid" - Session to interrupt
+ * }
+ */
+router.post('/interrupt', async (req, res) => {
+  try {
+    const { sessionId } = req.body;
+
+    if (!sessionId) {
+      return res.status(400).json({ error: 'sessionId required' });
+    }
+
+    console.log(`[Codex] Interrupt request for session: ${sessionId}`);
+
+    const result = codexWrapper.interrupt(sessionId);
+
+    if (result.success) {
+      console.log(`[Codex] Interrupted session ${sessionId} via ${result.method}`);
+    } else {
+      console.log(`[Codex] Failed to interrupt session ${sessionId}: ${result.reason}`);
+    }
+
+    res.json(result);
+  } catch (error) {
+    console.error('[Codex] Interrupt error:', error);
+    res.status(500).json({ error: error.message });
+  }
+});
+
 module.exports = router;

package/lib/server/routes/gemini.js

@@ -15,6 +15,20 @@ const contextBridge = require('../services/context-bridge');
 const router = express.Router();
 const geminiWrapper = new GeminiWrapper();
 
+function ensureConversation(conversationId, workspacePath) {
+  try {
+    const stmt = require('../db').prepare(`
+      INSERT OR IGNORE INTO conversations (id, title, created_at, updated_at, metadata)
+      VALUES (?, ?, ?, ?, ?)
+    `);
+    const now = Date.now();
+    const metadata = workspacePath ? JSON.stringify({ workspace: workspacePath }) : null;
+    stmt.run(conversationId, 'New Chat', now, now, metadata);
+  } catch (err) {
+    console.warn('[Gemini] Failed to ensure conversation exists:', err.message);
+  }
+}
+
 /**
  * POST /api/v1/gemini
  * Send message to Gemini CLI with SSE streaming
@@ -64,6 +78,8 @@ router.post('/', async (req, res) => {
 
     // Use SessionManager for session sync pattern
     const frontendConversationId = conversationId || uuidv4();
+    ensureConversation(frontendConversationId, workspacePath);
+
     const { sessionId, isNew: isNewSession } = await sessionManager.getOrCreateSession(
       frontendConversationId,
       'gemini',
@@ -87,11 +103,12 @@ router.post('/', async (req, res) => {
       type: 'message_start',
       messageId: `user-${Date.now()}`,
       sessionId,
+      conversationId: frontendConversationId,
       engine: 'gemini'
     })}\n\n`);
 
     // Check if this is an engine switch (requires context bridging)
-    const lastEngine = Message.getLastEngine(sessionId);
+    const lastEngine = Message.getLastEngine(frontendConversationId);
     const isEngineBridge = lastEngine && lastEngine !== 'gemini';
 
     // IMPORTANT: Skip contextBridge for Gemini native resume!
@@ -102,6 +119,7 @@ router.post('/', async (req, res) => {
     if (isEngineBridge) {
       // Engine switch: need context from previous engine
       const contextResult = await contextBridge.buildContext({
+        conversationId: frontendConversationId,
         sessionId,
         fromEngine: lastEngine,
         toEngine: 'gemini',
@@ -127,13 +145,14 @@ router.post('/', async (req, res) => {
     // Save user message to DB
     try {
       Message.create(
-        sessionId,
+        frontendConversationId,
         'user',
         message,
         { workspace: workspacePath, model },
         Date.now(),
         'gemini'
       );
+      sessionManager.bumpSessionActivity(sessionId, 1);
     } catch (dbErr) {
       console.warn('[Gemini] Failed to save user message:', dbErr.message);
     }
@@ -152,6 +171,7 @@ router.post('/', async (req, res) => {
       threadId: nativeSessionId, // Native Gemini session ID for resume
       model,
       workspacePath,
+      processId: sessionId, // Use Nexus sessionId for interrupt tracking
       onStatus: (event) => {
         // Forward all events to SSE
         res.write(`data: ${JSON.stringify(event)}\n\n`);
@@ -160,29 +180,35 @@ router.post('/', async (req, res) => {
 
     console.log(`[Gemini] Response received: ${result.text?.length || 0} chars`);
 
-    // Save native sessionId for future resume (if new)
-    if (result.sessionId && result.sessionId !== nativeSessionId) {
+    // Save native sessionId for future resume (always, even if unchanged)
+    if (result.sessionId) {
       sessionManager.setNativeThreadId(sessionId, result.sessionId);
-      console.log(`[Gemini] Saved native sessionId: ${result.sessionId}`);
+      const unchanged = nativeSessionId && nativeSessionId === result.sessionId ? ' (unchanged)' : '';
+      console.log(`[Gemini] Saved native sessionId: ${result.sessionId}${unchanged}`);
+    } else if (nativeSessionId) {
+      console.log(`[Gemini] Reused existing native sessionId: ${nativeSessionId}`);
+    } else {
+      console.warn('[Gemini] No sessionId returned; resume may not work for next turn');
     }
 
     // Save assistant response to DB
     try {
-      Message.create(
-        sessionId,
-        'assistant',
-        result.text,
-        { model, usage: result.usage },
-        Date.now(),
-        'gemini'
-      );
+    Message.create(
+      frontendConversationId,
+      'assistant',
+      result.text,
+      { model, usage: result.usage },
+      Date.now(),
+      'gemini'
+    );
+    sessionManager.bumpSessionActivity(sessionId, 1);
     } catch (dbErr) {
       console.warn('[Gemini] Failed to save assistant message:', dbErr.message);
     }
 
     // Smart auto-summary: trigger based on message count and engine bridging
-    if (contextBridge.shouldTriggerSummary(sessionId, isEngineBridge)) {
-      contextBridge.triggerSummaryGeneration(sessionId, '[Gemini]');
+    if (contextBridge.shouldTriggerSummary(frontendConversationId, isEngineBridge)) {
+      contextBridge.triggerSummaryGeneration(frontendConversationId, '[Gemini]');
     }
 
     // Send final message with full content
@@ -244,4 +270,38 @@ router.get('/models', (req, res) => {
   });
 });
 
+/**
+ * POST /api/v1/gemini/interrupt
+ * Interrupt running Gemini CLI process
+ *
+ * Request body:
+ * {
+ *   "sessionId": "uuid" - Session to interrupt
+ * }
+ */
+router.post('/interrupt', async (req, res) => {
+  try {
+    const { sessionId } = req.body;
+
+    if (!sessionId) {
+      return res.status(400).json({ error: 'sessionId required' });
+    }
+
+    console.log(`[Gemini] Interrupt request for session: ${sessionId}`);
+
+    const result = geminiWrapper.interrupt(sessionId);
+
+    if (result.success) {
+      console.log(`[Gemini] Interrupted session ${sessionId} via ${result.method}`);
+    } else {
+      console.log(`[Gemini] Failed to interrupt session ${sessionId}: ${result.reason}`);
+    }
+
+    res.json(result);
+  } catch (error) {
+    console.error('[Gemini] Interrupt error:', error);
+    res.status(500).json({ error: error.message });
+  }
+});
+
 module.exports = router;

package/lib/server/routes/sessions.js

@@ -4,6 +4,7 @@ const path = require('path');
 const { prepare, saveDb } = require('../db');
 const CliLoader = require('../services/cli-loader');
 const SummaryGenerator = require('../services/summary-generator');
+const sessionImporter = require('../services/session-importer');
 
 const router = express.Router();
 const cliLoader = new CliLoader();
@@ -16,6 +17,20 @@ const SESSION_DIRS = {
   gemini: path.join(process.env.HOME || '', '.gemini', 'sessions'),
 };
 
+/**
+ * POST /api/v1/sessions/import
+ * Importa tutte le sessioni native (Claude/Codex/Gemini) nel DB
+ */
+router.post('/import', async (_req, res) => {
+  try {
+    const imported = sessionImporter.importAll();
+    res.json({ success: true, imported });
+  } catch (error) {
+    console.error('[Sessions] Import error:', error);
+    res.status(500).json({ success: false, error: error.message });
+  }
+});
+
 /**
  * GET /api/v1/sessions/:id
  * Return session metadata from DB (sessions table)
@@ -66,8 +81,8 @@ router.get('/:id/messages', async (req, res) => {
 
     const { messages, pagination } = await cliLoader.loadMessagesFromCLI({
       sessionId,
-      threadId: session.session_path,     // native thread id (Codex/Gemini)
-      sessionPath: session.session_path,
+      threadId: session.session_path,     // native Codex/Gemini thread id
+      sessionPath: session.session_path,  // alias for compatibility
       engine: session.engine || 'claude-code',
       workspacePath: session.workspace_path,
       limit,
@@ -81,6 +96,7 @@ router.get('/:id/messages', async (req, res) => {
         workspace_path: session.workspace_path,
         title: session.title,
         engine: session.engine,
+        conversation_id: session.conversation_id,
         last_used_at: session.last_used_at,
         created_at: session.created_at,
         message_count: session.message_count
@@ -283,6 +299,7 @@ function getSessionFilePath(sessionId, engine, workspacePath, sessionPath) {
       const baseDir = SESSION_DIRS.codex;
       const flatPath = path.join(baseDir, `${nativeId}.jsonl`);
       if (fs.existsSync(flatPath)) return flatPath;
+      // Search nested rollout-*.jsonl files containing the threadId
       return findCodexSessionFile(baseDir, nativeId);
     case 'gemini':
       return path.join(SESSION_DIRS.gemini, `${sessionId}.jsonl`);
@@ -291,6 +308,9 @@ function getSessionFilePath(sessionId, engine, workspacePath, sessionPath) {
   }
 }
 
+/**
+ * Find Codex rollout file by threadId within YYYY/MM/DD directories
+ */
 function findCodexSessionFile(baseDir, threadId) {
   if (!threadId || !fs.existsSync(baseDir)) return null;
   try {

package/lib/server/server.js

@@ -7,6 +7,7 @@ const http = require('http');
 const { initDb, prepare } = require('./db');
 const User = require('./models/User');
 const WorkspaceManager = require('./services/workspace-manager');
+const sessionImporter = require('./services/session-importer');
 const pkg = require('../../package.json');
 
 // Import middleware
@@ -28,6 +29,7 @@ const wakeLockRouter = require('./routes/wake-lock');
 const uploadRouter = require('./routes/upload');
 const keysRouter = require('./routes/keys');
 const speechRouter = require('./routes/speech');
+const configRouter = require('./routes/config');
 
 const app = express();
 const PORT = process.env.PORT || 41800;
@@ -62,6 +64,7 @@ app.use(express.static(frontendDist));
 // Public routes
 app.use('/api/v1/auth', authRouter);
 app.use('/api/v1/models', modelsRouter);
+app.use('/api/v1/config', configRouter);
 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);
@@ -150,6 +153,14 @@ async function start() {
     // Continue anyway - database will sync on first workspace mount
   }
 
+  // Import native sessions from all engines (Claude/Codex/Gemini)
+  try {
+    const imported = sessionImporter.importAll();
+    console.log(`[Startup] Imported sessions → Claude:${imported.claude} Codex:${imported.codex} Gemini:${imported.gemini}`);
+  } catch (error) {
+    console.error('[Startup] ⚠️  Session import failed:', error.message);
+  }
+
   // Auto-seed dev user on demand (Termux/local) if no users exist
   const autoSeed = process.env.NEXUSCLI_AUTO_SEED === '1';
   if (autoSeed) {

package/lib/server/services/codex-wrapper.js

@@ -4,19 +4,20 @@
  *
  * Based on NexusChat codex-cli-wrapper.js pattern
  * Requires: codex-cli 0.62.1+ with exec subcommand
+ *
+ * @version 0.5.0 - Extended BaseCliWrapper for interrupt support
  */
 
 const { spawn, exec } = require('child_process');
 const CodexOutputParser = require('./codex-output-parser');
+const BaseCliWrapper = require('./base-cli-wrapper');
 
-class CodexWrapper {
+class CodexWrapper extends BaseCliWrapper {
   constructor(options = {}) {
+    super();  // Initialize activeProcesses from BaseCliWrapper
     this.workspaceDir = options.workspaceDir || process.cwd();
     this.codexBin = options.codexBin || 'codex';
 
-    // Track active sessions
-    this.activeSessions = new Set();
-
     console.log('[CodexWrapper] Initialized');
     console.log('[CodexWrapper] Workspace:', this.workspaceDir);
     console.log('[CodexWrapper] Binary:', this.codexBin);
@@ -34,7 +35,7 @@ class CodexWrapper {
    * @param {Function} options.onStatus - Callback for status events
    * @returns {Promise<Object>} Response with text, usage, threadId
    */
-  async sendMessage({ prompt, model, threadId, reasoningEffort, workspacePath, imageFiles = [], onStatus }) {
+  async sendMessage({ prompt, model, threadId, reasoningEffort, workspacePath, imageFiles = [], onStatus, processId: processIdOverride }) {
     return new Promise((resolve, reject) => {
       const parser = new CodexOutputParser();
       const cwd = workspacePath || this.workspaceDir;
@@ -91,6 +92,11 @@ class CodexWrapper {
         },
       });
 
+      // Register process for interrupt capability
+      // Prefer external processId (Nexus sessionId), else threadId, else temp
+      const processId = processIdOverride || threadId || `codex-${Date.now()}`;
+      this.registerProcess(processId, proc, 'spawn');
+
       proc.stdout.on('data', (data) => {
         const str = data.toString();
         stdout += str;
@@ -102,6 +108,9 @@ class CodexWrapper {
       });
 
       proc.on('close', (exitCode) => {
+        // Unregister process on exit
+        this.unregisterProcess(processId);
+
         clearTimeout(timeout);
         this.handleExit(exitCode, stdout, parser, prompt, resolve, reject);
       });