@abyrd9/harbor-cli 2.3.2 → 2.3.4

package/dist/index.js

@@ -8,6 +8,20 @@ import { readFileSync } from 'node:fs';
 import { fileURLToPath } from 'node:url';
 import os from 'node:os';
 import readline from 'node:readline';
+import pc from 'picocolors';
+// Colored output helpers
+const log = {
+    error: (msg) => console.log(`${pc.red('✗')} ${msg}`),
+    success: (msg) => console.log(`${pc.green('✓')} ${msg}`),
+    info: (msg) => console.log(`${pc.blue('ℹ')} ${msg}`),
+    warn: (msg) => console.log(`${pc.yellow('⚠')} ${msg}`),
+    step: (msg) => console.log(`${pc.cyan('→')} ${msg}`),
+    dim: (msg) => console.log(pc.dim(msg)),
+    plain: (msg) => console.log(msg),
+    header: (msg) => console.log(`\n${pc.bold(msg)}`),
+    cmd: (msg) => console.log(`  ${pc.dim('$')} ${pc.cyan(msg)}`),
+    label: (label, value) => console.log(`   ${pc.dim(label)}  ${value}`),
+};
 // Read version from package.json
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
@@ -144,20 +158,20 @@ async function checkDependencies() {
         }
     }
     if (missingDeps.length > 0) {
-        console.log('❌ Missing required dependencies:');
-        console.log(`\n🖥️  Detected OS: ${osInfo.platform} ${osInfo.arch}${osInfo.isWSL ? ' (WSL)' : ''}`);
+        log.error('Missing required dependencies');
+        log.plain(`\n${pc.dim('Detected OS:')} ${osInfo.platform} ${osInfo.arch}${osInfo.isWSL ? ' (WSL)' : ''}`);
         for (const dep of missingDeps) {
-            console.log(`\n📦 ${dep.name} (required for ${dep.requiredFor})`);
+            log.plain(`\n${pc.yellow(dep.name)} ${pc.dim(`(required for ${dep.requiredFor})`)}`);
             const instructions = getInstallInstructions(dep.name, osInfo);
             if (instructions.length > 0) {
-                console.log('   Installation options:');
-                instructions.forEach(instruction => { console.log(instruction); });
+                log.plain(pc.dim('   Installation options:'));
+                instructions.forEach(instruction => { log.plain(instruction); });
             }
             else {
-                console.log(`   General instructions: ${dep.installMsg}`);
+                log.plain(`   ${pc.dim('Instructions:')} ${dep.installMsg}`);
             }
         }
-        console.log('\n💡 After installing the dependencies, run Harbor again.');
+        log.plain(`\n${pc.dim('After installing dependencies, run Harbor again.')}`);
         throw new Error('Please install missing dependencies before continuing');
     }
 }
@@ -167,11 +181,11 @@ function promptConfigLocation() {
         output: process.stdout,
     });
     return new Promise((resolve) => {
-        console.log('\nFound package.json. Where would you like to store harbor config?');
-        console.log('  1. package.json (keeps everything in one place)');
-        console.log('  2. harbor.json (separate config file, auto-IntelliSense)\n');
+        log.plain(`\n${pc.bold('Found package.json.')} Where would you like to store harbor config?`);
+        log.plain(`  ${pc.cyan('1.')} package.json ${pc.dim('(keeps everything in one place)')}`);
+        log.plain(`  ${pc.cyan('2.')} harbor.json ${pc.dim('(separate config file, auto-IntelliSense)')}\n`);
         const ask = () => {
-            rl.question('Enter choice (1 or 2): ', (answer) => {
+            rl.question(`Enter choice ${pc.dim('(1 or 2)')}: `, (answer) => {
                 const choice = answer.trim();
                 if (choice === '1') {
                     rl.close();
@@ -182,7 +196,7 @@ function promptConfigLocation() {
                     resolve('harbor.json');
                 }
                 else {
-                    console.log('Please enter 1 or 2');
+                    log.warn('Please enter 1 or 2');
                     ask();
                 }
             });
@@ -201,192 +215,173 @@ const possibleProjectFiles = [
     'build.gradle', // Java Gradle projects
 ];
 const program = new Command();
-program
-    .name('harbor')
-    .description(`A CLI tool for orchestrating multiple local development services in tmux.
+// Custom help formatting
+function showCustomHelp() {
+    const dim = pc.dim;
+    const bold = pc.bold;
+    const cyan = pc.cyan;
+    const yellow = pc.yellow;
+    const green = pc.green;
+    console.log(`
+${bold('⚓ Harbor')} ${dim(`v${packageJson.version}`)}
+${dim('Orchestrate local dev services in tmux')}
 
-WHAT IT DOES:
-  Harbor manages multiple services (APIs, frontends, databases) in a single tmux 
-  session. It auto-discovers projects, starts them together, and provides logging.
+${yellow('Usage:')}
+  ${dim('$')} harbor ${cyan('<command>')} ${dim('[options]')}
 
-REQUIREMENTS:
-  - tmux (terminal multiplexer)
-  - jq (JSON processor)
+${yellow('Commands:')}
+  ${green('dock')}       Scan directories and create harbor.json config
+  ${green('moor')}       Add new services to existing config
+  ${green('launch')}     Start all services in tmux ${dim('(-d for headless)')}
+  ${green('anchor')}     Attach to a running Harbor session
+  ${green('scuttle')}    Stop all services
+  ${green('bearings')}   Show status of running services
 
-TYPICAL WORKFLOW:
-  1. harbor dock          # First time: scan and create harbor.json config
-  2. harbor launch        # Start all services in interactive tmux session
-     harbor launch -d     # Or start in headless/background mode
-  3. harbor bearings      # Check status of running services
-  4. harbor anchor        # Attach to running session (if headless)
-  5. harbor scuttle       # Stop all services when done
+${yellow('Quick Start:')}
+  ${dim('$')} harbor dock            ${dim('# Create config')}
+  ${dim('$')} harbor launch          ${dim('# Start services')}
+  ${dim('$')} harbor launch -d       ${dim('# Start headless')}
 
-CONFIGURATION:
-  Config is stored in harbor.json or package.json under "harbor" key.
-  Services can specify: name, path, command, log (boolean), maxLogLines.
+${yellow('Options:')}
+  ${cyan('-V, --version')}   Show version
+  ${cyan('-h, --help')}      Show help for command
 
-COMMANDS:
-  dock      Create new harbor.json by scanning for projects (package.json, go.mod, etc.)
-  moor      Add newly discovered services to existing config
-  launch    Start all configured services (use -d/--headless for background mode)
-  bearings  Show status: running services, session info, log file locations
-  anchor    Attach terminal to a running Harbor tmux session
-  scuttle   Stop all services by killing the tmux session`)
+${dim('Run')} harbor ${cyan('<command>')} --help ${dim('for detailed command info')}
+`);
+}
+program
+    .name('harbor')
+    .description('Orchestrate local dev services in tmux')
     .version(packageJson.version)
     .action(async () => await checkDependencies())
-    .addHelpCommand(false);
-// If no command is provided, display help
+    .addHelpCommand(false)
+    .configureHelp({
+    sortSubcommands: false,
+    sortOptions: false,
+});
+// Override help display
+program.helpInformation = () => '';
+program.on('--help', () => { });
+// If no command is provided, display custom help
 if (process.argv.length <= 2) {
-    program.help();
+    showCustomHelp();
+    process.exit(0);
+}
+// Handle -h and --help for main command
+if (process.argv.includes('-h') || process.argv.includes('--help')) {
+    if (process.argv.length === 3) {
+        showCustomHelp();
+        process.exit(0);
+    }
 }
 program.command('dock')
-    .description(`Initialize a new Harbor project by scanning directories for services.
-
-WHEN TO USE: Run this first in a new project that has no harbor.json yet.
-
-WHAT IT DOES:
-  - Scans subdirectories for project files (package.json, go.mod, Cargo.toml, etc.)
-  - Creates harbor.json with discovered services
-  - Auto-detects run commands (npm run dev, go run ., etc.)
-
-PREREQUISITES: No existing harbor.json or harbor config in package.json.
-
-EXAMPLE:
-  harbor dock              # Scan current directory
-  harbor dock -p ./apps    # Scan specific subdirectory`)
-    .option('-p, --path <path>', 'Directory to scan for service projects (scans subdirectories)', './')
+    .description('Scan directories and create harbor.json config')
+    .option('-p, --path <path>', 'Directory to scan for service projects', './')
     .action(async (options) => {
     try {
         await checkDependencies();
         const configExists = checkHasHarborConfig();
         if (configExists) {
-            console.log('❌ Error: Harbor project already initialized');
-            console.log('   - Harbor configuration already exists');
-            console.log('\nTo reinitialize, please remove the configuration first.');
+            log.error('Harbor project already initialized');
+            log.dim('   Configuration already exists');
+            log.plain('');
+            log.info('To reinitialize, remove the existing configuration first.');
             process.exit(1);
         }
         await generateDevFile(options.path);
-        console.log('✨ Environment prepared!');
+        log.plain('');
+        log.success(pc.green('Environment prepared!'));
     }
     catch (err) {
-        console.log('❌ Error:', err instanceof Error ? err.message : 'Unknown error');
+        log.error(err instanceof Error ? err.message : 'Unknown error');
         process.exit(1);
     }
 });
 program.command('moor')
-    .description(`Add newly discovered services to an existing Harbor configuration.
-
-WHEN TO USE: Run when you've added new service directories to your project.
-
-WHAT IT DOES:
-  - Scans for new project directories not already in config
-  - Adds them to existing harbor.json or package.json harbor config
-  - Skips directories already configured
-
-PREREQUISITES: Existing harbor.json or harbor config in package.json (run 'dock' first).
-
-EXAMPLE:
-  harbor moor              # Scan and add new services
-  harbor moor -p ./apps    # Scan specific subdirectory for new services`)
+    .description('Add new services to existing config')
     .option('-p, --path <path>', 'Directory to scan for new service projects', './')
     .action(async (options) => {
     try {
         await checkDependencies();
         if (!checkHasHarborConfig()) {
-            console.log('❌ No harbor configuration found');
-            console.log('\nTo initialize a new Harbor project, please use:');
-            console.log('  harbor dock');
+            log.error('No harbor configuration found');
+            log.plain('');
+            log.info('To initialize a new Harbor project:');
+            log.cmd('harbor dock');
             process.exit(1);
         }
         await generateDevFile(options.path);
     }
     catch (err) {
-        console.log('❌ Error:', err instanceof Error ? err.message : 'Unknown error');
+        log.error(err instanceof Error ? err.message : 'Unknown error');
         process.exit(1);
     }
 });
 program.command('launch')
-    .description(`Start all configured services in a tmux session.
-
-WHEN TO USE: Run to start your development environment.
-
-WHAT IT DOES:
-  - Kills any existing Harbor tmux session
-  - Runs 'before' scripts if configured
-  - Creates tmux session with a window per service
-  - Starts each service with its configured command
-  - Enables logging to .harbor/*.log if log:true in config
-  - Runs 'after' scripts when session ends
-
-MODES:
-  Interactive (default): Opens tmux session, use Shift+Left/Right to switch tabs
-  Headless (-d/--headless): Runs in background, use 'anchor' to attach later
-
-PREREQUISITES: harbor.json or harbor config in package.json.
-
-EXAMPLES:
-  harbor launch            # Start and attach to tmux session
-  harbor launch -d         # Start in background (headless mode)
-  harbor launch --headless # Same as -d
-  harbor launch --name my-session # Use custom session name`)
-    .option('-d, --detach', 'Run in background without attaching (headless mode). Use "anchor" to attach later.')
+    .description('Start all services in tmux (-d for headless)')
+    .option('-d, --detach', 'Run in background (headless mode)')
     .option('--headless', 'Alias for --detach')
-    .option('--name <name>', 'Override tmux session name from config')
+    .option('--name <name>', 'Override tmux session name')
     .action(async (options) => {
     try {
+        const isDetached = options.detach || options.headless;
+        // Check if already inside a tmux session (only matters for attached mode)
+        if (!isDetached && process.env.TMUX) {
+            log.error('Cannot launch in attached mode from inside a tmux session');
+            log.plain('');
+            log.info('Options:');
+            log.plain(`   ${pc.cyan('1.')} Use headless mode: ${pc.cyan('harbor launch -d')}`);
+            log.plain(`   ${pc.cyan('2.')} Detach from current session ${pc.dim('(Ctrl+b then d)')} and try again`);
+            process.exit(1);
+        }
         await checkDependencies();
-        await runServices({ detach: options.detach || options.headless, name: options.name });
+        await runServices({ detach: isDetached, name: options.name });
     }
     catch (err) {
-        console.log('❌ Error:', err instanceof Error ? err.message : 'Unknown error');
+        log.error(err instanceof Error ? err.message : 'Unknown error');
         process.exit(1);
     }
 });
 program.command('anchor')
-    .description(`Attach your terminal to a running Harbor tmux session.
-
-WHEN TO USE: After starting services with 'launch -d' (headless mode).
-
-WHAT IT DOES:
-  - Checks if a Harbor tmux session is running
-  - Attaches your terminal to it
-  - You can then switch between service tabs with Shift+Left/Right
-  - Press Ctrl+q to kill session, or detach with Ctrl+b then d
-  - Runs any configured 'after' scripts if the session is killed
-
-PREREQUISITES: Services must be running (started with 'harbor launch').
-
-EXAMPLES:
-  harbor launch -d               # Start in background
-  harbor anchor                  # Attach to default session
-  harbor anchor --name my-app    # Attach to a specific named session`)
-    .option('--name <name>', 'Specify which tmux session to attach to (defaults to config sessionName or "harbor")')
+    .description('Attach to a running Harbor session')
+    .option('--name <name>', 'Session name to attach to')
     .action(async (options) => {
     try {
+        // Check if already inside a tmux session
+        if (process.env.TMUX) {
+            log.error('Cannot anchor from inside a tmux session');
+            log.plain('');
+            log.info('You are already inside a tmux session. To attach:');
+            log.plain(`   ${pc.cyan('1.')} Detach from current session ${pc.dim('(Ctrl+b then d)')}`);
+            log.plain(`   ${pc.cyan('2.')} Run ${pc.cyan('harbor anchor')} from a regular terminal`);
+            process.exit(1);
+        }
         const config = await readHarborConfig();
         const sessionName = options.name || config.sessionName || 'harbor';
+        const socketName = `harbor-${sessionName}`;
         // Check if session exists
-        const checkSession = spawn('tmux', ['has-session', '-t', sessionName], {
+        const checkSession = spawn('tmux', ['-L', socketName, 'has-session', '-t', sessionName], {
             stdio: 'pipe',
         });
         await new Promise((resolve) => {
             checkSession.on('close', (code) => {
                 if (code !== 0) {
-                    console.log(`❌ No running Harbor session found (looking for: ${sessionName})`);
-                    console.log('\nTo start services, run:');
-                    console.log('  harbor launch');
+                    log.error(`No running Harbor session found ${pc.dim(`(looking for: ${sessionName})`)}`);
+                    log.plain('');
+                    log.info('To start services:');
+                    log.cmd('harbor launch');
                     process.exit(1);
                 }
                 resolve();
             });
         });
         // Attach to the session
-        const attach = spawn('tmux', ['attach-session', '-t', sessionName], {
+        const attach = spawn('tmux', ['-L', socketName, 'attach-session', '-t', sessionName], {
             stdio: 'inherit',
         });
         attach.on('close', async (code) => {
             // Check if session was killed (vs just detached)
-            const checkAfter = spawn('tmux', ['has-session', '-t', sessionName], {
+            const checkAfter = spawn('tmux', ['-L', socketName, 'has-session', '-t', sessionName], {
                 stdio: 'pipe',
             });
             const sessionStillExists = await new Promise((resolve) => {
@@ -400,7 +395,7 @@ EXAMPLES:
                     await execute(config.after, 'after');
                 }
                 catch {
-                    console.error('❌ After scripts failed');
+                    log.error('After scripts failed');
                     process.exit(1);
                 }
             }
@@ -408,33 +403,20 @@ EXAMPLES:
         });
     }
     catch (err) {
-        console.log('❌ Error:', err instanceof Error ? err.message : 'Unknown error');
+        log.error(err instanceof Error ? err.message : 'Unknown error');
         process.exit(1);
     }
 });
 program.command('scuttle')
-    .description(`Stop all running Harbor services by killing the tmux session.
-
-WHEN TO USE: When you want to stop all services and free up resources.
-
-WHAT IT DOES:
-  - Finds the running Harbor tmux session
-  - Kills the entire session (all service windows)
-  - All services stop immediately
-  - Runs any configured 'after' scripts
-
-SAFE TO RUN: If no session is running, it simply reports that and exits cleanly.
-
-EXAMPLES:
-  harbor scuttle                # Stop default session
-  harbor scuttle --name my-app  # Stop a specific named session`)
-    .option('--name <name>', 'Specify which tmux session to stop (defaults to config sessionName or "harbor")')
+    .description('Stop all services and kill the session')
+    .option('--name <name>', 'Session name to stop')
     .action(async (options) => {
     try {
         const config = await readHarborConfig();
         const sessionName = options.name || config.sessionName || 'harbor';
+        const socketName = `harbor-${sessionName}`;
         // Check if session exists
-        const checkSession = spawn('tmux', ['has-session', '-t', sessionName], {
+        const checkSession = spawn('tmux', ['-L', socketName, 'has-session', '-t', sessionName], {
             stdio: 'pipe',
         });
         const sessionExists = await new Promise((resolve) => {
@@ -443,68 +425,48 @@ EXAMPLES:
             });
         });
         if (!sessionExists) {
-            console.log(`ℹ️  No running Harbor session found (looking for: ${sessionName})`);
+            log.info(`No running Harbor session found ${pc.dim(`(looking for: ${sessionName})`)}`);
             process.exit(0);
         }
         // Kill the session
-        const killSession = spawn('tmux', ['kill-session', '-t', sessionName], {
+        const killSession = spawn('tmux', ['-L', socketName, 'kill-session', '-t', sessionName], {
             stdio: 'inherit',
         });
         killSession.on('close', async (code) => {
             if (code === 0) {
-                console.log(`✅ Harbor session '${sessionName}' stopped`);
+                log.success(`Harbor session ${pc.cyan(sessionName)} stopped`);
                 // Execute after scripts when session is killed
                 if (config.after && config.after.length > 0) {
                     try {
                         await execute(config.after, 'after');
                     }
                     catch {
-                        console.error('❌ After scripts failed');
+                        log.error('After scripts failed');
                         process.exit(1);
                     }
                 }
             }
             else {
-                console.log('❌ Failed to stop Harbor session');
+                log.error('Failed to stop Harbor session');
             }
             process.exit(code || 0);
         });
     }
     catch (err) {
-        console.log('❌ Error:', err instanceof Error ? err.message : 'Unknown error');
+        log.error(err instanceof Error ? err.message : 'Unknown error');
         process.exit(1);
     }
 });
 program.command('bearings')
-    .description(`Show status of running Harbor services and session information.
-
-WHEN TO USE: To check if services are running, especially in headless mode.
-
-WHAT IT SHOWS:
-  - Session name and running status
-  - List of service windows (with 📄 indicator if logging enabled)
-  - Log file paths and sizes
-  - Available commands (anchor, scuttle)
-
-OUTPUT EXAMPLE:
-  ⚓ Harbor Status
-     Session:  harbor
-     Status:   Running ✓
-     Services: [0] Terminal, [1] web 📄, [2] api 📄
-     Logs:     .harbor/harbor-web.log (1.2 KB)
-
-SAFE TO RUN: Works whether services are running or not.
-
-EXAMPLES:
-  harbor bearings                # Check default session
-  harbor bearings --name my-app  # Check a specific named session`)
-    .option('--name <name>', 'Specify which tmux session to check (defaults to config sessionName or "harbor")')
+    .description('Show status of running services')
+    .option('--name <name>', 'Session name to check')
     .action(async (options) => {
     try {
         const config = await readHarborConfig();
         const sessionName = options.name || config.sessionName || 'harbor';
+        const socketName = `harbor-${sessionName}`;
         // Check if session exists
-        const checkSession = spawn('tmux', ['has-session', '-t', sessionName], {
+        const checkSession = spawn('tmux', ['-L', socketName, 'has-session', '-t', sessionName], {
             stdio: 'pipe',
         });
         const sessionExists = await new Promise((resolve) => {
@@ -513,16 +475,19 @@ EXAMPLES:
             });
         });
         if (!sessionExists) {
-            console.log(`\n⚓ Harbor Status\n`);
-            console.log(`   Session:  ${sessionName}`);
-            console.log(`   Status:   Not running\n`);
-            console.log(`   To start services, run:`);
-            console.log(`     harbor launch         # interactive mode`);
-            console.log(`     harbor launch -d      # headless mode\n`);
+            log.header(`${pc.cyan('⚓')} Harbor Status`);
+            log.plain('');
+            log.label('Session:', sessionName);
+            log.label('Status:', pc.yellow('Not running'));
+            log.plain('');
+            log.info('To start services:');
+            log.cmd(`harbor launch         ${pc.dim('# interactive mode')}`);
+            log.cmd(`harbor launch -d      ${pc.dim('# headless mode')}`);
+            log.plain('');
             process.exit(0);
         }
         // Get list of windows (services)
-        const listWindows = spawn('tmux', ['list-windows', '-t', sessionName, '-F', '#{window_index}|#{window_name}|#{pane_current_command}'], {
+        const listWindows = spawn('tmux', ['-L', socketName, 'list-windows', '-t', sessionName, '-F', '#{window_index}|#{window_name}|#{pane_current_command}'], {
             stdio: ['pipe', 'pipe', 'pipe'],
         });
         let windowOutput = '';
@@ -533,38 +498,43 @@ EXAMPLES:
             listWindows.on('close', () => resolve());
         });
         const windows = windowOutput.trim().split('\n').filter(Boolean);
-        console.log(`\n⚓ Harbor Status\n`);
-        console.log(`   Session:  ${sessionName}`);
-        console.log(`   Status:   Running ✓`);
-        console.log(`   Windows:  ${windows.length}\n`);
-        console.log(`   Services:`);
+        log.header(`${pc.cyan('⚓')} Harbor Status`);
+        log.plain('');
+        log.label('Session:', sessionName);
+        log.label('Status:', pc.green('Running ✓'));
+        log.label('Windows:', String(windows.length));
+        log.plain('');
+        log.plain(`   ${pc.dim('Services:')}`);
         for (const window of windows) {
-            const [index, name, cmd] = window.split('|');
+            const [index, name] = window.split('|');
             const logFile = `.harbor/${sessionName}-${name}.log`;
             const hasLog = fs.existsSync(path.join(process.cwd(), logFile));
-            const logIndicator = hasLog ? ` 📄` : '';
-            console.log(`     [${index}] ${name}${logIndicator}`);
+            const logIndicator = hasLog ? pc.dim(' 📄') : '';
+            log.plain(`     ${pc.dim(`[${index}]`)} ${pc.cyan(name)}${logIndicator}`);
         }
         // Check for log files
         const harborDir = path.join(process.cwd(), '.harbor');
         if (fs.existsSync(harborDir)) {
             const logFiles = fs.readdirSync(harborDir).filter(f => f.endsWith('.log'));
             if (logFiles.length > 0) {
-                console.log(`\n   Logs:`);
+                log.plain('');
+                log.plain(`   ${pc.dim('Logs:')}`);
                 for (const logFile of logFiles) {
                     const logPath = path.join(harborDir, logFile);
                     const stats = fs.statSync(logPath);
                     const sizeKB = (stats.size / 1024).toFixed(1);
-                    console.log(`     .harbor/${logFile} (${sizeKB} KB)`);
+                    log.plain(`     ${pc.dim(`.harbor/${logFile}`)} ${pc.dim(`(${sizeKB} KB)`)}`);
                 }
             }
         }
-        console.log(`\n   Commands:`);
-        console.log(`     harbor anchor   - Anchor to the session`);
-        console.log(`     harbor scuttle  - Stop all services\n`);
+        log.plain('');
+        log.plain(`   ${pc.dim('Commands:')}`);
+        log.plain(`     ${pc.cyan('harbor anchor')}   ${pc.dim('Attach to the session')}`);
+        log.plain(`     ${pc.cyan('harbor scuttle')}  ${pc.dim('Stop all services')}`);
+        log.plain('');
     }
     catch (err) {
-        console.log('❌ Error:', err instanceof Error ? err.message : 'Unknown error');
+        log.error(err instanceof Error ? err.message : 'Unknown error');
         process.exit(1);
     }
 });
@@ -634,7 +604,7 @@ async function generateDevFile(dirPath) {
         try {
             const existing = await fs.promises.readFile('harbor.json', 'utf-8');
             config = JSON.parse(existing);
-            console.log('Found existing harbor.json, scanning for new services...');
+            log.info('Found existing harbor.json, scanning for new services...');
         }
         catch (err) {
             if (err.code !== 'ENOENT') {
@@ -648,7 +618,7 @@ async function generateDevFile(dirPath) {
                     // Existing harbor config in package.json, use it
                     config = packageJson.harbor;
                     writeToPackageJson = true;
-                    console.log('Found existing harbor config in package.json, scanning for new services...');
+                    log.info('Found existing harbor config in package.json, scanning for new services...');
                 }
                 else {
                     // package.json exists but no harbor config - ask user where to store it
@@ -659,7 +629,7 @@ async function generateDevFile(dirPath) {
                         before: [],
                         after: [],
                     };
-                    console.log(`Creating new harbor config in ${choice}...`);
+                    log.step(`Creating new harbor config in ${pc.cyan(choice)}...`);
                 }
             }
             catch (err) {
@@ -670,7 +640,7 @@ async function generateDevFile(dirPath) {
                 config = {
                     services: [],
                 };
-                console.log('Creating new harbor.json...');
+                log.step(`Creating new ${pc.cyan('harbor.json')}...`);
             }
         }
         // Create a map of existing services for easy lookup
@@ -694,19 +664,19 @@ async function generateDevFile(dirPath) {
                         service.command = 'go run .';
                     }
                     config.services.push(service);
-                    console.log(`Added new service: ${folder.name}`);
+                    log.success(`Added service: ${pc.green(folder.name)}`);
                     newServicesAdded = true;
                 }
                 else if (existing.has(folder.name)) {
-                    console.log(`Skipping existing service: ${folder.name}`);
+                    log.dim(`  Skipping existing service: ${folder.name}`);
                 }
                 else {
-                    console.log(`Skipping directory ${folder.name} (no recognized project files)`);
+                    log.dim(`  Skipping directory ${folder.name} (no recognized project files)`);
                 }
             }
         }
         if (!newServicesAdded) {
-            console.log('No new services found to add, feel free to add them manually');
+            log.info('No new services found to add, feel free to add them manually');
         }
         const validationError = validateConfig(config);
         if (validationError) {
@@ -718,15 +688,15 @@ async function generateDevFile(dirPath) {
             const packageJson = JSON.parse(packageData);
             packageJson.harbor = config;
             await fs.promises.writeFile('package.json', JSON.stringify(packageJson, null, 2), 'utf-8');
-            console.log('\npackage.json updated successfully with harbor configuration');
-            console.log('\n💡 Tip: To enable IntelliSense for the harbor config in package.json,');
-            console.log('   add this to your .vscode/settings.json:');
-            console.log('   {');
-            console.log('     "json.schemas": [{');
-            console.log('       "fileMatch": ["package.json"],');
-            console.log('       "url": "https://raw.githubusercontent.com/Abyrd9/harbor-cli/main/harbor.package-json.schema.json"');
-            console.log('     }]');
-            console.log('   }');
+            log.success(`${pc.cyan('package.json')} updated with harbor configuration`);
+            log.plain('');
+            log.info(`${pc.dim('Tip:')} To enable IntelliSense, add this to ${pc.cyan('.vscode/settings.json')}:`);
+            log.plain(pc.dim('   {'));
+            log.plain(pc.dim('     "json.schemas": [{'));
+            log.plain(pc.dim('       "fileMatch": ["package.json"],'));
+            log.plain(pc.dim('       "url": "https://raw.githubusercontent.com/Abyrd9/harbor-cli/main/harbor.package-json.schema.json"'));
+            log.plain(pc.dim('     }]'));
+            log.plain(pc.dim('   }'));
         }
         else {
             // Write to harbor.json with $schema for IntelliSense
@@ -735,10 +705,10 @@ async function generateDevFile(dirPath) {
                 ...config,
             };
             await fs.promises.writeFile('harbor.json', JSON.stringify(configWithSchema, null, 2), 'utf-8');
-            console.log('\nharbor.json created successfully');
+            log.success(`${pc.cyan('harbor.json')} created successfully`);
         }
-        console.log('\nImportant:');
-        console.log('  - Verify the auto-detected commands are correct for your services');
+        log.plain('');
+        log.info(`${pc.dim('Important:')} Verify the auto-detected commands are correct for your services`);
         return true;
     }
     catch (err) {
@@ -785,11 +755,12 @@ async function execute(scripts, scriptType) {
     if (!scripts || scripts.length === 0) {
         return;
     }
-    console.log(`\n🚀 Executing ${scriptType} scripts...`);
+    log.header(`Running ${scriptType} scripts...`);
     for (let i = 0; i < scripts.length; i++) {
         const script = scripts[i];
-        console.log(`\n📋 Running ${scriptType} script ${i + 1}/${scripts.length}: ${script.command}`);
-        console.log(`   📁 In directory: ${script.path}`);
+        log.plain('');
+        log.step(`${pc.dim(`[${i + 1}/${scripts.length}]`)} ${pc.cyan(script.command)}`);
+        log.dim(`   in ${script.path}`);
         try {
             await new Promise((resolve, reject) => {
                 const process = spawn('sh', ['-c', `cd "${script.path}" && ${script.command}`], {
@@ -797,7 +768,7 @@ async function execute(scripts, scriptType) {
                 });
                 process.on('close', (code) => {
                     if (code === 0) {
-                        console.log(`✅ ${scriptType} script ${i + 1} completed successfully`);
+                        log.success(`${scriptType} script ${i + 1} completed`);
                         resolve(null);
                     }
                     else {
@@ -810,18 +781,20 @@ async function execute(scripts, scriptType) {
             });
         }
         catch (err) {
-            console.error(`❌ Error executing ${scriptType} script ${i + 1}:`, err instanceof Error ? err.message : 'Unknown error');
+            log.error(`Error executing ${scriptType} script ${i + 1}: ${err instanceof Error ? err.message : 'Unknown error'}`);
             throw err;
         }
     }
-    console.log(`\n✅ All ${scriptType} scripts completed successfully`);
+    log.plain('');
+    log.success(`All ${scriptType} scripts completed`);
 }
 async function runServices(options = {}) {
     const hasHarborConfig = checkHasHarborConfig();
     if (!hasHarborConfig) {
-        console.log('❌ No harbor configuration found');
-        console.log('\nTo initialize a new Harbor project, please use:');
-        console.log('  harbor dock');
+        log.error('No harbor configuration found');
+        log.plain('');
+        log.info('To initialize a new Harbor project:');
+        log.cmd('harbor dock');
         process.exit(1);
     }
     // Load and validate config
@@ -830,12 +803,12 @@ async function runServices(options = {}) {
         config = await readHarborConfig();
         const validationError = validateConfig(config);
         if (validationError) {
-            console.log(`❌ Invalid harbor.json configuration: ${validationError}`);
+            log.error(`Invalid harbor.json configuration: ${validationError}`);
             process.exit(1);
         }
     }
     catch (err) {
-        console.error('Error reading config:', err);
+        log.error(`Error reading config: ${err}`);
         process.exit(1);
     }
     ensureLogSetup(config);
@@ -844,7 +817,7 @@ async function runServices(options = {}) {
         await execute(config.before || [], 'before');
     }
     catch {
-        console.error('❌ Before scripts failed, aborting launch');
+        log.error('Before scripts failed, aborting launch');
         process.exit(1);
     }
     // Ensure scripts exist and are executable
@@ -862,12 +835,12 @@ async function runServices(options = {}) {
     });
     return new Promise((resolve) => {
         command.on('error', (err) => {
-            console.error(`Error running dev.sh: ${err}`);
+            log.error(`Error running dev.sh: ${err}`);
             process.exit(1);
         });
         command.on('close', async (code) => {
             if (code !== 0) {
-                console.error(`dev.sh exited with code ${code}`);
+                log.error(`dev.sh exited with code ${code}`);
                 process.exit(1);
             }
             // Only execute after scripts in attached mode
@@ -877,7 +850,7 @@ async function runServices(options = {}) {
                     await execute(config.after || [], 'after');
                 }
                 catch {
-                    console.error('❌ After scripts failed');
+                    log.error('After scripts failed');
                     process.exit(1);
                 }
             }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@abyrd9/harbor-cli",
-  "version": "2.3.2",
+  "version": "2.3.4",
   "description": "A CLI tool for orchestrating local development services in a tmux session. Perfect for microservices and polyglot projects with automatic service discovery and before/after script support.",
   "type": "module",
   "bin": {
@@ -42,7 +42,8 @@
     "node": ">=18.0.0"
   },
   "dependencies": {
-    "@commander-js/extra-typings": "^14.0.0"
+    "@commander-js/extra-typings": "^14.0.0",
+    "picocolors": "^1.1.1"
   },
   "devDependencies": {
     "@types/node": "^24.0.3",

package/scripts/dev.sh

@@ -14,10 +14,15 @@ get_harbor_config() {
 # Get session name from env, config, or use default
 session_name="${HARBOR_SESSION_NAME:-$(get_harbor_config | jq -r '.sessionName // "harbor"')}"
 
+# Use a separate tmux socket for Harbor to avoid conflicts with existing tmux sessions
+# This prevents Harbor's global options from affecting other tmux sessions
+socket_name="harbor-${session_name}"
+tmux_cmd="tmux -L $socket_name"
+
 # Check if the session already exists and kill it
-if tmux has-session -t "$session_name" 2>/dev/null; then
+if $tmux_cmd has-session -t "$session_name" 2>/dev/null; then
     echo "Killing existing tmux session '$session_name'"
-    tmux kill-session -t "$session_name"
+    $tmux_cmd kill-session -t "$session_name"
 fi
 repo_root="$(pwd)"
 max_log_lines=1000
@@ -51,70 +56,76 @@ start_log_trim() {
 trap cleanup_logs EXIT
 
 # Start a new tmux session and rename the initial window
-tmux new-session -d -s "$session_name"
+$tmux_cmd new-session -d -s "$session_name"
 
 # Set tmux options
-tmux set-option -g prefix C-a
-tmux bind-key C-a send-prefix
-tmux set-option -g mouse on
-tmux set-option -g history-limit 50000
-tmux set-window-option -g mode-keys vi
+$tmux_cmd set-option -g prefix C-a
+$tmux_cmd bind-key C-a send-prefix
+$tmux_cmd set-option -g mouse on
+$tmux_cmd set-option -g history-limit 50000
+$tmux_cmd set-window-option -g mode-keys vi
 
 # Enable extended keys so modifier combinations (like Shift+Enter) pass through to applications
-tmux set-option -g extended-keys on
-tmux set-option -g xterm-keys on
+$tmux_cmd set-option -g extended-keys on
+$tmux_cmd set-option -g xterm-keys on
 
 # Add binding to kill session with Ctrl+q
-tmux bind-key -n C-q kill-session
+$tmux_cmd bind-key -n C-q kill-session
 
 # Add padding and styling to panes
-tmux set-option -g pane-border-style fg="#3f3f3f"
-tmux set-option -g pane-active-border-style fg="#6366f1"
-tmux set-option -g pane-border-status top
-tmux set-option -g pane-border-format ""
+$tmux_cmd set-option -g pane-border-style fg="#3f3f3f"
+$tmux_cmd set-option -g pane-active-border-style fg="#6366f1"
+$tmux_cmd set-option -g pane-border-status top
+$tmux_cmd set-option -g pane-border-format ""
 
 # Add padding inside panes
-tmux set-option -g status-left-length 100
-tmux set-option -g status-right-length 100
-tmux set-window-option -g window-style 'fg=colour247,bg=colour236'
-tmux set-window-option -g window-active-style 'fg=colour250,bg=black'
+$tmux_cmd set-option -g status-left-length 100
+$tmux_cmd set-option -g status-right-length 100
+$tmux_cmd set-window-option -g window-style 'fg=colour247,bg=colour236'
+$tmux_cmd set-window-option -g window-active-style 'fg=colour250,bg=black'
 
 # Set inner padding
-tmux set-option -g window-style "bg=#1c1917 fg=#a8a29e"
-tmux set-option -g window-active-style "bg=#1c1917 fg=#ffffff"
+$tmux_cmd set-option -g window-style "bg=#1c1917 fg=#a8a29e"
+$tmux_cmd set-option -g window-active-style "bg=#1c1917 fg=#ffffff"
 
 # Improve copy mode and mouse behavior
-tmux set-option -g set-clipboard external
-tmux bind-key -T copy-mode-vi v send-keys -X begin-selection
-tmux bind-key -T copy-mode-vi y send-keys -X copy-selection-and-cancel
-tmux bind-key -T copy-mode-vi MouseDragEnd1Pane send-keys -X copy-pipe-and-cancel "pbcopy"
+$tmux_cmd set-option -g set-clipboard external
+$tmux_cmd bind-key -T copy-mode-vi v send-keys -X begin-selection
+$tmux_cmd bind-key -T copy-mode-vi y send-keys -X copy-selection-and-cancel
+$tmux_cmd bind-key -T copy-mode-vi MouseDragEnd1Pane send-keys -X copy-pipe-and-cancel "pbcopy"
 
 # Set easier window navigation shortcuts (Shift+Left/Right to switch windows)
-tmux bind-key -n S-Left select-window -t :-
-tmux bind-key -n S-Right select-window -t :+
+$tmux_cmd bind-key -n S-Left select-window -t :-
+$tmux_cmd bind-key -n S-Right select-window -t :+
+
+# Add Ctrl+t to create new terminal window (marked with + prefix)
+$tmux_cmd bind-key -n C-t new-window -n "+Terminal"
+
+# Add Ctrl+w to close current window ONLY if it's user-created (starts with +)
+$tmux_cmd bind-key -n C-w if-shell 'tmux display-message -p "#{window_name}" | grep -q "^+"' 'kill-window' 'display-message "Cannot close service windows (only +Terminal tabs)"'
 
 # Configure status bar
-tmux set-option -g status-position top
-tmux set-option -g status-style bg="#1c1917",fg="#a8a29e"
-tmux set-option -g status-left ""
-tmux set-option -g status-right "#[fg=#a8a29e]shift+←/→ switch · ctrl+q close · #[fg=white]%H:%M#[default]"
-tmux set-window-option -g window-status-current-format "\
+$tmux_cmd set-option -g status-position top
+$tmux_cmd set-option -g status-style bg="#1c1917",fg="#a8a29e"
+$tmux_cmd set-option -g status-left ""
+$tmux_cmd set-option -g status-right "#[fg=#57534e]ctrl+t new · ctrl+w close · shift+←/→ switch · ctrl+q quit#[fg=#78716c] · %H:%M#[default]"
+$tmux_cmd set-window-option -g window-status-current-format "\
 #[fg=#6366f1, bg=#1c1917] →\
 #[fg=#6366f1, bg=#1c1917, bold] #W\
 #[fg=#6366f1, bg=#1c1917]  "
-tmux set-window-option -g window-status-format "\
+$tmux_cmd set-window-option -g window-status-format "\
 #[fg=#a8a29e, bg=#1c1917]  \
 #[fg=#a8a29e, bg=#1c1917] #W \
 #[fg=#a8a29e, bg=#1c1917] "
 
 # Add padding below status bar
-tmux set-option -g status 2
-tmux set-option -Fg 'status-format[1]' '#{status-format[0]}'
-tmux set-option -g 'status-format[0]' ''
+$tmux_cmd set-option -g status 2
+$tmux_cmd set-option -Fg 'status-format[1]' '#{status-format[0]}'
+$tmux_cmd set-option -g 'status-format[0]' ''
 
 # Create a new window for the interactive shell
 echo "Creating window for interactive shell"
-tmux rename-window -t "$session_name":0 'Terminal'
+$tmux_cmd rename-window -t "$session_name":0 'Terminal'
 
 window_index=1  # Start from index 1
 
@@ -142,24 +153,24 @@ while read service; do
         log_file="$repo_root/.harbor/${session_name}-${name}.log"
         : > "$log_file"
         # Use pipe-pane to capture ALL terminal output (works with any program, no buffering issues)
-        tmux new-window -t "$session_name":$window_index -n "$name"
-        tmux pipe-pane -t "$session_name":$window_index "cat >> \"$log_file\""
-        tmux send-keys -t "$session_name":$window_index "cd \"$path\" && $command" C-m
+        $tmux_cmd new-window -t "$session_name":$window_index -n "$name"
+        $tmux_cmd pipe-pane -t "$session_name":$window_index "cat >> \"$log_file\""
+        $tmux_cmd send-keys -t "$session_name":$window_index "cd \"$path\" && $command" C-m
         # Start background process to trim logs if they get too large
         start_log_trim "$log_file" "$effective_max_lines"
     else
-        tmux new-window -t "$session_name":$window_index -n "$name"
-        tmux send-keys -t "$session_name":$window_index "cd \"$path\" && $command" C-m
+        $tmux_cmd new-window -t "$session_name":$window_index -n "$name"
+        $tmux_cmd send-keys -t "$session_name":$window_index "cd \"$path\" && $command" C-m
     fi
     
     ((window_index++))
 done < <(get_harbor_config | jq -c '.services[]')
 
 # Bind 'Home' key to switch to the terminal window
-tmux bind-key -n Home select-window -t :0
+$tmux_cmd bind-key -n Home select-window -t :0
 
 # Select the terminal window
-tmux select-window -t "$session_name":0
+$tmux_cmd select-window -t "$session_name":0
 
 # Attach to the tmux session (unless running in detached/headless mode)
 if [ "${HARBOR_DETACH:-0}" = "1" ]; then
@@ -179,5 +190,5 @@ if [ "${HARBOR_DETACH:-0}" = "1" ]; then
         echo ""
     fi
 else
-    tmux attach-session -t "$session_name"
+    $tmux_cmd attach-session -t "$session_name"
 fi