@colmbus72/yeehaw 0.1.0

package/dist/lib/paths.d.ts

@@ -0,0 +1,8 @@
+export declare const YEEHAW_DIR: string;
+export declare const CONFIG_FILE: string;
+export declare const PROJECTS_DIR: string;
+export declare const BARNS_DIR: string;
+export declare const SESSIONS_DIR: string;
+export declare function getProjectPath(name: string): string;
+export declare function getBarnPath(name: string): string;
+export declare function getSessionPath(id: string): string;

package/dist/lib/paths.js

@@ -0,0 +1,28 @@
+import { homedir } from 'os';
+import { join } from 'path';
+export const YEEHAW_DIR = join(homedir(), '.yeehaw');
+export const CONFIG_FILE = join(YEEHAW_DIR, 'config.yaml');
+export const PROJECTS_DIR = join(YEEHAW_DIR, 'projects');
+export const BARNS_DIR = join(YEEHAW_DIR, 'barns');
+export const SESSIONS_DIR = join(YEEHAW_DIR, 'sessions');
+/**
+ * Validate a name to prevent path traversal attacks.
+ * Rejects names containing path separators or parent directory references.
+ */
+function validateName(name, type) {
+    if (name.includes('/') || name.includes('\\') || name.includes('..') || name.includes('\0')) {
+        throw new Error(`Invalid ${type} name: contains forbidden characters`);
+    }
+}
+export function getProjectPath(name) {
+    validateName(name, 'project');
+    return join(PROJECTS_DIR, `${name}.yaml`);
+}
+export function getBarnPath(name) {
+    validateName(name, 'barn');
+    return join(BARNS_DIR, `${name}.yaml`);
+}
+export function getSessionPath(id) {
+    validateName(id, 'session');
+    return join(SESSIONS_DIR, `${id}.yaml`);
+}

package/dist/lib/shell.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Escape a string for safe use in a single-quoted shell argument.
+ * Single quotes are the safest quoting mechanism in shell - they prevent
+ * all interpretation except for single quotes themselves.
+ *
+ * Strategy: Replace ' with '\'' (end quote, escaped quote, start quote)
+ * Then wrap the whole thing in single quotes.
+ *
+ * Example: "foo'bar" becomes "'foo'\''bar'"
+ */
+export declare function shellEscape(str: string): string;
+/**
+ * Escape multiple arguments and join with spaces
+ */
+export declare function shellEscapeArgs(...args: string[]): string;
+/**
+ * Build a safe shell command from a template and arguments.
+ * Replaces {0}, {1}, etc. with escaped versions of the arguments.
+ *
+ * Example:
+ *   shellCommand('cat {0}', '/path/with spaces')
+ *   // Returns: "cat '/path/with spaces'"
+ *
+ *   shellCommand('grep -i {0} {1}', 'pattern', '/path')
+ *   // Returns: "grep -i 'pattern' '/path'"
+ */
+export declare function shellCommand(template: string, ...args: string[]): string;
+/**
+ * Escape a value for safe use in double quotes (for cases where we need variable expansion)
+ * This is less safe than single quotes but sometimes necessary.
+ *
+ * Escapes: $ ` \ " ! (and newlines)
+ */
+export declare function shellEscapeDouble(str: string): string;

package/dist/lib/shell.js

@@ -0,0 +1,61 @@
+// src/lib/shell.ts
+/**
+ * Escape a string for safe use in a single-quoted shell argument.
+ * Single quotes are the safest quoting mechanism in shell - they prevent
+ * all interpretation except for single quotes themselves.
+ *
+ * Strategy: Replace ' with '\'' (end quote, escaped quote, start quote)
+ * Then wrap the whole thing in single quotes.
+ *
+ * Example: "foo'bar" becomes "'foo'\''bar'"
+ */
+export function shellEscape(str) {
+    // Handle empty string
+    if (str === '') {
+        return "''";
+    }
+    // If string contains no special characters, we can use it as-is
+    // But for safety, always quote
+    const escaped = str.replace(/'/g, "'\\''");
+    return `'${escaped}'`;
+}
+/**
+ * Escape multiple arguments and join with spaces
+ */
+export function shellEscapeArgs(...args) {
+    return args.map(shellEscape).join(' ');
+}
+/**
+ * Build a safe shell command from a template and arguments.
+ * Replaces {0}, {1}, etc. with escaped versions of the arguments.
+ *
+ * Example:
+ *   shellCommand('cat {0}', '/path/with spaces')
+ *   // Returns: "cat '/path/with spaces'"
+ *
+ *   shellCommand('grep -i {0} {1}', 'pattern', '/path')
+ *   // Returns: "grep -i 'pattern' '/path'"
+ */
+export function shellCommand(template, ...args) {
+    return template.replace(/\{(\d+)\}/g, (_, index) => {
+        const i = parseInt(index, 10);
+        if (i < args.length) {
+            return shellEscape(args[i]);
+        }
+        return `{${index}}`; // Leave unreplaced if no matching arg
+    });
+}
+/**
+ * Escape a value for safe use in double quotes (for cases where we need variable expansion)
+ * This is less safe than single quotes but sometimes necessary.
+ *
+ * Escapes: $ ` \ " ! (and newlines)
+ */
+export function shellEscapeDouble(str) {
+    return str
+        .replace(/\\/g, '\\\\')
+        .replace(/"/g, '\\"')
+        .replace(/\$/g, '\\$')
+        .replace(/`/g, '\\`')
+        .replace(/!/g, '\\!');
+}

package/dist/lib/ssh.d.ts

@@ -0,0 +1,15 @@
+export interface SshHost {
+    name: string;
+    hostname?: string;
+    user?: string;
+    port?: number;
+    identityFile?: string;
+}
+/**
+ * Parse ~/.ssh/config to find configured hosts
+ */
+export declare function parseSshConfig(): SshHost[];
+/**
+ * Get a list of SSH host names for quick selection
+ */
+export declare function getSshHostNames(): string[];

package/dist/lib/ssh.js

@@ -0,0 +1,77 @@
+import { readFileSync, existsSync } from 'fs';
+import { homedir } from 'os';
+import { join } from 'path';
+/**
+ * Parse ~/.ssh/config to find configured hosts
+ */
+export function parseSshConfig() {
+    const configPath = join(homedir(), '.ssh', 'config');
+    if (!existsSync(configPath)) {
+        return [];
+    }
+    try {
+        const content = readFileSync(configPath, 'utf-8');
+        const lines = content.split('\n');
+        const hosts = [];
+        let currentHost = null;
+        for (const line of lines) {
+            const trimmed = line.trim();
+            // Skip comments and empty lines
+            if (trimmed.startsWith('#') || trimmed === '') {
+                continue;
+            }
+            // Parse key-value pairs
+            const match = trimmed.match(/^(\S+)\s+(.+)$/);
+            if (!match)
+                continue;
+            const [, key, value] = match;
+            const keyLower = key.toLowerCase();
+            if (keyLower === 'host') {
+                // Skip wildcard hosts
+                if (value.includes('*')) {
+                    currentHost = null;
+                    continue;
+                }
+                // Save previous host if exists
+                if (currentHost) {
+                    hosts.push(currentHost);
+                }
+                currentHost = { name: value };
+            }
+            else if (currentHost) {
+                switch (keyLower) {
+                    case 'hostname':
+                        currentHost.hostname = value;
+                        break;
+                    case 'user':
+                        currentHost.user = value;
+                        break;
+                    case 'port':
+                        currentHost.port = parseInt(value, 10);
+                        break;
+                    case 'identityfile':
+                        // Expand ~ in path
+                        currentHost.identityFile = value.startsWith('~/')
+                            ? join(homedir(), value.slice(2))
+                            : value;
+                        break;
+                }
+            }
+        }
+        // Don't forget the last host
+        if (currentHost) {
+            hosts.push(currentHost);
+        }
+        // Filter out hosts without hostname (they're just aliases)
+        return hosts.filter((h) => h.hostname || h.name);
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Get a list of SSH host names for quick selection
+ */
+export function getSshHostNames() {
+    return parseSshConfig().map((h) => h.name);
+}

package/dist/lib/tmux-config.d.ts

@@ -0,0 +1,3 @@
+export declare const TMUX_CONFIG_PATH: string;
+export declare function generateTmuxConfig(): string;
+export declare function writeTmuxConfig(): string;

package/dist/lib/tmux-config.js

@@ -0,0 +1,42 @@
+import { writeFileSync } from 'fs';
+import { join } from 'path';
+import { YEEHAW_DIR } from './paths.js';
+export const TMUX_CONFIG_PATH = join(YEEHAW_DIR, 'tmux.conf');
+export function generateTmuxConfig() {
+    return `
+# Yeehaw tmux configuration
+# Auto-generated - do not edit manually
+
+# Scrollback and mouse support
+set -g mouse on
+set -g history-limit 50000
+
+# Yeehaw keybindings
+bind-key -n C-y select-window -t :0    # Return to dashboard
+bind-key -n C-h previous-window        # Go left one window
+bind-key -n C-l next-window            # Go right one window
+
+# Status bar styling (Yeehaw brand colors)
+set -g status-style "bg=#b8860b,fg=#1a1a1a"
+set -g status-left "#[bold] YEEHAW "
+set -g status-left-length 20
+set -g status-right " Ctrl-y: dashboard "
+set -g status-right-length 30
+
+# Window status format
+set -g window-status-format " #I:#W "
+set -g window-status-current-format "#[bg=#daa520,fg=#1a1a1a,bold] #I:#W "
+
+# Pane border styling
+set -g pane-border-style "fg=#b8860b"
+set -g pane-active-border-style "fg=#daa520"
+
+# Message styling
+set -g message-style "bg=#b8860b,fg=#1a1a1a"
+`.trim();
+}
+export function writeTmuxConfig() {
+    const content = generateTmuxConfig();
+    writeFileSync(TMUX_CONFIG_PATH, content);
+    return TMUX_CONFIG_PATH;
+}

package/dist/lib/tmux.d.ts

@@ -0,0 +1,32 @@
+export declare const YEEHAW_SESSION = "yeehaw";
+export interface TmuxWindow {
+    index: number;
+    name: string;
+    active: boolean;
+    paneTitle: string;
+    paneCurrentCommand: string;
+    windowActivity: number;
+}
+export declare function hasTmux(): boolean;
+export declare function isInsideYeehawSession(): boolean;
+export declare function yeehawSessionExists(): boolean;
+export declare function createYeehawSession(): void;
+export declare function setupStatusBarHooks(): void;
+export declare function attachToYeehaw(): void;
+export declare function createClaudeWindow(workingDir: string, windowName: 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 switchToWindow(windowIndex: number): void;
+export declare function listYeehawWindows(): TmuxWindow[];
+export declare function killWindow(windowIndex: number): void;
+/**
+ * Get formatted status text for a tmux window
+ */
+export declare function getWindowStatus(window: TmuxWindow): string;
+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;
+export declare function isInRemoteMode(): boolean;
+export declare function getRemoteWindowIndex(): number | null;