@colmbus72/yeehaw 0.1.0

package/dist/hooks/index.d.ts

@@ -0,0 +1,3 @@
+export { useConfig } from './useConfig.js';
+export { useSessions } from './useSessions.js';
+export { useRemoteYeehaw } from './useRemoteYeehaw.js';

package/dist/hooks/index.js

@@ -0,0 +1,3 @@
+export { useConfig } from './useConfig.js';
+export { useSessions } from './useSessions.js';
+export { useRemoteYeehaw } from './useRemoteYeehaw.js';

package/dist/hooks/useConfig.d.ts

@@ -0,0 +1,11 @@
+import type { Config, Project, Barn } from '../types.js';
+interface UseConfigReturn {
+    config: Config;
+    projects: Project[];
+    barns: Barn[];
+    currentProject: Project | null;
+    setCurrentProjectName: (name: string | null) => void;
+    reload: () => void;
+}
+export declare function useConfig(): UseConfigReturn;
+export {};

package/dist/hooks/useConfig.js

@@ -0,0 +1,36 @@
+import { useState, useEffect } from 'react';
+import { watch } from 'chokidar';
+import { loadConfig, loadProjects, loadBarns, loadProject } from '../lib/config.js';
+import { YEEHAW_DIR } from '../lib/paths.js';
+export function useConfig() {
+    const [config, setConfig] = useState(() => loadConfig());
+    const [projects, setProjects] = useState(() => loadProjects());
+    const [barns, setBarns] = useState(() => loadBarns());
+    const [currentProjectName, setCurrentProjectName] = useState(() => loadConfig().default_project);
+    const reload = () => {
+        setConfig(loadConfig());
+        setProjects(loadProjects());
+        setBarns(loadBarns());
+    };
+    useEffect(() => {
+        const watcher = watch(YEEHAW_DIR, {
+            ignoreInitial: true,
+            depth: 2,
+        });
+        watcher.on('all', () => {
+            reload();
+        });
+        return () => {
+            watcher.close();
+        };
+    }, []);
+    const currentProject = currentProjectName ? loadProject(currentProjectName) : null;
+    return {
+        config,
+        projects,
+        barns,
+        currentProject,
+        setCurrentProjectName,
+        reload,
+    };
+}

package/dist/hooks/useRemoteYeehaw.d.ts

@@ -0,0 +1,13 @@
+import type { Barn } from '../types.js';
+import { type DetectionState } from '../lib/detection.js';
+export interface RemoteEnvironment {
+    barn: Barn;
+    state: DetectionState;
+}
+interface UseRemoteYeehawReturn {
+    environments: RemoteEnvironment[];
+    isDetecting: boolean;
+    refresh: () => void;
+}
+export declare function useRemoteYeehaw(barns: Barn[]): UseRemoteYeehawReturn;
+export {};

package/dist/hooks/useRemoteYeehaw.js

@@ -0,0 +1,49 @@
+import { useState, useEffect, useCallback } from 'react';
+import { probeBarns, isCacheFresh } from '../lib/detection.js';
+import { hasValidSshConfig, isLocalBarn } from '../lib/config.js';
+export function useRemoteYeehaw(barns) {
+    const [results, setResults] = useState(new Map());
+    const [isDetecting, setIsDetecting] = useState(false);
+    const sshBarns = barns.filter(b => !isLocalBarn(b) && hasValidSshConfig(b));
+    const runDetection = useCallback(async () => {
+        if (sshBarns.length === 0)
+            return;
+        setIsDetecting(true);
+        try {
+            const detectionResults = await probeBarns(sshBarns);
+            setResults(prev => {
+                const next = new Map(prev);
+                for (const result of detectionResults) {
+                    next.set(result.barnName, result);
+                }
+                return next;
+            });
+        }
+        finally {
+            setIsDetecting(false);
+        }
+    }, [sshBarns.map(b => b.name).join(',')]);
+    // Run detection on mount and when barns change
+    useEffect(() => {
+        // Check if we need to refresh any cached results
+        const needsRefresh = sshBarns.some(barn => {
+            const cached = results.get(barn.name);
+            return !cached || !isCacheFresh(cached);
+        });
+        if (needsRefresh) {
+            runDetection();
+        }
+    }, [sshBarns.map(b => b.name).join(',')]);
+    // Build environments list - only include available barns
+    const environments = sshBarns
+        .map(barn => ({
+        barn,
+        state: results.get(barn.name)?.state ?? 'not-checked',
+    }))
+        .filter(env => env.state === 'available');
+    return {
+        environments,
+        isDetecting,
+        refresh: runDetection,
+    };
+}

package/dist/hooks/useSessions.d.ts

@@ -0,0 +1,11 @@
+import { type TmuxWindow } from '../lib/tmux.js';
+interface UseSessionsReturn {
+    windows: TmuxWindow[];
+    loading: boolean;
+    refresh: () => void;
+    createClaude: (workingDir: string, name: string) => number;
+    createShell: (workingDir: string, name: string) => number;
+    attachToWindow: (index: number) => void;
+}
+export declare function useSessions(): UseSessionsReturn;
+export {};

package/dist/hooks/useSessions.js

@@ -0,0 +1,46 @@
+import { useState, useEffect, useCallback } from 'react';
+import { listYeehawWindows, createClaudeWindow, createShellWindow, switchToWindow, } from '../lib/tmux.js';
+export function useSessions() {
+    const [windows, setWindows] = useState([]);
+    const [loading, setLoading] = useState(true);
+    const refresh = useCallback(() => {
+        const result = listYeehawWindows();
+        setWindows(prev => {
+            // Only update if windows actually changed (avoids unnecessary re-renders)
+            if (prev.length !== result.length)
+                return result;
+            const changed = result.some((w, i) => w.index !== prev[i].index || w.name !== prev[i].name);
+            return changed ? result : prev;
+        });
+    }, []);
+    useEffect(() => {
+        // Initial load with loading state
+        const result = listYeehawWindows();
+        setWindows(result);
+        setLoading(false);
+        // Poll every 5 seconds for window updates (without loading state changes)
+        const interval = setInterval(refresh, 5000);
+        return () => clearInterval(interval);
+    }, [refresh]);
+    const createClaude = useCallback((workingDir, name) => {
+        const windowIndex = createClaudeWindow(workingDir, name);
+        refresh();
+        return windowIndex;
+    }, [refresh]);
+    const createShell = useCallback((workingDir, name) => {
+        const windowIndex = createShellWindow(workingDir, name);
+        refresh();
+        return windowIndex;
+    }, [refresh]);
+    const attachToWindow = useCallback((index) => {
+        switchToWindow(index);
+    }, []);
+    return {
+        windows,
+        loading,
+        refresh,
+        createClaude,
+        createShell,
+        attachToWindow,
+    };
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,34 @@
+#!/usr/bin/env node
+import { jsx as _jsx } from "react/jsx-runtime";
+import { render } from 'ink';
+import { execaSync } from 'execa';
+import { App } from './app.js';
+import { isInsideYeehawSession, yeehawSessionExists, createYeehawSession, attachToYeehaw, hasTmux, } from './lib/tmux.js';
+import { ensureConfigDirs } from './lib/config.js';
+function main() {
+    // Ensure config directories exist
+    ensureConfigDirs();
+    // Check if tmux is available
+    if (!hasTmux()) {
+        console.error('Error: tmux is required but not installed');
+        console.error('Install tmux and try again');
+        process.exit(1);
+    }
+    // If we're already inside the yeehaw tmux session, just render the TUI
+    if (isInsideYeehawSession()) {
+        render(_jsx(App, {}));
+        return;
+    }
+    // We're not inside yeehaw session - need to create/attach
+    if (!yeehawSessionExists()) {
+        // Create new session with yeehaw running in window 0
+        createYeehawSession();
+        // Now we need to run yeehaw inside window 0
+        // Send the command to the window
+        execaSync('tmux', ['send-keys', '-t', 'yeehaw:0', 'yeehaw', 'Enter']);
+    }
+    // Attach to the yeehaw session
+    // This will exec into tmux and not return
+    attachToYeehaw();
+}
+main();

package/dist/lib/config.d.ts

@@ -0,0 +1,27 @@
+import type { Config, Project, Barn, Livestock } from '../types.js';
+export declare const LOCAL_BARN: Barn;
+export declare function isLocalBarn(barn: Barn): boolean;
+/**
+ * Type guard to check if a barn has valid SSH configuration.
+ * Returns true only if all required SSH fields are present.
+ */
+export declare function hasValidSshConfig(barn: Barn): barn is Barn & {
+    host: string;
+    user: string;
+    port: number;
+    identity_file: string;
+};
+export declare function ensureConfigDirs(): void;
+export declare function loadConfig(): Config;
+export declare function loadProjects(): Project[];
+export declare function loadProject(name: string): Project | null;
+export declare function loadBarns(): Barn[];
+export declare function loadBarn(name: string): Barn | null;
+export declare function saveProject(project: Project): void;
+export declare function deleteProject(name: string): boolean;
+export declare function saveBarn(barn: Barn): void;
+export declare function deleteBarn(name: string): boolean;
+export declare function getLivestockForBarn(barnName: string): Array<{
+    project: Project;
+    livestock: Livestock;
+}>;

package/dist/lib/config.js

@@ -0,0 +1,150 @@
+import { readFileSync, writeFileSync, existsSync, mkdirSync, readdirSync, unlinkSync } from 'fs';
+import YAML from 'js-yaml';
+import { YEEHAW_DIR, CONFIG_FILE, PROJECTS_DIR, BARNS_DIR, SESSIONS_DIR, getProjectPath, getBarnPath, } from './paths.js';
+// The local barn is always available - represents the local machine
+export const LOCAL_BARN = {
+    name: 'local',
+    critters: [],
+};
+// Check if a barn is the local machine
+export function isLocalBarn(barn) {
+    return barn.name === 'local';
+}
+/**
+ * Type guard to check if a barn has valid SSH configuration.
+ * Returns true only if all required SSH fields are present.
+ */
+export function hasValidSshConfig(barn) {
+    return (!isLocalBarn(barn) &&
+        typeof barn.host === 'string' && barn.host.length > 0 &&
+        typeof barn.user === 'string' && barn.user.length > 0 &&
+        typeof barn.port === 'number' &&
+        typeof barn.identity_file === 'string' && barn.identity_file.length > 0);
+}
+const DEFAULT_CONFIG = {
+    version: 1,
+    default_project: null,
+    editor: 'vim',
+    theme: 'dark',
+    show_activity: true,
+    claude: {
+        model: 'claude-sonnet-4-20250514',
+        auto_attach: true,
+    },
+    tmux: {
+        session_prefix: 'yh-',
+        default_shell: '/bin/zsh',
+    },
+};
+export function ensureConfigDirs() {
+    const dirs = [YEEHAW_DIR, PROJECTS_DIR, BARNS_DIR, SESSIONS_DIR];
+    for (const dir of dirs) {
+        if (!existsSync(dir)) {
+            mkdirSync(dir, { recursive: true });
+        }
+    }
+}
+export function loadConfig() {
+    ensureConfigDirs();
+    if (!existsSync(CONFIG_FILE)) {
+        writeFileSync(CONFIG_FILE, YAML.dump(DEFAULT_CONFIG), 'utf-8');
+        return DEFAULT_CONFIG;
+    }
+    const content = readFileSync(CONFIG_FILE, 'utf-8');
+    const parsed = YAML.load(content);
+    return { ...DEFAULT_CONFIG, ...parsed };
+}
+function normalizeProject(project) {
+    project.livestock = project.livestock || [];
+    return project;
+}
+export function loadProjects() {
+    ensureConfigDirs();
+    if (!existsSync(PROJECTS_DIR))
+        return [];
+    const files = readdirSync(PROJECTS_DIR).filter((f) => f.endsWith('.yaml'));
+    return files.map((file) => {
+        const content = readFileSync(getProjectPath(file.replace('.yaml', '')), 'utf-8');
+        const project = YAML.load(content);
+        return normalizeProject(project);
+    });
+}
+export function loadProject(name) {
+    const path = getProjectPath(name);
+    if (!existsSync(path))
+        return null;
+    const content = readFileSync(path, 'utf-8');
+    const project = YAML.load(content);
+    return normalizeProject(project);
+}
+export function loadBarns() {
+    ensureConfigDirs();
+    // Always include the local barn first
+    const barns = [LOCAL_BARN];
+    if (!existsSync(BARNS_DIR))
+        return barns;
+    const files = readdirSync(BARNS_DIR).filter((f) => f.endsWith('.yaml'));
+    for (const file of files) {
+        const content = readFileSync(getBarnPath(file.replace('.yaml', '')), 'utf-8');
+        const barn = YAML.load(content);
+        // Skip if someone manually created a 'local' barn file
+        if (barn.name !== 'local') {
+            barns.push(barn);
+        }
+    }
+    return barns;
+}
+export function loadBarn(name) {
+    // Local barn is always available
+    if (name === 'local') {
+        return LOCAL_BARN;
+    }
+    const path = getBarnPath(name);
+    if (!existsSync(path))
+        return null;
+    const content = readFileSync(path, 'utf-8');
+    return YAML.load(content);
+}
+export function saveProject(project) {
+    ensureConfigDirs();
+    const path = getProjectPath(project.name);
+    const content = YAML.dump(project);
+    writeFileSync(path, content, 'utf-8');
+}
+export function deleteProject(name) {
+    const path = getProjectPath(name);
+    if (!existsSync(path))
+        return false;
+    unlinkSync(path);
+    return true;
+}
+export function saveBarn(barn) {
+    ensureConfigDirs();
+    const path = getBarnPath(barn.name);
+    const content = YAML.dump(barn);
+    writeFileSync(path, content, 'utf-8');
+}
+export function deleteBarn(name) {
+    // Cannot delete the local barn
+    if (name === 'local')
+        return false;
+    const path = getBarnPath(name);
+    if (!existsSync(path))
+        return false;
+    unlinkSync(path);
+    return true;
+}
+// Get all livestock deployed to a specific barn (derived from projects)
+export function getLivestockForBarn(barnName) {
+    const projects = loadProjects();
+    const result = [];
+    for (const project of projects) {
+        for (const livestock of project.livestock || []) {
+            // Match by barn name, or match local barn with undefined/missing barn field
+            if (livestock.barn === barnName || (barnName === 'local' && !livestock.barn)) {
+                result.push({ project, livestock });
+            }
+        }
+    }
+    return result;
+}

package/dist/lib/detection.d.ts

@@ -0,0 +1,16 @@
+import type { Barn } from '../types.js';
+export type DetectionState = 'not-checked' | 'checking' | 'available' | 'unavailable' | 'unreachable';
+export interface BarnDetectionResult {
+    barnName: string;
+    state: DetectionState;
+    checkedAt: number;
+}
+/**
+ * Probe a single barn to check if Yeehaw is running.
+ * Returns 'available' if tmux session 'yeehaw' exists on the remote.
+ */
+export declare function probeBarns(barns: Barn[]): Promise<BarnDetectionResult[]>;
+/**
+ * Check if a cached result is still fresh.
+ */
+export declare function isCacheFresh(result: BarnDetectionResult): boolean;

package/dist/lib/detection.js

@@ -0,0 +1,41 @@
+import { execa } from 'execa';
+import { hasValidSshConfig, isLocalBarn } from './config.js';
+const CACHE_TTL_MS = 5 * 60 * 1000; // 5 minutes
+const SSH_TIMEOUT_SECONDS = 5;
+/**
+ * Probe a single barn to check if Yeehaw is running.
+ * Returns 'available' if tmux session 'yeehaw' exists on the remote.
+ */
+export async function probeBarns(barns) {
+    const sshBarns = barns.filter(b => !isLocalBarn(b) && hasValidSshConfig(b));
+    const probes = sshBarns.map(async (barn) => {
+        if (!hasValidSshConfig(barn)) {
+            return { barnName: barn.name, state: 'unreachable', checkedAt: Date.now() };
+        }
+        try {
+            const result = await execa('ssh', [
+                '-o', 'ConnectTimeout=' + SSH_TIMEOUT_SECONDS,
+                '-o', 'BatchMode=yes',
+                '-o', 'StrictHostKeyChecking=accept-new',
+                '-p', String(barn.port),
+                '-i', barn.identity_file,
+                `${barn.user}@${barn.host}`,
+                'tmux has-session -t yeehaw 2>/dev/null && echo "yeehaw:running"'
+            ], { timeout: (SSH_TIMEOUT_SECONDS + 2) * 1000 });
+            const state = result.stdout.includes('yeehaw:running')
+                ? 'available'
+                : 'unavailable';
+            return { barnName: barn.name, state, checkedAt: Date.now() };
+        }
+        catch {
+            return { barnName: barn.name, state: 'unreachable', checkedAt: Date.now() };
+        }
+    });
+    return Promise.all(probes);
+}
+/**
+ * Check if a cached result is still fresh.
+ */
+export function isCacheFresh(result) {
+    return Date.now() - result.checkedAt < CACHE_TTL_MS;
+}

package/dist/lib/editor.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Open content in user's editor and return the edited content.
+ * Similar to how git opens commit messages.
+ */
+export declare function editInEditor(initialContent: string, filename?: string): string | null;

package/dist/lib/editor.js

@@ -0,0 +1,35 @@
+import { execaSync } from 'execa';
+import { writeFileSync, readFileSync, unlinkSync, existsSync } from 'fs';
+import { join } from 'path';
+import { tmpdir } from 'os';
+import { randomBytes } from 'crypto';
+/**
+ * Open content in user's editor and return the edited content.
+ * Similar to how git opens commit messages.
+ */
+export function editInEditor(initialContent, filename = 'edit.md') {
+    const editor = process.env.EDITOR || process.env.VISUAL || 'nano';
+    const tempFile = join(tmpdir(), `yeehaw-${randomBytes(4).toString('hex')}-${filename}`);
+    try {
+        // Write initial content to temp file
+        writeFileSync(tempFile, initialContent, 'utf-8');
+        // Open editor (this blocks until editor is closed)
+        execaSync(editor, [tempFile], {
+            stdio: 'inherit',
+        });
+        // Read back the edited content
+        if (existsSync(tempFile)) {
+            const content = readFileSync(tempFile, 'utf-8');
+            unlinkSync(tempFile);
+            return content;
+        }
+        return null;
+    }
+    catch (error) {
+        // Clean up temp file if it exists
+        if (existsSync(tempFile)) {
+            unlinkSync(tempFile);
+        }
+        return null;
+    }
+}

package/dist/lib/errors.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Safely extract an error message from an unknown error value.
+ * This is the recommended pattern for catch blocks in TypeScript.
+ *
+ * @example
+ * try {
+ *   await riskyOperation();
+ * } catch (err) {
+ *   return { error: getErrorMessage(err) };
+ * }
+ */
+export declare function getErrorMessage(err: unknown): string;
+/**
+ * Type guard to check if a value is a non-null object
+ */
+export declare function isObject(value: unknown): value is Record<string, unknown>;
+/**
+ * Type guard to check if a value is a string
+ */
+export declare function isString(value: unknown): value is string;
+/**
+ * Type guard to check if a value is a number
+ */
+export declare function isNumber(value: unknown): value is number;
+/**
+ * Type guard to check if a value is a boolean
+ */
+export declare function isBoolean(value: unknown): value is boolean;

package/dist/lib/errors.js

@@ -0,0 +1,48 @@
+// src/lib/errors.ts
+/**
+ * Safely extract an error message from an unknown error value.
+ * This is the recommended pattern for catch blocks in TypeScript.
+ *
+ * @example
+ * try {
+ *   await riskyOperation();
+ * } catch (err) {
+ *   return { error: getErrorMessage(err) };
+ * }
+ */
+export function getErrorMessage(err) {
+    if (err instanceof Error) {
+        return err.message;
+    }
+    if (typeof err === 'string') {
+        return err;
+    }
+    if (err && typeof err === 'object' && 'message' in err) {
+        return String(err.message);
+    }
+    return String(err);
+}
+/**
+ * Type guard to check if a value is a non-null object
+ */
+export function isObject(value) {
+    return typeof value === 'object' && value !== null;
+}
+/**
+ * Type guard to check if a value is a string
+ */
+export function isString(value) {
+    return typeof value === 'string';
+}
+/**
+ * Type guard to check if a value is a number
+ */
+export function isNumber(value) {
+    return typeof value === 'number' && !isNaN(value);
+}
+/**
+ * Type guard to check if a value is a boolean
+ */
+export function isBoolean(value) {
+    return typeof value === 'boolean';
+}

package/dist/lib/git.d.ts

@@ -0,0 +1,11 @@
+import type { Barn } from '../types.js';
+export interface GitInfo {
+    isGitRepo: boolean;
+    remoteUrl?: string;
+    branch?: string;
+}
+export declare function detectGitInfo(path: string): GitInfo;
+/**
+ * Detect git info on a remote server via SSH.
+ */
+export declare function detectRemoteGitInfo(path: string, barn: Barn): GitInfo;

package/dist/lib/git.js

@@ -0,0 +1,73 @@
+import { execaSync } from 'execa';
+import { existsSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+import { hasValidSshConfig } from './config.js';
+import { shellEscape } from './shell.js';
+function expandPath(path) {
+    if (path.startsWith('~/')) {
+        return join(homedir(), path.slice(2));
+    }
+    return path;
+}
+export function detectGitInfo(path) {
+    const expandedPath = expandPath(path);
+    // Check if .git exists
+    if (!existsSync(join(expandedPath, '.git'))) {
+        return { isGitRepo: false };
+    }
+    try {
+        // Get remote URL
+        const remoteResult = execaSync('git', ['-C', expandedPath, 'config', '--get', 'remote.origin.url'], {
+            reject: false,
+        });
+        const remoteUrl = remoteResult.exitCode === 0 ? remoteResult.stdout.trim() : undefined;
+        // Get current branch
+        const branchResult = execaSync('git', ['-C', expandedPath, 'rev-parse', '--abbrev-ref', 'HEAD'], {
+            reject: false,
+        });
+        const branch = branchResult.exitCode === 0 ? branchResult.stdout.trim() : undefined;
+        return {
+            isGitRepo: true,
+            remoteUrl,
+            branch,
+        };
+    }
+    catch {
+        return { isGitRepo: false };
+    }
+}
+/**
+ * Detect git info on a remote server via SSH.
+ */
+export function detectRemoteGitInfo(path, barn) {
+    // Verify barn has valid SSH config
+    if (!hasValidSshConfig(barn)) {
+        return { isGitRepo: false };
+    }
+    try {
+        // Run git commands via SSH
+        const result = execaSync('ssh', [
+            '-p', String(barn.port),
+            '-i', barn.identity_file,
+            '-o', 'BatchMode=yes',
+            '-o', 'ConnectTimeout=5',
+            `${barn.user}@${barn.host}`,
+            `cd ${shellEscape(path)} && git config --get remote.origin.url 2>/dev/null && git rev-parse --abbrev-ref HEAD 2>/dev/null`
+        ], { timeout: 10000, reject: false });
+        if (result.exitCode !== 0) {
+            return { isGitRepo: false };
+        }
+        const lines = result.stdout.trim().split('\n');
+        const remoteUrl = lines[0] || undefined;
+        const branch = lines[1] || undefined;
+        return {
+            isGitRepo: true,
+            remoteUrl,
+            branch,
+        };
+    }
+    catch {
+        return { isGitRepo: false };
+    }
+}