agent-relay 1.6.0 → 2.0.0

package/packages/config/dist/bridge-config.js

@@ -0,0 +1,143 @@
+/**
+ * Bridge Configuration
+ * Handles loading and resolving bridge configuration from files and CLI args.
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import { getProjectPaths } from './project-namespace.js';
+const CONFIG_PATHS = [
+    path.join(os.homedir(), '.agent-relay', 'bridge.json'),
+    path.join(os.homedir(), '.config', 'agent-relay', 'bridge.json'),
+];
+/**
+ * Load bridge config from file
+ */
+export function loadBridgeConfig() {
+    for (const configPath of CONFIG_PATHS) {
+        if (fs.existsSync(configPath)) {
+            try {
+                const content = fs.readFileSync(configPath, 'utf-8');
+                return JSON.parse(content);
+            }
+            catch (err) {
+                console.error(`[bridge] Failed to parse ${configPath}:`, err);
+            }
+        }
+    }
+    return null;
+}
+/**
+ * Resolve project path (expand ~ and make absolute)
+ */
+export function resolvePath(p) {
+    if (p.startsWith('~')) {
+        p = path.join(os.homedir(), p.slice(1));
+    }
+    return path.resolve(p);
+}
+/**
+ * Get default lead name from directory name
+ */
+export function getDefaultLeadName(projectPath) {
+    const dirname = path.basename(projectPath);
+    // Capitalize first letter
+    return dirname.charAt(0).toUpperCase() + dirname.slice(1);
+}
+/**
+ * Resolve projects from CLI args and/or config file
+ */
+export function resolveProjects(cliPaths, cliOverride) {
+    const config = loadBridgeConfig();
+    const projects = [];
+    // If CLI paths provided, use those
+    if (cliPaths.length > 0) {
+        for (const p of cliPaths) {
+            const projectPath = resolvePath(p);
+            if (!fs.existsSync(projectPath)) {
+                console.error(`[bridge] Project path does not exist: ${projectPath}`);
+                continue;
+            }
+            const paths = getProjectPaths(projectPath);
+            // Check for project-specific config
+            const projectConfig = config?.projects?.[p] || config?.projects?.[projectPath];
+            projects.push({
+                path: projectPath,
+                id: paths.projectId,
+                socketPath: paths.socketPath,
+                leadName: projectConfig?.lead || getDefaultLeadName(projectPath),
+                cli: cliOverride || projectConfig?.cli || config?.defaultCli || 'claude',
+            });
+        }
+    }
+    // Otherwise use config file
+    else if (config?.projects) {
+        for (const [p, projectConfig] of Object.entries(config.projects)) {
+            const projectPath = resolvePath(p);
+            if (!fs.existsSync(projectPath)) {
+                console.error(`[bridge] Project path does not exist: ${projectPath}`);
+                continue;
+            }
+            const paths = getProjectPaths(projectPath);
+            projects.push({
+                path: projectPath,
+                id: paths.projectId,
+                socketPath: paths.socketPath,
+                leadName: projectConfig.lead || getDefaultLeadName(projectPath),
+                cli: cliOverride || projectConfig.cli || config.defaultCli || 'claude',
+            });
+        }
+    }
+    return projects;
+}
+/**
+ * Validate that daemons are running for all projects
+ */
+export function validateDaemons(projects) {
+    const valid = [];
+    const missing = [];
+    for (const project of projects) {
+        if (fs.existsSync(project.socketPath)) {
+            valid.push(project);
+        }
+        else {
+            missing.push(project);
+        }
+    }
+    return { valid, missing };
+}
+/**
+ * Start daemons for missing projects
+ */
+export async function startMissingDaemons(projects) {
+    const { execAsync } = await import('./bridge-utils.js');
+    for (const project of projects) {
+        console.log(`[bridge] Starting daemon for ${project.id}...`);
+        try {
+            // Start daemon in background
+            await execAsync(`cd "${project.path}" && agent-relay up &`, {
+                timeout: 5000,
+            });
+            // Wait for socket to appear
+            await waitForSocket(project.socketPath, 10000);
+            console.log(`[bridge] Daemon started for ${project.id}`);
+        }
+        catch (err) {
+            console.error(`[bridge] Failed to start daemon for ${project.id}:`, err);
+        }
+    }
+}
+/**
+ * Wait for socket file to exist
+ */
+async function waitForSocket(socketPath, timeoutMs) {
+    const startTime = Date.now();
+    while (Date.now() - startTime < timeoutMs) {
+        if (fs.existsSync(socketPath)) {
+            return;
+        }
+        await new Promise(r => setTimeout(r, 200));
+    }
+    throw new Error(`Timeout waiting for socket: ${socketPath}`);
+}
+//# sourceMappingURL=bridge-config.js.map

package/packages/config/dist/bridge-utils.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Bridge Utilities
+ */
+import { exec } from 'node:child_process';
+export declare const execAsync: typeof exec.__promisify__;
+/**
+ * Sleep for a given number of milliseconds
+ */
+export declare function sleep(ms: number): Promise<void>;
+/**
+ * Parse a cross-project message target
+ * Formats:
+ *   "project:agent" -> { projectId: "project", agentName: "agent" }
+ *   "*:agent" -> { projectId: "*", agentName: "agent" } (all projects)
+ *   "project:*" -> { projectId: "project", agentName: "*" } (broadcast in project)
+ *   "*:*" -> { projectId: "*", agentName: "*" } (broadcast everywhere)
+ */
+export declare function parseTarget(target: string): {
+    projectId: string;
+    agentName: string;
+} | null;
+/**
+ * Escape string for shell
+ */
+export declare function escapeForShell(str: string): string;
+/**
+ * Escape string for tmux send-keys
+ */
+export declare function escapeForTmux(str: string): string;
+//# sourceMappingURL=bridge-utils.d.ts.map

package/packages/config/dist/bridge-utils.js

@@ -0,0 +1,54 @@
+/**
+ * Bridge Utilities
+ */
+import { exec } from 'node:child_process';
+import { promisify } from 'node:util';
+export const execAsync = promisify(exec);
+/**
+ * Sleep for a given number of milliseconds
+ */
+export function sleep(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}
+/**
+ * Parse a cross-project message target
+ * Formats:
+ *   "project:agent" -> { projectId: "project", agentName: "agent" }
+ *   "*:agent" -> { projectId: "*", agentName: "agent" } (all projects)
+ *   "project:*" -> { projectId: "project", agentName: "*" } (broadcast in project)
+ *   "*:*" -> { projectId: "*", agentName: "*" } (broadcast everywhere)
+ */
+export function parseTarget(target) {
+    const parts = target.split(':');
+    if (parts.length !== 2) {
+        return null;
+    }
+    return {
+        projectId: parts[0],
+        agentName: parts[1],
+    };
+}
+/**
+ * Escape string for shell
+ */
+export function escapeForShell(str) {
+    return str
+        .replace(/\\/g, '\\\\')
+        .replace(/"/g, '\\"')
+        .replace(/\$/g, '\\$')
+        .replace(/`/g, '\\`')
+        .replace(/!/g, '\\!');
+}
+/**
+ * Escape string for tmux send-keys
+ */
+export function escapeForTmux(str) {
+    return str
+        .replace(/[\r\n]+/g, ' ')
+        .replace(/\\/g, '\\\\')
+        .replace(/"/g, '\\"')
+        .replace(/\$/g, '\\$')
+        .replace(/`/g, '\\`')
+        .replace(/!/g, '\\!');
+}
+//# sourceMappingURL=bridge-utils.js.map

package/packages/config/dist/cli-auth-config.js

@@ -0,0 +1,391 @@
+/**
+ * Shared CLI Auth Configuration
+ *
+ * Provider-specific CLI commands and patterns for OAuth authentication.
+ * Used by both the cloud API and workspace daemon.
+ */
+/**
+ * CLI commands and URL patterns for each provider
+ *
+ * Each CLI tool outputs an OAuth URL when run without credentials.
+ * We capture stdout/stderr and extract the URL using regex patterns.
+ *
+ * IMPORTANT: These CLIs are interactive - they output the auth URL then wait
+ * for the user to complete OAuth in their browser. We capture the URL and
+ * display it in a popup for the user.
+ */
+export const CLI_AUTH_CONFIG = {
+    anthropic: {
+        command: 'claude',
+        args: [],
+        urlPattern: /(https:\/\/[^\s]+)/,
+        credentialPath: '~/.claude/.credentials.json',
+        displayName: 'Claude',
+        waitTimeout: 30000, // Claude can take a while to show the auth URL
+        prompts: [
+            {
+                // Claude Code version selection - accept default (recommended)
+                pattern: /which\s*version|claude\s*code\s*version|select.*version/i,
+                response: '\r',
+                delay: 100,
+                description: 'Version selection prompt',
+            },
+            {
+                pattern: /dark\s*(mode|theme)/i,
+                response: '\r', // Press enter to accept default
+                delay: 100,
+                description: 'Dark mode prompt',
+            },
+            {
+                // Login method selection - "Select login method:" with Claude account or Console options
+                pattern: /select\s*login\s*method|how\s*would\s*you\s*like\s*to\s*authenticate|choose.*auth.*method|select.*auth|subscription\s*or.*api\s*key/i,
+                response: '\r', // Press enter for first option (Claude account with subscription)
+                delay: 100,
+                description: 'Login method selection',
+            },
+            {
+                // Login success - press enter to continue
+                pattern: /login\s*successful|logged\s*in.*press\s*enter|press\s*enter\s*to\s*continue/i,
+                response: '\r',
+                delay: 200,
+                description: 'Login success prompt',
+            },
+            {
+                // Trust directory - matches various trust prompts including:
+                // "Quick safety check: Is this a project you created or one you trust?"
+                // "Yes, I trust this folder"
+                // "Do you trust the files in this folder?"
+                pattern: /trust\s*(this|the)?\s*(files|directory|folder|workspace)|do\s*you\s*trust|safety\s*check|yes,?\s*i\s*trust/i,
+                response: '\r', // Press enter for first option (Yes, proceed)
+                delay: 300, // Slightly longer delay for menu to render
+                description: 'Trust directory prompt',
+            },
+            {
+                // "Ready to code here?" permission prompt - asks for file access permission
+                // Shows "Yes, continue" / "No, exit" options with "Enter to confirm"
+                // This is different from trust directory - it's about granting file permissions
+                pattern: /ready\s*to\s*code\s*here|permission\s*to\s*work\s*with\s*your\s*files|yes,?\s*continue/i,
+                response: '\r', // Press enter to accept "Yes, continue" (already selected)
+                delay: 300,
+                description: 'Ready to code permission prompt',
+            },
+            {
+                // Fallback: Any "press enter" or "enter to confirm/continue" prompt
+                // Keep this LAST so more specific handlers match first
+                // NOTE: Error messages like "Press Enter to retry" are handled by checking
+                // error patterns FIRST in the PTY handler, so this won't trigger on errors
+                pattern: /press\s*enter|enter\s*to\s*(confirm|continue|proceed)|hit\s*enter/i,
+                response: '\r',
+                delay: 300,
+                description: 'Generic enter prompt',
+            },
+        ],
+        successPatterns: [/success/i, /authenticated/i, /logged\s*in/i, /you.*(?:are|now).*logged/i],
+        errorPatterns: [
+            {
+                pattern: /oauth\s*error.*(?:status\s*code\s*)?400/i,
+                message: 'Authentication failed - the authorization code was invalid or expired',
+                recoverable: true,
+                hint: 'This usually happens if the login took too long or the code was already used. Please try again and complete the browser login within a few minutes.',
+            },
+            {
+                pattern: /oauth\s*error.*(?:status\s*code\s*)?401/i,
+                message: 'Authentication failed - unauthorized',
+                recoverable: true,
+                hint: 'Please try logging in again.',
+            },
+            {
+                pattern: /oauth\s*error.*(?:status\s*code\s*)?403/i,
+                message: 'Authentication failed - access denied',
+                recoverable: true,
+                hint: 'Your account may not have access to Claude Code. Please check your Anthropic subscription.',
+            },
+            {
+                pattern: /network\s*error|ENOTFOUND|ECONNREFUSED|timeout/i,
+                message: 'Network error during authentication',
+                recoverable: true,
+                hint: 'Please check your internet connection and try again.',
+            },
+            {
+                pattern: /invalid\s*(?:code|token)|code\s*(?:expired|invalid)/i,
+                message: 'The authorization code was invalid or has expired',
+                recoverable: true,
+                hint: 'OAuth codes expire quickly. Please try again and complete the browser login promptly.',
+            },
+        ],
+    },
+    openai: {
+        command: 'codex',
+        args: ['login'], // Standard OAuth flow
+        deviceFlowArgs: ['login', '--device-auth'], // Device auth for headless/container environments
+        supportsDeviceFlow: true,
+        urlPattern: /(https:\/\/[^\s]+)/,
+        credentialPath: '~/.codex/auth.json',
+        displayName: 'Codex',
+        waitTimeout: 30000,
+        prompts: [
+            {
+                pattern: /trust\s*(this|the)\s*(directory|folder|workspace)/i,
+                response: 'y\r',
+                delay: 100,
+                description: 'Trust directory prompt',
+            },
+        ],
+        successPatterns: [/success/i, /authenticated/i, /logged\s*in/i],
+    },
+    google: {
+        command: 'gemini',
+        args: [],
+        urlPattern: /(https:\/\/[^\s]+)/,
+        displayName: 'Gemini',
+        waitTimeout: 30000,
+        prompts: [
+            {
+                // Auth method selection - select first option (Login with Google for OAuth)
+                pattern: /login\s*with\s*google|google\s*account|choose.*auth|how\s*would\s*you\s*like\s*to\s*authenticate/i,
+                response: '\r',
+                delay: 200,
+                description: 'Auth method selection',
+            },
+            {
+                // API key detected - press Enter to confirm/continue
+                pattern: /press\s*enter|enter\s*to\s*(confirm|continue|proceed)|using.*api.*key|api.*key.*detected/i,
+                response: '\r',
+                delay: 300,
+                description: 'API key confirmation',
+            },
+            {
+                // Accept terms/privacy notice
+                pattern: /terms\s*of\s*service|privacy\s*notice|accept|agree/i,
+                response: '\r',
+                delay: 200,
+                description: 'Terms acceptance',
+            },
+        ],
+        successPatterns: [/success/i, /authenticated/i, /logged\s*in/i, /ready/i],
+    },
+    opencode: {
+        command: 'opencode',
+        args: ['auth', 'login'],
+        // OpenCode redirects to provider OAuth pages (Anthropic, OpenAI, Google)
+        urlPattern: /(https:\/\/[^\s]+)/,
+        credentialPath: '~/.local/share/opencode/auth.json',
+        displayName: 'OpenCode',
+        waitTimeout: 30000,
+        prompts: [
+            {
+                pattern: /select.*provider|choose.*provider|which.*provider/i,
+                response: '\r', // Select first provider (OpenCode Zen - recommended)
+                delay: 300,
+                description: 'Provider selection',
+            },
+            {
+                pattern: /opencode\s*zen|recommended/i,
+                response: '\r', // Confirm provider selection
+                delay: 200,
+                description: 'Confirm provider',
+            },
+        ],
+        // Success patterns include credential added and existing credentials list
+        successPatterns: [/success/i, /authenticated/i, /logged\s*in/i, /credential\s*added/i, /\d+\s*credentials?/i],
+    },
+    droid: {
+        command: 'droid',
+        args: ['--login'],
+        urlPattern: /(https:\/\/[^\s]+)/,
+        displayName: 'Droid',
+        waitTimeout: 30000,
+        prompts: [
+            {
+                pattern: /sign\s*in|log\s*in|authenticate/i,
+                response: '\r',
+                delay: 200,
+                description: 'Login prompt',
+            },
+        ],
+        successPatterns: [/success/i, /authenticated/i, /logged\s*in/i],
+    },
+    cursor: {
+        command: 'agent', // Cursor CLI installs as 'agent'
+        args: ['login'], // agent login - triggers OAuth flow
+        urlPattern: /(https:\/\/[^\s]+)/,
+        credentialPath: '~/.cursor/auth.json',
+        displayName: 'Cursor',
+        waitTimeout: 30000,
+        prompts: [
+            {
+                // Workspace Trust screen - must press 'a' to trust
+                // "Do you want to mark this workspace as trusted?"
+                // "[a] Trust this workspace"
+                // "[q] Quit"
+                pattern: /workspace\s*trust|mark\s*this\s*workspace\s*as\s*trusted|trust\s*this\s*workspace|\[a\]\s*trust/i,
+                response: 'a',
+                delay: 300,
+                description: 'Workspace trust prompt',
+            },
+            {
+                // Generic trust directory prompt (similar to Claude)
+                pattern: /trust\s*(this|the)?\s*(files|directory|folder|workspace)|do\s*you\s*trust/i,
+                response: '\r',
+                delay: 300,
+                description: 'Trust directory prompt',
+            },
+            {
+                // Login success - press enter to continue
+                pattern: /login\s*successful|logged\s*in.*press\s*enter|press\s*enter\s*to\s*continue/i,
+                response: '\r',
+                delay: 200,
+                description: 'Login success prompt',
+            },
+            {
+                // Generic enter prompt (fallback)
+                pattern: /press\s*enter|enter\s*to\s*(confirm|continue|proceed)/i,
+                response: '\r',
+                delay: 300,
+                description: 'Generic enter prompt',
+            },
+        ],
+        successPatterns: [/success/i, /authenticated/i, /logged\s*in/i, /you.*(?:are|now).*logged/i],
+        errorPatterns: [
+            {
+                pattern: /oauth\s*error|auth.*failed|authentication\s*error/i,
+                message: 'Authentication failed',
+                recoverable: true,
+                hint: 'Please try logging in again.',
+            },
+            {
+                pattern: /network\s*error|ENOTFOUND|ECONNREFUSED|timeout/i,
+                message: 'Network error during authentication',
+                recoverable: true,
+                hint: 'Please check your internet connection and try again.',
+            },
+        ],
+    },
+};
+/**
+ * Strip ANSI escape codes from text
+ */
+/* eslint-disable no-control-regex */
+export function stripAnsiCodes(text) {
+    // Handle various ANSI escape sequences:
+    // - CSI sequences: ESC [ params letter (params can include ?, >, =, etc.)
+    // - OSC sequences: ESC ] ... BEL/ST
+    // - Simple escapes: ESC letter
+    return text
+        .replace(/\x1b\[[0-9;?]*[a-zA-Z]/g, '') // CSI sequences including private modes (?2026h, etc.)
+        .replace(/\x1b\][^\x07]*\x07/g, '') // OSC sequences (title, etc.)
+        .replace(/\x1b[a-zA-Z]/g, ''); // Simple escape sequences
+}
+/* eslint-enable no-control-regex */
+/**
+ * Check if text matches any success pattern
+ */
+export function matchesSuccessPattern(text, patterns) {
+    const cleanText = stripAnsiCodes(text).toLowerCase();
+    return patterns.some((p) => p.test(cleanText));
+}
+/**
+ * Find matching prompt handler that hasn't been responded to yet
+ */
+export function findMatchingPrompt(text, prompts, respondedPrompts) {
+    const cleanText = stripAnsiCodes(text);
+    for (const prompt of prompts) {
+        if (respondedPrompts.has(prompt.description))
+            continue;
+        if (prompt.pattern.test(cleanText)) {
+            return prompt;
+        }
+    }
+    return null;
+}
+/**
+ * Check if text matches any error pattern and return the matched error
+ */
+export function findMatchingError(text, errorPatterns) {
+    if (!errorPatterns || errorPatterns.length === 0)
+        return null;
+    const cleanText = stripAnsiCodes(text);
+    for (const error of errorPatterns) {
+        if (error.pattern.test(cleanText)) {
+            return error;
+        }
+    }
+    return null;
+}
+/**
+ * Get list of supported provider IDs
+ */
+export function getSupportedProviderIds() {
+    return Object.keys(CLI_AUTH_CONFIG);
+}
+/**
+ * Get list of supported providers with details
+ */
+export function getSupportedProviders() {
+    return Object.entries(CLI_AUTH_CONFIG).map(([id, config]) => ({
+        id,
+        displayName: config.displayName,
+        command: config.command,
+    }));
+}
+/**
+ * Validate a provider's CLI auth configuration
+ * Returns null if valid, or an error message if invalid
+ */
+export function validateProviderConfig(providerId, config) {
+    if (!config.command || typeof config.command !== 'string') {
+        return `${providerId}: missing or invalid 'command'`;
+    }
+    if (!Array.isArray(config.args)) {
+        return `${providerId}: 'args' must be an array`;
+    }
+    if (!(config.urlPattern instanceof RegExp)) {
+        return `${providerId}: 'urlPattern' must be a RegExp`;
+    }
+    // Check urlPattern has a capture group
+    const testUrl = 'https://example.com/test';
+    const match = testUrl.match(config.urlPattern);
+    if (!match || !match[1]) {
+        return `${providerId}: 'urlPattern' must have a capture group - got ${config.urlPattern}`;
+    }
+    if (!config.displayName || typeof config.displayName !== 'string') {
+        return `${providerId}: missing or invalid 'displayName'`;
+    }
+    if (typeof config.waitTimeout !== 'number' || config.waitTimeout <= 0) {
+        return `${providerId}: 'waitTimeout' must be a positive number`;
+    }
+    if (!Array.isArray(config.prompts)) {
+        return `${providerId}: 'prompts' must be an array`;
+    }
+    for (let i = 0; i < config.prompts.length; i++) {
+        const prompt = config.prompts[i];
+        if (!(prompt.pattern instanceof RegExp)) {
+            return `${providerId}: prompt[${i}].pattern must be a RegExp`;
+        }
+        if (typeof prompt.response !== 'string') {
+            return `${providerId}: prompt[${i}].response must be a string`;
+        }
+        if (!prompt.description) {
+            return `${providerId}: prompt[${i}].description is required`;
+        }
+    }
+    if (!Array.isArray(config.successPatterns)) {
+        return `${providerId}: 'successPatterns' must be an array`;
+    }
+    return null;
+}
+/**
+ * Validate all provider configurations
+ * Returns array of error messages (empty if all valid)
+ */
+export function validateAllProviderConfigs() {
+    const errors = [];
+    for (const [id, config] of Object.entries(CLI_AUTH_CONFIG)) {
+        const error = validateProviderConfig(id, config);
+        if (error) {
+            errors.push(error);
+        }
+    }
+    return errors;
+}
+//# sourceMappingURL=cli-auth-config.js.map

package/packages/config/dist/cloud-config.d.ts

@@ -0,0 +1,75 @@
+/**
+ * Agent Relay Cloud - Configuration
+ */
+export interface CloudConfig {
+    port: number;
+    publicUrl: string;
+    appUrl: string;
+    sessionSecret: string;
+    localDashboardUrl?: string;
+    databaseUrl: string;
+    redisUrl: string;
+    github: {
+        clientId: string;
+        clientSecret: string;
+        webhookSecret?: string;
+    };
+    providers: {
+        anthropic?: {
+            clientId: string;
+        };
+        openai?: {
+            clientId: string;
+        };
+        google?: {
+            clientId: string;
+            clientSecret: string;
+        };
+    };
+    vault: {
+        masterKey: string;
+    };
+    compute: {
+        provider: 'fly' | 'railway' | 'docker';
+        fly?: {
+            apiToken: string;
+            org: string;
+            region?: string;
+            workspaceDomain?: string;
+            registryAuth?: {
+                username: string;
+                password: string;
+            };
+            snapshotRetentionDays?: number;
+            volumeSizeGb?: number;
+        };
+        railway?: {
+            apiToken: string;
+        };
+    };
+    nango: {
+        secretKey: string;
+        host?: string;
+    };
+    stripe: {
+        secretKey: string;
+        publishableKey: string;
+        webhookSecret: string;
+        priceIds: {
+            proMonthly?: string;
+            proYearly?: string;
+            teamMonthly?: string;
+            teamYearly?: string;
+            enterpriseMonthly?: string;
+            enterpriseYearly?: string;
+        };
+    };
+    adminUsers: string[];
+}
+export declare function loadConfig(): CloudConfig;
+/**
+ * Check if a GitHub username is an admin user
+ */
+export declare function isAdminUser(githubUsername: string): boolean;
+export declare function getConfig(): CloudConfig;
+//# sourceMappingURL=cloud-config.d.ts.map