@mmmbuto/nexuscli 0.7.6 → 0.7.7

package/lib/server/lib/pty-adapter.js

@@ -2,6 +2,8 @@
  * PTY Adapter for NexusCLI (Termux)
  * Provides node-pty-like interface using child_process.spawn
  * Termux-only: no native node-pty compilation needed
+ *
+ * @version 0.5.0 - Added stdin support for interrupt (ESC key)
  */
 
 const { spawn: cpSpawn } = require('child_process');
@@ -18,7 +20,7 @@ function spawn(command, args, options = {}) {
     cwd: options.cwd,
     env: options.env,
     shell: false,
-    stdio: ['ignore', 'pipe', 'pipe'],
+    stdio: ['pipe', 'pipe', 'pipe'],  // stdin enabled for interrupt support
   });
 
   const dataHandlers = [];
@@ -49,6 +51,18 @@ function spawn(command, args, options = {}) {
     onExit: (fn) => exitHandlers.push(fn),
     onError: (fn) => errorHandlers.push(fn),
     write: (data) => proc.stdin?.writable && proc.stdin.write(data),
+    /**
+     * Send ESC key (0x1B) to interrupt CLI
+     * Used to gracefully stop Claude/Gemini CLI execution
+     * @returns {boolean} true if ESC was sent successfully
+     */
+    sendEsc: () => {
+      if (proc.stdin?.writable) {
+        proc.stdin.write('\x1B');
+        return true;
+      }
+      return false;
+    },
     kill: (signal = 'SIGTERM') => proc.kill(signal),
     pid: proc.pid,
   };

package/lib/server/routes/chat.js

@@ -15,6 +15,20 @@ const claudeWrapper = new ClaudeWrapper();
 const historySync = new HistorySync();
 const summaryGenerator = new SummaryGenerator();
 
+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('[Chat] Failed to ensure conversation exists:', err.message);
+  }
+}
+
 /**
  * POST /api/v1/chat
  * Send message to Claude Code CLI with SSE streaming
@@ -54,6 +68,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,
       'claude',
@@ -69,10 +85,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 !== 'claude';
 
     // IMPORTANT: Skip contextBridge for Claude native resume!
@@ -85,6 +101,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: 'claude',
@@ -110,7 +127,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 },
@@ -118,6 +135,7 @@ router.post('/', async (req, res) => {
           'claude'  // Engine tracking for context bridging
         );
         console.log(`[Chat] Saved user message: ${userMessage.id} (engine: claude)`);
+        sessionManager.bumpSessionActivity(sessionId, 1);
 
       } catch (msgErr) {
         console.warn('[Chat] Failed to save user message:', msgErr.message);
@@ -138,7 +156,7 @@ router.post('/', async (req, res) => {
       // Save assistant response to database with engine tracking
       try {
         const assistantMessage = Message.create(
-          sessionId,
+          frontendConversationId,
           'assistant',
           result.text,
           { usage: result.usage, model },
@@ -146,6 +164,7 @@ router.post('/', async (req, res) => {
           'claude'  // Engine tracking for context bridging
         );
         console.log(`[Chat] Saved assistant message: ${assistantMessage.id} (engine: claude)`);
+        sessionManager.bumpSessionActivity(sessionId, 1);
       } catch (msgErr) {
         console.warn('[Chat] Failed to save assistant message:', msgErr.message);
       }
@@ -157,7 +176,8 @@ router.post('/', async (req, res) => {
           invalidateConversations(); // Clear cache for fresh sidebar
           res.write(`data: ${JSON.stringify({
             type: 'session_created',
-            sessionId
+            sessionId,
+            conversationId: frontendConversationId
           })}\n\n`);
         } catch (syncErr) {
           console.warn('[Chat] History sync failed after new chat:', syncErr.message);
@@ -179,8 +199,8 @@ router.post('/', async (req, res) => {
       }
 
       // Smart auto-summary: trigger based on message count and engine bridging
-      if (contextBridge.shouldTriggerSummary(sessionId, isEngineBridge)) {
-        contextBridge.triggerSummaryGeneration(sessionId, '[Chat]');
+      if (contextBridge.shouldTriggerSummary(frontendConversationId, isEngineBridge)) {
+        contextBridge.triggerSummaryGeneration(frontendConversationId, '[Chat]');
       }
 
       // Send completion event
@@ -189,7 +209,8 @@ router.post('/', async (req, res) => {
         messageId: `assistant-${Date.now()}`,
         content: result.text,
         usage: result.usage,
-        sessionId
+        sessionId,
+        conversationId: frontendConversationId
       })}\n\n`);
 
       res.end();
@@ -215,4 +236,45 @@ router.post('/', async (req, res) => {
   }
 });
 
+/**
+ * POST /api/v1/chat/interrupt
+ * Interrupt running Claude CLI process
+ *
+ * Request body:
+ * {
+ *   "sessionId": "uuid" - Session to interrupt
+ * }
+ *
+ * Response:
+ * {
+ *   "success": boolean,
+ *   "method": "esc" | "sigint" (if success),
+ *   "reason": string (if failed)
+ * }
+ */
+router.post('/interrupt', async (req, res) => {
+  try {
+    const { sessionId } = req.body;
+
+    if (!sessionId) {
+      return res.status(400).json({ error: 'sessionId required' });
+    }
+
+    console.log(`[Chat] Interrupt request for session: ${sessionId}`);
+
+    const result = claudeWrapper.interrupt(sessionId);
+
+    if (result.success) {
+      console.log(`[Chat] Interrupted session ${sessionId} via ${result.method}`);
+    } else {
+      console.log(`[Chat] Failed to interrupt session ${sessionId}: ${result.reason}`);
+    }
+
+    res.json(result);
+  } catch (error) {
+    console.error('[Chat] Interrupt error:', error);
+    res.status(500).json({ error: error.message });
+  }
+});
+
 module.exports = router;

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);
       }
@@ -152,7 +170,7 @@ router.post('/', async (req, res) => {
       // Save assistant response to database with engine tracking
       try {
         const assistantMessage = Message.create(
-          sessionId,
+          frontendConversationId,
           'assistant',
           result.text,
           { usage: result.usage, model },
@@ -160,13 +178,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 +194,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 +240,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);
     }
@@ -168,21 +187,22 @@ router.post('/', async (req, res) => {
 
     // 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 +264,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

@@ -66,8 +66,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 +81,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 +284,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 +293,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

@@ -28,6 +28,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 +63,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);

package/lib/server/services/base-cli-wrapper.js

@@ -0,0 +1,137 @@
+/**
+ * Base CLI Wrapper - Common interrupt logic for all CLI wrappers
+ *
+ * Provides unified process tracking and interrupt capability for:
+ * - ClaudeWrapper (PTY)
+ * - GeminiWrapper (PTY)
+ * - CodexWrapper (child_process.spawn)
+ *
+ * @version 0.5.0 - Interrupt Support
+ */
+
+class BaseCliWrapper {
+  constructor() {
+    // Map: sessionId → { process, type, startTime }
+    this.activeProcesses = new Map();
+  }
+
+  /**
+   * Register active process for interrupt capability
+   * @param {string} sessionId - Session/conversation ID
+   * @param {Object} process - PTY process or child_process
+   * @param {string} type - 'pty' or 'spawn'
+   */
+  registerProcess(sessionId, process, type = 'pty') {
+    this.activeProcesses.set(sessionId, {
+      process,
+      type,
+      startTime: Date.now()
+    });
+    console.log(`[BaseWrapper] Registered ${type} process for session ${sessionId}`);
+  }
+
+  /**
+   * Unregister process on completion
+   * @param {string} sessionId
+   */
+  unregisterProcess(sessionId) {
+    if (this.activeProcesses.has(sessionId)) {
+      this.activeProcesses.delete(sessionId);
+      console.log(`[BaseWrapper] Unregistered process for session ${sessionId}`);
+    }
+  }
+
+  /**
+   * Interrupt running process
+   *
+   * Strategy:
+   * - PTY: Try ESC (0x1B) first, then SIGINT
+   * - Spawn: SIGINT directly
+   *
+   * @param {string} sessionId
+   * @returns {{ success: boolean, method?: string, reason?: string }}
+   */
+  interrupt(sessionId) {
+    const entry = this.activeProcesses.get(sessionId);
+
+    if (!entry) {
+      console.log(`[BaseWrapper] No active process for session ${sessionId}`);
+      return { success: false, reason: 'no_active_process' };
+    }
+
+    const { process, type } = entry;
+
+    try {
+      if (type === 'pty') {
+        // PTY process: Try ESC first (gentler), then SIGINT
+        if (typeof process.sendEsc === 'function' && process.sendEsc()) {
+          console.log(`[BaseWrapper] Sent ESC to PTY session ${sessionId}`);
+          // Don't remove yet - let onExit handle cleanup
+          return { success: true, method: 'esc' };
+        }
+
+        // ESC failed or not available, use SIGINT
+        if (typeof process.kill === 'function') {
+          process.kill('SIGINT');
+          console.log(`[BaseWrapper] Sent SIGINT to PTY session ${sessionId}`);
+          return { success: true, method: 'sigint' };
+        }
+      } else if (type === 'spawn') {
+        // child_process.spawn: SIGINT directly
+        if (typeof process.kill === 'function') {
+          process.kill('SIGINT');
+          console.log(`[BaseWrapper] Sent SIGINT to spawn session ${sessionId}`);
+          return { success: true, method: 'sigint' };
+        }
+      }
+
+      return { success: false, reason: 'kill_not_available' };
+    } catch (err) {
+      console.error(`[BaseWrapper] Interrupt error for session ${sessionId}:`, err.message);
+      return { success: false, reason: err.message };
+    }
+  }
+
+  /**
+   * Check if session has active process
+   * @param {string} sessionId
+   * @returns {boolean}
+   */
+  isActive(sessionId) {
+    return this.activeProcesses.has(sessionId);
+  }
+
+  /**
+   * Get count of active processes
+   * @returns {number}
+   */
+  getActiveCount() {
+    return this.activeProcesses.size;
+  }
+
+  /**
+   * Get all active session IDs
+   * @returns {string[]}
+   */
+  getActiveSessions() {
+    return Array.from(this.activeProcesses.keys());
+  }
+
+  /**
+   * Get process info for session
+   * @param {string} sessionId
+   * @returns {{ type: string, startTime: number, duration: number } | null}
+   */
+  getProcessInfo(sessionId) {
+    const entry = this.activeProcesses.get(sessionId);
+    if (!entry) return null;
+
+    return {
+      type: entry.type,
+      startTime: entry.startTime,
+      duration: Date.now() - entry.startTime
+    };
+  }
+}
+
+module.exports = BaseCliWrapper;