@mmmbuto/nexuscli 0.5.0

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

@@ -0,0 +1,312 @@
+const fs = require('fs');
+const path = require('path');
+const pty = require('../lib/pty-adapter');
+const OutputParser = require('./output-parser');
+const { getApiKey } = require('../db');
+
+/**
+ * Wrapper for Claude Code CLI (local installation)
+ *
+ * Features:
+ * - Uses local Claude Code installation (/home/dag/.claude/local/claude)
+ * - OAuth authentication (handled by CLI)
+ * - Real-time status streaming via onStatus callback
+ * - Session management with conversation ID
+ *
+ * Architecture:
+ * - Spawns Claude Code CLI with node-pty
+ * - Parses stdout for tool use, thinking, file ops
+ * - Emits status events → SSE stream
+ * - Returns final response text → saved in DB
+ */
+class ClaudeWrapper {
+  constructor(options = {}) {
+    this.claudePath = this.resolveClaudePath(options.claudePath);
+    this.workspaceDir = options.workspaceDir || process.env.NEXUSCLI_WORKSPACE || process.cwd();
+  }
+
+  isExistingSession(sessionId, workspacePath) {
+    // ONLY check filesystem - Claude CLI's .jsonl files are the source of truth
+    // NexusCLI's database (sessions/conversations tables) may have IDs that
+    // Claude CLI doesn't recognize, causing "No conversation found" errors
+    try {
+      const projectsDir = path.join(process.env.HOME || '', '.claude', 'projects');
+      if (fs.existsSync(projectsDir)) {
+        const dirs = fs.readdirSync(projectsDir);
+        for (const dir of dirs) {
+          const sessionFile = path.join(projectsDir, dir, `${sessionId}.jsonl`);
+          if (fs.existsSync(sessionFile)) {
+            console.log(`[ClaudeWrapper] Session ${sessionId} found in filesystem: ${sessionFile}`);
+            return true;
+          }
+        }
+      }
+    } catch (err) {
+      console.warn('[ClaudeWrapper] Filesystem lookup failed:', err.message);
+    }
+
+    console.log(`[ClaudeWrapper] Session ${sessionId} not found in Claude projects - treating as NEW`);
+    return false;
+  }
+
+  resolveClaudePath(overridePath) {
+    if (overridePath && fs.existsSync(overridePath)) return overridePath;
+    const envPath = process.env.NEXUSCLI_CLAUDE_PATH;
+    if (envPath && fs.existsSync(envPath)) return envPath;
+
+    const candidates = [
+      path.join(process.env.HOME || '', '.claude', 'local', 'claude'),
+      path.join(process.env.PREFIX || '', 'bin', 'claude'),
+      path.join(process.env.HOME || '', 'bin', 'claude'),
+      '/usr/local/bin/claude',
+      '/usr/bin/claude',
+    ].filter(Boolean);
+
+    for (const candidate of candidates) {
+      try {
+        if (fs.existsSync(candidate) && fs.statSync(candidate).mode & 0o111) {
+          return candidate;
+        }
+      } catch (_) {
+        // ignore
+      }
+    }
+
+    return null;
+  }
+
+  /**
+   * Send message to Claude Code CLI
+   *
+   * @param {Object} params
+   * @param {string} params.prompt - User message
+   * @param {string} params.conversationId - Session ID for Claude
+   * @param {string} params.model - Model (sonnet, opus, haiku, or full name)
+   * @param {string} params.workspacePath - Workspace directory for Claude CLI --cwd
+   * @param {Function} params.onStatus - Callback for status events (tool use, thinking)
+   * @returns {Promise<{text: string, usage: Object}>}
+   */
+  async sendMessage({ prompt, conversationId, model = 'sonnet', workspacePath, onStatus }) {
+    return new Promise((resolve, reject) => {
+      const parser = new OutputParser();
+      // Prevent double-settling when PTY fires both error and exit events
+      let promiseSettled = false;
+
+      if (!this.claudePath || !fs.existsSync(this.claudePath)) {
+        const msg = `Claude CLI not found (set NEXUSCLI_CLAUDE_PATH)`;
+        console.error('[ClaudeWrapper]', msg);
+        if (onStatus) {
+          onStatus({ type: 'error', category: 'runtime', message: msg });
+        }
+        return reject(new Error(msg));
+      }
+
+      // Check if this is an existing session (DB is source of truth)
+      const isExistingSession = this.isExistingSession(conversationId);
+
+      // Build Claude Code CLI args
+      const args = [
+        '--dangerously-skip-permissions', // Auto-approve all tool use
+        '--model', model,
+        '--print', // Non-interactive mode
+        '--verbose', // Enable detailed output
+        '--output-format', 'stream-json', // JSON streaming events
+      ];
+
+      // Session management: -r (resume) or --session-id (new)
+      if (isExistingSession) {
+        args.push('-r', conversationId); // Resume with full history
+      } else {
+        args.push('--session-id', conversationId); // Create new session
+      }
+
+      args.push(prompt);
+
+      // Use provided workspace or fallback to default
+      const cwd = workspacePath || this.workspaceDir;
+
+      // Build environment - detect DeepSeek models and configure API accordingly
+      const spawnEnv = { ...process.env };
+      const isDeepSeek = model.startsWith('deepseek-');
+
+      if (isDeepSeek) {
+        // Get API key from database (priority) or fallback to env var
+        const deepseekKey = getApiKey('deepseek') || process.env.DEEPSEEK_API_KEY;
+
+        if (!deepseekKey) {
+          const errorMsg = `DeepSeek API key not configured!\n\n` +
+            `Run this command to add your API key:\n` +
+            `  nexuscli api set deepseek YOUR_API_KEY\n\n` +
+            `Get your key at: https://platform.deepseek.com/api_keys`;
+
+          console.error(`[ClaudeWrapper] ❌ ${errorMsg}`);
+
+          if (onStatus) {
+            onStatus({
+              type: 'error',
+              category: 'config',
+              message: errorMsg
+            });
+          }
+
+          return reject(new Error(errorMsg));
+        }
+
+        // DeepSeek uses Anthropic-compatible API at different endpoint
+        spawnEnv.ANTHROPIC_BASE_URL = 'https://api.deepseek.com/anthropic';
+        spawnEnv.ANTHROPIC_AUTH_TOKEN = deepseekKey;
+        console.log(`[ClaudeWrapper] DeepSeek detected - using api.deepseek.com/anthropic`);
+      }
+
+      console.log(`[ClaudeWrapper] Model: ${model}${isDeepSeek ? ' (DeepSeek API)' : ''}`);
+      console.log(`[ClaudeWrapper] Session: ${conversationId} (${isExistingSession ? 'RESUME' : 'NEW'})`);
+      console.log(`[ClaudeWrapper] Working dir: ${cwd}`);
+
+      // Spawn Claude Code CLI with PTY
+      // On Termux, invoke node directly with the cli.js script for better compatibility
+      let command = this.claudePath;
+      let spawnArgs = args;
+
+      if (!pty.isPtyAvailable() && this.claudePath.endsWith('/claude')) {
+        // Resolve symlink to actual cli.js and invoke with node
+        const fs = require('fs');
+        try {
+          const realPath = fs.realpathSync(this.claudePath);
+          if (realPath.endsWith('.js')) {
+            command = process.execPath; // node binary
+            spawnArgs = [realPath, ...args];
+            console.log('[ClaudeWrapper] Termux mode: invoking node directly with', realPath);
+          }
+        } catch (err) {
+          console.warn('[ClaudeWrapper] Failed to resolve symlink, using path as-is:', err.message);
+        }
+      }
+
+      let ptyProcess;
+      try {
+        ptyProcess = pty.spawn(command, spawnArgs, {
+        name: 'xterm-color',
+        cols: 80,
+        rows: 30,
+        cwd: cwd,  // Use session-specific workspace
+        env: spawnEnv,  // Use configured env (includes DeepSeek API if needed)
+      });
+      } catch (err) {
+        const msg = `Failed to spawn Claude CLI: ${err.message}`;
+        console.error('[ClaudeWrapper]', msg);
+        if (onStatus) {
+          onStatus({ type: 'error', category: 'runtime', message: msg });
+        }
+        return reject(new Error(msg));
+      }
+
+      let stdout = '';
+
+      // Process output chunks
+      ptyProcess.onData((data) => {
+        stdout += data;
+        console.log(`[ClaudeWrapper] PTY data chunk: ${data.substring(0, 200)}`);
+
+        // Parse and emit status events
+        if (onStatus) {
+          try {
+            const events = parser.parse(data);
+            console.log(`[ClaudeWrapper] Parsed ${events.length} events`);
+            events.forEach(event => {
+              // Only emit status events (not response chunks)
+              if (event.type === 'status' || event.type === 'status_update') {
+                console.log(`[ClaudeWrapper] Status: ${event.category} - ${event.message}`);
+                onStatus(event);
+              }
+            });
+          } catch (parseError) {
+            console.error('[ClaudeWrapper] Parser error:', parseError);
+          }
+        }
+      });
+
+      // Handle exit
+      const handleError = (err) => {
+        console.error('[ClaudeWrapper] spawn error:', err);
+
+        // Ignore spurious EIO errors that occur after process exit (PTY race condition)
+        if (err.code === 'EIO' && promiseSettled) {
+          console.log('[ClaudeWrapper] Ignoring post-exit EIO error (PTY race condition)');
+          return;
+        }
+
+        if (promiseSettled) {
+          console.log('[ClaudeWrapper] PTY cleanup error (ignored):', err.code || err.message);
+          return;
+        }
+
+        promiseSettled = true;
+
+        if (onStatus) {
+          onStatus({ type: 'error', category: 'runtime', message: err.message });
+        }
+        reject(new Error(`Claude CLI spawn error: ${err.message}`));
+      };
+
+      if (typeof ptyProcess.on === 'function') {
+        ptyProcess.on('error', handleError);
+      } else if (typeof ptyProcess.onError === 'function') {
+        ptyProcess.onError(handleError);
+      }
+
+      ptyProcess.onExit(({ exitCode }) => {
+        console.log(`[ClaudeWrapper] Exit code: ${exitCode}`);
+
+        if (exitCode !== 0) {
+          if (promiseSettled) {
+            console.log(`[ClaudeWrapper] Exit after settle (exit ${exitCode}) - ignoring`);
+            return;
+          }
+
+          promiseSettled = true;
+          console.error('[ClaudeWrapper] Error output:', stdout.substring(0, 500));
+          reject(new Error(`Claude CLI error (exit ${exitCode}): ${stdout.substring(0, 200)}`));
+          return;
+        }
+
+        if (promiseSettled) {
+          console.log('[ClaudeWrapper] Exit already handled - skipping resolve');
+          return;
+        }
+
+        promiseSettled = true;
+
+        // Extract final response from JSON stream
+        const finalResponse = parser.extractFinalResponse();
+
+        // Get real token usage from JSON metadata
+        const usageData = parser.getUsage();
+        const usage = {
+          prompt_tokens: usageData?.input_tokens || 0,
+          completion_tokens: usageData?.output_tokens || 0,
+          total_tokens: (usageData?.input_tokens || 0) + (usageData?.output_tokens || 0),
+          cache_read_tokens: usageData?.cache_read_input_tokens || 0,
+          cache_creation_tokens: usageData?.cache_creation_input_tokens || 0,
+        };
+
+        console.log(`[ClaudeWrapper] Response length: ${finalResponse.length} chars`);
+        console.log(`[ClaudeWrapper] Token usage:`, usage);
+
+        resolve({
+          text: finalResponse,
+          usage,
+        });
+      });
+
+    });
+  }
+
+  /**
+   * Clean up session tracking when conversation is deleted
+   */
+  deleteSession(conversationId) {
+    console.log(`[ClaudeWrapper] Removed session tracking: ${conversationId}`);
+  }
+}
+
+module.exports = ClaudeWrapper;

package/lib/server/services/cli-loader.js

@@ -0,0 +1,384 @@
+/**
+ * CliLoader - Unified message loader for TRI CLI (Claude/Codex/Gemini)
+ *
+ * Loads messages on-demand from CLI history files (lazy loading).
+ * Filesystem is the source of truth - no DB caching of messages.
+ *
+ * Session file locations:
+ * - Claude: ~/.claude/projects/<workspace-slug>/<sessionId>.jsonl
+ * - Codex:  ~/.codex/sessions/<sessionId>.jsonl (if available)
+ * - Gemini: ~/.gemini/sessions/<sessionId>.jsonl (if available)
+ *
+ * @version 0.4.0 - TRI CLI Support
+ */
+
+const fs = require('fs');
+const path = require('path');
+const readline = require('readline');
+
+const DEFAULT_LIMIT = 30;
+
+// Engine-specific paths
+const ENGINE_PATHS = {
+  claude: path.join(process.env.HOME || '', '.claude'),
+  codex: path.join(process.env.HOME || '', '.codex'),
+  gemini: path.join(process.env.HOME || '', '.gemini'),
+};
+
+class CliLoader {
+  constructor() {
+    this.claudePath = ENGINE_PATHS.claude;
+    this.codexPath = ENGINE_PATHS.codex;
+    this.geminiPath = ENGINE_PATHS.gemini;
+  }
+
+  /**
+   * Load messages from CLI history by session.
+   * Supports all three engines: Claude, Codex, Gemini.
+   *
+   * @param {Object} params
+   * @param {string} params.sessionId - Session UUID
+   * @param {string} params.engine - 'claude'|'claude-code'|'codex'|'gemini'
+   * @param {string} params.workspacePath - Workspace directory (required for Claude)
+   * @param {number} [params.limit=30] - Max messages to return
+   * @param {number} [params.before] - Timestamp cursor for pagination (ms)
+   * @param {string} [params.mode='asc'] - Return order ('asc'|'desc')
+   * @returns {Promise<{messages: Array, pagination: Object}>}
+   */
+  async loadMessagesFromCLI({
+    sessionId,
+    engine = 'claude',
+    workspacePath,
+    limit = DEFAULT_LIMIT,
+    before,
+    mode = 'asc'
+  }) {
+    if (!sessionId) {
+      throw new Error('sessionId is required');
+    }
+
+    const startedAt = Date.now();
+    const normalizedEngine = this._normalizeEngine(engine);
+
+    let result;
+    switch (normalizedEngine) {
+      case 'claude':
+        result = await this.loadClaudeMessages({ sessionId, workspacePath, limit, before, mode });
+        break;
+
+      case 'codex':
+        result = await this.loadCodexMessages({ sessionId, limit, before, mode });
+        break;
+
+      case 'gemini':
+        result = await this.loadGeminiMessages({ sessionId, limit, before, mode });
+        break;
+
+      default:
+        throw new Error(`Unsupported engine: ${engine}`);
+    }
+
+    console.log(`[CliLoader] ${normalizedEngine} messages loaded in ${Date.now() - startedAt}ms (session ${sessionId}, ${result.messages.length} msgs)`);
+    return result;
+  }
+
+  /**
+   * Normalize engine name variants
+   */
+  _normalizeEngine(engine) {
+    if (!engine) return 'claude';
+    const lower = engine.toLowerCase();
+    if (lower.includes('claude')) return 'claude';
+    if (lower.includes('codex') || lower.includes('openai')) return 'codex';
+    if (lower.includes('gemini') || lower.includes('google')) return 'gemini';
+    return lower;
+  }
+
+  /**
+   * Convert workspace path to slug (for .claude/projects/ directory)
+   * Same as Claude Code behavior: /path/to/dir → -path-to-dir
+   * Also converts dots to dashes (e.g., com.termux → com-termux)
+   */
+  pathToSlug(workspacePath) {
+    if (!workspacePath) return '-default';
+    // Replace slashes AND dots with dashes (matches Claude Code behavior)
+    return workspacePath.replace(/[\/\.]/g, '-');
+  }
+
+  // ============================================================
+  // CLAUDE - Load from ~/.claude/projects/<slug>/<sessionId>.jsonl
+  // ============================================================
+
+  async loadClaudeMessages({ sessionId, workspacePath, limit, before, mode }) {
+    if (!workspacePath) {
+      console.warn('[CliLoader] No workspacePath for Claude, using cwd');
+      workspacePath = process.cwd();
+    }
+
+    const slug = this.pathToSlug(workspacePath);
+    const sessionFile = path.join(this.claudePath, 'projects', slug, `${sessionId}.jsonl`);
+
+    if (!fs.existsSync(sessionFile)) {
+      console.warn(`[CliLoader] Claude session file not found: ${sessionFile}`);
+      return this._emptyResult();
+    }
+
+    const rawMessages = await this._parseJsonlFile(sessionFile);
+
+    // Filter and normalize
+    const messages = rawMessages
+      .filter(entry => entry.type === 'user' || entry.type === 'assistant')
+      .map(entry => this._normalizeClaudeEntry(entry));
+
+    return this._paginateMessages(messages, limit, before, mode);
+  }
+
+  /**
+   * Normalize Claude Code session entry to message shape
+   */
+  _normalizeClaudeEntry(entry) {
+    // Extract content - handle both string and array of content blocks
+    let content = '';
+    const rawContent = entry.message?.content;
+
+    if (typeof rawContent === 'string') {
+      content = rawContent;
+    } else if (Array.isArray(rawContent)) {
+      // Claude Code uses array of content blocks: [{type: 'text', text: '...'}, ...]
+      content = rawContent
+        .filter(block => block.type === 'text' && block.text)
+        .map(block => block.text)
+        .join('\n');
+    } else if (entry.display || entry.text) {
+      // Fallback for older formats
+      content = entry.display || entry.text || '';
+    }
+
+    const role = entry.message?.role || entry.type || 'assistant';
+    const created_at = new Date(entry.timestamp).getTime() || Date.now();
+
+    return {
+      id: entry.message?.id || `claude-${created_at}`,
+      role,
+      content,
+      engine: 'claude',
+      created_at,
+      metadata: {
+        model: entry.message?.model,
+        stop_reason: entry.message?.stop_reason
+      }
+    };
+  }
+
+  // ============================================================
+  // CODEX - Load from ~/.codex/sessions/<sessionId>.jsonl
+  // ============================================================
+
+  async loadCodexMessages({ sessionId, limit, before, mode }) {
+    const sessionFile = path.join(this.codexPath, 'sessions', `${sessionId}.jsonl`);
+
+    // Codex may not persist sessions locally - check if file exists
+    if (!fs.existsSync(sessionFile)) {
+      // This is expected - Codex exec mode doesn't save history locally
+      console.log(`[CliLoader] Codex session file not found (expected): ${sessionFile}`);
+      return this._emptyResult();
+    }
+
+    const rawMessages = await this._parseJsonlFile(sessionFile);
+
+    // Filter and normalize
+    const messages = rawMessages
+      .filter(entry => entry.role === 'user' || entry.role === 'assistant')
+      .map(entry => this._normalizeCodexEntry(entry));
+
+    return this._paginateMessages(messages, limit, before, mode);
+  }
+
+  /**
+   * Normalize Codex session entry to message shape
+   */
+  _normalizeCodexEntry(entry) {
+    const role = entry.role || 'assistant';
+    const created_at = entry.timestamp ? new Date(entry.timestamp).getTime() : Date.now();
+
+    // Codex may store content as string or object
+    let content = '';
+    if (typeof entry.content === 'string') {
+      content = entry.content;
+    } else if (entry.message) {
+      content = typeof entry.message === 'string' ? entry.message : JSON.stringify(entry.message);
+    }
+
+    return {
+      id: entry.id || `codex-${created_at}`,
+      role,
+      content,
+      engine: 'codex',
+      created_at,
+      metadata: {
+        model: entry.model,
+        reasoning_effort: entry.reasoning_effort
+      }
+    };
+  }
+
+  // ============================================================
+  // GEMINI - Load from ~/.gemini/sessions/<sessionId>.jsonl
+  // ============================================================
+
+  async loadGeminiMessages({ sessionId, limit, before, mode }) {
+    const sessionFile = path.join(this.geminiPath, 'sessions', `${sessionId}.jsonl`);
+
+    // Gemini CLI may not save sessions - check if file exists
+    if (!fs.existsSync(sessionFile)) {
+      console.log(`[CliLoader] Gemini session file not found: ${sessionFile}`);
+      return this._emptyResult();
+    }
+
+    const rawMessages = await this._parseJsonlFile(sessionFile);
+
+    // Filter and normalize
+    const messages = rawMessages
+      .filter(entry => entry.role === 'user' || entry.role === 'model' || entry.role === 'assistant')
+      .map(entry => this._normalizeGeminiEntry(entry));
+
+    return this._paginateMessages(messages, limit, before, mode);
+  }
+
+  /**
+   * Normalize Gemini session entry to message shape
+   */
+  _normalizeGeminiEntry(entry) {
+    // Gemini uses 'model' instead of 'assistant'
+    const role = entry.role === 'model' ? 'assistant' : (entry.role || 'assistant');
+    const created_at = entry.timestamp ? new Date(entry.timestamp).getTime() : Date.now();
+
+    // Gemini content format
+    let content = '';
+    if (typeof entry.content === 'string') {
+      content = entry.content;
+    } else if (Array.isArray(entry.parts)) {
+      // Gemini uses parts array: [{text: '...'}]
+      content = entry.parts
+        .filter(p => p.text)
+        .map(p => p.text)
+        .join('\n');
+    } else if (entry.text) {
+      content = entry.text;
+    }
+
+    return {
+      id: entry.id || `gemini-${created_at}`,
+      role,
+      content,
+      engine: 'gemini',
+      created_at,
+      metadata: {
+        model: entry.model
+      }
+    };
+  }
+
+  // ============================================================
+  // UTILITY METHODS
+  // ============================================================
+
+  /**
+   * Parse JSONL file line by line (memory efficient)
+   */
+  async _parseJsonlFile(filePath) {
+    const entries = [];
+
+    const fileStream = fs.createReadStream(filePath);
+    const rl = readline.createInterface({
+      input: fileStream,
+      crlfDelay: Infinity
+    });
+
+    for await (const line of rl) {
+      if (!line.trim()) continue;
+
+      try {
+        const entry = JSON.parse(line);
+        entries.push(entry);
+      } catch (e) {
+        // Skip malformed lines
+        console.warn(`[CliLoader] Skipping malformed JSON line in ${filePath}`);
+      }
+    }
+
+    return entries;
+  }
+
+  /**
+   * Apply pagination to messages array
+   */
+  _paginateMessages(messages, limit, before, mode) {
+    // Filter by timestamp if 'before' cursor provided
+    let filtered = messages;
+    if (before) {
+      filtered = messages.filter(m => m.created_at < Number(before));
+    }
+
+    // Sort newest first for pagination slicing
+    filtered.sort((a, b) => b.created_at - a.created_at);
+
+    // Apply limit
+    const page = filtered.slice(0, limit);
+    const hasMore = filtered.length > limit;
+    const oldestTimestamp = page.length ? page[page.length - 1].created_at : null;
+
+    // Return in requested order (default asc for UI rendering)
+    const ordered = mode === 'desc'
+      ? page
+      : [...page].sort((a, b) => a.created_at - b.created_at);
+
+    return {
+      messages: ordered,
+      pagination: {
+        hasMore,
+        oldestTimestamp,
+        total: messages.length
+      }
+    };
+  }
+
+  /**
+   * Return empty result structure
+   */
+  _emptyResult() {
+    return {
+      messages: [],
+      pagination: {
+        hasMore: false,
+        oldestTimestamp: null,
+        total: 0
+      }
+    };
+  }
+
+  /**
+   * Get session file path for an engine
+   * Useful for external checks
+   */
+  getSessionFilePath(sessionId, engine, workspacePath) {
+    const normalizedEngine = this._normalizeEngine(engine);
+
+    switch (normalizedEngine) {
+      case 'claude':
+        const slug = this.pathToSlug(workspacePath);
+        return path.join(this.claudePath, 'projects', slug, `${sessionId}.jsonl`);
+
+      case 'codex':
+        return path.join(this.codexPath, 'sessions', `${sessionId}.jsonl`);
+
+      case 'gemini':
+        return path.join(this.geminiPath, 'sessions', `${sessionId}.jsonl`);
+
+      default:
+        return null;
+    }
+  }
+}
+
+module.exports = CliLoader;