@damper/cli 0.9.12 → 0.9.14

package/dist/commands/start.js

@@ -5,7 +5,7 @@ import { createWorktree, getMainProjectRoot, removeWorktreeDir } from '../servic
 import { bootstrapContext, refreshContext } from '../services/context-bootstrap.js';
 import { pickTask } from '../ui/task-picker.js';
 import { launchClaude, launchClaudeForReview, postTaskFlow, isClaudeInstalled, isDamperMcpConfigured, configureDamperMcp } from '../services/claude.js';
-import { getWorktreesForProject, cleanupStaleWorktrees } from '../services/state.js';
+import { getWorktreesForProject, cleanupStaleWorktrees, getPreference, setPreference } from '../services/state.js';
 import { getApiKey, isProjectConfigured, getProjectConfigPath } from '../services/config.js';
 import { shortIdRaw } from '../ui/format.js';
 export async function startCommand(options) {
@@ -39,6 +39,8 @@ export async function startCommand(options) {
         }
         process.exit(1);
     }
+    // Check if tmux is installed (enables persistent task title bar)
+    await ensureTmux();
     // Ensure MCP is configured globally (without key - key comes from env)
     if (!isDamperMcpConfigured()) {
         console.log(pc.dim('Configuring Damper MCP...'));
@@ -310,3 +312,77 @@ async function handleReviewAndComplete(options) {
     }
     console.log();
 }
+/**
+ * Check if tmux is installed; offer to install or recommend it if not.
+ * Skipped if the user previously dismissed the prompt.
+ */
+async function ensureTmux() {
+    // Already dismissed?
+    if (getPreference('tmuxPromptDismissed'))
+        return;
+    // Already installed?
+    try {
+        const { execa } = await import('execa');
+        await execa('tmux', ['-V'], { stdio: 'pipe' });
+        return; // tmux is available
+    }
+    catch {
+        // not installed — continue
+    }
+    // Check if brew is available
+    let hasBrew = false;
+    try {
+        const { execa } = await import('execa');
+        await execa('brew', ['--version'], { stdio: 'pipe' });
+        hasBrew = true;
+    }
+    catch {
+        // no brew
+    }
+    console.log(pc.yellow('\n⚠ tmux not found'));
+    console.log(pc.dim('  tmux enables a persistent task title bar while Claude runs.'));
+    if (hasBrew) {
+        const { select } = await import('@inquirer/prompts');
+        const action = await select({
+            message: 'Install tmux via Homebrew?',
+            choices: [
+                { name: 'Install now (brew install tmux)', value: 'install' },
+                { name: 'Skip for now', value: 'skip' },
+                { name: "Don't ask again", value: 'dismiss' },
+            ],
+        });
+        if (action === 'install') {
+            console.log(pc.dim('\nInstalling tmux...'));
+            try {
+                const { execa } = await import('execa');
+                await execa('brew', ['install', 'tmux'], { stdio: 'inherit' });
+                console.log(pc.green('✓ tmux installed\n'));
+            }
+            catch {
+                console.log(pc.red('Failed to install tmux. You can install it manually: brew install tmux\n'));
+            }
+        }
+        else if (action === 'dismiss') {
+            setPreference('tmuxPromptDismissed', true);
+            console.log(pc.dim('You can install it later: brew install tmux\n'));
+        }
+        else {
+            console.log(pc.dim('Continuing without tmux.\n'));
+        }
+    }
+    else {
+        console.log(pc.dim('  Install it with: brew install tmux'));
+        console.log(pc.dim('  Or see: https://github.com/tmux/tmux/wiki/Installing\n'));
+        const { select } = await import('@inquirer/prompts');
+        const action = await select({
+            message: 'What would you like to do?',
+            choices: [
+                { name: 'Continue without tmux', value: 'skip' },
+                { name: "Don't remind me again", value: 'dismiss' },
+            ],
+        });
+        if (action === 'dismiss') {
+            setPreference('tmuxPromptDismissed', true);
+        }
+    }
+}

package/dist/services/claude.js

@@ -4,7 +4,7 @@ import * as os from 'node:os';
 import { spawn } from 'node:child_process';
 import { execa } from 'execa';
 import pc from 'picocolors';
-import { shortIdRaw, setTerminalTitle, clearTerminalTitle, TerminalStatusBar } from '../ui/format.js';
+import { shortIdRaw, setTerminalTitle, clearTerminalTitle } from '../ui/format.js';
 const CLAUDE_SETTINGS_DIR = path.join(os.homedir(), '.claude');
 const CLAUDE_SETTINGS_FILE = path.join(CLAUDE_SETTINGS_DIR, 'settings.json');
 /**
@@ -81,6 +81,62 @@ export function configureDamperMcp() {
     // Write back
     fs.writeFileSync(CLAUDE_SETTINGS_FILE, JSON.stringify(settings, null, 2));
 }
+/**
+ * Check if tmux is available
+ */
+async function isTmuxAvailable() {
+    try {
+        await execa('tmux', ['-V'], { stdio: 'pipe' });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Launch a command inside a tmux session with a persistent status bar.
+ * The session auto-exits when the command finishes.
+ */
+async function launchInTmux(options) {
+    const { label, command, args, cwd, env } = options;
+    const sessionName = `damper-${Date.now()}`;
+    // Build the full command string to run inside tmux
+    // When the command finishes, tmux exits automatically via remain-on-exit off
+    const escapedArgs = args.map(a => `'${a.replace(/'/g, "'\\''")}'`).join(' ');
+    const fullCmd = `${command} ${escapedArgs}`;
+    // Create a detached tmux session running the command directly
+    // Using tmux new-session with the command means the session dies when the command exits
+    await execa('tmux', [
+        'new-session', '-d',
+        '-s', sessionName,
+        '-x', String(process.stdout.columns || 80),
+        '-y', String(process.stdout.rows || 24),
+        fullCmd,
+    ], { cwd, env: { ...process.env, ...env }, stdio: 'pipe' });
+    // Configure the status bar
+    const statusBarCmds = [
+        ['set-option', '-t', sessionName, 'status', 'on'],
+        ['set-option', '-t', sessionName, 'status-position', 'top'],
+        ['set-option', '-t', sessionName, 'status-style', 'bg=#1e1e2e,fg=#cdd6f4'],
+        ['set-option', '-t', sessionName, 'status-left', ` ${label} `],
+        ['set-option', '-t', sessionName, 'status-left-length', '100'],
+        ['set-option', '-t', sessionName, 'status-right', ''],
+    ];
+    for (const cmd of statusBarCmds) {
+        await execa('tmux', cmd, { stdio: 'pipe' }).catch(() => { });
+    }
+    // Attach to the session — blocks until Claude exits and tmux session ends
+    await new Promise((resolve) => {
+        const child = spawn('tmux', ['attach-session', '-t', sessionName], {
+            cwd,
+            stdio: 'inherit',
+        });
+        child.on('error', () => resolve());
+        child.on('close', () => resolve());
+    });
+    // Cleanup in case session lingers
+    await execa('tmux', ['kill-session', '-t', sessionName], { stdio: 'pipe' }).catch(() => { });
+}
 /**
  * Launch Claude Code in a directory
  */
@@ -136,35 +192,42 @@ export async function launchClaude(options) {
         args = yolo ? ['--dangerously-skip-permissions', initialPrompt] : [initialPrompt];
         console.log(pc.dim(`Launching Claude in ${cwd}...`));
     }
-    // Set terminal title and bottom status bar
+    // Set terminal title (works in tab bar regardless of tmux)
     const taskLabel = `#${shortIdRaw(taskId)}: ${taskTitle}`;
     setTerminalTitle(taskLabel);
-    const statusBar = new TerminalStatusBar(taskLabel);
-    statusBar.show();
-    // Launch Claude Code
-    // Use spawn with stdio: 'inherit' for proper TTY passthrough
-    // Signals (Ctrl+C, Escape) are handled naturally since child inherits the terminal
-    await new Promise((resolve) => {
-        const child = spawn('claude', args, {
+    const hasTmux = await isTmuxAvailable();
+    if (hasTmux) {
+        // Launch inside tmux with a persistent status bar
+        await launchInTmux({
+            label: taskLabel,
+            command: 'claude',
+            args,
             cwd,
-            stdio: 'inherit',
-            env: {
-                ...process.env,
-                DAMPER_API_KEY: apiKey,
-            },
+            env: { DAMPER_API_KEY: apiKey },
         });
-        child.on('error', (err) => {
-            if (err.code === 'ENOENT') {
-                console.log(pc.red('\nError: Claude Code CLI not found.'));
-                console.log(pc.dim('Install it with: npm install -g @anthropic-ai/claude-code\n'));
-                process.exit(1);
-            }
-            resolve();
+    }
+    else {
+        // Fallback: direct spawn (no status bar, just terminal title)
+        await new Promise((resolve) => {
+            const child = spawn('claude', args, {
+                cwd,
+                stdio: 'inherit',
+                env: {
+                    ...process.env,
+                    DAMPER_API_KEY: apiKey,
+                },
+            });
+            child.on('error', (err) => {
+                if (err.code === 'ENOENT') {
+                    console.log(pc.red('\nError: Claude Code CLI not found.'));
+                    console.log(pc.dim('Install it with: npm install -g @anthropic-ai/claude-code\n'));
+                    process.exit(1);
+                }
+                resolve();
+            });
+            child.on('close', () => resolve());
         });
-        child.on('close', () => resolve());
-    });
-    // Clean up status bar and terminal title
-    statusBar.hide();
+    }
     clearTerminalTitle();
     console.log(pc.dim('\n─────────────────────────────────────────\n'));
     return { cwd, taskId, apiKey };
@@ -549,18 +612,27 @@ export async function launchClaudeForReview(options) {
     ].join('\n');
     const reviewLabel = `Review #${shortIdRaw(taskId)}`;
     setTerminalTitle(reviewLabel);
-    const statusBar = new TerminalStatusBar(reviewLabel);
-    statusBar.show();
-    await new Promise((resolve) => {
-        const child = spawn('claude', [prompt], {
+    const hasTmux = await isTmuxAvailable();
+    if (hasTmux) {
+        await launchInTmux({
+            label: reviewLabel,
+            command: 'claude',
+            args: [prompt],
             cwd,
-            stdio: 'inherit',
-            env: { ...process.env, DAMPER_API_KEY: apiKey },
+            env: { DAMPER_API_KEY: apiKey },
         });
-        child.on('error', () => resolve());
-        child.on('close', () => resolve());
-    });
-    statusBar.hide();
+    }
+    else {
+        await new Promise((resolve) => {
+            const child = spawn('claude', [prompt], {
+                cwd,
+                stdio: 'inherit',
+                env: { ...process.env, DAMPER_API_KEY: apiKey },
+            });
+            child.on('error', () => resolve());
+            child.on('close', () => resolve());
+        });
+    }
     clearTerminalTitle();
 }
 /**
@@ -573,18 +645,27 @@ async function launchClaudeForMerge(options) {
     const prompt = 'IMPORTANT: Your ONLY job is to resolve merge conflicts. Do NOT read TASK_CONTEXT.md or work on any task. Run: git merge origin/main --no-edit. If there are conflicts, resolve them, stage, and commit. Do not use any MCP tools.';
     const mergeLabel = 'Resolving merge conflicts';
     setTerminalTitle(mergeLabel);
-    const statusBar = new TerminalStatusBar(mergeLabel);
-    statusBar.show();
-    await new Promise((resolve) => {
-        const child = spawn('claude', ['--allowedTools', 'Bash,Read,Write,Edit,Glob,Grep', prompt], {
+    const hasTmux = await isTmuxAvailable();
+    if (hasTmux) {
+        await launchInTmux({
+            label: mergeLabel,
+            command: 'claude',
+            args: ['--allowedTools', 'Bash,Read,Write,Edit,Glob,Grep', prompt],
             cwd,
-            stdio: 'inherit',
-            env: { ...process.env, DAMPER_API_KEY: apiKey },
+            env: { DAMPER_API_KEY: apiKey },
         });
-        child.on('error', () => resolve());
-        child.on('close', () => resolve());
-    });
-    statusBar.hide();
+    }
+    else {
+        await new Promise((resolve) => {
+            const child = spawn('claude', ['--allowedTools', 'Bash,Read,Write,Edit,Glob,Grep', prompt], {
+                cwd,
+                stdio: 'inherit',
+                env: { ...process.env, DAMPER_API_KEY: apiKey },
+            });
+            child.on('error', () => resolve());
+            child.on('close', () => resolve());
+        });
+    }
     clearTerminalTitle();
 }
 /**

package/dist/services/state.d.ts

@@ -13,3 +13,10 @@ export declare function removeWorktree(taskId: string): void;
 export declare function removeWorktreeByPath(worktreePath: string): void;
 export declare function cleanupStaleWorktrees(): WorktreeState[];
 export declare function getWorktreesForProject(projectRoot: string): WorktreeState[];
+interface Preferences {
+    tmuxPromptDismissed?: boolean;
+    [key: string]: unknown;
+}
+export declare function getPreference<K extends keyof Preferences>(key: K): Preferences[K];
+export declare function setPreference<K extends keyof Preferences>(key: K, value: Preferences[K]): void;
+export {};

package/dist/services/state.js

@@ -75,3 +75,28 @@ export function getWorktreesForProject(projectRoot) {
     const normalized = path.resolve(projectRoot);
     return readState().worktrees.filter(w => path.resolve(w.projectRoot) === normalized);
 }
+// ── Preferences (persistent user choices) ──
+const PREFS_FILE = path.join(STATE_DIR, 'preferences.json');
+function readPrefs() {
+    ensureStateDir();
+    if (!fs.existsSync(PREFS_FILE))
+        return {};
+    try {
+        return JSON.parse(fs.readFileSync(PREFS_FILE, 'utf-8'));
+    }
+    catch {
+        return {};
+    }
+}
+function writePrefs(prefs) {
+    ensureStateDir();
+    fs.writeFileSync(PREFS_FILE, JSON.stringify(prefs, null, 2));
+}
+export function getPreference(key) {
+    return readPrefs()[key];
+}
+export function setPreference(key, value) {
+    const prefs = readPrefs();
+    prefs[key] = value;
+    writePrefs(prefs);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@damper/cli",
-  "version": "0.9.12",
+  "version": "0.9.14",
   "description": "CLI tool for orchestrating Damper task workflows with Claude Code",
   "author": "Damper <hello@usedamper.com>",
   "repository": {