tpc-explorer 1.0.0

package/index.js

@@ -0,0 +1,951 @@
+#!/usr/bin/env node
+const blessed = require('blessed');
+const contrib = require('blessed-contrib');
+const fs = require('fs-extra');
+const path = require('path');
+const highlight = require('cli-highlight').highlight;
+const pty = require('node-pty');
+const { execSync } = require('child_process');
+const os = require('os');
+
+// ── Tokyo Night Storm Theme ─────────────────────────────────────────────
+const theme = {
+  bg: '#1a1b26',
+  sidebar: '#16161e',
+  accent: '#7aa2f7',
+  accentDim: '#3d59a1',
+  text: '#a9b1d6',
+  textDim: '#565f89',
+  textBright: '#c0caf5',
+  border: '#292e42',
+  borderFocus: '#7aa2f7',
+  green: '#9ece6a',
+  red: '#f7768e',
+  yellow: '#e0af68',
+  purple: '#bb9af7',
+  cyan: '#7dcfff',
+  orange: '#ff9e64'
+};
+
+// ── Emoji Icons ─────────────────────────────────────────────────────────
+const fileIconMap = {
+  js: '⬡ ', jsx: '⬡ ', mjs: '⬡ ', cjs: '⬡ ',
+  ts: '◇ ', tsx: '◇ ', mts: '◇ ',
+  html: '◈ ', htm: '◈ ',
+  css: '◉ ', scss: '◉ ', sass: '◉ ', less: '◉ ',
+  vue: '▲ ', svelte: '◆ ',
+  json: '{ }', yaml: '≡ ', yml: '≡ ', toml: '≡ ',
+  xml: '⟨⟩', csv: '⊞ ', env: '⚿ ', ini: '⚙ ',
+  py: '🐍', rb: '💎', go: '◆ ', rs: '⚙ ',
+  java: '☕', kt: '◆ ', scala: '◆ ',
+  c: 'C ', cpp: '⊕ ', h: 'H ', hpp: '⊕ ',
+  cs: '# ', swift: '◇ ', php: '⟠ ', lua: '☾ ', r: 'R ',
+  sh: '▶ ', bash: '▶ ', zsh: '▶ ', fish: '▶ ', ps1: '▶ ',
+  md: '⊹ ', mdx: '⊹ ', txt: '⊡ ', rst: '⊹ ',
+  pdf: '◰ ', doc: '◰ ', docx: '◰ ',
+  png: '◧ ', jpg: '◧ ', jpeg: '◧ ', gif: '◧ ',
+  svg: '◈ ', ico: '◧ ', webp: '◧ ',
+  lock: '⊘ ', dockerfile: '🐳', gitignore: '⊙ ',
+};
+const fileColorMap = {
+  js: theme.yellow, jsx: theme.yellow, mjs: theme.yellow, cjs: theme.yellow,
+  ts: theme.cyan, tsx: theme.cyan, mts: theme.cyan,
+  html: theme.orange, htm: theme.orange,
+  css: theme.purple, scss: theme.purple, sass: theme.purple,
+  py: theme.green, go: theme.cyan, rs: theme.orange,
+  rb: theme.red, java: theme.orange,
+  json: theme.yellow, yaml: theme.green, yml: theme.green,
+  md: theme.cyan, mdx: theme.cyan,
+  sh: theme.green, bash: theme.green, zsh: theme.green,
+  lock: theme.textDim, svg: theme.purple, vue: theme.green,
+  c: theme.cyan, cpp: theme.cyan, h: theme.purple,
+};
+
+function hexToAnsi(hex) {
+  if (!hex || hex[0] !== '#') return '';
+  const r = parseInt(hex.slice(1, 3), 16);
+  const g = parseInt(hex.slice(3, 5), 16);
+  const b = parseInt(hex.slice(5, 7), 16);
+  return `\x1b[38;2;${r};${g};${b}m`;
+}
+
+function getFileIcon(filename, isDir) {
+  if (isDir) return `${hexToAnsi(theme.accent)}▸ \x1b[0m`;
+  const ext = path.extname(filename).slice(1).toLowerCase();
+  const baseName = filename.toLowerCase();
+  if (baseName === 'dockerfile') return `${hexToAnsi(theme.cyan)}🐳\x1b[0m`;
+  if (baseName === '.gitignore') return `${hexToAnsi(theme.orange)}⊙ \x1b[0m`;
+  if (baseName === 'package.json') return `${hexToAnsi(theme.green)}⬢ \x1b[0m`;
+  if (baseName === 'tsconfig.json') return `${hexToAnsi(theme.cyan)}◇ \x1b[0m`;
+  const icon = fileIconMap[ext] || '⊡ ';
+  const color = fileColorMap[ext] || theme.textDim;
+  return `${hexToAnsi(color)}${icon}\x1b[0m`;
+}
+
+// ── Session History Loading ─────────────────────────────────────────────
+function loadSessions() {
+  const cwd = process.cwd();
+  const sessions = [];
+
+  // Claude sessions
+  const claudeProjectKey = cwd.replace(/\//g, '-');
+  const claudeDir = path.join(os.homedir(), '.claude', 'projects', claudeProjectKey);
+  if (fs.existsSync(claudeDir)) {
+    const files = fs.readdirSync(claudeDir).filter(f => f.endsWith('.jsonl'));
+    for (const f of files) {
+      try {
+        const fullPath = path.join(claudeDir, f);
+        const stat = fs.statSync(fullPath);
+        const lines = fs.readFileSync(fullPath, 'utf-8').trim().split('\n');
+        let firstMsg = '';
+        for (const line of lines) {
+          try {
+            const obj = JSON.parse(line);
+            if (obj.type === 'user' && obj.message?.content && !firstMsg) {
+              const c = typeof obj.message.content === 'string' ? obj.message.content : '';
+              firstMsg = c.replace(/<[^>]+>/g, '').trim().slice(0, 50) || '(command)';
+            }
+          } catch (e) {}
+        }
+        sessions.push({
+          type: 'claude',
+          id: f.replace('.jsonl', ''),
+          modified: stat.mtime,
+          summary: firstMsg || '(empty)',
+          messages: lines.length,
+        });
+      } catch (e) {}
+    }
+  }
+
+  // Codex sessions — scan for sessions whose cwd matches
+  const codexBaseDir = path.join(os.homedir(), '.codex', 'sessions');
+  if (fs.existsSync(codexBaseDir)) {
+    try {
+      const walkCodex = (dir) => {
+        const entries = fs.readdirSync(dir);
+        for (const entry of entries) {
+          const full = path.join(dir, entry);
+          const st = fs.statSync(full);
+          if (st.isDirectory()) { walkCodex(full); continue; }
+          if (!entry.endsWith('.jsonl')) continue;
+          try {
+            const firstLine = fs.readFileSync(full, 'utf-8').split('\n')[0];
+            const meta = JSON.parse(firstLine);
+            if (meta.type === 'session_meta' && meta.payload?.cwd === cwd) {
+              sessions.push({
+                type: 'codex',
+                id: meta.payload.id,
+                modified: new Date(meta.payload.timestamp || st.mtime),
+                summary: `Codex ${meta.payload.cli_version || ''}`.trim(),
+                messages: 0,
+                filePath: full,
+              });
+            }
+          } catch (e) {}
+        }
+      };
+      walkCodex(codexBaseDir);
+    } catch (e) {}
+  }
+
+  // Sort newest first
+  sessions.sort((a, b) => b.modified - a.modified);
+  return sessions;
+}
+
+function formatSessionItem(s) {
+  const icon = s.type === 'claude' ? `${hexToAnsi(theme.orange)}◆\x1b[0m` : `${hexToAnsi(theme.green)}⊞\x1b[0m`;
+  const age = formatAge(s.modified);
+  const dim = hexToAnsi(theme.textDim);
+  const text = s.summary.slice(0, 25);
+  return `${icon} ${text} ${dim}${age}\x1b[0m`;
+}
+
+function formatAge(date) {
+  const ms = Date.now() - date.getTime();
+  const mins = Math.floor(ms / 60000);
+  if (mins < 1) return 'now';
+  if (mins < 60) return `${mins}m`;
+  const hrs = Math.floor(mins / 60);
+  if (hrs < 24) return `${hrs}h`;
+  const days = Math.floor(hrs / 24);
+  return `${days}d`;
+}
+
+// ── AI Session Pool State (declared early for use in updateStatusBar) ───
+let liveSessions = [];
+let activeSessionIdx = -1;
+let viewMode = 'file';
+
+// ── Screen Setup ────────────────────────────────────────────────────────
+const screen = blessed.screen({
+  smartCSR: true,
+  title: 'TPC Explorer Pro',
+  fullUnicode: true,
+  mouse: true,
+  style: { bg: theme.bg }
+});
+
+const grid = new contrib.grid({ rows: 12, cols: 12, screen: screen });
+
+// ── Widgets ─────────────────────────────────────────────────────────────
+const tree = grid.set(0, 0, 7, 3, contrib.tree, {
+  label: ' ⊟ EXPLORER ',
+  mouse: true,
+  style: {
+    fg: theme.text,
+    bg: theme.sidebar,
+    selected: { bg: theme.accentDim, fg: theme.textBright },
+    label: { fg: theme.accent }
+  },
+  border: { type: 'line', fg: theme.border },
+  template: { extend: '  ', retract: '  ' },
+  padding: { left: 1 }
+});
+
+const historyList = grid.set(7, 0, 4, 3, blessed.list, {
+  label: ' ◆ SESSIONS ',
+  mouse: true,
+  keys: true,
+  tags: false,
+  scrollable: true,
+  alwaysScroll: true,
+  scrollbar: { ch: '▐', style: { fg: theme.accentDim, bg: theme.sidebar } },
+  style: {
+    fg: theme.text,
+    bg: theme.sidebar,
+    selected: { bg: theme.accentDim, fg: theme.textBright },
+    label: { fg: theme.purple },
+    border: { fg: theme.border }
+  },
+  border: { type: 'line', fg: theme.border },
+  padding: { left: 1 }
+});
+
+const viewer = grid.set(0, 3, 11, 9, blessed.box, {
+  label: ' ◈ PREVIEW ',
+  mouse: true,
+  keys: true,
+  tags: false,
+  alwaysScroll: true,
+  scrollable: true,
+  scrollbar: { ch: '▐', style: { fg: theme.accentDim, bg: theme.bg } },
+  style: {
+    fg: theme.text,
+    bg: theme.bg,
+    label: { fg: theme.accent }
+  },
+  border: { type: 'line', fg: theme.border },
+  padding: { left: 1 }
+});
+
+const statusBar = grid.set(11, 0, 1, 12, blessed.box, {
+  tags: false,
+  style: { bg: theme.sidebar, fg: theme.text },
+  padding: { left: 1 }
+});
+updateStatusBar('normal');
+
+const prompt = blessed.prompt({
+  parent: screen, top: 'center', left: 'center', width: '50%', height: 'shrink',
+  border: 'line', label: ' Input ',
+  style: { border: { fg: theme.accent }, bg: theme.sidebar, fg: theme.text },
+  hidden: true
+});
+const question = blessed.question({
+  parent: screen, top: 'center', left: 'center', width: '50%', height: 'shrink',
+  border: 'line', label: ' Confirm ',
+  style: { border: { fg: theme.red }, bg: theme.sidebar, fg: theme.text },
+  hidden: true
+});
+
+// ── AI Picker ───────────────────────────────────────────────────────────
+const aiPicker = blessed.list({
+  parent: screen,
+  top: 'center',
+  left: 'center',
+  width: 42,
+  height: 8,
+  label: ` ◆ Launch AI Assistant `,
+  mouse: true,
+  keys: true,
+  tags: false,
+  border: { type: 'line', fg: theme.purple },
+  style: {
+    fg: theme.text,
+    bg: theme.sidebar,
+    selected: { bg: theme.accentDim, fg: theme.textBright },
+    label: { fg: theme.purple },
+    border: { fg: theme.purple }
+  },
+  padding: { left: 2, right: 2 },
+  items: [
+    `⬡  Claude Code`,
+    `⊞  OpenAI Codex`,
+  ],
+  hidden: true
+});
+
+// ── Session History ─────────────────────────────────────────────────────
+let sessionData = []; // Array of session objects
+let historyLineMap = []; // Maps list index → session object or null (for headers/empty)
+let sessionsLoaded = false; // Cache: only load from disk once per app run
+
+function refreshHistory(forceReload) {
+  const prevSelected = historyList.selected || 0;
+  if (!sessionsLoaded || forceReload) {
+    sessionData = loadSessions();
+    sessionsLoaded = true;
+  }
+  const claudeSessions = sessionData.filter(s => s.type === 'claude');
+  const codexSessions = sessionData.filter(s => s.type === 'codex');
+
+  const items = [];
+  historyLineMap = [];
+
+  // Claude section
+  items.push(`${hexToAnsi(theme.orange)}\x1b[1m◆ Claude\x1b[0m`);
+  historyLineMap.push(null);
+  if (claudeSessions.length > 0) {
+    for (const s of claudeSessions) {
+      items.push(` ${formatSessionItem(s)}`);
+      historyLineMap.push(s);
+    }
+  } else {
+    items.push(`  ${hexToAnsi(theme.textDim)}(none)\x1b[0m`);
+    historyLineMap.push(null);
+  }
+
+  // Codex section
+  items.push(`${hexToAnsi(theme.green)}\x1b[1m⊞ Codex\x1b[0m`);
+  historyLineMap.push(null);
+  if (codexSessions.length > 0) {
+    for (const s of codexSessions) {
+      items.push(` ${formatSessionItem(s)}`);
+      historyLineMap.push(s);
+    }
+  } else {
+    items.push(`  ${hexToAnsi(theme.textDim)}(none)\x1b[0m`);
+    historyLineMap.push(null);
+  }
+
+  historyList.setItems(items);
+  historyList.select(Math.min(prevSelected, items.length - 1));
+  screen.render();
+}
+
+// Resume a session from the history list
+historyList.on('select', (item, index) => {
+  const session = historyLineMap[index];
+  if (!session) return; // header or (none) line
+  if (session.type === 'claude') {
+    launchAIWithArgs('claude', ['--resume', session.id], 'Claude Code');
+  } else {
+    launchAIWithArgs('codex', ['resume', session.id], 'OpenAI Codex');
+  }
+});
+
+// ── File Tree Logic ─────────────────────────────────────────────────────
+function getFiles(dir) {
+  const result = { name: path.basename(dir) || dir, children: {}, path: dir, extended: true };
+  try {
+    const items = fs.readdirSync(dir);
+    items.sort((a, b) => {
+      try {
+        const aIsDir = fs.statSync(path.join(dir, a)).isDirectory();
+        const bIsDir = fs.statSync(path.join(dir, b)).isDirectory();
+        if (aIsDir && !bIsDir) return -1;
+        if (!aIsDir && bIsDir) return 1;
+      } catch (e) {}
+      return a.localeCompare(b);
+    }).forEach(item => {
+      if (item.startsWith('.') || item === 'node_modules' || item === 'dist' || item === '.git') return;
+      const fullPath = path.join(dir, item);
+      let isDir = false;
+      try { isDir = fs.statSync(fullPath).isDirectory(); } catch (e) { return; }
+      const displayName = `${getFileIcon(item, isDir)} ${item}`;
+
+      if (isDir) {
+        result.children[displayName] = { name: displayName, path: fullPath, children: {} };
+        try {
+          const subItems = fs.readdirSync(fullPath);
+          subItems.forEach(sub => {
+            if (!sub.startsWith('.')) {
+              try {
+                const subStat = fs.statSync(path.join(fullPath, sub));
+                const subDisplayName = `${getFileIcon(sub, subStat.isDirectory())} ${sub}`;
+                result.children[displayName].children[subDisplayName] = { name: subDisplayName, path: path.join(fullPath, sub) };
+              } catch (e) {}
+            }
+          });
+        } catch (e) {}
+      } else {
+        result.children[displayName] = { name: displayName, path: fullPath };
+      }
+    });
+  } catch (err) {}
+  return result;
+}
+
+let isRefreshing = false;
+function refreshTree() {
+  isRefreshing = true;
+  const data = getFiles(process.cwd());
+  tree.setData(data);
+  isRefreshing = false;
+  screen.render();
+}
+
+// ── Line Numbers ────────────────────────────────────────────────────────
+function addLineNumbers(text) {
+  const lines = text.split('\n');
+  const gutterWidth = String(lines.length).length;
+  const dim = hexToAnsi('#565f89');
+  const sep = hexToAnsi('#292e42');
+  return lines.map((line, i) => {
+    const num = String(i + 1).padStart(gutterWidth);
+    return `${dim}${num} ${sep}│\x1b[0m ${line}`;
+  }).join('\n');
+}
+
+// ── Viewer Update ───────────────────────────────────────────────────────
+let lastPath = null;
+function updateViewer(nodePath) {
+  if (!nodePath || !fs.existsSync(nodePath) || nodePath === lastPath) return;
+  lastPath = nodePath;
+
+  viewer.setContent('');
+  viewer.scrollTo(0);
+  screen.realloc();
+
+  try {
+    const stat = fs.statSync(nodePath);
+    if (stat.isFile()) {
+      const sizeKB = (stat.size / 1024).toFixed(1);
+      const content = fs.readFileSync(nodePath, 'utf-8');
+      const ext = path.extname(nodePath).slice(1);
+      const lineCount = content.split('\n').length;
+      const highlighted = highlight(content, { language: ext, ignoreIllegals: true });
+      viewer.setContent(addLineNumbers(highlighted));
+      const icon = getFileIcon(path.basename(nodePath), false);
+      const dim = hexToAnsi('#565f89');
+      viewer.setLabel(` ${icon} ${path.basename(nodePath)}  ${dim}${lineCount} lines │ ${sizeKB} KB\x1b[0m `);
+    } else if (stat.isDirectory()) {
+      const items = fs.readdirSync(nodePath);
+      const dirIcon = `${hexToAnsi(theme.accent)}▾ \x1b[0m`;
+      let content = `\n  ${dirIcon}${hexToAnsi(theme.accent)}\x1b[1m${path.basename(nodePath)}\x1b[0m\n`;
+      content += `  ${hexToAnsi('#292e42')}${'─'.repeat(Math.min(50, path.basename(nodePath).length + 10))}\x1b[0m\n\n`;
+      const dirItems = items.filter(i => !i.startsWith('.')).sort((a, b) => {
+        try {
+          const aIsDir = fs.statSync(path.join(nodePath, a)).isDirectory();
+          const bIsDir = fs.statSync(path.join(nodePath, b)).isDirectory();
+          if (aIsDir && !bIsDir) return -1;
+          if (!aIsDir && bIsDir) return 1;
+        } catch (e) {}
+        return a.localeCompare(b);
+      });
+      dirItems.forEach(item => {
+        let subIsDir = false;
+        try { subIsDir = fs.statSync(path.join(nodePath, item)).isDirectory(); } catch (e) {}
+        content += `    ${getFileIcon(item, subIsDir)} ${item}\n`;
+      });
+      if (dirItems.length === 0) content += `    ${hexToAnsi('#565f89')}(Empty directory)\x1b[0m`;
+      viewer.setContent(content);
+      const dim = hexToAnsi('#565f89');
+      viewer.setLabel(` ${dirIcon}${path.basename(nodePath)}  ${dim}${dirItems.length} items\x1b[0m `);
+    }
+  } catch (err) {
+    viewer.setContent(`${hexToAnsi(theme.red)}⊘ Error:\x1b[0m ${err.message}`);
+  }
+
+  screen.render();
+}
+
+// ── Status Bar ──────────────────────────────────────────────────────────
+function updateStatusBar(mode) {
+  const sep = `${hexToAnsi('#292e42')}│\x1b[0m`;
+  const key = (k) => `\x1b[1m${hexToAnsi(theme.accent)}${k}\x1b[0m`;
+  const sessionCount = liveSessions.length;
+  const sessionHint = sessionCount > 0 ? `  ${sep}  ${key('Ctrl-A')} Sessions (${sessionCount})` : '';
+  const quit = `${key('Ctrl-D')} ${hexToAnsi(theme.red)}Quit All\x1b[0m`;
+  if (mode === 'ai') {
+    statusBar.setContent(
+      ` ${key('Ctrl-C')} Stop  ${sep}  ${key('Ctrl-T')} Switch  ${sep}  ${key('Ctrl-A')} Sessions (${sessionCount})  ${sep}  ${quit}`
+    );
+  } else {
+    statusBar.setContent(
+      ` ${key('n')} New  ${sep}  ${key('f')} Folder  ${sep}  ${key('d')} Del  ${sep}  ${key('r')} Refresh  ${sep}  ${key('Ctrl-T')} Switch  ${sep}  ${key('a')} AI${sessionHint}  ${sep}  ${quit}`
+    );
+  }
+}
+
+// ── xterm-headless ──────────────────────────────────────────────────────
+function cleanForBlessed(text) {
+  return text
+    .replace(/\x1b\[(\d+)C/g, (_, n) => ' '.repeat(parseInt(n)))
+    .replace(/\x1b\[\d*[ABDEFGHJKSTXZdf]/g, '')
+    .replace(/\x1b\[\?[0-9;]*[hl]/g, '')
+    .replace(/\x1b\[>[0-9;]*[a-zA-Z]/g, '')
+    .replace(/\x1b\[![a-zA-Z]/g, '')
+    .replace(/\x1b\][^\x07\x1b]*(?:\x07|\x1b\\)/g, '')
+    .replace(/\x1b[()][0-9A-B]/g, '')
+    .replace(/\x1b[=>78DEHM]/g, '')
+    .replace(/\r/g, '');
+}
+
+let xtermModules = null;
+function getXterm() {
+  if (!xtermModules) {
+    xtermModules = Promise.all([
+      import('@xterm/headless'),
+      import('@xterm/addon-serialize')
+    ]).then(([xtermMod, serMod]) => ({
+      Terminal: xtermMod.default.Terminal,
+      SerializeAddon: serMod.default.SerializeAddon
+    }));
+  }
+  return xtermModules;
+}
+getXterm();
+
+// ── AI Session Pool ─────────────────────────────────────────────────────
+// Each live session: { id, cmd, label, color, pty, xterm, serialize, ready, renderTimer }
+
+function getActiveSession() {
+  if (activeSessionIdx >= 0 && activeSessionIdx < liveSessions.length) return liveSessions[activeSessionIdx];
+  return null;
+}
+
+function showAIPicker() {
+  aiPicker.show();
+  aiPicker.focus();
+  screen.render();
+}
+
+function hideAIPicker() {
+  aiPicker.hide();
+  tree.rows.focus();
+  screen.render();
+}
+
+// Switch viewer to show a live session by index
+function switchToSession(idx) {
+  if (idx < 0 || idx >= liveSessions.length) return;
+  activeSessionIdx = idx;
+  viewMode = 'ai';
+  lastPath = null;
+  const s = liveSessions[idx];
+  viewer.setLabel(` ${hexToAnsi(s.color)}◆ ${s.label}\x1b[0m `);
+  viewer.style.border.fg = s.color;
+  if (s.xterm && s.serialize) {
+    viewer.setContent(cleanForBlessed(s.serialize.serialize()));
+  }
+  updateStatusBar('ai');
+  focusIndex = panels.indexOf('viewer');
+  tree.style.border.fg = theme.border;
+  historyList.style.border.fg = theme.border;
+  viewer.focus();
+  screen.render();
+}
+
+// ── Session Switcher Popup (Ctrl+A) ────────────────────────────────────
+const sessionSwitcher = blessed.list({
+  parent: screen,
+  top: 'center',
+  left: 'center',
+  width: 50,
+  height: 10,
+  label: ` ◆ Active Sessions `,
+  mouse: true,
+  keys: true,
+  tags: false,
+  border: { type: 'line', fg: theme.accent },
+  style: {
+    fg: theme.text,
+    bg: theme.sidebar,
+    selected: { bg: theme.accentDim, fg: theme.textBright },
+    label: { fg: theme.accent },
+    border: { fg: theme.accent }
+  },
+  padding: { left: 2, right: 2 },
+  hidden: true
+});
+
+function showSessionSwitcher() {
+  if (liveSessions.length === 0) return;
+  const items = liveSessions.map((s, i) => {
+    const marker = i === activeSessionIdx && viewMode === 'ai' ? `${hexToAnsi(theme.green)}▸\x1b[0m` : ' ';
+    return `${marker} ${hexToAnsi(s.color)}◆\x1b[0m ${s.label}`;
+  });
+  sessionSwitcher.setItems(items);
+  sessionSwitcher.select(activeSessionIdx >= 0 ? activeSessionIdx : 0);
+  sessionSwitcher.show();
+  sessionSwitcher.focus();
+  screen.render();
+}
+
+sessionSwitcher.on('select', (item, index) => {
+  sessionSwitcher.hide();
+  switchToSession(index);
+});
+
+sessionSwitcher.key(['escape', 'q', 'C-a'], () => {
+  sessionSwitcher.hide();
+  screen.render();
+});
+
+// Launch AI: new session
+async function launchAI(choice) {
+  hideAIPicker();
+  const cmd = choice === 0 ? 'claude' : 'codex';
+  const label = choice === 0 ? 'Claude Code' : 'OpenAI Codex';
+  await launchAIWithArgs(cmd, [], label);
+}
+
+// Launch AI: with arbitrary args (used for both new and resume)
+async function launchAIWithArgs(cmd, args, label) {
+  const cwd = process.cwd();
+
+  viewMode = 'ai';
+  lastPath = null;
+
+  viewer.setContent('');
+  viewer.scrollTo(0);
+  screen.realloc();
+
+  const headerColor = cmd === 'claude' ? theme.orange : theme.green;
+  viewer.setLabel(` ${hexToAnsi(headerColor)}◆ ${label}\x1b[0m `);
+  viewer.style.border.fg = headerColor;
+  updateStatusBar('ai');
+  screen.render();
+
+  const cols = Math.max(viewer.width - viewer.iwidth - 2, 40);
+  const rows = Math.max(viewer.height - viewer.iheight, 10);
+
+  const { Terminal, SerializeAddon } = await getXterm();
+  const xterm = new Terminal({ cols, rows, allowProposedApi: true });
+  const serialize = new SerializeAddon();
+  xterm.loadAddon(serialize);
+
+  let fullCmd;
+  try {
+    fullCmd = execSync(`which ${cmd}`, { encoding: 'utf-8' }).trim();
+  } catch (e) {
+    viewer.setContent(`\n  ${hexToAnsi(theme.red)}⊘ Error: "${cmd}" not found in PATH.\x1b[0m\n\n  Install it first, then try again.\n`);
+    viewMode = 'file';
+    xterm.dispose();
+    updateStatusBar('normal');
+    screen.render();
+    return;
+  }
+
+  let ptyProc;
+  try {
+    ptyProc = pty.spawn(fullCmd, args, {
+      name: 'xterm-256color',
+      cols, rows,
+      cwd: cwd,
+      env: { ...process.env, TERM: 'xterm-256color' }
+    });
+  } catch (e) {
+    viewer.setContent(`\n  ${hexToAnsi(theme.red)}⊘ Failed to launch "${cmd}":\x1b[0m\n\n  ${e.message}\n`);
+    viewMode = 'file';
+    xterm.dispose();
+    updateStatusBar('normal');
+    screen.render();
+    return;
+  }
+
+  // Create session object
+  const session = {
+    id: `${cmd}-${Date.now()}`,
+    cmd, label, color: headerColor,
+    pty: ptyProc, xterm, serialize,
+    ready: false, renderTimer: null
+  };
+  liveSessions.push(session);
+  activeSessionIdx = liveSessions.length - 1;
+
+  function renderXterm() {
+    if (!session.xterm || !session.serialize) return;
+    // Only update viewer if this session is the active one being shown
+    if (viewMode !== 'ai' || liveSessions[activeSessionIdx] !== session) return;
+    const raw = session.serialize.serialize();
+    viewer.setContent(cleanForBlessed(raw));
+    screen.render();
+  }
+
+  ptyProc.onData((data) => {
+    if (!session.ready) session.ready = true;
+    session.xterm.write(data, () => {
+      if (!session.renderTimer) {
+        session.renderTimer = setTimeout(() => {
+          session.renderTimer = null;
+          renderXterm();
+        }, 16);
+      }
+    });
+  });
+
+  ptyProc.onExit(({ exitCode }) => {
+    if (session.renderTimer) { clearTimeout(session.renderTimer); session.renderTimer = null; }
+
+    // Remove from live sessions
+    const idx = liveSessions.indexOf(session);
+    if (idx !== -1) {
+      liveSessions.splice(idx, 1);
+      // Adjust activeSessionIdx
+      if (liveSessions.length === 0) {
+        activeSessionIdx = -1;
+        viewMode = 'file';
+        viewer.style.border.fg = theme.border;
+        viewer.setLabel(' ◈ PREVIEW ');
+        updateStatusBar('normal');
+      } else if (activeSessionIdx >= liveSessions.length) {
+        activeSessionIdx = liveSessions.length - 1;
+      }
+    }
+
+    // Show final output if this was the displayed session
+    if (viewMode === 'ai' && activeSessionIdx >= 0) {
+      switchToSession(activeSessionIdx);
+    }
+
+    session.xterm.dispose();
+    session.xterm = null;
+    session.serialize = null;
+    session.pty = null;
+
+    refreshHistory();
+    screen.render();
+  });
+
+  viewer.focus();
+  focusIndex = panels.indexOf('viewer');
+  viewer.style.border.fg = headerColor;
+  tree.style.border.fg = theme.border;
+  historyList.style.border.fg = theme.border;
+  screen.render();
+}
+
+function stopActiveSession() {
+  const s = getActiveSession();
+  if (s && s.pty) {
+    s.pty.kill();
+  }
+}
+
+// Forward keyboard input to active AI session
+viewer.on('keypress', (ch, key) => {
+  const s = getActiveSession();
+  if (!s || !s.pty || !s.ready || viewMode !== 'ai') return;
+  if (key) {
+    if (key.name === 'return') { s.pty.write('\r'); }
+    else if (key.name === 'backspace') { s.pty.write('\x7f'); }
+    else if (key.name === 'escape') { s.pty.write('\x1b'); }
+    else if (key.name === 'up') { s.pty.write('\x1b[A'); }
+    else if (key.name === 'down') { s.pty.write('\x1b[B'); }
+    else if (key.name === 'right') { s.pty.write('\x1b[C'); }
+    else if (key.name === 'left') { s.pty.write('\x1b[D'); }
+    else if (key.ctrl && key.name === 'c') { s.pty.write('\x03'); }
+    else if (key.ctrl && key.name === 'd') { s.pty.write('\x04'); }
+    else if (key.ctrl && key.name === 'l') { s.pty.write('\x0c'); }
+    else if (key.ctrl && key.name === 'z') { s.pty.write('\x1a'); }
+    else if (ch) { s.pty.write(ch); }
+  } else if (ch) {
+    s.pty.write(ch);
+  }
+});
+
+aiPicker.on('select', (item, index) => {
+  launchAI(index);
+});
+
+aiPicker.key(['escape', 'q'], () => {
+  hideAIPicker();
+});
+
+// ── Event Handlers ──────────────────────────────────────────────────────
+tree.on('select', (node) => {
+  if (node.path) {
+    viewMode = 'file';
+    updateViewer(node.path);
+  }
+});
+
+tree.rows.on('scroll', () => {
+  if (isRefreshing) return;
+  const node = tree.nodeLines[tree.rows.selected];
+  if (node && node.path) {
+    viewMode = 'file';
+    updateViewer(node.path);
+  }
+});
+
+tree.rows.key(['n'], () => {
+  prompt.input('New file name:', '', (err, value) => {
+    if (value) { try { fs.ensureFileSync(path.join(process.cwd(), value)); refreshTree(); } catch (e) {} }
+    tree.rows.focus();
+    screen.render();
+  });
+});
+
+tree.rows.key(['f'], () => {
+  prompt.input('New folder name:', '', (err, value) => {
+    if (value) { try { fs.ensureDirSync(path.join(process.cwd(), value)); refreshTree(); } catch (e) {} }
+    tree.rows.focus();
+    screen.render();
+  });
+});
+
+tree.rows.key(['d', 'delete'], () => {
+  const node = tree.nodeLines[tree.rows.selected];
+  if (node && node.path) {
+    question.ask(`Delete ${path.basename(node.path)}? (y/n)`, (err, data) => {
+      if (data) { try { fs.removeSync(node.path); lastPath = null; viewer.setContent(''); refreshTree(); } catch (e) {} }
+      tree.rows.focus();
+      screen.render();
+    });
+  }
+});
+
+screen.key(['a'], () => {
+  if (!aiPicker.hidden || !sessionSwitcher.hidden) return;
+  if (panels[focusIndex] === 'viewer' && viewMode === 'ai') return; // don't trigger while typing in AI
+  showAIPicker();
+});
+
+screen.key(['C-a'], () => {
+  if (!aiPicker.hidden) return;
+  if (!sessionSwitcher.hidden) { sessionSwitcher.hide(); screen.render(); return; }
+  if (liveSessions.length > 0) {
+    showSessionSwitcher();
+  }
+});
+
+screen.key(['r'], () => {
+  if (!aiPicker.hidden || !sessionSwitcher.hidden) return;
+  if (panels[focusIndex] === 'viewer' && viewMode === 'ai') return;
+  lastPath = null;
+  screen.realloc();
+  refreshTree();
+  refreshHistory(true);
+});
+
+// Tab cycles: tree → history → viewer → tree
+const panels = ['tree', 'history', 'viewer'];
+let focusIndex = 0;
+
+function setFocusPanel(idx) {
+  focusIndex = idx;
+  // Reset all borders
+  tree.style.border.fg = theme.border;
+  historyList.style.border.fg = theme.border;
+  viewer.style.border.fg = theme.border;
+
+  if (panels[idx] === 'tree') {
+    tree.rows.focus();
+    tree.style.border.fg = theme.borderFocus;
+    updateStatusBar('normal');
+  } else if (panels[idx] === 'history') {
+    refreshHistory(true); // reload from disk to catch external sessions
+    historyList.focus();
+    historyList.style.border.fg = theme.purple;
+    updateStatusBar('normal');
+  } else {
+    viewer.focus();
+    const s = getActiveSession();
+    if (s && s.pty) {
+      // Restore AI terminal view
+      viewMode = 'ai';
+      lastPath = null;
+      viewer.style.border.fg = s.color;
+      viewer.setLabel(` ${hexToAnsi(s.color)}◆ ${s.label}\x1b[0m `);
+      if (s.xterm && s.serialize) {
+        viewer.setContent(cleanForBlessed(s.serialize.serialize()));
+      }
+      updateStatusBar('ai');
+    } else {
+      viewer.style.border.fg = theme.borderFocus;
+      updateStatusBar('normal');
+    }
+  }
+  screen.render();
+}
+
+screen.key(['C-t'], () => {
+  if (!aiPicker.hidden || !sessionSwitcher.hidden) return;
+  focusIndex = (focusIndex + 1) % panels.length;
+  setFocusPanel(focusIndex);
+});
+
+screen.key(['tab'], () => {
+  if (!aiPicker.hidden || !sessionSwitcher.hidden) return;
+  // When AI is active and viewer is focused, forward tab to pty
+  const s = getActiveSession();
+  if (s && s.pty && s.ready && viewMode === 'ai' && panels[focusIndex] === 'viewer') {
+    s.pty.write('\t');
+    return;
+  }
+  focusIndex = (focusIndex + 1) % panels.length;
+  setFocusPanel(focusIndex);
+});
+
+screen.key(['escape'], () => {
+  if (!sessionSwitcher.hidden) { sessionSwitcher.hide(); screen.render(); return; }
+  if (!aiPicker.hidden) { hideAIPicker(); return; }
+  const s = getActiveSession();
+  if (s && s.pty && viewMode === 'ai' && panels[focusIndex] === 'viewer') { s.pty.write('\x1b'); return; }
+  process.exit(0);
+});
+
+screen.key(['q'], () => {
+  if (!aiPicker.hidden || !sessionSwitcher.hidden) return;
+  if (viewMode === 'ai' && panels[focusIndex] === 'viewer') return;
+  process.exit(0);
+});
+
+screen.key(['C-c'], () => {
+  const s = getActiveSession();
+  if (s && s.pty && viewMode === 'ai' && panels[focusIndex] === 'viewer') { s.pty.write('\x03'); return; }
+  process.exit(0);
+});
+
+// Ctrl-D: kill ALL live sessions and quit immediately
+screen.key(['C-d'], () => {
+  for (const s of liveSessions) {
+    if (s.pty) { try { s.pty.kill(); } catch (e) {} }
+    if (s.xterm) { try { s.xterm.dispose(); } catch (e) {} }
+  }
+  liveSessions = [];
+  process.exit(0);
+});
+
+// Double Ctrl-C to force quit active AI session
+let lastCtrlC = 0;
+screen.on('keypress', (ch, key) => {
+  const s = getActiveSession();
+  if (key && key.ctrl && key.name === 'c' && s && s.pty && viewMode === 'ai' && panels[focusIndex] === 'viewer') {
+    const now = Date.now();
+    if (now - lastCtrlC < 500) {
+      stopActiveSession();
+    }
+    lastCtrlC = now;
+  }
+});
+
+screen.on('resize', () => {
+  const cols = Math.max(viewer.width - viewer.iwidth - 2, 40);
+  const rows = Math.max(viewer.height - viewer.iheight, 10);
+  // Resize ALL live sessions
+  for (const s of liveSessions) {
+    if (s.pty) s.pty.resize(cols, rows);
+    if (s.xterm) s.xterm.resize(cols, rows);
+  }
+});
+
+// ── Init ────────────────────────────────────────────────────────────────
+refreshTree();
+refreshHistory();
+setFocusPanel(0);

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "tpc-explorer",
+  "version": "1.0.0",
+  "description": "Terminal file explorer with embedded AI assistants (Claude Code / OpenAI Codex)",
+  "main": "index.js",
+  "bin": {
+    "tpc": "./index.js"
+  },
+  "keywords": [
+    "terminal",
+    "file-explorer",
+    "tui",
+    "claude",
+    "codex",
+    "ai",
+    "cli"
+  ],
+  "author": "",
+  "license": "ISC",
+  "type": "commonjs",
+  "os": [
+    "darwin",
+    "linux",
+    "win32"
+  ],
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "files": [
+    "index.js",
+    "setup.js"
+  ],
+  "dependencies": {
+    "@xterm/addon-serialize": "^0.14.0",
+    "@xterm/headless": "^6.0.0",
+    "blessed": "^0.1.81",
+    "blessed-contrib": "^4.11.0",
+    "cli-highlight": "^2.1.11",
+    "fs-extra": "^11.3.4",
+    "node-pty": "^1.1.0"
+  },
+  "scripts": {
+    "postinstall": "node setup.js",
+    "test": "echo \"No tests\" && exit 0"
+  }
+}

package/setup.js

@@ -0,0 +1,67 @@
+#!/usr/bin/env node
+const os = require('os');
+const { execSync } = require('child_process');
+const path = require('path');
+const fs = require('fs');
+
+const platform = os.platform();
+const arch = os.arch();
+
+console.log(`\n  TPC Explorer Pro - Setup`);
+console.log(`  Platform: ${platform} (${arch})`);
+console.log(`  Node: ${process.version}\n`);
+
+// Check node version
+const major = parseInt(process.version.slice(1).split('.')[0]);
+if (major < 18) {
+  console.error('  Error: Node.js >= 18 is required.');
+  process.exit(1);
+}
+
+// Platform-specific prerequisites check
+if (platform === 'darwin') {
+  // macOS: need Xcode CLI tools for node-gyp (node-pty)
+  try {
+    execSync('xcode-select -p', { stdio: 'ignore' });
+    console.log('  [ok] Xcode Command Line Tools found');
+  } catch (e) {
+    console.log('  [!] Xcode Command Line Tools not found.');
+    console.log('      Run: xcode-select --install');
+    console.log('      Then re-run: npx tpc-explorer');
+  }
+} else if (platform === 'linux') {
+  // Linux: need build-essential and python for node-gyp
+  const checks = [
+    { cmd: 'gcc --version', name: 'gcc', install: 'sudo apt install build-essential' },
+    { cmd: 'make --version', name: 'make', install: 'sudo apt install build-essential' },
+  ];
+  for (const c of checks) {
+    try {
+      execSync(c.cmd, { stdio: 'ignore' });
+      console.log(`  [ok] ${c.name} found`);
+    } catch (e) {
+      console.log(`  [!] ${c.name} not found. Install: ${c.install}`);
+    }
+  }
+} else if (platform === 'win32') {
+  console.log('  [info] Windows detected.');
+  console.log('  [info] node-pty requires "windows-build-tools".');
+  console.log('  [info] If build fails, run: npm install -g windows-build-tools');
+}
+
+// Rebuild node-pty for the current platform/arch
+console.log('\n  Building native modules (node-pty)...');
+try {
+  const nodePtyDir = path.dirname(require.resolve('node-pty/package.json'));
+  execSync('npx node-gyp rebuild', {
+    cwd: nodePtyDir,
+    stdio: 'inherit',
+    env: { ...process.env, HOME: os.homedir() }
+  });
+  console.log('  [ok] node-pty built successfully\n');
+} catch (e) {
+  console.log('  [!] node-pty build failed. AI terminal features may not work.');
+  console.log('      Try: cd node_modules/node-pty && npx node-gyp rebuild\n');
+}
+
+console.log('  Ready! Run "tpc" to start the explorer.\n');