agent-relay 1.6.0 → 2.0.4

package/dist/utils/command-resolver.js

@@ -1,76 +0,0 @@
-/**
- * Command Path Resolver
- *
- * Resolves full paths for CLI commands to avoid posix_spawnp failures
- * when PATH isn't properly inherited in spawned processes.
- */
-import { execSync } from 'node:child_process';
-import fs from 'node:fs';
-/**
- * Resolve the full path of a command using 'which' and resolve any symlinks
- * Returns the full path if found, or the original command if not found
- * (letting the spawn fail with a clearer error)
- */
-export function resolveCommand(command) {
-    // If already an absolute path, just resolve symlinks
-    if (command.startsWith('/')) {
-        return resolveSymlinks(command);
-    }
-    try {
-        const output = execSync(`which ${command}`, {
-            encoding: 'utf-8',
-            stdio: ['pipe', 'pipe', 'pipe'],
-            // Ensure we have a reasonable PATH
-            env: {
-                ...process.env,
-                PATH: process.env.PATH || '/usr/local/bin:/usr/bin:/bin:/opt/homebrew/bin',
-            },
-        });
-        const resolvedPath = output.trim();
-        if (resolvedPath) {
-            // Resolve any symlinks to get the actual binary path
-            // This fixes posix_spawnp issues with symlinked binaries
-            return resolveSymlinks(resolvedPath);
-        }
-    }
-    catch (err) {
-        // Command not found in PATH - log for debugging
-        console.warn(`[command-resolver] 'which ${command}' failed:`, err.message?.split('\n')[0] || 'unknown error');
-    }
-    // Return original command - spawn will fail with a clearer error
-    return command;
-}
-/**
- * Resolve symlinks to get the actual file path
- * Uses fs.realpathSync which handles all symlink levels
- */
-function resolveSymlinks(filePath) {
-    try {
-        const resolved = fs.realpathSync(filePath);
-        if (resolved !== filePath) {
-            console.log(`[command-resolver] Resolved symlink: ${filePath} -> ${resolved}`);
-        }
-        return resolved;
-    }
-    catch (err) {
-        // If realpath fails, return original (spawn will give clearer error)
-        console.warn(`[command-resolver] realpath failed for ${filePath}:`, err.message);
-        return filePath;
-    }
-}
-/**
- * Check if a command exists in PATH
- */
-export function commandExists(command) {
-    try {
-        execSync(`which ${command}`, {
-            encoding: 'utf-8',
-            stdio: ['pipe', 'pipe', 'pipe'],
-        });
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-//# sourceMappingURL=command-resolver.js.map

package/dist/utils/index.d.ts

@@ -1,4 +0,0 @@
-export * from './name-generator.js';
-export * from './logger.js';
-export * from './precompiled-patterns.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/utils/index.js

@@ -1,4 +0,0 @@
-export * from './name-generator.js';
-export * from './logger.js';
-export * from './precompiled-patterns.js';
-//# sourceMappingURL=index.js.map

package/dist/utils/project-namespace.d.ts

@@ -1,70 +0,0 @@
-/**
- * Project Namespace Utility
- *
- * Generates project-specific paths for agent-relay data storage.
- * This allows multiple projects to use agent-relay simultaneously
- * without conflicts.
- */
-/**
- * Get the project root by looking for common markers
- */
-export declare function findProjectRoot(startDir?: string): string;
-/**
- * Get namespaced paths for a project
- */
-export interface ProjectPaths {
-    /** Root directory for all agent-relay data for this project */
-    dataDir: string;
-    /** Team data directory */
-    teamDir: string;
-    /** SQLite database path */
-    dbPath: string;
-    /** Unix socket path */
-    socketPath: string;
-    /** The project root that was used */
-    projectRoot: string;
-    /** Short identifier for the project */
-    projectId: string;
-}
-export declare function getProjectPaths(projectRoot?: string): ProjectPaths;
-/**
- * Get the default paths (for backwards compatibility or explicit global usage)
- */
-export declare function getGlobalPaths(): ProjectPaths;
-/**
- * Ensure the project data directory exists
- */
-export declare function ensureProjectDir(projectRoot?: string): ProjectPaths;
-/**
- * List all known projects
- */
-export declare function listProjects(): Array<{
-    projectId: string;
-    projectRoot: string;
-    dataDir: string;
-}>;
-/**
- * Detect the actual workspace directory for cloud deployments.
- *
- * In cloud workspaces, repos are cloned to /workspace/{repo-name}.
- * This function finds the correct working directory:
- *
- * Priority:
- * 1. WORKSPACE_CWD env var (explicit override)
- * 2. If baseDir itself is a git repo, use it
- * 3. Scan baseDir for cloned repos - use the first one found (alphabetically)
- * 4. Fall back to baseDir
- *
- * @param baseDir - The base workspace directory (e.g., /workspace)
- * @returns The actual workspace path to use
- */
-export declare function detectWorkspacePath(baseDir: string): string;
-/**
- * List all git repos in a workspace directory.
- * Useful for allowing users to select which repo to work in.
- *
- * @param baseDir - The base workspace directory
- * @returns Array of repo paths
- */
-export declare function listWorkspaceRepos(baseDir: string): string[];
-//# sourceMappingURL=project-namespace.d.ts.map

package/dist/utils/project-namespace.js

@@ -1,216 +0,0 @@
-/**
- * Project Namespace Utility
- *
- * Generates project-specific paths for agent-relay data storage.
- * This allows multiple projects to use agent-relay simultaneously
- * without conflicts.
- */
-import crypto from 'node:crypto';
-import path from 'node:path';
-import fs from 'node:fs';
-import os from 'node:os';
-/**
- * Get the base directory for agent-relay data.
- * Priority:
- * 1. AGENT_RELAY_DATA_DIR environment variable
- * 2. XDG_DATA_HOME/agent-relay (Linux/macOS standard)
- * 3. ~/.agent-relay (fallback)
- */
-function getBaseDir() {
-    // Explicit override
-    if (process.env.AGENT_RELAY_DATA_DIR) {
-        return process.env.AGENT_RELAY_DATA_DIR;
-    }
-    // XDG Base Directory Specification
-    const xdgDataHome = process.env.XDG_DATA_HOME;
-    if (xdgDataHome) {
-        return path.join(xdgDataHome, 'agent-relay');
-    }
-    // Default: ~/.agent-relay
-    return path.join(os.homedir(), '.agent-relay');
-}
-const BASE_DIR = getBaseDir();
-/**
- * Generate a short hash of a path for namespacing
- */
-function hashPath(projectPath) {
-    const normalized = path.resolve(projectPath);
-    const hash = crypto.createHash('sha256').update(normalized).digest('hex');
-    return hash.substring(0, 12); // First 12 chars is enough
-}
-/**
- * Get the project root by looking for common markers
- */
-export function findProjectRoot(startDir = process.cwd()) {
-    let current = path.resolve(startDir);
-    const root = path.parse(current).root;
-    const markers = ['.git', 'package.json', 'Cargo.toml', 'go.mod', 'pyproject.toml', '.agent-relay'];
-    while (current !== root) {
-        for (const marker of markers) {
-            if (fs.existsSync(path.join(current, marker))) {
-                return current;
-            }
-        }
-        current = path.dirname(current);
-    }
-    // Fallback to start directory
-    return path.resolve(startDir);
-}
-export function getProjectPaths(projectRoot) {
-    const root = projectRoot ?? findProjectRoot();
-    const projectId = hashPath(root);
-    const dataDir = path.join(BASE_DIR, projectId);
-    return {
-        dataDir,
-        teamDir: path.join(dataDir, 'team'),
-        dbPath: path.join(dataDir, 'messages.sqlite'),
-        socketPath: path.join(dataDir, 'relay.sock'),
-        projectRoot: root,
-        projectId,
-    };
-}
-/**
- * Get the default paths (for backwards compatibility or explicit global usage)
- */
-export function getGlobalPaths() {
-    return {
-        dataDir: BASE_DIR,
-        teamDir: path.join(BASE_DIR, 'team'),
-        dbPath: path.join(BASE_DIR, 'messages.sqlite'),
-        socketPath: path.join(BASE_DIR, 'relay.sock'),
-        projectRoot: process.cwd(),
-        projectId: 'global',
-    };
-}
-/**
- * Ensure the project data directory exists
- */
-export function ensureProjectDir(projectRoot) {
-    const paths = getProjectPaths(projectRoot);
-    if (!fs.existsSync(paths.dataDir)) {
-        fs.mkdirSync(paths.dataDir, { recursive: true });
-    }
-    if (!fs.existsSync(paths.teamDir)) {
-        fs.mkdirSync(paths.teamDir, { recursive: true });
-    }
-    // Write a marker file with project info
-    const markerPath = path.join(paths.dataDir, '.project');
-    fs.writeFileSync(markerPath, JSON.stringify({
-        projectRoot: paths.projectRoot,
-        projectId: paths.projectId,
-        createdAt: new Date().toISOString(),
-    }, null, 2));
-    return paths;
-}
-/**
- * List all known projects
- */
-export function listProjects() {
-    if (!fs.existsSync(BASE_DIR)) {
-        return [];
-    }
-    const projects = [];
-    for (const entry of fs.readdirSync(BASE_DIR)) {
-        const dataDir = path.join(BASE_DIR, entry);
-        const markerPath = path.join(dataDir, '.project');
-        if (fs.existsSync(markerPath)) {
-            try {
-                const info = JSON.parse(fs.readFileSync(markerPath, 'utf-8'));
-                projects.push({
-                    projectId: entry,
-                    projectRoot: info.projectRoot,
-                    dataDir,
-                });
-            }
-            catch {
-                // Invalid marker, skip
-            }
-        }
-    }
-    return projects;
-}
-/**
- * Detect the actual workspace directory for cloud deployments.
- *
- * In cloud workspaces, repos are cloned to /workspace/{repo-name}.
- * This function finds the correct working directory:
- *
- * Priority:
- * 1. WORKSPACE_CWD env var (explicit override)
- * 2. If baseDir itself is a git repo, use it
- * 3. Scan baseDir for cloned repos - use the first one found (alphabetically)
- * 4. Fall back to baseDir
- *
- * @param baseDir - The base workspace directory (e.g., /workspace)
- * @returns The actual workspace path to use
- */
-export function detectWorkspacePath(baseDir) {
-    // 1. Explicit override
-    if (process.env.WORKSPACE_CWD) {
-        return process.env.WORKSPACE_CWD;
-    }
-    // 2. Check if baseDir itself is a git repo
-    if (fs.existsSync(path.join(baseDir, '.git'))) {
-        return baseDir;
-    }
-    // 3. Scan for cloned repos (directories with .git)
-    try {
-        const entries = fs.readdirSync(baseDir, { withFileTypes: true });
-        const repos = [];
-        for (const entry of entries) {
-            if (entry.isDirectory()) {
-                const repoPath = path.join(baseDir, entry.name);
-                const gitPath = path.join(repoPath, '.git');
-                if (fs.existsSync(gitPath)) {
-                    repos.push(repoPath);
-                }
-            }
-        }
-        // Sort alphabetically for consistent behavior
-        repos.sort();
-        // Use the first repo found
-        if (repos.length > 0) {
-            if (repos.length > 1) {
-                console.log(`[workspace] Multiple repos found, using first: ${repos[0]} (others: ${repos.slice(1).join(', ')})`);
-            }
-            else {
-                console.log(`[workspace] Detected repo: ${repos[0]}`);
-            }
-            return repos[0];
-        }
-    }
-    catch (err) {
-        // Failed to scan, fall back
-        console.warn(`[workspace] Failed to scan ${baseDir}:`, err);
-    }
-    // 4. Fall back to baseDir
-    return baseDir;
-}
-/**
- * List all git repos in a workspace directory.
- * Useful for allowing users to select which repo to work in.
- *
- * @param baseDir - The base workspace directory
- * @returns Array of repo paths
- */
-export function listWorkspaceRepos(baseDir) {
-    const repos = [];
-    try {
-        const entries = fs.readdirSync(baseDir, { withFileTypes: true });
-        for (const entry of entries) {
-            if (entry.isDirectory()) {
-                const repoPath = path.join(baseDir, entry.name);
-                const gitPath = path.join(repoPath, '.git');
-                if (fs.existsSync(gitPath)) {
-                    repos.push(repoPath);
-                }
-            }
-        }
-        repos.sort();
-    }
-    catch {
-        // Failed to scan
-    }
-    return repos;
-}
-//# sourceMappingURL=project-namespace.js.map

package/dist/wrapper/base-wrapper.d.ts

@@ -1,217 +0,0 @@
-/**
- * BaseWrapper - Abstract base class for agent wrappers
- *
- * Provides shared functionality between TmuxWrapper and PtyWrapper:
- * - Message queue management and deduplication
- * - Spawn/release command parsing and execution
- * - Continuity integration (agent ID, summary saving)
- * - Relay command handling
- * - Line joining for multi-line commands
- *
- * Subclasses implement:
- * - start() - Initialize and start the agent process
- * - stop() - Stop the agent process
- * - performInjection() - Inject content into the agent
- * - getCleanOutput() - Get cleaned output for parsing
- */
-import { EventEmitter } from 'node:events';
-import { RelayClient } from './client.js';
-import type { ParsedCommand, ParsedSummary } from './parser.js';
-import type { SendPayload, SendMeta, SpeakOnTrigger, Envelope } from '../protocol/types.js';
-import type { ChannelMessagePayload } from '../protocol/channels.js';
-import { type QueuedMessage, type InjectionMetrics, type CliType } from './shared.js';
-import { type ContinuityManager } from '../continuity/index.js';
-import { UniversalIdleDetector } from './idle-detector.js';
-import { StuckDetector, type StuckReason } from './stuck-detector.js';
-/**
- * Base configuration shared by all wrapper types
- */
-export interface BaseWrapperConfig {
-    /** Agent name (must be unique) */
-    name: string;
-    /** Command to execute */
-    command: string;
-    /** Command arguments */
-    args?: string[];
-    /** Relay daemon socket path */
-    socketPath?: string;
-    /** Working directory */
-    cwd?: string;
-    /** Environment variables */
-    env?: Record<string, string>;
-    /** Relay prefix pattern (default: '->relay:') */
-    relayPrefix?: string;
-    /** CLI type (auto-detected if not set) */
-    cliType?: CliType;
-    /** Dashboard port for spawn/release API */
-    dashboardPort?: number;
-    /** Callback when spawn command is parsed */
-    onSpawn?: (name: string, cli: string, task: string) => Promise<void>;
-    /** Callback when release command is parsed */
-    onRelease?: (name: string) => Promise<void>;
-    /** Agent ID to resume from (for continuity) */
-    resumeAgentId?: string;
-    /** Stream logs to daemon */
-    streamLogs?: boolean;
-    /** Task/role description */
-    task?: string;
-    /** Shadow configuration */
-    shadowOf?: string;
-    shadowSpeakOn?: SpeakOnTrigger[];
-    /** Milliseconds of idle time before injection is allowed (default: 1500) */
-    idleBeforeInjectMs?: number;
-    /** Confidence threshold for idle detection (0-1, default: 0.7) */
-    idleConfidenceThreshold?: number;
-    /** Skip initial instruction injection (when using --append-system-prompt) */
-    skipInstructions?: boolean;
-    /** Skip continuity loading (for spawned agents that don't need session recovery) */
-    skipContinuity?: boolean;
-}
-/**
- * Abstract base class for agent wrappers
- */
-export declare abstract class BaseWrapper extends EventEmitter {
-    protected config: BaseWrapperConfig;
-    protected client: RelayClient;
-    protected relayPrefix: string;
-    protected cliType: CliType;
-    protected running: boolean;
-    protected messageQueue: QueuedMessage[];
-    protected sentMessageHashes: Set<string>;
-    protected isInjecting: boolean;
-    protected receivedMessageIds: Set<string>;
-    protected injectionMetrics: InjectionMetrics;
-    protected processedSpawnCommands: Set<string>;
-    protected processedReleaseCommands: Set<string>;
-    protected pendingFencedSpawn: {
-        name: string;
-        cli: string;
-        taskLines: string[];
-    } | null;
-    protected continuity?: ContinuityManager;
-    protected agentId?: string;
-    protected processedContinuityCommands: Set<string>;
-    protected sessionEndProcessed: boolean;
-    protected sessionEndData?: {
-        summary?: string;
-        completedTasks?: string[];
-    };
-    protected lastSummaryRawContent: string;
-    protected idleDetector: UniversalIdleDetector;
-    protected stuckDetector: StuckDetector;
-    constructor(config: BaseWrapperConfig);
-    /** Start the agent process */
-    abstract start(): Promise<void>;
-    /** Stop the agent process */
-    abstract stop(): Promise<void> | void;
-    /** Inject content into the agent */
-    protected abstract performInjection(content: string): Promise<void>;
-    /** Get cleaned output for parsing */
-    protected abstract getCleanOutput(): string;
-    get isRunning(): boolean;
-    get name(): string;
-    getAgentId(): string | undefined;
-    getInjectionMetrics(): InjectionMetrics & {
-        successRate: number;
-    };
-    get pendingMessageCount(): number;
-    /**
-     * Set the PID for process state inspection (Linux only).
-     * Call this after the agent process is started.
-     */
-    protected setIdleDetectorPid(pid: number): void;
-    /**
-     * Start stuck detection. Call after the agent process starts.
-     */
-    protected startStuckDetection(): void;
-    /**
-     * Stop stuck detection. Call when the agent process stops.
-     */
-    protected stopStuckDetection(): void;
-    /**
-     * Check if the agent is currently stuck.
-     */
-    isStuck(): boolean;
-    /**
-     * Get the reason for being stuck (if stuck).
-     */
-    getStuckReason(): StuckReason | null;
-    /**
-     * Feed output to the idle and stuck detectors.
-     * Call this whenever new output is received from the agent.
-     */
-    protected feedIdleDetectorOutput(output: string): void;
-    /**
-     * Check if the agent is idle and ready for injection.
-     * Returns idle state with confidence signals.
-     */
-    protected checkIdleForInjection(): {
-        isIdle: boolean;
-        confidence: number;
-        signals: Array<{
-            source: string;
-            confidence: number;
-        }>;
-    };
-    /**
-     * Wait for the agent to become idle.
-     * Returns when idle or after timeout.
-     */
-    protected waitForIdleState(timeoutMs?: number, pollMs?: number): Promise<{
-        isIdle: boolean;
-        confidence: number;
-    }>;
-    /**
-     * Handle incoming message from relay
-     */
-    protected handleIncomingMessage(from: string, payload: SendPayload, messageId: string, meta?: SendMeta, originalTo?: string): void;
-    /**
-     * Handle incoming channel message from relay.
-     * Channel messages include a channel indicator so the agent knows to reply to the channel.
-     */
-    protected handleIncomingChannelMessage(from: string, channel: string, body: string, envelope: Envelope<ChannelMessagePayload>): void;
-    /**
-     * Send a relay command via the client
-     */
-    protected sendRelayCommand(cmd: ParsedCommand): void;
-    /**
-     * Parse spawn and release commands from output
-     */
-    protected parseSpawnReleaseCommands(content: string): void;
-    /**
-     * Execute a spawn command
-     */
-    protected executeSpawn(name: string, cli: string, task: string): Promise<void>;
-    /**
-     * Execute a release command
-     */
-    protected executeRelease(name: string): Promise<void>;
-    /**
-     * Initialize agent ID for continuity/resume
-     */
-    protected initializeAgentId(): Promise<void>;
-    /**
-     * Parse continuity commands from output
-     */
-    protected parseContinuityCommands(content: string): Promise<void>;
-    /**
-     * Save a parsed summary to the continuity ledger
-     */
-    protected saveSummaryToLedger(summary: ParsedSummary): Promise<void>;
-    /**
-     * Reset session-specific state for wrapper reuse
-     */
-    resetSessionState(): void;
-    /**
-     * Join continuation lines for multi-line relay/continuity commands.
-     * TUIs like Claude Code insert real newlines in output, causing
-     * messages to span multiple lines. This joins indented
-     * continuation lines back to the command line.
-     */
-    protected joinContinuationLines(content: string): string;
-    /**
-     * Clean up resources
-     */
-    protected destroyClient(): void;
-}
-//# sourceMappingURL=base-wrapper.d.ts.map