@colmbus72/yeehaw 0.4.2 → 0.6.0

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;
@@ -19,17 +24,19 @@ export declare function setupStatusBarHooks(): void;
 export declare function ensureCorrectStatusBar(): void;
 export declare function attachToYeehaw(): void;
 export declare function createClaudeWindow(workingDir: string, windowName: string): number;
+export declare function createClaudeWindowWithPrompt(workingDir: string, windowName: string, systemPrompt: string): number;
 export declare function createShellWindow(workingDir: string, windowName: string, shell?: string): number;
 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;

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);
@@ -130,23 +131,44 @@ export function attachToYeehaw() {
 }
 // All yeehaw MCP tools that should be auto-approved
 const YEEHAW_MCP_TOOLS = [
+    // Project management
     'mcp__yeehaw__list_projects',
     'mcp__yeehaw__get_project',
     'mcp__yeehaw__create_project',
     'mcp__yeehaw__update_project',
     'mcp__yeehaw__delete_project',
+    // Livestock management
     'mcp__yeehaw__add_livestock',
     'mcp__yeehaw__remove_livestock',
+    'mcp__yeehaw__read_livestock_logs',
+    'mcp__yeehaw__read_livestock_env',
+    // Barn management
     'mcp__yeehaw__list_barns',
     'mcp__yeehaw__get_barn',
     'mcp__yeehaw__create_barn',
     'mcp__yeehaw__update_barn',
     'mcp__yeehaw__delete_barn',
+    // Critter management
+    'mcp__yeehaw__add_critter',
+    'mcp__yeehaw__remove_critter',
+    'mcp__yeehaw__read_critter_logs',
+    'mcp__yeehaw__discover_critters',
+    // Wiki management
     'mcp__yeehaw__get_wiki',
+    'mcp__yeehaw__get_wiki_section',
     'mcp__yeehaw__add_wiki_section',
     '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 +197,43 @@ 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 createClaudeWindowWithPrompt(workingDir, windowName, systemPrompt) {
+    // Build MCP config for yeehaw server
+    const mcpConfig = JSON.stringify({
+        mcpServers: {
+            yeehaw: {
+                command: 'node',
+                args: [MCP_SERVER_PATH],
+            },
+        },
+    });
+    // Build allowed tools list for auto-approval
+    const allowedTools = YEEHAW_MCP_TOOLS.join(',');
+    // Escape the system prompt for shell - use single quotes and escape any single quotes in content
+    const escapedPrompt = systemPrompt.replace(/'/g, "'\\''");
+    // Create new window running claude with yeehaw MCP server and system prompt
+    const claudeCmd = `claude --mcp-config ${shellEscape(mcpConfig)} --allowedTools ${shellEscape(allowedTools)} --plugin-dir ${shellEscape(CLAUDE_PLUGIN_PATH)} --system-prompt '${escapedPrompt}'`;
+    execaSync('tmux', [
+        'new-window',
+        '-a',
+        '-t', YEEHAW_SESSION,
+        '-n', windowName,
+        '-c', workingDir,
+        claudeCmd,
+    ]);
+    // Get the window index we just created
+    const result = execaSync('tmux', [
+        'display-message', '-p', '#{window_index}'
+    ]);
+    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 +252,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 +283,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 +299,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 +368,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

@@ -24,11 +24,21 @@ export interface Project {
     gradientInverted?: boolean;
     livestock?: Livestock[];
     wiki?: WikiSection[];
+    issueProvider?: IssueProviderConfig;
 }
 export interface WikiSection {
     title: string;
     content: string;
 }
+export type IssueProviderConfig = {
+    type: 'github';
+} | {
+    type: 'linear';
+    teamId?: string;
+    teamName?: string;
+} | {
+    type: 'none';
+};
 export interface Livestock {
     name: string;
     path: string;
@@ -40,8 +50,11 @@ export interface Livestock {
 }
 export interface Critter {
     name: string;
-    type: string;
-    status?: 'running' | 'stopped' | 'unknown';
+    service: string;
+    service_path?: string;
+    config_path?: string;
+    log_path?: string;
+    use_journald?: boolean;
 }
 export interface Barn {
     name: string;
@@ -90,6 +103,14 @@ export type AppView = {
     livestock: Livestock;
     source: 'project' | 'barn';
     sourceBarn?: Barn;
+} | {
+    type: 'critter';
+    barn: Barn;
+    critter: Critter;
+} | {
+    type: 'critter-logs';
+    barn: Barn;
+    critter: Critter;
 } | {
     type: 'night-sky';
 };

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,9 @@ 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;
+    onSelectCritter: (critter: Critter) => 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, onSelectCritter, }: BarnContextProps): import("react/jsx-runtime").JSX.Element;
 export {};