@vinh0809it/claude-sessions 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 vinh0809it
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,130 @@
+# claude-sessions
+
+A zero-dependency terminal UI for browsing, resuming, moving, and deleting [Claude Code](https://claude.ai/code) sessions.
+
+```
+  claude-sessions                         path:/home/you/projects/acme
+  [.claude-main]
+    /home/you/projects/acme/api
+  > booking-overlap-check                 2026-05-11 23:00
+    ekyc-japan-fallback                   2026-05-11 22:52
+  [.claude-company]
+    /home/you/projects/acme/api
+    payment-status-check                  2026-05-11 16:10
+  ↑↓/jk=nav  /=search  Enter=open  n=new  m=move  d=del  q=quit  [42]
+```
+
+## Features
+
+- **Auto-discovers** all `~/.claude*` config directories — works with multiple Claude Code profiles out of the box
+- **Live search** across session titles and first messages; results show `[profile] project ›` inline
+- **Open in new tab** — press Enter to resume a session in a new terminal tab (kitty, WezTerm, tmux, or custom)
+- **New session** — press `n` to open a fresh Claude session in any profile and folder
+- **Move sessions** — press `m` to move a session to a different profile, an existing folder, or a custom path
+- **Delete sessions** with confirmation (removes both the `.jsonl` file and companion directory)
+- **Filter by folder** — pass a path to scope the list to sessions in that directory tree
+- Zero runtime dependencies — pure Node.js stdlib
+
+## Install
+
+```sh
+# Global install (recommended)
+npm install -g cli-claude-sessions
+
+# Or run without installing
+npx cli-claude-sessions
+
+# Or manually
+curl -fsSL https://raw.githubusercontent.com/vinh0809it/claude-sessions/main/index.js \
+  -o ~/.local/bin/claude-sessions && chmod +x ~/.local/bin/claude-sessions
+```
+
+Requires Node.js 18+.
+
+## Usage
+
+```sh
+claude-sessions                    # Browse all sessions (TUI)
+claude-sessions ~/projects/acme    # Filter to a specific folder
+claude-sessions --named-only       # Only show /rename'd sessions
+claude-sessions --list             # Plain list (pipe-friendly)
+claude-sessions --json             # JSON output
+claude-sessions -d ~/.claude-work  # Scan a specific config dir
+```
+
+### TUI keys
+
+| Key | Action |
+|-----|--------|
+| `↑` `↓` / `j` `k` | Navigate |
+| `PgUp` `PgDn` | Page up / down |
+| `g` / `G` | Jump to top / bottom |
+| `/` | Search by title or message content |
+| `Esc` | Clear search |
+| `Enter` | Open session in a new terminal tab |
+| `n` | New session (choose profile + folder) |
+| `m` | Move session to another profile / folder |
+| `d` | Delete session (asks confirmation) |
+| `q` / `Ctrl-C` | Quit |
+
+## Multiple profiles
+
+Claude Code supports custom config directories via `CLAUDE_CONFIG_DIR`. `claude-sessions` auto-discovers **all** `~/.claude*` directories, so multiple profiles just work:
+
+```sh
+# ~/.bashrc or ~/.zshrc
+alias claude-main='CLAUDE_CONFIG_DIR=~/.claude-main claude'
+alias claude-work='CLAUDE_CONFIG_DIR=~/.claude-work claude'
+```
+
+Sessions are grouped by profile in the UI. Press `m` to move a session to a different profile or folder (including a custom typed path). Press `n` to open a new session in any profile and folder.
+
+## Open in new tab
+
+Press `Enter` on any session to resume it in a new terminal tab. The terminal is auto-detected:
+
+| Terminal | Support | Notes |
+|----------|---------|-------|
+| **Kitty** | ✅ | Requires `allow_remote_control yes` in `kitty.conf` |
+| **WezTerm** | ✅ | Uses `wezterm cli spawn` |
+| **tmux** | ✅ | Opens a new window in the current session |
+| Others | ⚙️ | Use `CLAUDE_SESSIONS_OPEN_CMD` |
+
+### Custom open command
+
+Set `CLAUDE_SESSIONS_OPEN_CMD` with placeholders `%cmd%`, `%title%`, and `%project%`:
+
+```sh
+# Ghostty (or any terminal with a new-tab flag)
+export CLAUDE_SESSIONS_OPEN_CMD="ghostty --command=bash -i -c %cmd%"
+
+# iTerm2 via osascript
+export CLAUDE_SESSIONS_OPEN_CMD="osascript -e 'tell app \"iTerm\" to create window with default profile command \"bash -i -c %cmd%\"'"
+
+# Force a specific supported terminal
+export CLAUDE_SESSIONS_TERMINAL=wezterm
+```
+
+## How sessions are stored
+
+Claude Code stores sessions in `~/.claude*/projects/<encoded-path>/<uuid>.jsonl`. Each line is a JSON record. `claude-sessions` reads:
+
+- `type: "custom-title"` → the name set by `/rename`
+- First `type: "user"` message → shown as a fallback title
+- `cwd` field → the actual project path (used for filtering)
+
+## Contributing
+
+Issues and PRs welcome. The entire tool is a single `index.js` with no build step.
+
+```sh
+git clone https://github.com/vinh0809it/claude-sessions
+cd claude-sessions
+node index.js          # run directly
+npm link               # install globally from source
+npm test               # run the test suite (Node built-in test runner, no extra deps)
+```
+
+## License
+
+[MIT](LICENSE)

package/index.js

@@ -0,0 +1,933 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * claude-sessions — Terminal UI for Claude Code sessions
+ *
+ * Usage:
+ *   claude-sessions [folder]        TUI, optionally filtered by folder path
+ *   claude-sessions --list [folder] Plain list output
+ *   claude-sessions --named-only    Only /rename'd sessions
+ *   claude-sessions --json          JSON output
+ *   claude-sessions -d <path>       Scan a specific config dir
+ *   claude-sessions --version       Print version
+ *   claude-sessions -h              Help
+ *
+ * TUI keys:
+ *   ↑ ↓  j k        Navigate
+ *   PgUp PgDn        Page up / down
+ *   g G              Jump to top / bottom
+ *   /                Search (shows [config] project inline)
+ *   Esc              Clear search
+ *   Enter            Open session in a new terminal tab
+ *   n                New session
+ *   m                Move session to another config / folder
+ *   d                Delete session
+ *   q  Ctrl-C        Quit
+ *
+ * Environment variables:
+ *   CLAUDE_SESSIONS_TERMINAL    Force terminal: kitty | wezterm | tmux
+ *   CLAUDE_SESSIONS_OPEN_CMD    Custom open command (placeholders: %cmd% %title% %project%)
+ */
+
+const fs    = require('fs');
+const path  = require('path');
+const os    = require('os');
+const { spawnSync } = require('child_process');
+
+const VERSION = require('./package.json').version;
+
+// ─── Config dir discovery ─────────────────────────────────────────────────────
+
+function discoverConfigDirs() {
+  const home = os.homedir();
+  try {
+    return fs.readdirSync(home)
+      .filter(n => n === '.claude' || n.startsWith('.claude-'))
+      .map(n => path.join(home, n))
+      .filter(d => {
+        try { return fs.statSync(d).isDirectory() && fs.existsSync(path.join(d, 'projects')); }
+        catch { return false; }
+      })
+      .sort((a, b) => {
+        const na = path.basename(a), nb = path.basename(b);
+        if (na === '.claude') return 1;
+        if (nb === '.claude') return -1;
+        return na.localeCompare(nb);
+      });
+  } catch { return []; }
+}
+
+// ─── Args ─────────────────────────────────────────────────────────────────────
+
+function parseArgs() {
+  const args = process.argv.slice(2);
+  const opts = { dir: null, namedOnly: false, json: false, list: false, help: false, version: false, filterPath: null };
+  for (let i = 0; i < args.length; i++) {
+    const a = args[i];
+    if      (a === '-d' || a === '--dir')        opts.dir = args[++i];
+    else if (a === '--named-only')               opts.namedOnly = true;
+    else if (a === '--json')                     opts.json = true;
+    else if (a === '--list')                     opts.list = true;
+    else if (a === '--version' || a === '-v')    opts.version = true;
+    else if (a === '-h' || a === '--help')       opts.help = true;
+    else if (!a.startsWith('-'))                 opts.filterPath = path.resolve(a);
+  }
+  return opts;
+}
+
+// ─── Session reading ──────────────────────────────────────────────────────────
+
+function readSession(jsonlPath) {
+  let title = null, firstUserMessage = null, cwd = null, timestamp = null;
+  try {
+    const lines = fs.readFileSync(jsonlPath, 'utf8').split('\n');
+    for (const line of lines) {
+      if (!line) continue;
+      try {
+        const r = JSON.parse(line);
+        if (r.type === 'custom-title' && r.customTitle) title = r.customTitle;
+        if (!firstUserMessage && r.type === 'user' && r.message?.content) {
+          const c = r.message.content;
+          const text = typeof c === 'string' ? c : (c.find?.(x => x.type === 'text')?.text ?? '');
+          if (text) firstUserMessage = text.trim().replace(/\s+/g, ' ').slice(0, 80);
+        }
+        if (!cwd && r.cwd) cwd = r.cwd;
+        if (!timestamp && r.timestamp) timestamp = r.timestamp;
+      } catch { /* malformed line — skip */ }
+    }
+  } catch { /* unreadable file — return nulls */ }
+  return { title, firstUserMessage, cwd, timestamp };
+}
+
+function scanConfigDir(configDir, filterPath) {
+  const projectsDir = path.join(configDir, 'projects');
+  if (!fs.existsSync(projectsDir)) return [];
+  const results = [];
+
+  let projectEntries;
+  try { projectEntries = fs.readdirSync(projectsDir); } catch { return []; }
+
+  for (const pd of projectEntries) {
+    const pdFull = path.join(projectsDir, pd);
+    try { if (!fs.statSync(pdFull).isDirectory()) continue; } catch { continue; }
+
+    let files;
+    try {
+      files = fs.readdirSync(pdFull)
+        .filter(f => f.endsWith('.jsonl'))
+        .map(f => {
+          const p = path.join(pdFull, f);
+          return { file: f, mtime: fs.statSync(p).mtime, jsonlPath: p };
+        })
+        .sort((a, b) => b.mtime - a.mtime);
+    } catch { continue; }
+
+    // .project-path hint written at move time takes highest priority
+    let dirPathHint = null;
+    try {
+      const hint = fs.readFileSync(path.join(pdFull, '.project-path'), 'utf8').trim();
+      if (hint) dirPathHint = hint;
+    } catch {}
+
+    for (const { file, mtime, jsonlPath } of files) {
+      const { title, firstUserMessage, cwd, timestamp } = readSession(jsonlPath);
+      let project = cwd || pd;
+      if (dirPathHint) {
+        project = dirPathHint;
+      } else if (cwd && encodePathToDir(cwd) !== pd) {
+        // JSONL cwd is stale; find a sibling whose cwd encodes to this dir name
+        for (const sib of files) {
+          if (sib.jsonlPath === jsonlPath) continue;
+          const { cwd: sibCwd } = readSession(sib.jsonlPath);
+          if (sibCwd && encodePathToDir(sibCwd) === pd) { project = sibCwd; break; }
+        }
+      }
+      if (filterPath && !project.startsWith(filterPath)) continue;
+      results.push({
+        configDir:     path.basename(configDir),
+        configDirPath: configDir,
+        project,
+        sessionId:    file.replace('.jsonl', ''),
+        title,
+        firstMessage: firstUserMessage,
+        lastModified: mtime,
+        timestamp,
+        jsonlPath,
+      });
+    }
+  }
+  return results.sort((a, b) => b.lastModified - a.lastModified);
+}
+
+function loadSessions(opts) {
+  const dirs = opts.dir ? [path.resolve(opts.dir)] : discoverConfigDirs();
+  if (dirs.length === 0) process.stderr.write('No Claude Code config directories found in ~\n');
+  const all = dirs.flatMap(d => scanConfigDir(d, opts.filterPath));
+  return opts.namedOnly ? all.filter(s => s.title) : all;
+}
+
+// ─── Session operations ───────────────────────────────────────────────────────
+
+function deleteSessionFiles(session) {
+  try { fs.unlinkSync(session.jsonlPath); } catch {}
+  const dir = session.jsonlPath.replace(/\.jsonl$/, '');
+  try {
+    if (fs.statSync(dir).isDirectory()) fs.rmSync(dir, { recursive: true, force: true });
+  } catch {}
+}
+
+function moveSession(session, targetConfigDirPath, targetProjectDirName, targetRawPath = null) {
+  const srcProjectDirName = path.basename(path.dirname(session.jsonlPath));
+  const destDirName       = targetProjectDirName || srcProjectDirName;
+  const targetProjectDir  = path.join(targetConfigDirPath, 'projects', destDirName);
+  fs.mkdirSync(targetProjectDir, { recursive: true });
+
+  const targetJsonl = path.join(targetProjectDir, path.basename(session.jsonlPath));
+  fs.renameSync(session.jsonlPath, targetJsonl);
+
+  const srcDir = session.jsonlPath.replace(/\.jsonl$/, '');
+  try {
+    if (fs.statSync(srcDir).isDirectory()) {
+      fs.renameSync(srcDir, targetJsonl.replace(/\.jsonl$/, ''));
+    }
+  } catch {}
+
+  if (targetRawPath) {
+    try { fs.writeFileSync(path.join(targetProjectDir, '.project-path'), targetRawPath, 'utf8'); } catch {}
+  }
+
+  session.configDir     = path.basename(targetConfigDirPath);
+  session.configDirPath = targetConfigDirPath;
+  session.jsonlPath     = targetJsonl;
+}
+
+function listProjectFolders(configDirPath) {
+  const projectsDir = path.join(configDirPath, 'projects');
+  if (!fs.existsSync(projectsDir)) return [];
+  try {
+    return fs.readdirSync(projectsDir)
+      .filter(d => { try { return fs.statSync(path.join(projectsDir, d)).isDirectory(); } catch { return false; } })
+      .map(d => {
+        let displayPath = d;
+        try {
+          const f = fs.readdirSync(path.join(projectsDir, d)).find(f => f.endsWith('.jsonl'));
+          if (f) {
+            const { cwd } = readSession(path.join(projectsDir, d, f));
+            if (cwd) displayPath = shortenPath(cwd);
+          }
+        } catch {}
+        return { projectDirName: d, displayPath };
+      })
+      .sort((a, b) => a.displayPath.localeCompare(b.displayPath));
+  } catch { return []; }
+}
+
+function encodePathToDir(absPath) {
+  return absPath.replace(/\//g, '-');
+}
+
+function tabComplete(input) {
+  const expanded      = input.replace(/^~/, os.homedir());
+  const endsWithSlash = expanded.endsWith('/');
+  const baseDir       = endsWithSlash ? (expanded.slice(0, -1) || '/') : path.dirname(expanded);
+  const prefix        = endsWithSlash ? '' : path.basename(expanded);
+
+  let matches;
+  try {
+    matches = fs.readdirSync(baseDir)
+      .filter(n => n.startsWith(prefix) && (() => {
+        try { return fs.statSync(path.join(baseDir, n)).isDirectory(); } catch { return false; }
+      })())
+      .sort();
+  } catch { return { completed: input, matches: [] }; }
+
+  if (!matches.length) return { completed: input, matches: [] };
+
+  if (matches.length === 1) {
+    const completed = (path.join(baseDir, matches[0]) + '/').replace(os.homedir(), '~');
+    return { completed, matches: [] };
+  }
+
+  let common = matches[0];
+  for (const m of matches.slice(1)) {
+    let i = 0;
+    while (i < common.length && i < m.length && common[i] === m[i]) i++;
+    common = common.slice(0, i);
+  }
+
+  if (common.length > prefix.length) {
+    const completed = path.join(baseDir, common).replace(os.homedir(), '~');
+    return { completed, matches: matches.map(m => m + '/') };
+  }
+
+  return { completed: input, matches: matches.map(m => m + '/') };
+}
+
+// ─── Terminal detection & open ────────────────────────────────────────────────
+
+function detectTerminal() {
+  const forced = process.env.CLAUDE_SESSIONS_TERMINAL;
+  if (forced) return forced;
+  if (process.env.KITTY_WINDOW_ID !== undefined) return 'kitty';
+  if (process.env.WEZTERM_PANE    !== undefined) return 'wezterm';
+  if (process.env.TMUX)                          return 'tmux';
+  if (process.env.TERM_PROGRAM === 'iTerm.app')  return 'iterm2';
+  return null;
+}
+
+function shellEsc(s) { return "'" + String(s).replace(/'/g, "'\\''") + "'"; }
+
+function trySpawn(cmd, args) {
+  const r = spawnSync(cmd, args, { stdio: ['ignore', 'ignore', 'pipe'] });
+  return r.status === 0
+    ? { ok: true }
+    : { ok: false, msg: r.stderr?.toString().trim() || `${cmd} exited with ${r.status}` };
+}
+
+function resolveProjectPath(session) {
+  const sessionDir = path.dirname(session.jsonlPath);
+  // Check hint file first (written at move time; survives restarts)
+  try {
+    const hint = fs.readFileSync(path.join(sessionDir, '.project-path'), 'utf8').trim();
+    if (hint && fs.existsSync(hint)) return hint;
+  } catch {}
+  // Fall back to a sibling session whose cwd resolves to an existing path
+  try {
+    const siblings = fs.readdirSync(sessionDir)
+      .filter(f => f.endsWith('.jsonl') && f !== path.basename(session.jsonlPath));
+    for (const sibling of siblings) {
+      const { cwd } = readSession(path.join(sessionDir, sibling));
+      if (cwd && fs.existsSync(cwd)) return cwd;
+    }
+  } catch {}
+  return fs.existsSync(session.project) ? session.project : os.homedir();
+}
+
+function launchInTerminal(shellCmd, title, projectPath) {
+  const customTpl = process.env.CLAUDE_SESSIONS_OPEN_CMD;
+  if (customTpl) {
+    const expanded = customTpl
+      .replace(/%cmd%/g,     shellEsc(shellCmd))
+      .replace(/%title%/g,   shellEsc(title))
+      .replace(/%project%/g, shellEsc(projectPath));
+    const r = spawnSync('bash', ['-c', expanded], { stdio: 'ignore' });
+    return r.status === 0 ? { ok: true } : { ok: false, msg: `Custom open command failed (exit ${r.status})` };
+  }
+
+  const term = detectTerminal();
+  switch (term) {
+    case 'kitty':
+      return trySpawn('kitty', ['@', 'launch', '--type=tab', `--tab-title=${title}`, 'bash', '-i', '-c', shellCmd]);
+    case 'wezterm':
+      return trySpawn('wezterm', ['cli', 'spawn', '--', 'bash', '-i', '-c', shellCmd]);
+    case 'tmux':
+      return trySpawn('tmux', ['new-window', '-n', title.slice(0, 20), `bash -i -c ${shellEsc(shellCmd)}`]);
+    default:
+      return { ok: false, msg: 'Terminal not supported. Set CLAUDE_SESSIONS_OPEN_CMD or CLAUDE_SESSIONS_TERMINAL.' };
+  }
+}
+
+function openSession(session) {
+  const projectPath = resolveProjectPath(session);
+  const title       = session.title || session.sessionId.slice(0, 8);
+  const resumeCmd   = `CLAUDE_CONFIG_DIR=${shellEsc(session.configDirPath)} claude -r ${session.sessionId}`;
+  const shellCmd    = `cd ${shellEsc(projectPath)} && ${resumeCmd}; exec $SHELL`;
+  return launchInTerminal(shellCmd, title, projectPath);
+}
+
+function openNewSession(configDirPath, projectPath) {
+  const title    = path.basename(projectPath);
+  const cmd      = `CLAUDE_CONFIG_DIR=${shellEsc(configDirPath)} claude`;
+  const shellCmd = `cd ${shellEsc(projectPath)} && ${cmd}; exec $SHELL`;
+  return launchInTerminal(shellCmd, title, projectPath);
+}
+
+// ─── Utilities ────────────────────────────────────────────────────────────────
+
+function fmtDate(d) {
+  return new Date(d).toLocaleString(undefined, { hour12: false });
+}
+
+function shortConfig(configDir) {
+  return path.basename(configDir).replace(/^\.claude-?/, '') || 'default';
+}
+
+function shortenPath(p) {
+  const home = os.homedir();
+  return p.startsWith(home) ? '~' + p.slice(home.length) : p;
+}
+
+// ─── Plain list output ────────────────────────────────────────────────────────
+
+function ansi(code, s) { return process.stdout.isTTY ? `\x1b[${code}m${s}\x1b[0m` : s; }
+
+function printList(sessions) {
+  if (!sessions.length) { console.log('No sessions found.'); return; }
+  let lastConfig = null, lastProject = null;
+  for (const s of sessions) {
+    if (s.configDir !== lastConfig) {
+      if (lastConfig) console.log();
+      console.log(ansi('1;36', `[${s.configDir}]`));
+      lastConfig = s.configDir; lastProject = null;
+    }
+    if (s.project !== lastProject) {
+      console.log(ansi('33', `  ${shortenPath(s.project)}`));
+      lastProject = s.project;
+    }
+    const label = s.title
+      ? ansi('1;32', s.title)
+      : ansi('2', `(${(s.firstMessage || 'untitled').slice(0, 60)}…)`);
+    console.log(`    ${label}  ${ansi('2', fmtDate(s.lastModified))}`);
+    console.log(ansi('2', `    id: ${s.sessionId}`));
+  }
+}
+
+// ─── TUI ──────────────────────────────────────────────────────────────────────
+
+const ESC        = '\x1b';
+const clrLine    = `${ESC}[2K`;
+const clrScreen  = `${ESC}[2J`;
+const hideCursor = `${ESC}[?25l`;
+const showCursor = `${ESC}[?25h`;
+const altBuf     = `${ESC}[?1049h`;
+const normBuf    = `${ESC}[?1049l`;
+
+const mv    = (r, c) => `${ESC}[${r};${c}H`;
+const bold  = s => `${ESC}[1m${s}${ESC}[0m`;
+const dim   = s => `${ESC}[2m${s}${ESC}[0m`;
+const inv   = s => `${ESC}[7m${s}${ESC}[0m`;
+const fgc   = (code, s) => `${ESC}[${code}m${s}${ESC}[0m`;
+const bgc   = (code, s) => `${ESC}[${code}m${s}${ESC}[0m`;
+const trunc = (s, n) => n > 0 && s.length > n ? s.slice(0, n - 1) + '…' : s;
+const pad   = (s, n) => s.padEnd(n).slice(0, n);
+
+// ─── Picker ───────────────────────────────────────────────────────────────────
+// Shared profile → folder → input flow used by both move and new modes.
+// step: 'profile' | 'folder' | 'input'
+
+class Picker {
+  constructor({ headerLabel, profileLabel = 'Select profile', inputPrompt, buildProfileItems, buildFolderItems, onConfirmItem, onConfirmCustom }) {
+    this.step  = 'profile';
+    this.items = [];
+    this.selIdx = 0;
+    this.scroll = 0;
+    this.config = null;  // config dir path chosen at the profile step
+    this.input  = '';
+    this.completions = [];
+
+    this._headerLabel       = headerLabel;
+    this._profileLabel      = profileLabel;
+    this._inputPrompt       = inputPrompt;
+    this._buildProfileItems = buildProfileItems;
+    this._buildFolderItems  = buildFolderItems;
+    this._onConfirmItem     = onConfirmItem;
+    this._onConfirmCustom   = onConfirmCustom;
+  }
+
+  enter() {
+    this.step        = 'profile';
+    this.items       = this._buildProfileItems();
+    this.selIdx      = 0;
+    this.scroll      = 0;
+    this.config      = null;
+    this.input       = '';
+    this.completions = [];
+  }
+
+  _enterFolderStep(configDirPath) {
+    this.config = configDirPath;
+    this.step   = 'folder';
+    this.items  = this._buildFolderItems(configDirPath);
+    this.selIdx = 0;
+    this.scroll = 0;
+  }
+
+  // Returns false when the picker should be dismissed (Esc at profile step).
+  handleKey(key) {
+    if (this.step === 'input') {
+      if (key === '\x1b') {
+        this.step        = 'folder';
+        this.completions = [];
+        this.items       = this._buildFolderItems(this.config);
+      } else if (key === '\t') {
+        const { completed, matches } = tabComplete(this.input || '~/');
+        this.input       = completed;
+        this.completions = matches.length > 1 ? matches : [];
+      } else if (key === '\x7f') {
+        this.input       = this.input.slice(0, -1);
+        this.completions = [];
+      } else if (key === '\r') {
+        const raw = this.input.trim();
+        this.completions = [];
+        if (raw) {
+          const absPath = raw.replace(/^~/, os.homedir()).replace(/\/+$/, '');
+          this._onConfirmCustom(absPath);
+        } else {
+          this.step = 'folder';
+        }
+      } else if (key.length === 1 && key >= ' ') {
+        this.input      += key;
+        this.completions = [];
+      }
+      return true;
+    }
+
+    if (key === '\x1b') {
+      if (this.step === 'folder') {
+        this.step   = 'profile';
+        this.items  = this._buildProfileItems();
+        this.selIdx = 0;
+        this.scroll = 0;
+      } else {
+        return false; // cancel at profile step
+      }
+      return true;
+    }
+
+    if (key === '\x1b[A' || key === 'k') { this.selIdx = Math.max(0, this.selIdx - 1); return true; }
+    if (key === '\x1b[B' || key === 'j') { this.selIdx = Math.min(this.items.length - 1, this.selIdx + 1); return true; }
+
+    if (key === '\r') {
+      const item = this.items[this.selIdx];
+      if (!item) return true;
+      if (item.type === 'profile') { this._enterFolderStep(item.configDirPath); return true; }
+      if (item.type === 'new')     { this.step = 'input'; this.input = '~/'; this.completions = []; return true; }
+      this._onConfirmItem(item);
+    }
+    return true;
+  }
+
+  render(out, W, H) {
+    const headerLabel = typeof this._headerLabel === 'function' ? this._headerLabel() : this._headerLabel;
+    out.push(mv(2, 1), clrLine, `  ${headerLabel}`);
+
+    out.push(mv(3, 1), clrLine);
+    const divider = dim('─'.repeat(Math.max(0, W - 2)));
+    if (this.step === 'profile') {
+      out.push(`  ` + bold(this._profileLabel) + `  ` + divider);
+    } else {
+      out.push(`  ` + bold('Select folder in ') + bold(fgc('96', `[${path.basename(this.config)}]`)) + `  ` + divider);
+    }
+
+    let listStart = 4;
+    if (this.step === 'input') {
+      out.push(mv(4, 1), clrLine, `  ${fgc('93', this._inputPrompt)} ${this.input}█`);
+      out.push(mv(5, 1), clrLine);
+      if (this.completions.length > 1) {
+        const cols = Math.max(1, Math.floor((W - 2) / 22));
+        const rows = Math.ceil(this.completions.length / cols);
+        for (let r = 0; r < Math.min(rows, H - 8); r++) {
+          out.push(mv(r + 5, 1), clrLine);
+          out.push(`  ` + dim(this.completions.slice(r * cols, r * cols + cols).map(n => pad(n, 22)).join(' ')));
+        }
+        listStart = H;
+      } else {
+        out.push(dim(`  Tab to complete path`));
+        listStart = 6;
+      }
+    }
+
+    const items  = this.step === 'input' ? [] : this.items;
+    const maxVis = Math.max(0, H - listStart - 1);
+    if (this.selIdx < this.scroll) this.scroll = this.selIdx;
+    if (this.selIdx >= this.scroll + maxVis) this.scroll = this.selIdx - maxVis + 1;
+    if (this.scroll < 0) this.scroll = 0;
+
+    for (let r = 0; r < maxVis; r++) {
+      out.push(mv(listStart + r, 1), clrLine);
+      const item = items[this.scroll + r];
+      if (!item) continue;
+      const isSel  = (this.scroll + r) === this.selIdx;
+      const label  = item.type === 'same'    ? dim(item.label)
+                   : item.type === 'new'     ? fgc('93', item.label)
+                   : item.type === 'profile' ? bold(fgc('96', item.label))
+                   : fgc('33', item.label);
+      out.push(isSel ? inv(pad(`    ${item.label}`, W)) : `    ${label}`);
+    }
+  }
+}
+
+// ─── TUI ─────────────────────────────────────────────────────────────────────
+
+class TUI {
+  constructor(sessions, filterPath) {
+    this.all        = sessions;
+    this.filterPath = filterPath || '';
+    this.search     = '';
+    this.mode       = null;  // null | 'search' | 'delete' | 'move' | 'new'
+    this.statusMsg  = '';
+    this._statusTimer = null;
+    this.selIdx     = 0;
+    this.scrollTop  = 0;
+    this.items      = [];
+    this.w = process.stdout.columns || 80;
+    this.h = process.stdout.rows    || 24;
+
+    this.movePicker = this._createMovePicker();
+    this.newPicker  = this._createNewPicker();
+    this.rebuild();
+  }
+
+  get listH() { return this.h - 2; }
+
+  _createMovePicker() {
+    return new Picker({
+      headerLabel: () => {
+        const s = this.selectedSession();
+        const label = s?.title || s?.firstMessage?.slice(0, 60) || s?.sessionId?.slice(0, 8) || '';
+        return `Moving: ` + (label ? fgc('92', `"${trunc(label, this.w - 12)}"`) : dim('(untitled)'));
+      },
+      profileLabel: 'Select target profile',
+      inputPrompt:  'New path:',
+      buildProfileItems: () => {
+        const s = this.selectedSession();
+        return discoverConfigDirs().map(d => ({
+          type: 'profile',
+          label: path.basename(d) + (d === s?.configDirPath ? '  (current)' : ''),
+          configDirPath: d,
+        }));
+      },
+      buildFolderItems: (configDirPath) => {
+        const s          = this.selectedSession();
+        const isSameConfig = configDirPath === s?.configDirPath;
+        const srcDirName   = s ? path.basename(path.dirname(s.jsonlPath)) : null;
+        const items = [];
+        if (!isSameConfig) {
+          items.push({ type: 'same', label: (s ? shortenPath(s.project) : '') + '  (keep same folder)', dirName: null });
+        }
+        listProjectFolders(configDirPath)
+          .filter(f => !(isSameConfig && f.projectDirName === srcDirName))
+          .forEach(f => items.push({ type: 'folder', label: f.displayPath, dirName: f.projectDirName }));
+        items.push({ type: 'new', label: '[type a new path…]', dirName: null });
+        return items;
+      },
+      onConfirmItem:   (item) => this._doMove(item.dirName),
+      onConfirmCustom: (absPath) => this._doMove(encodePathToDir(absPath), absPath),
+    });
+  }
+
+  _createNewPicker() {
+    return new Picker({
+      headerLabel: fgc('92', 'New session'),
+      inputPrompt: 'Path:',
+      buildProfileItems: () => discoverConfigDirs().map(d => ({
+        type: 'profile', label: path.basename(d), configDirPath: d,
+      })),
+      buildFolderItems: (configDirPath) => [
+        ...listProjectFolders(configDirPath).map(f => ({
+          type: 'folder',
+          label: f.displayPath,
+          projectPath: f.displayPath.replace(/^~/, os.homedir()),
+        })),
+        { type: 'new', label: '[type a new path…]', projectPath: null },
+      ],
+      onConfirmItem:   (item) => { if (item.projectPath) this._doNew(item.projectPath); },
+      onConfirmCustom: (absPath) => this._doNew(absPath),
+    });
+  }
+
+  // ── Item list ───────────────────────────────────────────────────────────────
+
+  rebuild() {
+    const q        = this.search.toLowerCase();
+    const filtered = q
+      ? this.all.filter(s =>
+          (s.title        || '').toLowerCase().includes(q) ||
+          (s.firstMessage || '').toLowerCase().includes(q) ||
+          s.project.toLowerCase().includes(q))
+      : this.all;
+
+    this.items = [];
+    let lastConfig = null;
+    for (const s of filtered) {
+      if (s.configDir !== lastConfig) {
+        this.items.push({ type: 'config', label: s.configDir });
+        lastConfig = s.configDir;
+      }
+      this.items.push({ type: 'session', session: s });
+    }
+
+    const total = this.sessionItems().length;
+    this.selIdx = Math.min(this.selIdx, Math.max(0, total - 1));
+    this.ensureVisible();
+  }
+
+  sessionItems()    { return this.items.filter(i => i.type === 'session'); }
+  selectedSession() { return this.sessionItems()[this.selIdx]?.session ?? null; }
+
+  selItemRow() {
+    let si = 0;
+    for (let i = 0; i < this.items.length; i++) {
+      if (this.items[i].type === 'session') {
+        if (si === this.selIdx) return i;
+        si++;
+      }
+    }
+    return -1;
+  }
+
+  ensureVisible() {
+    const r = this.selItemRow();
+    if (r === -1) return;
+    if (r < this.scrollTop) this.scrollTop = r;
+    if (r >= this.scrollTop + this.listH) this.scrollTop = r - this.listH + 1;
+    if (this.scrollTop < 0) this.scrollTop = 0;
+  }
+
+  setStatus(msg, ms = 2500) {
+    this.statusMsg = msg;
+    clearTimeout(this._statusTimer);
+    this._statusTimer = setTimeout(() => { this.statusMsg = ''; this.render(); }, ms);
+  }
+
+  reloadAll() {
+    this.all = discoverConfigDirs().flatMap(d => scanConfigDir(d, this.filterPath || null));
+  }
+
+  _doMove(targetDirName, targetRawPath = null) {
+    const s = this.selectedSession();
+    if (!s) { this.mode = null; return; }
+    const sessionId     = s.sessionId;
+    const targetConfig  = this.movePicker.config;
+    try {
+      moveSession(s, targetConfig, targetDirName, targetRawPath);
+      this.mode = null;
+      this.reloadAll();
+      this.rebuild();
+      const idx = this.sessionItems().findIndex(i => i.session.sessionId === sessionId);
+      if (idx >= 0) { this.selIdx = idx; this.ensureVisible(); }
+      this.setStatus(`Moved to [${path.basename(targetConfig)}]`);
+    } catch (e) {
+      this.mode = null;
+      this.setStatus(`Move failed: ${e.message}`, 4000);
+    }
+  }
+
+  _doNew(projectPath) {
+    if (!projectPath) return;
+    const result = openNewSession(this.newPicker.config, projectPath);
+    this.mode = null;
+    this.setStatus(
+      result.ok ? `Opening new session in ${shortenPath(projectPath)}` : result.msg,
+      result.ok ? 2500 : 5000
+    );
+  }
+
+  // ── Render ──────────────────────────────────────────────────────────────────
+
+  render() {
+    const W = this.w, H = this.h;
+    const out = [hideCursor, altBuf, clrScreen, mv(1, 1)];
+
+    const filterInfo = this.filterPath ? `  path:${this.filterPath}` : '';
+    const searchInfo = this.search     ? `  search:${this.search}`   : '';
+    out.push(bgc('44', bold(fgc('97', pad(trunc(`  claude-sessions${filterInfo}${searchInfo}`, W), W)))));
+
+    if (this.mode === 'move') {
+      this.movePicker.render(out, W, H);
+    } else if (this.mode === 'new') {
+      this.newPicker.render(out, W, H);
+    } else {
+      // Session list
+      const visible = this.items.slice(this.scrollTop, this.scrollTop + this.listH);
+      let si = this.items.slice(0, this.scrollTop).filter(i => i.type === 'session').length;
+
+      for (let r = 0; r < this.listH; r++) {
+        out.push(mv(r + 2, 1), clrLine);
+        const item = visible[r];
+        if (!item) continue;
+
+        if (item.type === 'config') {
+          out.push(bold(fgc('96', `  [${item.label}]`)));
+        } else {
+          const s        = item.session;
+          const isSel    = si === this.selIdx;
+          const title    = s.title || (s.firstMessage ? `(${s.firstMessage})` : '(untitled)');
+          const project  = shortenPath(s.project);
+          const dateStr  = fmtDate(s.lastModified);
+          const cfgTag   = this.search ? `[${shortConfig(s.configDir)}] ` : '';
+          const dateW    = dateStr.length;
+          const avail    = Math.max(12, W - 2 - cfgTag.length - 2 - 2 - dateW);
+          const titleW   = Math.floor(avail * 0.5);
+          const projectW = avail - titleW;
+
+          if (isSel) {
+            const plain = `  ${cfgTag}${trunc(title, titleW).padEnd(titleW)}  ${trunc(project, projectW).padEnd(projectW)}  ${dateStr}`;
+            out.push(inv(pad(plain, W)));
+          } else {
+            out.push(
+              `  ${this.search ? fgc('96', cfgTag) : ''}` +
+              (s.title ? fgc('92', pad(trunc(title, titleW), titleW)) : dim(pad(trunc(title, titleW), titleW))) +
+              `  ${fgc('33', pad(trunc(project, projectW), projectW))}` +
+              `  ${dim(dateStr)}`
+            );
+          }
+          si++;
+        }
+      }
+    }
+
+    // Footer
+    out.push(mv(H, 1));
+    const sel   = this.selectedSession();
+    const total = this.sessionItems().length;
+    let footer;
+
+    if (this.mode === 'delete') {
+      const name = sel?.title || sel?.firstMessage?.slice(0, 35) || 'this session';
+      footer = `  Delete "${trunc(name, 35)}"?  y=yes  n/Esc=cancel`;
+    } else if (this.mode === 'move') {
+      const step = this.movePicker.step;
+      footer = step === 'profile' ? `  ↑↓/jk=navigate  Enter=select profile  Esc=cancel`
+             : step === 'input'   ? `  Tab=complete path  Enter=confirm  Esc=back`
+             :                      `  ↑↓/jk=navigate  Enter=select  Esc=back to profiles`;
+    } else if (this.mode === 'new') {
+      const step = this.newPicker.step;
+      footer = step === 'profile' ? `  ↑↓/jk=navigate  Enter=select profile  Esc=cancel`
+             : step === 'input'   ? `  Tab=complete path  Enter=confirm  Esc=back`
+             :                      `  ↑↓/jk=navigate  Enter=select folder  Esc=back to profiles`;
+    } else if (this.mode === 'search') {
+      footer = `  SEARCH: ${this.search}█  Esc=cancel  Enter=done`;
+    } else if (this.statusMsg) {
+      footer = `  ${this.statusMsg}`;
+    } else {
+      const ctx = sel ? `  ${dim(trunc(sel.project, W - 45))}` : '';
+      footer = `  ↑↓/jk=nav  /=search  Enter=open  n=new  m=move  d=del  q=quit  [${total}]${ctx}`;
+    }
+
+    out.push(bgc('40', fgc('37', pad(trunc(footer, W), W))));
+    process.stdout.write(out.join(''));
+  }
+
+  // ── Input ───────────────────────────────────────────────────────────────────
+
+  handleKey(key) {
+    if (this.mode === 'delete') {
+      this.mode = null;
+      if (key === 'y' || key === 'Y') {
+        const s = this.selectedSession();
+        if (s) {
+          deleteSessionFiles(s);
+          this.all = this.all.filter(x => x.sessionId !== s.sessionId);
+          this.setStatus(`Deleted: ${s.title || s.sessionId.slice(0, 8)}`);
+          this.rebuild();
+        }
+      }
+      return true;
+    }
+
+    if (this.mode === 'move') {
+      if (this.movePicker.handleKey(key) === false) this.mode = null;
+      return true;
+    }
+
+    if (this.mode === 'new') {
+      if (this.newPicker.handleKey(key) === false) this.mode = null;
+      return true;
+    }
+
+    if (this.mode === 'search') {
+      if      (key === '\x1b')                       { this.mode = null; this.search = ''; this.rebuild(); }
+      else if (key === '\r')                         { this.mode = null; }
+      else if (key === '\x7f')                       { this.search = this.search.slice(0, -1); this.rebuild(); }
+      else if (key.length === 1 && key >= ' ')       { this.search += key; this.rebuild(); }
+      return true;
+    }
+
+    // Normal mode
+    const total = this.sessionItems().length;
+    const move  = (delta) => {
+      this.selIdx = Math.max(0, Math.min(total - 1, this.selIdx + delta));
+      this.ensureVisible();
+    };
+
+    if (key === 'q' || key === '\x03') return false;
+
+    if      (key === '/')                   { this.mode = 'search'; }
+    else if (key === '\x1b')                { this.search = ''; this.rebuild(); }
+    else if (key === '\r') {
+      const s = this.selectedSession();
+      if (s) {
+        const result = openSession(s);
+        this.setStatus(
+          result.ok ? `Opened "${s.title || s.sessionId.slice(0, 8)}" in new tab` : result.msg,
+          result.ok ? 2500 : 5000
+        );
+      }
+    }
+    else if (key === 'd')                   { if (this.selectedSession()) this.mode = 'delete'; }
+    else if (key === 'n')                   { this.newPicker.enter(); this.mode = 'new'; }
+    else if (key === 'm') {
+      if (this.selectedSession()) { this.movePicker.enter(); this.mode = 'move'; }
+      else this.setStatus('No session selected.');
+    }
+    else if (key === '\x1b[A' || key === 'k') move(-1);
+    else if (key === '\x1b[B' || key === 'j') move(+1);
+    else if (key === '\x1b[5~')               move(-this.listH);
+    else if (key === '\x1b[6~')               move(+this.listH);
+    else if (key === 'g')                     { this.selIdx = 0; this.ensureVisible(); }
+    else if (key === 'G')                     { this.selIdx = Math.max(0, total - 1); this.ensureVisible(); }
+
+    return true;
+  }
+
+  cleanup() { process.stdout.write(showCursor + normBuf); }
+
+  start() {
+    process.stdin.setRawMode(true);
+    process.stdin.resume();
+    process.stdin.setEncoding('utf8');
+
+    process.stdout.on('resize', () => {
+      this.w = process.stdout.columns;
+      this.h = process.stdout.rows;
+      this.ensureVisible();
+      this.render();
+    });
+
+    this.render();
+
+    process.stdin.on('data', key => {
+      if (this.handleKey(key) === false) {
+        this.cleanup();
+        process.exit(0);
+      }
+      this.render();
+    });
+
+    process.on('exit',   () => this.cleanup());
+    process.on('SIGTERM', () => { this.cleanup(); process.exit(0); });
+  }
+}
+
+// ─── Main ─────────────────────────────────────────────────────────────────────
+
+function printHelp() {
+  const src   = fs.readFileSync(__filename, 'utf8');
+  const match = src.match(/\/\*\*([\s\S]*?)\*\//);
+  if (match) console.log(match[0].replace(/\/\*\*|\*\//g, '').replace(/^ \* ?/gm, '').trim());
+}
+
+function main() {
+  const opts = parseArgs();
+  if (opts.version) { console.log(VERSION); return; }
+  if (opts.help)    { printHelp(); return; }
+
+  const sessions = loadSessions(opts);
+
+  if (opts.json) {
+    const out = sessions.map(({ jsonlPath: _j, configDirPath: _c, ...rest }) => rest);
+    console.log(JSON.stringify(out, null, 2));
+  } else if (opts.list || !process.stdout.isTTY) {
+    printList(sessions);
+  } else {
+    new TUI(sessions, opts.filterPath).start();
+  }
+}
+
+if (require.main === module) {
+  main();
+} else {
+  module.exports = { encodePathToDir, tabComplete, resolveProjectPath, moveSession, readSession };
+}

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "@vinh0809it/claude-sessions",
+  "version": "0.1.0",
+  "description": "Terminal UI for browsing, resuming, moving, and deleting Claude Code sessions",
+  "bin": {
+    "claude-sessions": "./index.js"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "keywords": [
+    "claude",
+    "claude-code",
+    "anthropic",
+    "cli",
+    "tui",
+    "terminal",
+    "sessions"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/vinh0809it/claude-sessions.git"
+  },
+  "bugs": {
+    "url": "https://github.com/vinh0809it/claude-sessions/issues"
+  },
+  "homepage": "https://github.com/vinh0809it/claude-sessions#readme",
+  "scripts": {
+    "test": "node --test test/*.js"
+  },
+  "files": [
+    "index.js"
+  ]
+}