@colmbus72/yeehaw 0.4.1 → 0.5.0

package/dist/lib/critters.js

@@ -0,0 +1,201 @@
+import { execa } from 'execa';
+import { buildSshCommand } from './livestock.js';
+import { shellEscape } from './shell.js';
+import { getErrorMessage } from './errors.js';
+/**
+ * Services that are interesting for developers (databases, web servers, etc.)
+ */
+const INTERESTING_SERVICE_PATTERNS = [
+    // Databases
+    'mysql', 'mariadb', 'postgres', 'postgresql', 'mongodb', 'mongo',
+    // Caches
+    'redis', 'memcached',
+    // Web servers
+    'nginx', 'apache', 'httpd', 'caddy',
+    // PHP
+    'php-fpm', 'php7', 'php8',
+    // Python
+    'gunicorn', 'uvicorn', 'celery',
+    // Node
+    'node', 'pm2',
+    // Mail
+    'postfix', 'dovecot',
+    // Queue
+    'rabbitmq', 'kafka',
+    // Search
+    'elasticsearch', 'opensearch', 'meilisearch',
+    // Other
+    'supervisor', 'docker',
+];
+/**
+ * Check if a service name matches any interesting pattern
+ */
+function isInterestingService(serviceName) {
+    const lower = serviceName.toLowerCase();
+    return INTERESTING_SERVICE_PATTERNS.some(pattern => lower.includes(pattern));
+}
+/**
+ * Extract a friendly name from a service name
+ * e.g., "mysql.service" -> "mysql", "php8.1-fpm.service" -> "php8.1-fpm"
+ */
+function extractServiceName(service) {
+    return service.replace(/\.service$/, '');
+}
+/**
+ * Read logs from a critter (via journald or custom path)
+ */
+export async function readCritterLogs(critter, barn, options = {}) {
+    const { lines = 100, pattern } = options;
+    const escapedLines = String(lines);
+    let cmd;
+    if (critter.use_journald !== false) {
+        // Use journalctl
+        const escapedService = shellEscape(critter.service);
+        cmd = `journalctl -u ${escapedService} -n ${escapedLines} --no-pager`;
+        if (pattern) {
+            const escapedPattern = shellEscape(pattern);
+            cmd += ` | grep -i ${escapedPattern} || true`;
+        }
+    }
+    else if (critter.log_path) {
+        // Use custom log path
+        const escapedLogPath = shellEscape(critter.log_path);
+        cmd = `tail -n ${escapedLines} ${escapedLogPath}`;
+        if (pattern) {
+            const escapedPattern = shellEscape(pattern);
+            cmd += ` | grep -i ${escapedPattern} || true`;
+        }
+    }
+    else {
+        return { content: '', error: 'Critter has no log_path and use_journald is disabled' };
+    }
+    // Local barn
+    if (barn.name === 'local') {
+        try {
+            const result = await execa('sh', ['-c', cmd]);
+            if (!result.stdout.trim()) {
+                return { content: '', error: `No logs found for ${critter.name}` };
+            }
+            return { content: result.stdout };
+        }
+        catch (err) {
+            return { content: '', error: `Failed to read logs: ${getErrorMessage(err)}` };
+        }
+    }
+    // Remote barn - SSH
+    if (!barn.host || !barn.user) {
+        return { content: '', error: `Barn '${barn.name}' is not configured for SSH` };
+    }
+    try {
+        const sshArgs = buildSshCommand(barn);
+        const result = await execa(sshArgs[0], [...sshArgs.slice(1), cmd]);
+        if (!result.stdout.trim()) {
+            return { content: '', error: `No logs found for ${critter.name}` };
+        }
+        return { content: result.stdout };
+    }
+    catch (err) {
+        return { content: '', error: `SSH error: ${getErrorMessage(err)}` };
+    }
+}
+/**
+ * Parse systemctl show output into key-value pairs
+ */
+function parseSystemctlShow(output) {
+    const result = {};
+    for (const line of output.split('\n')) {
+        const eqIndex = line.indexOf('=');
+        if (eqIndex !== -1) {
+            const key = line.slice(0, eqIndex);
+            const value = line.slice(eqIndex + 1);
+            result[key] = value;
+        }
+    }
+    return result;
+}
+/**
+ * Discover critters (running services) on a barn
+ */
+export async function discoverCritters(barn) {
+    // Command to list running services
+    const listCmd = 'systemctl list-units --type=service --state=running --no-pager --plain';
+    let output;
+    // Local barn
+    if (barn.name === 'local') {
+        try {
+            const result = await execa('sh', ['-c', listCmd]);
+            output = result.stdout;
+        }
+        catch (err) {
+            return { critters: [], error: `Failed to list services: ${getErrorMessage(err)}` };
+        }
+    }
+    else {
+        // Remote barn - SSH
+        if (!barn.host || !barn.user) {
+            return { critters: [], error: `Barn '${barn.name}' is not configured for SSH` };
+        }
+        try {
+            const sshArgs = buildSshCommand(barn);
+            const result = await execa(sshArgs[0], [...sshArgs.slice(1), listCmd]);
+            output = result.stdout;
+        }
+        catch (err) {
+            return { critters: [], error: `SSH error: ${getErrorMessage(err)}` };
+        }
+    }
+    // Parse the output - each line: "unit.service loaded active running description"
+    const lines = output.split('\n').filter(line => line.trim());
+    const discovered = [];
+    for (const line of lines) {
+        const parts = line.trim().split(/\s+/);
+        if (parts.length < 1)
+            continue;
+        const service = parts[0];
+        if (!service.endsWith('.service'))
+            continue;
+        if (!isInterestingService(service))
+            continue;
+        const suggested_name = extractServiceName(service);
+        // Try to get more details about this service
+        let binary;
+        let config_path;
+        const showCmd = `systemctl show ${shellEscape(service)} --property=ExecStart`;
+        try {
+            let showOutput;
+            if (barn.name === 'local') {
+                const showResult = await execa('sh', ['-c', showCmd]);
+                showOutput = showResult.stdout;
+            }
+            else {
+                const sshArgs = buildSshCommand(barn);
+                const showResult = await execa(sshArgs[0], [...sshArgs.slice(1), showCmd]);
+                showOutput = showResult.stdout;
+            }
+            const props = parseSystemctlShow(showOutput);
+            // Extract binary from ExecStart (format: { path=/usr/bin/mysqld ; argv[]=... })
+            if (props.ExecStart) {
+                const pathMatch = props.ExecStart.match(/path=([^\s;]+)/);
+                if (pathMatch) {
+                    binary = pathMatch[1];
+                }
+                // Try to find config flags like --config= or -c
+                const configMatch = props.ExecStart.match(/--config[=\s]([^\s;]+)/);
+                if (configMatch) {
+                    config_path = configMatch[1];
+                }
+            }
+        }
+        catch {
+            // Ignore errors getting details - just use basic info
+        }
+        discovered.push({
+            service,
+            suggested_name,
+            binary,
+            config_path,
+            status: 'running',
+        });
+    }
+    return { critters: discovered };
+}

package/dist/lib/hooks.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Install the Claude hook script to ~/.yeehaw/bin/
+ */
+export declare function installHookScript(): string;
+/**
+ * Get the path to the hook script
+ */
+export declare function getHookScriptPath(): string;
+/**
+ * Get the Claude settings.json hooks configuration
+ */
+export declare function getClaudeHooksConfig(): object;
+/**
+ * Check if Claude hooks are already configured
+ */
+export declare function checkClaudeHooksInstalled(): boolean;
+/**
+ * Check if hook script exists
+ */
+export declare function hookScriptExists(): boolean;

package/dist/lib/hooks.js

@@ -0,0 +1,91 @@
+import { existsSync, mkdirSync, writeFileSync, chmodSync, readFileSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+import { HOOKS_DIR, SIGNALS_DIR } from './paths.js';
+const HOOK_SCRIPT_NAME = 'claude-hook';
+const HOOK_SCRIPT_CONTENT = `#!/bin/bash
+# Yeehaw Claude Hook - writes session status for the CLI to read
+STATUS="$1"
+PANE_ID="\${TMUX_PANE:-unknown}"
+SIGNAL_DIR="$HOME/.yeehaw/session-signals"
+SIGNAL_FILE="$SIGNAL_DIR/\${PANE_ID//[^a-zA-Z0-9]/_}.json"
+
+mkdir -p "$SIGNAL_DIR"
+cat > "$SIGNAL_FILE" << EOF
+{"status":"$STATUS","updated":$(date +%s)}
+EOF
+`;
+/**
+ * Install the Claude hook script to ~/.yeehaw/bin/
+ */
+export function installHookScript() {
+    // Ensure directories exist
+    if (!existsSync(HOOKS_DIR)) {
+        mkdirSync(HOOKS_DIR, { recursive: true });
+    }
+    if (!existsSync(SIGNALS_DIR)) {
+        mkdirSync(SIGNALS_DIR, { recursive: true });
+    }
+    const scriptPath = join(HOOKS_DIR, HOOK_SCRIPT_NAME);
+    writeFileSync(scriptPath, HOOK_SCRIPT_CONTENT, 'utf-8');
+    chmodSync(scriptPath, 0o755);
+    return scriptPath;
+}
+/**
+ * Get the path to the hook script
+ */
+export function getHookScriptPath() {
+    return join(HOOKS_DIR, HOOK_SCRIPT_NAME);
+}
+/**
+ * Get the Claude settings.json hooks configuration
+ */
+export function getClaudeHooksConfig() {
+    const hookPath = join(HOOKS_DIR, HOOK_SCRIPT_NAME);
+    return {
+        hooks: {
+            PreToolUse: [
+                {
+                    matcher: '*',
+                    hooks: [`${hookPath} working`],
+                },
+            ],
+            Stop: [
+                {
+                    matcher: '*',
+                    hooks: [`${hookPath} waiting`],
+                },
+            ],
+            Notification: [
+                {
+                    matcher: 'idle_prompt',
+                    hooks: [`${hookPath} waiting`],
+                },
+            ],
+        },
+    };
+}
+/**
+ * Check if Claude hooks are already configured
+ */
+export function checkClaudeHooksInstalled() {
+    const claudeSettingsPath = join(homedir(), '.claude', 'settings.json');
+    if (!existsSync(claudeSettingsPath)) {
+        return false;
+    }
+    try {
+        const content = readFileSync(claudeSettingsPath, 'utf-8');
+        const settings = JSON.parse(content);
+        return settings.hooks?.PreToolUse?.some((h) => h.hooks?.some((cmd) => cmd.includes('yeehaw')));
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Check if hook script exists
+ */
+export function hookScriptExists() {
+    const scriptPath = join(HOOKS_DIR, HOOK_SCRIPT_NAME);
+    return existsSync(scriptPath);
+}

package/dist/lib/hotkeys.js

@@ -2,38 +2,42 @@
 export const HOTKEYS = [
     // === GLOBAL (everywhere) ===
     { key: '?', description: 'Toggle help', category: 'system', scopes: ['global'] },
-    { key: 'q', description: 'Back / Detach', category: 'system', scopes: ['global'] },
+    { key: 'q', description: 'Detach', category: 'system', scopes: ['global-dashboard'] },
+    { key: 'Q', description: 'Quit Yeehaw', category: 'system', scopes: ['global-dashboard'] },
     { key: 'Esc', description: 'Back / Cancel', category: 'system', scopes: ['global'] },
     // === LIST NAVIGATION (any focused list) ===
-    { key: 'j/k', description: 'Navigate up/down', category: 'navigation', scopes: ['list'] },
-    { key: 'g/G', description: 'Go to first/last', category: 'navigation', scopes: ['list'] },
-    { key: 'Enter', description: 'Select item', category: 'navigation', scopes: ['list'] },
+    { key: 'j/k', description: 'Move up/down', category: 'navigation', scopes: ['list'] },
+    { key: 'g/G', description: 'Jump to first/last', category: 'navigation', scopes: ['list'] },
+    { key: 'Enter', description: 'Open selected item', category: 'navigation', scopes: ['list'] },
     // === CONTENT NAVIGATION (markdown panels) ===
     { key: 'j/k', description: 'Scroll up/down', category: 'navigation', scopes: ['content'] },
     { key: 'g/G', description: 'Jump to top/bottom', category: 'navigation', scopes: ['content'] },
     { key: 'PgUp/PgDn', description: 'Scroll page', category: 'navigation', scopes: ['content'] },
-    // === GLOBAL DASHBOARD ===
+    // === PANEL NAVIGATION ===
     { key: 'Tab', description: 'Switch panel', category: 'navigation', scopes: ['global-dashboard', 'project-context', 'barn-context', 'wiki-view', 'issues-view'] },
-    { key: 'Q', description: 'Quit Yeehaw', category: 'system', scopes: ['global-dashboard'] },
-    { key: 'c', description: 'New Claude session', category: 'action', scopes: ['global-dashboard', 'project-context'] },
-    { key: '1-9', description: 'Quick switch window', category: 'action', scopes: ['global-dashboard', 'project-context'] },
-    { key: 's', description: 'Open shell session', category: 'action', scopes: ['global-dashboard', 'project-context', 'barn-context', 'livestock-detail'], panel: 'barns' },
-    // === CONTEXT-AWARE ACTIONS ===
+    // === GLOBAL SESSION SWITCHING ===
+    { key: '1-9', description: 'Switch to session', category: 'action', scopes: ['global-dashboard', 'project-context'] },
+    // === ROW-LEVEL ACTIONS (shown on selected rows) ===
+    { key: 'c', description: 'Claude session (at path)', category: 'action', scopes: ['global-dashboard'], panel: 'projects' },
+    { key: 'c', description: 'Claude session (at path)', category: 'action', scopes: ['project-context'], panel: 'livestock' },
+    { key: 's', description: 'Shell into server', category: 'action', scopes: ['global-dashboard'], panel: 'barns' },
+    { key: 's', description: 'Shell into server', category: 'action', scopes: ['project-context', 'barn-context'], panel: 'livestock' },
+    // === CARD/PAGE-LEVEL ACTIONS ===
     { key: 'n', description: 'New (in focused panel)', category: 'action', scopes: ['global-dashboard', 'project-context', 'barn-context', 'wiki-view'] },
-    { key: 'e', description: 'Edit selected', category: 'action', scopes: ['project-context', 'barn-context', 'wiki-view'] },
-    { key: 'd', description: 'Delete (with confirm)', category: 'action', scopes: ['project-context', 'barn-context', 'wiki-view'] },
-    { key: 'D', description: 'Delete container (type name)', category: 'action', scopes: ['project-context', 'barn-context'] },
-    // === PROJECT CONTEXT ===
+    { key: 'e', description: 'Edit', category: 'action', scopes: ['project-context', 'barn-context', 'wiki-view', 'livestock-detail'] },
+    { key: 'd', description: 'Delete', category: 'action', scopes: ['project-context', 'barn-context', 'wiki-view'] },
+    { key: 'D', description: 'Delete container', category: 'action', scopes: ['project-context', 'barn-context'] },
+    // === PROJECT CONTEXT PAGE-LEVEL ===
     { key: 'w', description: 'Open wiki', category: 'action', scopes: ['project-context'] },
     { key: 'i', description: 'Open issues', category: 'action', scopes: ['project-context'] },
+    // === LIVESTOCK DETAIL PAGE-LEVEL ===
+    { key: 'c', description: 'Claude session', category: 'action', scopes: ['livestock-detail'] },
+    { key: 's', description: 'Shell session', category: 'action', scopes: ['livestock-detail'] },
+    { key: 'l', description: 'View logs', category: 'action', scopes: ['livestock-detail'] },
     // === ISSUES VIEW ===
-    { key: 'r', description: 'Refresh issues', category: 'action', scopes: ['issues-view'] },
+    { key: 'r', description: 'Refresh', category: 'action', scopes: ['issues-view', 'logs-view'] },
     { key: 'o', description: 'Open in browser', category: 'action', scopes: ['issues-view'] },
-    // === LIVESTOCK DETAIL ===
-    { key: 'l', description: 'View logs', category: 'action', scopes: ['livestock-detail'] },
-    // === LOGS VIEW ===
-    { key: 'r', description: 'Refresh logs', category: 'action', scopes: ['logs-view'] },
-    // === NIGHT SKY (screensaver) ===
+    // === NIGHT SKY ===
     { key: 'v', description: 'Visualizer', category: 'navigation', scopes: ['global-dashboard'] },
     { key: 'c', description: 'Spawn cloud', category: 'action', scopes: ['night-sky'] },
     { key: 'r', description: 'Randomize', category: 'action', scopes: ['night-sky'] },

package/dist/lib/paths.d.ts

@@ -3,6 +3,8 @@ export declare const CONFIG_FILE: string;
 export declare const PROJECTS_DIR: string;
 export declare const BARNS_DIR: string;
 export declare const SESSIONS_DIR: string;
+export declare const SIGNALS_DIR: string;
+export declare const HOOKS_DIR: string;
 export declare function getProjectPath(name: string): string;
 export declare function getBarnPath(name: string): string;
 export declare function getSessionPath(id: string): string;

package/dist/lib/paths.js

@@ -5,6 +5,8 @@ export const CONFIG_FILE = join(YEEHAW_DIR, 'config.yaml');
 export const PROJECTS_DIR = join(YEEHAW_DIR, 'projects');
 export const BARNS_DIR = join(YEEHAW_DIR, 'barns');
 export const SESSIONS_DIR = join(YEEHAW_DIR, 'sessions');
+export const SIGNALS_DIR = join(YEEHAW_DIR, 'session-signals');
+export const HOOKS_DIR = join(YEEHAW_DIR, 'bin');
 /**
  * Validate a name to prevent path traversal attacks.
  * Rejects names containing path separators or parent directory references.

package/dist/lib/signals.d.ts

@@ -0,0 +1,30 @@
+export type SessionStatus = 'working' | 'waiting' | 'idle' | 'error';
+export interface SessionSignal {
+    status: SessionStatus;
+    updated: number;
+}
+export interface WindowStatusInfo {
+    text: string;
+    status: SessionStatus;
+    icon: string;
+}
+/**
+ * Read signal file for a tmux pane
+ */
+export declare function readSignal(paneId: string): SessionSignal | null;
+/**
+ * Get status icon for a session status
+ */
+export declare function getStatusIcon(status: SessionStatus): string;
+/**
+ * Ensure the signals directory exists
+ */
+export declare function ensureSignalsDir(): void;
+/**
+ * Clean up signal file for a pane
+ */
+export declare function cleanupSignal(paneId: string): void;
+/**
+ * Clean up all stale signal files (older than 1 hour)
+ */
+export declare function cleanupStaleSignals(): void;

package/dist/lib/signals.js

@@ -0,0 +1,104 @@
+import { existsSync, readFileSync, readdirSync, unlinkSync, mkdirSync } from 'fs';
+import { join } from 'path';
+import { SIGNALS_DIR } from './paths.js';
+const STATUS_ICONS = {
+    working: '⠿',
+    waiting: '◆',
+    idle: '○',
+    error: '✖',
+};
+const SIGNAL_MAX_AGE_MS = 5 * 60 * 1000; // 5 minutes
+/**
+ * Sanitize pane ID to create a safe filename
+ */
+function sanitizePaneId(paneId) {
+    return paneId.replace(/[^a-zA-Z0-9]/g, '_');
+}
+/**
+ * Read signal file for a tmux pane
+ */
+export function readSignal(paneId) {
+    if (!existsSync(SIGNALS_DIR))
+        return null;
+    const filename = `${sanitizePaneId(paneId)}.json`;
+    const filepath = join(SIGNALS_DIR, filename);
+    if (!existsSync(filepath))
+        return null;
+    try {
+        const content = readFileSync(filepath, 'utf-8');
+        const signal = JSON.parse(content);
+        // Check if signal is stale
+        const ageMs = Date.now() - signal.updated * 1000;
+        if (ageMs > SIGNAL_MAX_AGE_MS) {
+            return null;
+        }
+        return signal;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Get status icon for a session status
+ */
+export function getStatusIcon(status) {
+    return STATUS_ICONS[status];
+}
+/**
+ * Ensure the signals directory exists
+ */
+export function ensureSignalsDir() {
+    if (!existsSync(SIGNALS_DIR)) {
+        mkdirSync(SIGNALS_DIR, { recursive: true });
+    }
+}
+/**
+ * Clean up signal file for a pane
+ */
+export function cleanupSignal(paneId) {
+    const filename = `${sanitizePaneId(paneId)}.json`;
+    const filepath = join(SIGNALS_DIR, filename);
+    try {
+        if (existsSync(filepath)) {
+            unlinkSync(filepath);
+        }
+    }
+    catch {
+        // Ignore cleanup errors
+    }
+}
+/**
+ * Clean up all stale signal files (older than 1 hour)
+ */
+export function cleanupStaleSignals() {
+    if (!existsSync(SIGNALS_DIR))
+        return;
+    const STALE_AGE_MS = 60 * 60 * 1000; // 1 hour
+    const now = Date.now();
+    try {
+        const files = readdirSync(SIGNALS_DIR).filter(f => f.endsWith('.json'));
+        for (const file of files) {
+            const filepath = join(SIGNALS_DIR, file);
+            try {
+                const content = readFileSync(filepath, 'utf-8');
+                const signal = JSON.parse(content);
+                const ageMs = now - signal.updated * 1000;
+                if (ageMs > STALE_AGE_MS) {
+                    unlinkSync(filepath);
+                }
+            }
+            catch {
+                // Delete malformed files
+                try {
+                    unlinkSync(filepath);
+                }
+                catch {
+                    // Ignore
+                }
+            }
+        }
+    }
+    catch {
+        // Ignore errors
+    }
+}

package/dist/lib/tmux.d.ts

@@ -1,11 +1,16 @@
+import { type WindowStatusInfo } from './signals.js';
+export type { WindowStatusInfo, SessionStatus } from './signals.js';
 export declare const YEEHAW_SESSION = "yeehaw";
+export type WindowType = 'claude' | 'shell' | 'ssh' | '';
 export interface TmuxWindow {
     index: number;
     name: string;
     active: boolean;
+    paneId: string;
     paneTitle: string;
     paneCurrentCommand: string;
     windowActivity: number;
+    type: WindowType;
 }
 export declare function hasTmux(): boolean;
 export declare function isInsideYeehawSession(): boolean;
@@ -23,13 +28,14 @@ export declare function createShellWindow(workingDir: string, windowName: string
 export declare function createSshWindow(windowName: string, host: string, user: string, port: number, identityFile: string, remotePath: string): number;
 export declare function detachFromSession(): void;
 export declare function killYeehawSession(): void;
+export declare function restartYeehaw(): void;
 export declare function switchToWindow(windowIndex: number): void;
 export declare function listYeehawWindows(): TmuxWindow[];
 export declare function killWindow(windowIndex: number): void;
 /**
- * Get formatted status text for a tmux window
+ * Get formatted status info for a tmux window
  */
-export declare function getWindowStatus(window: TmuxWindow): string;
+export declare function getWindowStatus(window: TmuxWindow): WindowStatusInfo;
 export declare function updateStatusBar(projectName?: string): void;
 export declare function enterRemoteMode(barnName: string, host: string, user: string, port: number, identityFile: string): number;
 export declare function exitRemoteMode(): void;