codedash-app 3.3.1 → 4.0.0

package/bin/cli.js

@@ -1,8 +1,9 @@
 #!/usr/bin/env node
 
-const { loadSessions } = require('../src/data');
+const { loadSessions, searchFullText, getSessionPreview, computeSessionCost } = require('../src/data');
 const { startServer } = require('../src/server');
 const { exportArchive, importArchive } = require('../src/migrate');
+const { convertSession } = require('../src/convert');
 
 const DEFAULT_PORT = 3847;
 const args = process.argv.slice(2);
@@ -57,6 +58,117 @@ switch (command) {
     break;
   }
 
+  case 'search':
+  case 'find': {
+    const query = args.slice(1).join(' ');
+    if (!query) {
+      console.error('  Usage: codedash search <query>');
+      process.exit(1);
+    }
+    const sessions = loadSessions();
+    const results = searchFullText(query, sessions);
+    if (results.length === 0) {
+      console.log(`\n  No results for "${query}"\n`);
+    } else {
+      console.log(`\n  \x1b[36m\x1b[1m${results.length} sessions\x1b[0m matching "${query}"\n`);
+      for (const r of results.slice(0, 15)) {
+        const s = sessions.find(x => x.id === r.sessionId);
+        const proj = s ? (s.project_short || '') : '';
+        const tool = s ? s.tool : '?';
+        const date = s ? s.last_time : '';
+        console.log(`  \x1b[1m${r.sessionId.slice(0, 12)}\x1b[0m  ${tool}  ${date}  \x1b[2m${proj}\x1b[0m`);
+        for (const m of r.matches.slice(0, 2)) {
+          const role = m.role === 'user' ? '\x1b[34mYOU\x1b[0m' : '\x1b[32mAI \x1b[0m';
+          console.log(`    ${role} ${m.snippet.replace(/\n/g, ' ').slice(0, 100)}`);
+        }
+      }
+      if (results.length > 15) console.log(`\n  \x1b[2m... and ${results.length - 15} more\x1b[0m`);
+      console.log('');
+    }
+    break;
+  }
+
+  case 'show': {
+    const sid = args[1];
+    if (!sid) {
+      console.error('  Usage: codedash show <session-id>');
+      process.exit(1);
+    }
+    const allS = loadSessions();
+    const session = allS.find(s => s.id === sid || s.id.startsWith(sid));
+    if (!session) {
+      console.error(`  Session not found: ${sid}`);
+      process.exit(1);
+    }
+    const preview = getSessionPreview(session.id, session.project, 20);
+    const cost = computeSessionCost(session.id, session.project);
+
+    console.log('');
+    console.log(`  \x1b[36m\x1b[1mSession ${session.id}\x1b[0m`);
+    console.log(`  Tool:    ${session.tool}`);
+    console.log(`  Project: ${session.project_short || session.project || 'unknown'}`);
+    console.log(`  Started: ${session.first_time}`);
+    console.log(`  Last:    ${session.last_time}`);
+    console.log(`  Msgs:    ${session.messages} inputs, ${session.detail_messages || 0} total`);
+    if (cost.cost > 0) {
+      console.log(`  Cost:    $${cost.cost.toFixed(2)} (${cost.model || 'unknown'})`);
+      console.log(`  Tokens:  ${(cost.inputTokens/1000).toFixed(0)}K in / ${(cost.outputTokens/1000).toFixed(0)}K out`);
+    }
+    console.log('');
+
+    if (preview.length > 0) {
+      console.log('  \x1b[1mConversation:\x1b[0m');
+      for (const m of preview) {
+        const role = m.role === 'user' ? '\x1b[34mYOU\x1b[0m' : '\x1b[32mAI \x1b[0m';
+        const text = m.content.replace(/\n/g, ' ').slice(0, 120);
+        console.log(`  ${role} ${text}`);
+      }
+      console.log('');
+    }
+
+    console.log(`  Resume: \x1b[2m${session.tool === 'codex' ? 'codex resume' : 'claude --resume'} ${session.id}\x1b[0m`);
+    console.log('');
+    break;
+  }
+
+  case 'convert': {
+    const sid = args[1];
+    const target = args[2]; // 'claude' or 'codex'
+    if (!sid || !target) {
+      console.log(`
+  \x1b[36m\x1b[1mConvert session between agents\x1b[0m
+
+  Usage: codedash convert <session-id> <target-format>
+
+  Formats: claude, codex
+
+  Examples:
+    codedash convert 019d54ed codex     Convert Claude session to Codex
+    codedash convert 13ae5748 claude    Convert Codex session to Claude
+`);
+      break;
+    }
+    // Find full session ID
+    const allConv = loadSessions();
+    const match = allConv.find(s => s.id === sid || s.id.startsWith(sid));
+    if (!match) {
+      console.error(`  Session not found: ${sid}`);
+      process.exit(1);
+    }
+    console.log(`\n  Converting ${match.tool} session \x1b[1m${match.id.slice(0, 12)}\x1b[0m → ${target}...`);
+    const result = convertSession(match.id, match.project, target);
+    if (!result.ok) {
+      console.error(`  \x1b[31mError:\x1b[0m ${result.error}\n`);
+      process.exit(1);
+    }
+    console.log(`  \x1b[32mDone!\x1b[0m`);
+    console.log(`  New session: ${result.target.sessionId}`);
+    console.log(`  Messages:    ${result.target.messages}`);
+    console.log(`  File:        ${result.target.file}`);
+    console.log(`  Resume:      \x1b[2m${result.target.resumeCmd}\x1b[0m\n`);
+    break;
+  }
+
   case 'update':
   case 'upgrade': {
     const { execSync: execU } = require('child_process');
@@ -137,13 +249,16 @@ switch (command) {
 
   \x1b[1mUsage:\x1b[0m
     codedash run [port] [--no-browser]   Start the dashboard server
-    codedash update                      Update to latest version
-    codedash restart [--port=N]          Restart the server
-    codedash stop [--port=N]             Stop the server
+    codedash search <query>              Search across all session messages
+    codedash show <session-id>           Show session details + messages
     codedash list [limit]                List sessions in terminal
     codedash stats                       Show session statistics
+    codedash convert <id> <format>       Convert session (claude/codex)
     codedash export [file.tar.gz]        Export all sessions to archive
     codedash import <file.tar.gz>        Import sessions from archive
+    codedash update                      Update to latest version
+    codedash restart [--port=N]          Restart the server
+    codedash stop [--port=N]             Stop the server
     codedash help                        Show this help
     codedash version                     Show version
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codedash-app",
-  "version": "3.3.1",
+  "version": "4.0.0",
   "description": "Termius-style browser dashboard for Claude Code sessions. View, search, resume, and delete sessions with a dark-themed UI.",
   "bin": {
     "codedash": "./bin/cli.js"

package/src/convert.js

@@ -0,0 +1,273 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const crypto = require('crypto');
+const { findSessionFile, extractContent, isSystemMessage } = require('./data');
+
+const CLAUDE_DIR = path.join(os.homedir(), '.claude');
+const CODEX_DIR = path.join(os.homedir(), '.codex');
+
+// ── Read session into canonical format ────────────────────
+
+function readSession(sessionId, project) {
+  const found = findSessionFile(sessionId, project);
+  if (!found) return null;
+
+  const messages = [];
+  const lines = fs.readFileSync(found.file, 'utf8').split('\n').filter(Boolean);
+  let sessionMeta = {};
+
+  for (const line of lines) {
+    try {
+      const entry = JSON.parse(line);
+
+      if (found.format === 'claude') {
+        if (entry.type === 'permission-mode') {
+          sessionMeta.permissionMode = entry.permissionMode;
+          sessionMeta.originalSessionId = entry.sessionId;
+        }
+        if (entry.type === 'user' || entry.type === 'assistant') {
+          const msg = entry.message || {};
+          let content = '';
+          if (typeof msg.content === 'string') {
+            content = msg.content;
+          } else if (Array.isArray(msg.content)) {
+            content = msg.content
+              .filter(b => b.type === 'text')
+              .map(b => b.text)
+              .join('\n');
+          }
+          if (!content || isSystemMessage(content)) continue;
+
+          messages.push({
+            role: entry.type === 'user' ? 'user' : 'assistant',
+            content: content,
+            timestamp: entry.timestamp || '',
+            model: msg.model || '',
+          });
+        }
+      } else {
+        // Codex
+        if (entry.type === 'session_meta' && entry.payload) {
+          sessionMeta.cwd = entry.payload.cwd;
+          sessionMeta.originalSessionId = entry.payload.id;
+        }
+        if (entry.type === 'response_item' && entry.payload) {
+          const role = entry.payload.role;
+          if (role !== 'user' && role !== 'assistant') continue;
+          const content = extractContent(entry.payload.content);
+          if (!content || isSystemMessage(content)) continue;
+
+          messages.push({
+            role: role,
+            content: content,
+            timestamp: entry.timestamp || '',
+            model: '',
+          });
+        }
+      }
+    } catch {}
+  }
+
+  return {
+    sourceFormat: found.format,
+    sourceFile: found.file,
+    sessionId: sessionId,
+    meta: sessionMeta,
+    messages: messages,
+  };
+}
+
+// ── Write as Claude Code session ──────────────────────────
+
+function writeClaude(canonical, targetProject) {
+  const newSessionId = crypto.randomUUID();
+  const projectKey = (targetProject || os.homedir()).replace(/[\/\.]/g, '-');
+  const projectDir = path.join(CLAUDE_DIR, 'projects', projectKey);
+
+  if (!fs.existsSync(projectDir)) {
+    fs.mkdirSync(projectDir, { recursive: true });
+  }
+
+  const outFile = path.join(projectDir, `${newSessionId}.jsonl`);
+  const cwd = targetProject || canonical.meta.cwd || os.homedir();
+  const lines = [];
+
+  // Permission mode entry
+  lines.push(JSON.stringify({
+    type: 'permission-mode',
+    permissionMode: 'default',
+    sessionId: newSessionId,
+  }));
+
+  let prevUuid = null;
+
+  for (const msg of canonical.messages) {
+    const uuid = crypto.randomUUID();
+    const entry = {
+      parentUuid: prevUuid,
+      isSidechain: false,
+      type: msg.role === 'user' ? 'user' : 'assistant',
+      uuid: uuid,
+      timestamp: msg.timestamp || new Date().toISOString(),
+      userType: 'external',
+      entrypoint: 'cli',
+      cwd: cwd,
+      sessionId: newSessionId,
+      version: '2.1.91',
+      gitBranch: 'main',
+    };
+
+    if (msg.role === 'user') {
+      entry.message = { role: 'user', content: msg.content };
+      entry.promptId = crypto.randomUUID();
+    } else {
+      entry.message = {
+        model: msg.model || 'claude-sonnet-4-6',
+        id: 'msg_converted_' + uuid.slice(0, 8),
+        type: 'message',
+        role: 'assistant',
+        content: [{ type: 'text', text: msg.content }],
+        stop_reason: 'end_turn',
+      };
+    }
+
+    lines.push(JSON.stringify(entry));
+    prevUuid = uuid;
+  }
+
+  // Write atomically
+  const tmpFile = outFile + '.tmp';
+  fs.writeFileSync(tmpFile, lines.join('\n') + '\n');
+  fs.renameSync(tmpFile, outFile);
+
+  // Add to history.jsonl
+  const historyFile = path.join(CLAUDE_DIR, 'history.jsonl');
+  const historyEntry = JSON.stringify({
+    sessionId: newSessionId,
+    project: cwd,
+    timestamp: Date.now(),
+    display: `[Converted from ${canonical.sourceFormat}] ${canonical.messages[0]?.content?.slice(0, 100) || ''}`,
+    pastedContents: {},
+  });
+  fs.appendFileSync(historyFile, historyEntry + '\n');
+
+  return {
+    sessionId: newSessionId,
+    file: outFile,
+    format: 'claude',
+    messages: canonical.messages.length,
+    resumeCmd: `claude --resume ${newSessionId}`,
+  };
+}
+
+// ── Write as Codex session ────────────────────────────────
+
+function writeCodex(canonical, targetProject) {
+  const newSessionId = crypto.randomUUID();
+  const now = new Date();
+  const dateDir = path.join(
+    CODEX_DIR, 'sessions',
+    String(now.getFullYear()),
+    String(now.getMonth() + 1).padStart(2, '0'),
+    String(now.getDate()).padStart(2, '0')
+  );
+
+  if (!fs.existsSync(dateDir)) {
+    fs.mkdirSync(dateDir, { recursive: true });
+  }
+
+  const fileName = `rollout-${now.toISOString().replace(/[:.]/g, '-').slice(0, 19)}-${newSessionId}.jsonl`;
+  const outFile = path.join(dateDir, fileName);
+  const cwd = targetProject || canonical.meta.cwd || os.homedir();
+  const lines = [];
+
+  // Session meta
+  lines.push(JSON.stringify({
+    timestamp: now.toISOString(),
+    type: 'session_meta',
+    payload: {
+      id: newSessionId,
+      timestamp: now.toISOString(),
+      cwd: cwd,
+      originator: 'codex_cli_rs',
+      cli_version: '0.101.0',
+      source: 'cli',
+      model_provider: 'openai',
+    },
+  }));
+
+  // Messages
+  for (const msg of canonical.messages) {
+    lines.push(JSON.stringify({
+      timestamp: msg.timestamp || now.toISOString(),
+      type: 'response_item',
+      payload: {
+        type: 'message',
+        role: msg.role,
+        content: [{ type: 'input_text', text: msg.content }],
+      },
+    }));
+  }
+
+  // Write atomically
+  const tmpFile = outFile + '.tmp';
+  fs.writeFileSync(tmpFile, lines.join('\n') + '\n');
+  fs.renameSync(tmpFile, outFile);
+
+  // Add to codex history
+  const historyFile = path.join(CODEX_DIR, 'history.jsonl');
+  if (!fs.existsSync(path.dirname(historyFile))) {
+    fs.mkdirSync(path.dirname(historyFile), { recursive: true });
+  }
+  const historyEntry = JSON.stringify({
+    session_id: newSessionId,
+    ts: Math.floor(Date.now() / 1000),
+    text: `[Converted from ${canonical.sourceFormat}] ${canonical.messages[0]?.content?.slice(0, 100) || ''}`,
+  });
+  fs.appendFileSync(historyFile, historyEntry + '\n');
+
+  return {
+    sessionId: newSessionId,
+    file: outFile,
+    format: 'codex',
+    messages: canonical.messages.length,
+    resumeCmd: `codex resume ${newSessionId}`,
+  };
+}
+
+// ── Main convert function ─────────────────────────────────
+
+function convertSession(sessionId, project, targetFormat) {
+  const canonical = readSession(sessionId, project);
+  if (!canonical) {
+    return { ok: false, error: 'Session not found' };
+  }
+
+  if (canonical.sourceFormat === targetFormat) {
+    return { ok: false, error: `Session is already in ${targetFormat} format` };
+  }
+
+  if (canonical.messages.length === 0) {
+    return { ok: false, error: 'Session has no messages to convert' };
+  }
+
+  let result;
+  if (targetFormat === 'claude') {
+    result = writeClaude(canonical, project);
+  } else if (targetFormat === 'codex') {
+    result = writeCodex(canonical, project);
+  } else {
+    return { ok: false, error: `Unknown target format: ${targetFormat}` };
+  }
+
+  return {
+    ok: true,
+    source: { format: canonical.sourceFormat, sessionId: sessionId, messages: canonical.messages.length },
+    target: result,
+  };
+}
+
+module.exports = { convertSession, readSession };

package/src/data.js

@@ -829,6 +829,9 @@ module.exports = {
   getCostAnalytics,
   computeSessionCost,
   MODEL_PRICING,
+  findSessionFile,
+  extractContent,
+  isSystemMessage,
   CLAUDE_DIR,
   CODEX_DIR,
   HISTORY_FILE,

package/src/frontend/app.js

@@ -1081,6 +1081,8 @@ async function openDetail(s) {
   if (s.has_detail) {
     infoHtml += '<button class="launch-btn btn-secondary" onclick="closeDetail();openReplay(\'' + s.id + '\',\'' + escHtml(s.project || '') + '\')">Replay</button>';
     infoHtml += '<button class="launch-btn btn-secondary" onclick="exportMd(\'' + s.id + '\',\'' + escHtml(s.project || '') + '\')">Export MD</button>';
+    var convertTarget = s.tool === 'codex' ? 'claude' : 'codex';
+    infoHtml += '<button class="launch-btn btn-secondary" onclick="convertTo(\'' + s.id + '\',\'' + escHtml(s.project || '') + '\',\'' + convertTarget + '\')">Convert to ' + convertTarget + '</button>';
   }
   infoHtml += '<button class="star-btn detail-star' + (isStarred ? ' active' : '') + '" onclick="toggleStar(\'' + s.id + '\')">&#9733; ' + (isStarred ? 'Starred' : 'Star') + '</button>';
   infoHtml += '<button class="launch-btn btn-delete" onclick="showDeleteConfirm(\'' + s.id + '\',\'' + escHtml(s.project || '') + '\')">Delete</button>';
@@ -1744,6 +1746,31 @@ function focusSession(sessionId) {
   });
 }
 
+// ── Convert session ───────────────────────────────────────────
+
+async function convertTo(sessionId, project, targetFormat) {
+  if (!confirm('Convert this session to ' + targetFormat + '? A new session will be created.')) return;
+  showToast('Converting...');
+  try {
+    var resp = await fetch('/api/convert', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ sessionId: sessionId, project: project, targetFormat: targetFormat }),
+    });
+    var data = await resp.json();
+    if (data.ok) {
+      showToast('Converted! New session: ' + data.target.sessionId.slice(0, 12));
+      // Refresh to show new session
+      await loadSessions();
+      closeDetail();
+    } else {
+      showToast('Error: ' + (data.error || 'unknown'));
+    }
+  } catch (e) {
+    showToast('Convert failed: ' + e.message);
+  }
+}
+
 // ── Install agents ────────────────────────────────────────────
 
 var AGENT_INSTALL = {

package/src/server.js

@@ -5,6 +5,7 @@ const { URL } = require('url');
 const { exec } = require('child_process');
 const { loadSessions, loadSessionDetail, deleteSession, getGitCommits, exportSessionMarkdown, getSessionPreview, searchFullText, getActiveSessions, getSessionReplay, getCostAnalytics, computeSessionCost } = require('./data');
 const { detectTerminals, openInTerminal, focusTerminalByPid } = require('./terminals');
+const { convertSession } = require('./convert');
 const { getHTML } = require('./html');
 
 function startServer(port, openBrowser = true) {
@@ -110,6 +111,19 @@ function startServer(port, openBrowser = true) {
       json(res, active);
     }
 
+    // ── Convert session ─────────────────────
+    else if (req.method === 'POST' && pathname === '/api/convert') {
+      readBody(req, body => {
+        try {
+          const { sessionId, project, targetFormat } = JSON.parse(body);
+          const result = convertSession(sessionId, project || '', targetFormat);
+          json(res, result);
+        } catch (e) {
+          json(res, { ok: false, error: e.message }, 400);
+        }
+      });
+    }
+
     // ── Focus terminal ──────────────────────
     else if (req.method === 'POST' && pathname === '/api/focus') {
       readBody(req, body => {