@colmbus72/yeehaw 0.4.2 → 0.5.0

package/dist/lib/tmux.js

@@ -4,6 +4,7 @@ import { fileURLToPath } from 'url';
 import { dirname, join } from 'path';
 import { writeTmuxConfig, TMUX_CONFIG_PATH } from './tmux-config.js';
 import { shellEscape } from './shell.js';
+import { readSignal, getStatusIcon } from './signals.js';
 // Get the path to the MCP server (it's in dist/, not dist/lib/)
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
@@ -147,6 +148,15 @@ const YEEHAW_MCP_TOOLS = [
     'mcp__yeehaw__update_wiki_section',
     'mcp__yeehaw__delete_wiki_section',
 ];
+/**
+ * Set the window type option for a window (used for reliable window type detection)
+ */
+function setWindowType(windowIndex, type) {
+    execaSync('tmux', [
+        'set-option', '-w', '-t', `${YEEHAW_SESSION}:${windowIndex}`,
+        '@yeehaw_type', type,
+    ]);
+}
 export function createClaudeWindow(workingDir, windowName) {
     // Build MCP config for yeehaw server
     const mcpConfig = JSON.stringify({
@@ -175,7 +185,10 @@ export function createClaudeWindow(workingDir, windowName) {
     const result = execaSync('tmux', [
         'display-message', '-p', '#{window_index}'
     ]);
-    return parseInt(result.stdout.trim(), 10);
+    const windowIndex = parseInt(result.stdout.trim(), 10);
+    // Mark this window as a Claude session
+    setWindowType(windowIndex, 'claude');
+    return windowIndex;
 }
 export function createShellWindow(workingDir, windowName, shell) {
     // Use the user's configured shell from $SHELL, fallback to /bin/bash
@@ -194,7 +207,10 @@ export function createShellWindow(workingDir, windowName, shell) {
     const result = execaSync('tmux', [
         'display-message', '-p', '#{window_index}'
     ]);
-    return parseInt(result.stdout.trim(), 10);
+    const windowIndex = parseInt(result.stdout.trim(), 10);
+    // Mark this window as a shell session
+    setWindowType(windowIndex, 'shell');
+    return windowIndex;
 }
 export function createSshWindow(windowName, host, user, port, identityFile, remotePath) {
     // Two levels of escaping needed:
@@ -222,7 +238,10 @@ export function createSshWindow(windowName, host, user, port, identityFile, remo
     const result = execaSync('tmux', [
         'display-message', '-p', '#{window_index}'
     ]);
-    return parseInt(result.stdout.trim(), 10);
+    const windowIndex = parseInt(result.stdout.trim(), 10);
+    // Mark this window as an SSH session
+    setWindowType(windowIndex, 'ssh');
+    return windowIndex;
 }
 export function detachFromSession() {
     execaSync('tmux', ['detach-client']);
@@ -235,29 +254,37 @@ export function killYeehawSession() {
         // Session might already be dead
     }
 }
+export function restartYeehaw() {
+    // Respawn window 0 with a fresh yeehaw process
+    // This kills the current process but preserves all other windows
+    execaSync('tmux', ['respawn-window', '-k', '-t', `${YEEHAW_SESSION}:0`, 'yeehaw']);
+}
 export function switchToWindow(windowIndex) {
     execaSync('tmux', ['select-window', '-t', `${YEEHAW_SESSION}:${windowIndex}`]);
 }
 export function listYeehawWindows() {
     try {
         // Use tab as delimiter since pane_title can contain colons
+        // Include @yeehaw_type window option for reliable window type detection
         const result = execaSync('tmux', [
             'list-windows',
             '-t', YEEHAW_SESSION,
-            '-F', '#{window_index}\t#{window_name}\t#{window_active}\t#{pane_title}\t#{pane_current_command}\t#{window_activity}',
+            '-F', '#{window_index}\t#{window_name}\t#{window_active}\t#{pane_id}\t#{pane_title}\t#{pane_current_command}\t#{window_activity}\t#{@yeehaw_type}',
         ]);
         return result.stdout
             .split('\n')
             .filter(Boolean)
             .map((line) => {
-            const [index, name, active, paneTitle, paneCurrentCommand, windowActivity] = line.split('\t');
+            const [index, name, active, paneId, paneTitle, paneCurrentCommand, windowActivity, type] = line.split('\t');
             return {
                 index: parseInt(index, 10),
                 name,
                 active: active === '1',
+                paneId: paneId || '',
                 paneTitle: paneTitle || '',
                 paneCurrentCommand: paneCurrentCommand || '',
                 windowActivity: parseInt(windowActivity, 10) || 0,
+                type: (type || ''),
             };
         });
     }
@@ -296,34 +323,58 @@ function isClaudeWorking(paneTitle) {
     return spinnerChars.some(char => paneTitle.startsWith(char));
 }
 /**
- * Get formatted status text for a tmux window
+ * Get formatted status info for a tmux window
  */
 export function getWindowStatus(window) {
-    const isClaudeSession = window.name.includes('claude') && window.paneCurrentCommand === 'node';
+    const isClaudeSession = window.type === 'claude';
     const relativeTime = formatRelativeTime(window.windowActivity);
+    // Check for signal file first (written by Claude hooks)
+    if (isClaudeSession && window.paneId) {
+        const signal = readSignal(window.paneId);
+        if (signal) {
+            const icon = getStatusIcon(signal.status);
+            const text = signal.status === 'waiting'
+                ? 'Waiting for input'
+                : signal.status === 'working'
+                    ? window.paneTitle || 'Working...'
+                    : signal.status === 'error'
+                        ? 'Error'
+                        : `idle ${relativeTime}`;
+            return { text: `${icon} ${text}`, status: signal.status, icon };
+        }
+    }
+    // Fallback to tmux-native detection for Claude sessions
     if (isClaudeSession) {
-        // For Claude sessions, use pane title (contains task context)
         if (window.paneTitle) {
             const working = isClaudeWorking(window.paneTitle);
             if (working) {
-                return window.paneTitle; // Shows spinner + task description
+                return {
+                    text: window.paneTitle,
+                    status: 'working',
+                    icon: getStatusIcon('working'),
+                };
             }
-            // Not working - show title with idle time if stale
-            if (relativeTime !== 'now' && relativeTime !== '1m') {
-                return `${window.paneTitle} (${relativeTime})`;
-            }
-            return window.paneTitle;
+            // Not working - likely idle
+            const text = relativeTime !== 'now' && relativeTime !== '1m'
+                ? `${window.paneTitle} (${relativeTime})`
+                : window.paneTitle;
+            return { text, status: 'idle', icon: getStatusIcon('idle') };
         }
-        return relativeTime === 'now' ? 'active' : `idle ${relativeTime}`;
+        const text = relativeTime === 'now' ? 'active' : `idle ${relativeTime}`;
+        return { text: `○ ${text}`, status: 'idle', icon: '○' };
+    }
+    // For shell sessions, check if pane is dead
+    if (window.paneCurrentCommand === '') {
+        return { text: '✖ disconnected', status: 'error', icon: '✖' };
     }
     // For shell sessions, show current command
     const cmd = window.paneCurrentCommand;
     if (cmd && cmd !== 'zsh' && cmd !== 'bash' && cmd !== 'sh' && cmd !== 'fish') {
-        // Running a specific command
-        return cmd;
+        return { text: cmd, status: 'working', icon: getStatusIcon('working') };
     }
     // At shell prompt - show idle time
-    return relativeTime === 'now' ? 'ready' : `idle ${relativeTime}`;
+    const text = relativeTime === 'now' ? 'ready' : `idle ${relativeTime}`;
+    return { text: `○ ${text}`, status: 'idle', icon: '○' };
 }
 export function updateStatusBar(projectName) {
     const left = projectName

package/dist/mcp-server.js

@@ -23,8 +23,9 @@
 import { Server } from '@modelcontextprotocol/sdk/server/index.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { CallToolRequestSchema, ListToolsRequestSchema, ListResourcesRequestSchema, ReadResourceRequestSchema, } from '@modelcontextprotocol/sdk/types.js';
-import { loadProjects, loadProject, loadBarns, loadBarn, saveProject, saveBarn, deleteProject, deleteBarn, getLivestockForBarn, ensureConfigDirs, } from './lib/config.js';
+import { loadProjects, loadProject, loadBarns, loadBarn, saveProject, saveBarn, deleteProject, deleteBarn, getLivestockForBarn, ensureConfigDirs, addCritterToBarn, removeCritterFromBarn, getCritter, } from './lib/config.js';
 import { readLivestockLogs, readLivestockEnv } from './lib/livestock.js';
+import { readCritterLogs, discoverCritters } from './lib/critters.js';
 import { requireString, optionalString, optionalNumber, optionalBoolean, } from './lib/mcp-validation.js';
 const server = new Server({
     name: 'yeehaw',
@@ -381,6 +382,60 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
                     required: ['project', 'title'],
                 },
             },
+            // Critter tools
+            {
+                name: 'add_critter',
+                description: 'Add a critter (system service like mysql, redis, nginx) to a barn',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        barn: { type: 'string', description: 'Barn name' },
+                        name: { type: 'string', description: 'Critter name (user-friendly, e.g., "mysql", "redis-cache")' },
+                        service: { type: 'string', description: 'systemd service name (e.g., "mysql.service")' },
+                        config_path: { type: 'string', description: 'Path to config file (optional)' },
+                        log_path: { type: 'string', description: 'Custom log path if not using journald (optional)' },
+                        use_journald: { type: 'boolean', description: 'Use journalctl for logs (default: true)' },
+                    },
+                    required: ['barn', 'name', 'service'],
+                },
+            },
+            {
+                name: 'remove_critter',
+                description: 'Remove a critter from a barn',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        barn: { type: 'string', description: 'Barn name' },
+                        name: { type: 'string', description: 'Critter name to remove' },
+                    },
+                    required: ['barn', 'name'],
+                },
+            },
+            {
+                name: 'read_critter_logs',
+                description: 'Read logs from a critter (via journald or custom path)',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        barn: { type: 'string', description: 'Barn name' },
+                        critter: { type: 'string', description: 'Critter name' },
+                        lines: { type: 'number', description: 'Last N lines (default: 100)' },
+                        pattern: { type: 'string', description: 'Grep pattern to filter logs (case-insensitive)' },
+                    },
+                    required: ['barn', 'critter'],
+                },
+            },
+            {
+                name: 'discover_critters',
+                description: 'Scan a barn for running services and return suggestions for critters to add',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        barn: { type: 'string', description: 'Barn name to scan' },
+                    },
+                    required: ['barn'],
+                },
+            },
         ],
     };
 });
@@ -851,6 +906,111 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                     content: [{ type: 'text', text: `Deleted wiki section '${title}' from project '${project.name}'` }],
                 };
             }
+            // Critter operations
+            case 'add_critter': {
+                const barnName = requireString(args, 'barn');
+                const critterName = requireString(args, 'name');
+                const service = requireString(args, 'service');
+                const config_path = optionalString(args, 'config_path');
+                const log_path = optionalString(args, 'log_path');
+                const use_journald = optionalBoolean(args, 'use_journald', true);
+                const critter = {
+                    name: critterName,
+                    service,
+                    config_path,
+                    log_path,
+                    use_journald,
+                };
+                try {
+                    addCritterToBarn(barnName, critter);
+                    return {
+                        content: [{ type: 'text', text: `Added critter '${critterName}' (${service}) to barn '${barnName}'` }],
+                    };
+                }
+                catch (err) {
+                    return {
+                        content: [{ type: 'text', text: err instanceof Error ? err.message : String(err) }],
+                        isError: true,
+                    };
+                }
+            }
+            case 'remove_critter': {
+                const barnName = requireString(args, 'barn');
+                const critterName = requireString(args, 'name');
+                try {
+                    const removed = removeCritterFromBarn(barnName, critterName);
+                    if (!removed) {
+                        return {
+                            content: [{ type: 'text', text: `Critter '${critterName}' not found on barn '${barnName}'` }],
+                            isError: true,
+                        };
+                    }
+                    return {
+                        content: [{ type: 'text', text: `Removed critter '${critterName}' from barn '${barnName}'` }],
+                    };
+                }
+                catch (err) {
+                    return {
+                        content: [{ type: 'text', text: err instanceof Error ? err.message : String(err) }],
+                        isError: true,
+                    };
+                }
+            }
+            case 'read_critter_logs': {
+                const barnName = requireString(args, 'barn');
+                const critterName = requireString(args, 'critter');
+                const lines = optionalNumber(args, 'lines');
+                const pattern = optionalString(args, 'pattern');
+                const barn = loadBarn(barnName);
+                if (!barn) {
+                    return {
+                        content: [{ type: 'text', text: `Barn not found: ${barnName}` }],
+                        isError: true,
+                    };
+                }
+                const critter = getCritter(barnName, critterName);
+                if (!critter) {
+                    return {
+                        content: [{ type: 'text', text: `Critter '${critterName}' not found on barn '${barnName}'` }],
+                        isError: true,
+                    };
+                }
+                const result = await readCritterLogs(critter, barn, { lines, pattern });
+                if (result.error) {
+                    return {
+                        content: [{ type: 'text', text: result.error }],
+                        isError: true,
+                    };
+                }
+                return {
+                    content: [{ type: 'text', text: result.content }],
+                };
+            }
+            case 'discover_critters': {
+                const barnName = requireString(args, 'barn');
+                const barn = loadBarn(barnName);
+                if (!barn) {
+                    return {
+                        content: [{ type: 'text', text: `Barn not found: ${barnName}` }],
+                        isError: true,
+                    };
+                }
+                const result = await discoverCritters(barn);
+                if (result.error) {
+                    return {
+                        content: [{ type: 'text', text: result.error }],
+                        isError: true,
+                    };
+                }
+                if (result.critters.length === 0) {
+                    return {
+                        content: [{ type: 'text', text: 'No interesting services discovered on this barn' }],
+                    };
+                }
+                return {
+                    content: [{ type: 'text', text: JSON.stringify(result.critters, null, 2) }],
+                };
+            }
             default:
                 return {
                     content: [{ type: 'text', text: `Unknown tool: ${name}` }],

package/dist/types.d.ts

@@ -40,8 +40,10 @@ export interface Livestock {
 }
 export interface Critter {
     name: string;
-    type: string;
-    status?: 'running' | 'stopped' | 'unknown';
+    service: string;
+    config_path?: string;
+    log_path?: string;
+    use_journald?: boolean;
 }
 export interface Barn {
     name: string;

package/dist/views/BarnContext.d.ts

@@ -1,4 +1,4 @@
-import type { Barn, Project, Livestock } from '../types.js';
+import type { Barn, Project, Livestock, Critter } from '../types.js';
 import type { TmuxWindow } from '../lib/tmux.js';
 interface LivestockWithProject {
     project: Project;
@@ -17,6 +17,8 @@ interface BarnContextProps {
     onDeleteBarn: (barnName: string) => void;
     onAddLivestock: (project: Project, livestock: Livestock) => void;
     onRemoveLivestock: (project: Project, livestockName: string) => void;
+    onAddCritter: (critter: Critter) => void;
+    onRemoveCritter: (critterName: string) => void;
 }
-export declare function BarnContext({ barn, livestock, projects, windows, onBack, onSshToBarn, onSelectLivestock, onOpenLivestockSession, onUpdateBarn, onDeleteBarn, onAddLivestock, onRemoveLivestock, }: BarnContextProps): import("react/jsx-runtime").JSX.Element;
+export declare function BarnContext({ barn, livestock, projects, windows, onBack, onSshToBarn, onSelectLivestock, onOpenLivestockSession, onUpdateBarn, onDeleteBarn, onAddLivestock, onRemoveLivestock, onAddCritter, onRemoveCritter, }: BarnContextProps): import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/views/BarnContext.js

@@ -9,7 +9,7 @@ import { PathInput } from '../components/PathInput.js';
 import { detectRemoteGitInfo, detectGitInfo } from '../lib/git.js';
 import { isLocalBarn } from '../lib/config.js';
 import { parseGitHubUrl } from '../lib/github.js';
-export function BarnContext({ barn, livestock, projects, windows, onBack, onSshToBarn, onSelectLivestock, onOpenLivestockSession, onUpdateBarn, onDeleteBarn, onAddLivestock, onRemoveLivestock, }) {
+export function BarnContext({ barn, livestock, projects, windows, onBack, onSshToBarn, onSelectLivestock, onOpenLivestockSession, onUpdateBarn, onDeleteBarn, onAddLivestock, onRemoveLivestock, onAddCritter, onRemoveCritter, }) {
     const [focusedPanel, setFocusedPanel] = useState('livestock');
     const [mode, setMode] = useState('normal');
     // Check if this is the local barn
@@ -28,6 +28,11 @@ export function BarnContext({ barn, livestock, projects, windows, onBack, onSshT
     // Delete livestock state
     const [selectedLivestockIndex, setSelectedLivestockIndex] = useState(0);
     const [deleteLivestockTarget, setDeleteLivestockTarget] = useState(null);
+    // Critter state
+    const [selectedCritterIndex, setSelectedCritterIndex] = useState(0);
+    const [newCritterName, setNewCritterName] = useState('');
+    const [newCritterService, setNewCritterService] = useState('');
+    const [deleteCritterTarget, setDeleteCritterTarget] = useState(null);
     // Filter windows that are barn sessions
     const barnWindows = windows.filter((w) => w.index > 0 && w.name.startsWith(`barn-${barn.name}`));
     const startEdit = () => {
@@ -80,24 +85,26 @@ export function BarnContext({ barn, livestock, projects, windows, onBack, onSshT
             }
             return;
         }
+        // Handle delete critter confirmation
+        if (mode === 'delete-critter-confirm' && deleteCritterTarget) {
+            if (input === 'y') {
+                onRemoveCritter(deleteCritterTarget.name);
+                setDeleteCritterTarget(null);
+                setSelectedCritterIndex(Math.max(0, selectedCritterIndex - 1));
+                setMode('normal');
+            }
+            else if (input === 'n') {
+                setDeleteCritterTarget(null);
+                setMode('normal');
+            }
+            return;
+        }
         if (mode !== 'normal')
             return;
         if (key.tab) {
             setFocusedPanel((p) => (p === 'livestock' ? 'critters' : 'livestock'));
             return;
         }
-        if (input === 's') {
-            // Context-aware shell: livestock session if focused on livestock, otherwise SSH to barn
-            if (focusedPanel === 'livestock' && livestock.length > 0) {
-                const target = livestock[selectedLivestockIndex];
-                if (target) {
-                    onOpenLivestockSession(target.project, target.livestock);
-                    return;
-                }
-            }
-            onSshToBarn();
-            return;
-        }
         if (input === 'e' && !isLocal) {
             startEdit();
             return;
@@ -125,6 +132,23 @@ export function BarnContext({ barn, livestock, projects, windows, onBack, onSshT
             }
             return;
         }
+        if (input === 'n' && focusedPanel === 'critters') {
+            // Start add critter flow
+            setNewCritterName('');
+            setNewCritterService('');
+            setMode('add-critter-name');
+            return;
+        }
+        if (input === 'd' && focusedPanel === 'critters' && (barn.critters || []).length > 0) {
+            // Delete selected critter
+            const critters = barn.critters || [];
+            const target = critters[selectedCritterIndex];
+            if (target) {
+                setDeleteCritterTarget(target);
+                setMode('delete-critter-confirm');
+            }
+            return;
+        }
     });
     // Edit mode screens
     if (mode === 'edit-host') {
@@ -220,29 +244,64 @@ export function BarnContext({ barn, livestock, projects, windows, onBack, onSshT
     if (mode === 'delete-livestock-confirm' && deleteLivestockTarget) {
         return (_jsxs(Box, { flexDirection: "column", flexGrow: 1, children: [_jsx(BarnHeader, { name: barn.name, subtitle: "Remove livestock" }), _jsxs(Box, { flexDirection: "column", padding: 2, children: [_jsx(Text, { bold: true, color: "red", children: "Remove Livestock" }), _jsx(Box, { marginTop: 1, children: _jsxs(Text, { children: ["Remove \"", deleteLivestockTarget.livestock.name, "\" from ", deleteLivestockTarget.project.name, "?"] }) }), _jsx(Box, { marginTop: 1, children: _jsxs(Text, { dimColor: true, children: ["Path: ", deleteLivestockTarget.livestock.path] }) }), _jsxs(Box, { marginTop: 1, gap: 2, children: [_jsx(Text, { color: "red", bold: true, children: "[y] Yes, remove" }), _jsx(Text, { dimColor: true, children: "[n/Esc] Cancel" })] })] })] }));
     }
+    // Add critter flow: name → service
+    if (mode === 'add-critter-name') {
+        return (_jsxs(Box, { flexDirection: "column", flexGrow: 1, children: [_jsx(BarnHeader, { name: barn.name, subtitle: "Adding critter" }), _jsxs(Box, { flexDirection: "column", padding: 2, children: [_jsxs(Text, { bold: true, color: "green", children: ["Add Critter to ", barn.name] }), _jsx(Text, { dimColor: true, children: "A critter is a system service like mysql, redis, nginx, etc." }), _jsxs(Box, { marginTop: 1, children: [_jsx(Text, { children: "Name: " }), _jsx(TextInput, { value: newCritterName, onChange: setNewCritterName, onSubmit: () => {
+                                        if (newCritterName.trim()) {
+                                            // Auto-suggest service name
+                                            setNewCritterService(`${newCritterName.trim()}.service`);
+                                            setMode('add-critter-service');
+                                        }
+                                    }, placeholder: "mysql, redis, nginx..." })] }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: "Enter: next, Esc: cancel" }) })] })] }));
+    }
+    if (mode === 'add-critter-service') {
+        return (_jsxs(Box, { flexDirection: "column", flexGrow: 1, children: [_jsx(BarnHeader, { name: barn.name, subtitle: "Adding critter" }), _jsxs(Box, { flexDirection: "column", padding: 2, children: [_jsxs(Text, { bold: true, color: "green", children: ["Add Critter: ", newCritterName] }), _jsx(Text, { dimColor: true, children: "Enter the systemd service name" }), _jsxs(Box, { marginTop: 1, children: [_jsx(Text, { children: "Service: " }), _jsx(TextInput, { value: newCritterService, onChange: setNewCritterService, onSubmit: () => {
+                                        if (newCritterService.trim()) {
+                                            const critter = {
+                                                name: newCritterName.trim(),
+                                                service: newCritterService.trim(),
+                                                use_journald: true,
+                                            };
+                                            onAddCritter(critter);
+                                            setMode('normal');
+                                        }
+                                    }, placeholder: "mysql.service, redis-server.service..." })] }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: "Enter: save, Esc: cancel" }) })] })] }));
+    }
+    // Delete critter confirmation
+    if (mode === 'delete-critter-confirm' && deleteCritterTarget) {
+        return (_jsxs(Box, { flexDirection: "column", flexGrow: 1, children: [_jsx(BarnHeader, { name: barn.name, subtitle: "Remove critter" }), _jsxs(Box, { flexDirection: "column", padding: 2, children: [_jsx(Text, { bold: true, color: "red", children: "Remove Critter" }), _jsx(Box, { marginTop: 1, children: _jsxs(Text, { children: ["Remove \"", deleteCritterTarget.name, "\" from ", barn.name, "?"] }) }), _jsx(Box, { marginTop: 1, children: _jsxs(Text, { dimColor: true, children: ["Service: ", deleteCritterTarget.service] }) }), _jsxs(Box, { marginTop: 1, gap: 2, children: [_jsx(Text, { color: "red", bold: true, children: "[y] Yes, remove" }), _jsx(Text, { dimColor: true, children: "[n/Esc] Cancel" })] })] })] }));
+    }
     // Build livestock items
     const livestockItems = livestock.map((l) => ({
         id: `${l.project.name}/${l.livestock.name}`,
         label: `${l.project.name}/${l.livestock.name}`,
         status: 'active',
         meta: l.livestock.path,
+        actions: [{ key: 's', label: 'shell' }],
     }));
     // Build critter items
     const critterItems = (barn.critters || []).map((c) => ({
         id: c.name,
         label: c.name,
-        status: c.status === 'running' ? 'active' : c.status === 'stopped' ? 'inactive' : 'inactive',
-        meta: c.type,
+        status: 'active', // Critters are assumed active (discovery only finds running services)
+        meta: c.service,
     }));
     // Panel-specific hints (page-level hotkeys like s are in BottomBar)
-    const livestockHints = '[s] shell  [n] new  [d] delete';
-    const crittersHints = '';
+    const livestockHints = '[n] new  [d] delete';
+    const crittersHints = '[n] new  [d] delete';
     return (_jsxs(Box, { flexDirection: "column", flexGrow: 1, children: [_jsx(BarnHeader, { name: barn.name, subtitle: isLocal ? 'Local machine' : `${barn.user}@${barn.host}:${barn.port}` }), !isLocal && (_jsx(Box, { paddingX: 2, marginY: 1, children: _jsxs(Box, { gap: 4, children: [_jsxs(Text, { children: [_jsx(Text, { dimColor: true, children: "Host:" }), " ", barn.host] }), _jsxs(Text, { children: [_jsx(Text, { dimColor: true, children: "User:" }), " ", barn.user] }), _jsxs(Text, { children: [_jsx(Text, { dimColor: true, children: "Port:" }), " ", barn.port] }), _jsxs(Text, { children: [_jsx(Text, { dimColor: true, children: "Key:" }), " ", barn.identity_file] })] }) })), _jsxs(Box, { flexGrow: 1, marginY: 1, paddingX: 1, gap: 2, children: [_jsx(Panel, { title: "Livestock", focused: focusedPanel === 'livestock', width: "50%", hints: livestockHints, children: livestockItems.length > 0 ? (_jsx(List, { items: livestockItems, focused: focusedPanel === 'livestock', selectedIndex: selectedLivestockIndex, onSelectionChange: setSelectedLivestockIndex, onSelect: (item) => {
                                 const found = livestock.find((l) => `${l.project.name}/${l.livestock.name}` === item.id);
                                 if (found) {
                                     onSelectLivestock(found.project, found.livestock);
                                 }
-                            } })) : (_jsx(Box, { flexDirection: "column", children: _jsx(Text, { dimColor: true, children: "No livestock deployed to this barn" }) })) }), _jsx(Panel, { title: "Critters", focused: focusedPanel === 'critters', width: "50%", hints: crittersHints, children: critterItems.length > 0 ? (_jsx(List, { items: critterItems, focused: focusedPanel === 'critters', onSelect: () => {
-                                // TODO: Could show critter details or manage service
-                            } })) : (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { dimColor: true, children: "No critters configured" }), _jsx(Text, { dimColor: true, italic: true, children: "Critters are system services (nginx, mysql, etc.)" })] })) })] })] }));
+                            }, onAction: (item, actionKey) => {
+                                if (actionKey === 's') {
+                                    const found = livestock.find((l) => `${l.project.name}/${l.livestock.name}` === item.id);
+                                    if (found) {
+                                        onOpenLivestockSession(found.project, found.livestock);
+                                    }
+                                }
+                            } })) : (_jsx(Box, { flexDirection: "column", children: _jsx(Text, { dimColor: true, children: "No livestock deployed to this barn" }) })) }), _jsx(Panel, { title: "Critters", focused: focusedPanel === 'critters', width: "50%", hints: crittersHints, children: critterItems.length > 0 ? (_jsx(List, { items: critterItems, focused: focusedPanel === 'critters', selectedIndex: selectedCritterIndex, onSelectionChange: setSelectedCritterIndex, onSelect: () => {
+                                // Could show critter details or logs in future
+                            } })) : (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { dimColor: true, children: "No critters configured" }), _jsx(Text, { dimColor: true, italic: true, children: "Press [n] to add a critter" })] })) })] })] }));
 }

package/dist/views/GlobalDashboard.d.ts

@@ -11,11 +11,11 @@ interface GlobalDashboardProps {
     onSelectProject: (project: Project) => void;
     onSelectBarn: (barn: Barn) => void;
     onSelectWindow: (window: TmuxWindow) => void;
-    onNewClaude: () => void;
+    onNewClaudeForProject: (project: Project) => void;
     onCreateProject: (name: string, path: string) => void;
     onCreateBarn: (barn: Barn) => void;
     onSshToBarn: (barn: Barn) => void;
     onInputModeChange?: (isInputMode: boolean) => void;
 }
-export declare function GlobalDashboard({ projects, barns, windows, versionInfo, onSelectProject, onSelectBarn, onSelectWindow, onNewClaude, onCreateProject, onCreateBarn, onSshToBarn, onInputModeChange, }: GlobalDashboardProps): import("react/jsx-runtime").JSX.Element;
+export declare function GlobalDashboard({ projects, barns, windows, versionInfo, onSelectProject, onSelectBarn, onSelectWindow, onNewClaudeForProject, onCreateProject, onCreateBarn, onSshToBarn, onInputModeChange, }: GlobalDashboardProps): import("react/jsx-runtime").JSX.Element;
 export {};