@mmmbuto/nexuscli 0.5.3 → 0.5.5

package/lib/server/routes/codex.js

@@ -70,6 +70,10 @@ router.post('/', async (req, res) => {
     console.log(`[Codex] Session resolved: ${sessionId} (new: ${isNewSession})`);
     const isNewChat = isNewSession;
 
+    // Get native Codex threadId for session resume (if exists)
+    const nativeThreadId = isNewSession ? null : sessionManager.getNativeThreadId(sessionId);
+    console.log(`[Codex] Native threadId: ${nativeThreadId || '(new thread)'}`);
+
     // Set up SSE
     res.setHeader('Content-Type', 'text/event-stream');
     res.setHeader('Cache-Control', 'no-cache');
@@ -118,11 +122,11 @@ router.post('/', async (req, res) => {
         console.warn('[Codex] Failed to save user message:', msgErr.message);
       }
 
-      // Call Codex wrapper with workspace path
+      // Call Codex wrapper with native threadId for session resume
       const result = await codexWrapper.sendMessage({
-        prompt: promptWithContext,
+        prompt: nativeThreadId ? message : promptWithContext, // Use raw message if resuming native session
         model,
-        sessionId,
+        threadId: nativeThreadId, // Native Codex thread ID for resume
         reasoningEffort,
         workspacePath,
         onStatus: (event) => {
@@ -131,6 +135,11 @@ router.post('/', async (req, res) => {
         }
       });
 
+      // Save native threadId for future resume (if new)
+      if (result.threadId && result.threadId !== nativeThreadId) {
+        sessionManager.setNativeThreadId(sessionId, result.threadId);
+      }
+
       // Save assistant response to database with engine tracking
       try {
         const assistantMessage = Message.create(

package/lib/server/routes/gemini.js

@@ -72,6 +72,10 @@ router.post('/', async (req, res) => {
 
     console.log(`[Gemini] Session resolved: ${sessionId} (new: ${isNewSession})`);
 
+    // Get native Gemini sessionId for session resume (if exists)
+    const nativeSessionId = isNewSession ? null : sessionManager.getNativeThreadId(sessionId);
+    console.log(`[Gemini] Native sessionId: ${nativeSessionId || '(new session)'}`);
+
     // Set up SSE
     res.setHeader('Content-Type', 'text/event-stream');
     res.setHeader('Cache-Control', 'no-cache');
@@ -133,10 +137,10 @@ router.post('/', async (req, res) => {
 
     console.log('[Gemini] Calling Gemini CLI...');
 
-    // Call Gemini wrapper with SSE streaming
+    // Call Gemini wrapper with native sessionId for session resume
     const result = await geminiWrapper.sendMessage({
-      prompt: promptWithContext,
-      sessionId,
+      prompt: nativeSessionId ? message : promptWithContext, // Use raw message if resuming native session
+      threadId: nativeSessionId, // Native Gemini session ID for resume
       model,
       workspacePath,
       onStatus: (event) => {
@@ -147,6 +151,12 @@ 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) {
+      sessionManager.setNativeThreadId(sessionId, result.sessionId);
+      console.log(`[Gemini] Saved native sessionId: ${result.sessionId}`);
+    }
+
     // Save assistant response to DB
     try {
       Message.create(

package/lib/server/server.js

@@ -169,50 +169,62 @@ async function start() {
   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);
+  const hasHttpsCerts = fs.existsSync(certPath) && fs.existsSync(keyPath);
 
-  let server;
-  let protocol = 'http';
+  // Always start HTTP server on main port
+  const httpServer = http.createServer(app);
 
-  if (useHttps) {
+  // Start HTTPS server on PORT+1 if certificates exist (for remote mic access)
+  let httpsServer = null;
+  const HTTPS_PORT = parseInt(PORT) + 1;
+
+  if (hasHttpsCerts) {
     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');
+      httpsServer = https.createServer(httpsOptions, app);
+      console.log('[Startup] HTTPS certificates found');
     } catch (err) {
-      console.warn('[Startup] Failed to load certificates, falling back to HTTP:', err.message);
-      server = http.createServer(app);
+      console.warn('[Startup] Failed to load certificates:', err.message);
     }
-  } 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, () => {
+  httpServer.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(`✅ HTTP:  http://localhost:${PORT}`);
+
+    if (httpsServer) {
+      httpsServer.listen(HTTPS_PORT, () => {
+        console.log(`🔒 HTTPS: https://localhost:${HTTPS_PORT} (for remote mic)`);
+        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('');
+      });
+    } else {
+      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('');
     }
-    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('');
   });
 }
 

package/lib/server/services/codex-output-parser.js

@@ -263,6 +263,13 @@ class CodexOutputParser {
     return this.usage;
   }
 
+  /**
+   * Get thread ID (native Codex session ID)
+   */
+  getThreadId() {
+    return this.threadId;
+  }
+
   /**
    * Reset parser state for new request
    */
@@ -270,6 +277,7 @@ class CodexOutputParser {
     this.buffer = '';
     this.finalResponse = '';
     this.usage = null;
+    this.threadId = null;
     this.pendingCommands.clear();
   }
 }

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

@@ -27,29 +27,27 @@ class CodexWrapper {
    * @param {Object} options - Message options
    * @param {string} options.prompt - User prompt
    * @param {string} options.model - Model name (e.g., gpt-5.1-codex-max)
-   * @param {string} options.sessionId - Session ID for conversation continuity
+   * @param {string} options.threadId - Native Codex thread ID for session resume
    * @param {string} options.reasoningEffort - Reasoning level (low, medium, high, xhigh)
    * @param {string} options.workspacePath - Working directory override
    * @param {string[]} options.imageFiles - Array of image file paths for multimodal
    * @param {Function} options.onStatus - Callback for status events
-   * @returns {Promise<Object>} Response with text, usage
+   * @returns {Promise<Object>} Response with text, usage, threadId
    */
-  async sendMessage({ prompt, model, sessionId, reasoningEffort, workspacePath, imageFiles = [], onStatus }) {
+  async sendMessage({ prompt, model, threadId, reasoningEffort, workspacePath, imageFiles = [], onStatus }) {
     return new Promise((resolve, reject) => {
       const parser = new CodexOutputParser();
       const cwd = workspacePath || this.workspaceDir;
 
       // Build CLI arguments
-      const args = [
-        'exec',
-        '--json',                                    // JSONL output for parsing
-        '--skip-git-repo-check',                     // Allow non-git directories
-        '--dangerously-bypass-approvals-and-sandbox', // Full access (safety via CLAUDE.md policy)
-        '-C', cwd,                                   // Working directory
-      ];
-
-      // Add model if specified
-      if (model) {
+      // If threadId exists, use 'exec --json resume <threadId>' to continue session
+      // Otherwise use 'exec --json' for new session
+      const args = threadId
+        ? ['exec', '--json', 'resume', threadId]
+        : ['exec', '--json', '--skip-git-repo-check', '--dangerously-bypass-approvals-and-sandbox', '-C', cwd];
+
+      // Add model if specified (only for new sessions)
+      if (model && !threadId) {
         const baseModel = this.extractBaseModel(model);
         args.push('-m', baseModel);
       }
@@ -72,7 +70,7 @@ class CodexWrapper {
 
       console.log('[CodexWrapper] Model:', model);
       console.log('[CodexWrapper] Reasoning:', reasoningEffort);
-      console.log('[CodexWrapper] Session:', sessionId);
+      console.log('[CodexWrapper] ThreadId:', threadId || '(new session)');
       console.log('[CodexWrapper] CWD:', cwd);
       console.log('[CodexWrapper] Args:', args.slice(0, 6).join(' ') + '...');
 
@@ -151,8 +149,10 @@ class CodexWrapper {
 
     const finalResponse = parser.getFinalResponse();
     const usage = parser.getUsage();
+    const threadId = parser.getThreadId();
 
     console.log('[CodexWrapper] Final response length:', finalResponse.length);
+    console.log('[CodexWrapper] ThreadId:', threadId);
 
     // Calculate token counts (fallback)
     const promptTokens = usage?.input_tokens || Math.ceil(prompt.length / 4);
@@ -160,6 +160,7 @@ class CodexWrapper {
 
     resolve({
       text: finalResponse,
+      threadId, // Native Codex session ID for resume
       usage: {
         prompt_tokens: promptTokens,
         completion_tokens: completionTokens,

package/lib/server/services/context-bridge.js

@@ -139,11 +139,13 @@ class ContextBridge {
     for (let i = messages.length - 1; i >= 0; i--) {
       const msg = messages[i];
 
-      // For code-focused engines, filter out non-code content
+      // For code-focused engines, compress assistant responses to code only
+      // BUT always keep user messages for context continuity
       let content = msg.content;
-      if (config.codeOnly) {
-        content = this.extractCodeContent(content);
-        if (!content) continue; // Skip if no code
+      if (config.codeOnly && msg.role === 'assistant') {
+        const codeContent = this.extractCodeContent(content);
+        // Only use code-only if there's actual code, otherwise keep truncated original
+        content = codeContent || (content.length > 500 ? content.substring(0, 500) + '...' : content);
       }
 
       // Truncate long messages

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

@@ -67,15 +67,15 @@ class GeminiWrapper {
    *
    * @param {Object} params
    * @param {string} params.prompt - User message/prompt
-   * @param {string} params.sessionId - Session UUID (for logging)
+   * @param {string} params.threadId - Native Gemini session ID for resume
    * @param {string} [params.model='gemini-3-pro-preview'] - Model name
    * @param {string} [params.workspacePath] - Workspace directory
    * @param {Function} [params.onStatus] - Callback for status events (SSE streaming)
-   * @returns {Promise<{text: string, usage: Object}>}
+   * @returns {Promise<{text: string, usage: Object, sessionId: string}>}
    */
   async sendMessage({
     prompt,
-    sessionId,
+    threadId,
     model = DEFAULT_MODEL,
     workspacePath,
     onStatus
@@ -87,16 +87,23 @@ class GeminiWrapper {
       const cwd = workspacePath || this.workspaceDir;
 
       // Build CLI arguments
-      // Note: cwd is set in pty.spawn() options, no need for --include-directories
+      // If threadId exists, use --resume to continue native session
       const args = [
         '-y',                              // YOLO mode - auto-approve all actions
         '-m', model,                       // Model selection
         '-o', 'stream-json',               // JSON streaming for structured events
-        prompt                             // Prompt as positional argument
       ];
 
+      // Add resume flag if continuing existing session
+      if (threadId) {
+        args.push('--resume', threadId);
+      }
+
+      // Add prompt as positional argument
+      args.push(prompt);
+
       console.log(`[GeminiWrapper] Model: ${model}`);
-      console.log(`[GeminiWrapper] Session: ${sessionId}`);
+      console.log(`[GeminiWrapper] ThreadId: ${threadId || '(new session)'}`);
       console.log(`[GeminiWrapper] CWD: ${cwd}`);
       console.log(`[GeminiWrapper] Prompt length: ${prompt.length}`);
 
@@ -170,6 +177,7 @@ class GeminiWrapper {
 
         resolve({
           text: finalResponse,
+          sessionId: parser.getSessionId(), // Native Gemini session ID for resume
           usage: {
             prompt_tokens: promptTokens,
             completion_tokens: completionTokens,

package/lib/server/services/session-manager.js

@@ -46,10 +46,18 @@ class SessionManager {
   /**
    * Check if session file exists on disk
    * Claude: ~/.claude/projects/<workspace-slug>/<sessionId>.jsonl
-   * Codex: ~/.codex/sessions/<sessionId>.jsonl (if available)
+   * Codex: Uses exec mode (no session files) - DB is source of truth
    * Gemini: ~/.gemini/sessions/<sessionId>.jsonl (if available)
    */
   sessionFileExists(sessionId, engine, workspacePath) {
+    const normalizedEngine = this._normalizeEngine(engine);
+
+    // Codex/Gemini exec mode doesn't create session files - trust DB mapping
+    // Session continuity is managed via NexusCLI's message DB + contextBridge
+    if (normalizedEngine === 'codex' || normalizedEngine === 'gemini') {
+      return true; // Always trust DB for exec-mode CLI sessions
+    }
+
     try {
       const sessionPath = this.getSessionFilePath(sessionId, engine, workspacePath);
       if (!sessionPath) return false;
@@ -452,6 +460,40 @@ class SessionManager {
       timestamp: new Date().toISOString()
     };
   }
+
+  /**
+   * Get native thread ID for Codex/Gemini sessions
+   * Uses session_path column to store native CLI thread ID
+   * @param {string} sessionId - NexusCLI session ID
+   * @returns {string|null} Native thread ID or null
+   */
+  getNativeThreadId(sessionId) {
+    try {
+      const stmt = prepare('SELECT session_path FROM sessions WHERE id = ?');
+      const row = stmt.get(sessionId);
+      return row?.session_path || null;
+    } catch (error) {
+      console.warn(`[SessionManager] Failed to get native threadId:`, error.message);
+      return null;
+    }
+  }
+
+  /**
+   * Set native thread ID for Codex/Gemini sessions
+   * @param {string} sessionId - NexusCLI session ID
+   * @param {string} threadId - Native CLI thread ID
+   */
+  setNativeThreadId(sessionId, threadId) {
+    if (!threadId) return;
+    try {
+      const stmt = prepare('UPDATE sessions SET session_path = ? WHERE id = ?');
+      stmt.run(threadId, sessionId);
+      saveDb();
+      console.log(`[SessionManager] Set native threadId: ${sessionId} → ${threadId}`);
+    } catch (error) {
+      console.warn(`[SessionManager] Failed to set native threadId:`, error.message);
+    }
+  }
 }
 
 // Singleton instance

package/lib/server/services/workspace-manager.js

@@ -396,7 +396,7 @@ class WorkspaceManager {
    * @returns {string}
    */
   getSessionPath(workspacePath) {
-    // Convert /home/user/myproject → -home-user-myproject
+    // Convert /var/www/cli.wellanet.dev → -var-www-cli-wellanet-dev
     const projectDir = workspacePath.replace(/\//g, '-').replace(/^-/, '');
     return path.join(this.claudePath, 'projects', projectDir);
   }

package/lib/server/tests/performance.test.js

@@ -45,7 +45,7 @@ describe('Performance Benchmarks', () => {
 
   test('Workspace validation should be fast', async () => {
     const manager = new WorkspaceManager();
-    const testPath = '/home/user/myproject';
+    const testPath = '/var/www/cli.wellanet.dev';
 
     const start = Date.now();
     const validated = await manager.validateWorkspace(testPath);

package/lib/server/tests/services.test.js

@@ -16,7 +16,7 @@ describe('WorkspaceManager', () => {
 
   test('should validate workspace path', async () => {
     // Test with allowed path
-    const validPath = '/home/user/myproject';
+    const validPath = '/var/www/cli.wellanet.dev';
     const result = await manager.validateWorkspace(validPath);
     expect(result).toBe(validPath);
   });
@@ -147,7 +147,7 @@ describe('SummaryGenerator', () => {
 describe('Integration - Service Interactions', () => {
   test('WorkspaceManager should use consistent path resolution', async () => {
     const manager = new WorkspaceManager();
-    const testPath = '/home/user/myproject';
+    const testPath = '/var/www/cli.wellanet.dev';
     const validated = await manager.validateWorkspace(testPath);
     expect(validated).toBe(testPath);
   });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mmmbuto/nexuscli",
-  "version": "0.5.3",
+  "version": "0.5.5",
   "description": "NexusCLI - TRI CLI Control Plane (Claude/Codex/Gemini)",
   "main": "lib/server/server.js",
   "bin": {