@colmbus72/yeehaw 0.4.2 → 0.6.0

package/dist/lib/critters.js

@@ -0,0 +1,365 @@
+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 };
+}
+/**
+ * List systemd services on a barn
+ * @param barn - The barn to query
+ * @param activeOnly - If true, only return running services (default: true)
+ */
+export async function listSystemServices(barn, activeOnly = true) {
+    // For active only: list-units shows running services
+    // For all: list-unit-files shows all installed services
+    const cmd = activeOnly
+        ? 'systemctl list-units --type=service --state=running --no-pager --no-legend'
+        : 'systemctl list-unit-files --type=service --no-pager --no-legend';
+    let output;
+    // Local barn
+    if (barn.name === 'local') {
+        try {
+            const result = await execa('sh', ['-c', cmd]);
+            output = result.stdout;
+        }
+        catch (err) {
+            return { services: [], error: `Failed to list services: ${getErrorMessage(err)}` };
+        }
+    }
+    else {
+        // Remote barn - SSH
+        if (!barn.host || !barn.user) {
+            return { services: [], error: `Barn '${barn.name}' is not configured for SSH` };
+        }
+        try {
+            const sshArgs = buildSshCommand(barn);
+            const result = await execa(sshArgs[0], [...sshArgs.slice(1), cmd]);
+            output = result.stdout;
+        }
+        catch (err) {
+            return { services: [], error: `SSH error: ${getErrorMessage(err)}` };
+        }
+    }
+    const services = [];
+    const lines = output.split('\n').filter(line => line.trim());
+    for (const line of lines) {
+        const parts = line.trim().split(/\s+/);
+        if (parts.length < 1)
+            continue;
+        const serviceName = parts[0];
+        if (!serviceName.endsWith('.service'))
+            continue;
+        if (activeOnly) {
+            // list-units format: UNIT LOAD ACTIVE SUB DESCRIPTION...
+            services.push({
+                name: serviceName,
+                state: 'running',
+                description: parts.slice(4).join(' ') || undefined,
+            });
+        }
+        else {
+            // list-unit-files format: UNIT STATE PRESET
+            const stateStr = parts[1]?.toLowerCase() || '';
+            services.push({
+                name: serviceName,
+                state: stateStr === 'enabled' ? 'unknown' : 'stopped',
+            });
+        }
+    }
+    return { services };
+}
+/**
+ * Get details about a systemd service by parsing its unit file
+ */
+export async function getServiceDetails(barn, serviceName) {
+    // Get the unit file path
+    const pathCmd = `systemctl show -p FragmentPath ${shellEscape(serviceName)} --value`;
+    let servicePath;
+    if (barn.name === 'local') {
+        try {
+            const result = await execa('sh', ['-c', pathCmd]);
+            servicePath = result.stdout.trim();
+        }
+        catch (err) {
+            return { error: `Failed to get service path: ${getErrorMessage(err)}` };
+        }
+    }
+    else {
+        if (!barn.host || !barn.user) {
+            return { error: `Barn '${barn.name}' is not configured for SSH` };
+        }
+        try {
+            const sshArgs = buildSshCommand(barn);
+            const result = await execa(sshArgs[0], [...sshArgs.slice(1), pathCmd]);
+            servicePath = result.stdout.trim();
+        }
+        catch (err) {
+            return { error: `SSH error: ${getErrorMessage(err)}` };
+        }
+    }
+    if (!servicePath) {
+        return { error: 'Could not find service unit file' };
+    }
+    // Read the service file to extract details
+    const catCmd = `cat ${shellEscape(servicePath)}`;
+    let serviceContent;
+    if (barn.name === 'local') {
+        try {
+            const result = await execa('sh', ['-c', catCmd]);
+            serviceContent = result.stdout;
+        }
+        catch (err) {
+            return { error: `Failed to read service file: ${getErrorMessage(err)}` };
+        }
+    }
+    else {
+        try {
+            const sshArgs = buildSshCommand(barn);
+            const result = await execa(sshArgs[0], [...sshArgs.slice(1), catCmd]);
+            serviceContent = result.stdout;
+        }
+        catch (err) {
+            return { error: `SSH error: ${getErrorMessage(err)}` };
+        }
+    }
+    // Parse the service file
+    let config_path;
+    let log_path;
+    let use_journald = true;
+    for (const line of serviceContent.split('\n')) {
+        const trimmed = line.trim();
+        // Look for ExecStart to find config flags
+        if (trimmed.startsWith('ExecStart=')) {
+            const execLine = trimmed.slice('ExecStart='.length);
+            // Common config flag patterns
+            const configPatterns = [
+                /--config[=\s]([^\s]+)/,
+                /--defaults-file[=\s]([^\s]+)/,
+                /-c\s+([^\s]+)/,
+                /--conf[=\s]([^\s]+)/,
+            ];
+            for (const pattern of configPatterns) {
+                const match = execLine.match(pattern);
+                if (match) {
+                    config_path = match[1];
+                    break;
+                }
+            }
+        }
+        // Check StandardOutput/StandardError for log paths
+        if (trimmed.startsWith('StandardOutput=') || trimmed.startsWith('StandardError=')) {
+            const value = trimmed.split('=')[1];
+            if (value && !value.startsWith('journal') && !value.startsWith('inherit')) {
+                // Could be file:path or append:path
+                const fileMatch = value.match(/(?:file|append):(.+)/);
+                if (fileMatch) {
+                    log_path = fileMatch[1];
+                    use_journald = false;
+                }
+            }
+        }
+    }
+    return {
+        details: {
+            service_path: servicePath,
+            config_path,
+            log_path,
+            use_journald,
+        },
+    };
+}

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.d.ts

@@ -1,4 +1,4 @@
-export type HotkeyScope = 'global' | 'global-dashboard' | 'project-context' | 'barn-context' | 'wiki-view' | 'issues-view' | 'livestock-detail' | 'logs-view' | 'night-sky' | 'list' | 'content';
+export type HotkeyScope = 'global' | 'global-dashboard' | 'project-context' | 'barn-context' | 'wiki-view' | 'issues-view' | 'livestock-detail' | 'logs-view' | 'critter-detail' | 'critter-logs' | 'night-sky' | 'list' | 'content';
 export type HotkeyCategory = 'navigation' | 'action' | 'system';
 export interface Hotkey {
     key: string;

package/dist/lib/hotkeys.js

@@ -2,38 +2,46 @@
 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 (local only)', 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'] },
+    // === CRITTER DETAIL PAGE-LEVEL ===
+    { key: 'l', description: 'View logs', category: 'action', scopes: ['critter-detail'] },
+    { key: 'e', description: 'Edit', category: 'action', scopes: ['critter-detail'] },
     // === ISSUES VIEW ===
-    { key: 'r', description: 'Refresh issues', category: 'action', scopes: ['issues-view'] },
+    { key: 'r', description: 'Refresh', category: 'action', scopes: ['issues-view', 'logs-view', 'critter-logs'] },
     { 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) ===
+    { key: 'c', description: 'Open in Claude', category: 'action', scopes: ['issues-view'] },
+    // === 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/issues/github.d.ts

@@ -0,0 +1,11 @@
+import type { Issue, IssueProvider, FetchIssuesOptions } from './types.js';
+import type { Livestock } from '../../types.js';
+export declare class GitHubProvider implements IssueProvider {
+    readonly type: "github";
+    private repos;
+    constructor(livestock: Livestock[]);
+    isAuthenticated(): Promise<boolean>;
+    authenticate(): Promise<void>;
+    fetchIssues(options?: FetchIssuesOptions): Promise<Issue[]>;
+    getIssue(id: string): Promise<Issue>;
+}