agent-relay 1.6.0 → 2.0.4

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

@@ -1,320 +0,0 @@
-/**
- * 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: [
-            {
-                pattern: /login\s*with\s*google|google\s*account|choose.*auth/i,
-                response: '\r', // Select first option (Login with Google)
-                delay: 200,
-                description: 'Auth method selection',
-            },
-        ],
-        successPatterns: [/success/i, /authenticated/i, /logged\s*in/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],
-    },
-};
-/**
- * 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/dist/state/agent-state.js

@@ -1,120 +0,0 @@
-/**
- * Agent State Manager
- * Persists agent context between spawns for non-hook CLIs (Codex, Gemini, etc.)
- */
-import * as fs from 'fs';
-import * as path from 'path';
-export class AgentStateManager {
-    dataDir;
-    constructor(dataDir = '/tmp/agent-relay-team') {
-        this.dataDir = dataDir;
-    }
-    getStatePath(agentName) {
-        return path.join(this.dataDir, agentName, 'state.json');
-    }
-    /**
-     * Load agent state from file
-     */
-    load(agentName) {
-        const statePath = this.getStatePath(agentName);
-        if (!fs.existsSync(statePath)) {
-            return null;
-        }
-        try {
-            const content = fs.readFileSync(statePath, 'utf-8');
-            return JSON.parse(content);
-        }
-        catch {
-            return null;
-        }
-    }
-    /**
-     * Save agent state to file
-     */
-    save(state) {
-        const statePath = this.getStatePath(state.name);
-        const dir = path.dirname(statePath);
-        if (!fs.existsSync(dir)) {
-            fs.mkdirSync(dir, { recursive: true });
-        }
-        fs.writeFileSync(statePath, JSON.stringify(state, null, 2));
-    }
-    /**
-     * Update specific fields in state
-     */
-    update(agentName, updates) {
-        const existing = this.load(agentName) || {
-            name: agentName,
-            lastActive: new Date().toISOString(),
-            currentTask: '',
-            completedTasks: [],
-            decisions: [],
-            context: '',
-            files: [],
-        };
-        const updated = {
-            ...existing,
-            ...updates,
-            lastActive: new Date().toISOString(),
-        };
-        this.save(updated);
-        return updated;
-    }
-    /**
-     * Format state as context for agent prompt
-     */
-    formatAsContext(agentName) {
-        const state = this.load(agentName);
-        if (!state) {
-            return 'No previous session state found. Starting fresh.';
-        }
-        const lines = [
-            '=== PREVIOUS SESSION CONTEXT ===',
-            `Last active: ${state.lastActive}`,
-            '',
-        ];
-        if (state.currentTask) {
-            lines.push(`Current task: ${state.currentTask}`);
-        }
-        if (state.completedTasks.length > 0) {
-            lines.push('');
-            lines.push('Completed tasks:');
-            state.completedTasks.forEach(t => lines.push(`  - ${t}`));
-        }
-        if (state.decisions.length > 0) {
-            lines.push('');
-            lines.push('Key decisions made:');
-            state.decisions.forEach(d => lines.push(`  - ${d}`));
-        }
-        if (state.context) {
-            lines.push('');
-            lines.push('Context:');
-            lines.push(state.context);
-        }
-        if (state.files.length > 0) {
-            lines.push('');
-            lines.push('Files being worked on:');
-            state.files.forEach(f => lines.push(`  - ${f}`));
-        }
-        lines.push('=== END CONTEXT ===');
-        lines.push('');
-        return lines.join('\n');
-    }
-}
-/**
- * CLI helper to save state from agent output
- * Agent outputs: [[STATE]]{"currentTask": "...", "context": "..."}[[/STATE]]
- */
-export function parseStateFromOutput(output) {
-    const match = output.match(/\[\[STATE\]\]([\s\S]*?)\[\[\/STATE\]\]/);
-    if (!match) {
-        return null;
-    }
-    try {
-        return JSON.parse(match[1]);
-    }
-    catch {
-        return null;
-    }
-}
-//# sourceMappingURL=agent-state.js.map

package/dist/storage/adapter.d.ts

@@ -1,154 +0,0 @@
-import type { PayloadKind, SendMeta } from '../protocol/types.js';
-export type MessageStatus = 'unread' | 'read' | 'acked' | 'failed';
-export interface StoredMessage {
-    id: string;
-    ts: number;
-    from: string;
-    to: string;
-    topic?: string;
-    kind: PayloadKind;
-    body: string;
-    data?: Record<string, unknown>;
-    /** Optional metadata (importance, replyTo, etc.) */
-    payloadMeta?: SendMeta;
-    /** Optional thread ID for grouping related messages */
-    thread?: string;
-    deliverySeq?: number;
-    deliverySessionId?: string;
-    sessionId?: string;
-    /** Per-recipient message status */
-    status: MessageStatus;
-    /** Whether the message is marked as urgent */
-    is_urgent: boolean;
-    /** Whether the message was sent as a broadcast (to: '*') */
-    is_broadcast?: boolean;
-    /** Number of replies in this thread (when message.id is used as thread) */
-    replyCount?: number;
-}
-export interface MessageQuery {
-    limit?: number;
-    sinceTs?: number;
-    from?: string;
-    to?: string;
-    topic?: string;
-    /** Filter by thread ID */
-    thread?: string;
-    order?: 'asc' | 'desc';
-    /** Only include unread messages */
-    unreadOnly?: boolean;
-    /** Only include urgent messages */
-    urgentOnly?: boolean;
-}
-export interface StoredSession {
-    id: string;
-    agentName: string;
-    cli?: string;
-    projectId?: string;
-    projectRoot?: string;
-    startedAt: number;
-    endedAt?: number;
-    messageCount: number;
-    summary?: string;
-    resumeToken?: string;
-    /** How the session was closed: 'agent' (explicit), 'disconnect', 'error', or undefined (still active) */
-    closedBy?: 'agent' | 'disconnect' | 'error';
-}
-export interface SessionQuery {
-    agentName?: string;
-    projectId?: string;
-    since?: number;
-    limit?: number;
-}
-export interface AgentSummary {
-    agentName: string;
-    projectId?: string;
-    lastUpdated: number;
-    currentTask?: string;
-    completedTasks?: string[];
-    decisions?: string[];
-    context?: string;
-    files?: string[];
-}
-export interface StorageAdapter {
-    init(): Promise<void>;
-    saveMessage(message: StoredMessage): Promise<void>;
-    getMessages(query?: MessageQuery): Promise<StoredMessage[]>;
-    getMessageById?(id: string): Promise<StoredMessage | null>;
-    updateMessageStatus?(id: string, status: MessageStatus): Promise<void>;
-    close?(): Promise<void>;
-    startSession?(session: Omit<StoredSession, 'messageCount'>): Promise<void>;
-    endSession?(sessionId: string, options?: {
-        summary?: string;
-        closedBy?: 'agent' | 'disconnect' | 'error';
-    }): Promise<void>;
-    getSessions?(query?: SessionQuery): Promise<StoredSession[]>;
-    getRecentSessions?(limit?: number): Promise<StoredSession[]>;
-    incrementSessionMessageCount?(sessionId: string): Promise<void>;
-    getSessionByResumeToken?(resumeToken: string): Promise<StoredSession | null>;
-    saveAgentSummary?(summary: Omit<AgentSummary, 'lastUpdated'>): Promise<void>;
-    getAgentSummary?(agentName: string): Promise<AgentSummary | null>;
-    getAllAgentSummaries?(): Promise<AgentSummary[]>;
-    getPendingMessagesForSession?(agentName: string, sessionId: string): Promise<StoredMessage[]>;
-    getMaxSeqByStream?(agentName: string, sessionId: string): Promise<Array<{
-        peer: string;
-        topic?: string;
-        maxSeq: number;
-    }>>;
-}
-/**
- * Storage configuration options.
- * Can be set via CLI options or environment variables.
- */
-export interface StorageConfig {
-    /** Storage type: 'sqlite', 'sqlite-batched', 'none', or 'postgres' (future) */
-    type?: string;
-    /** Path for SQLite database */
-    path?: string;
-    /** Connection URL for database (postgres://..., mysql://...) */
-    url?: string;
-    /** Batch configuration for batched adapters */
-    batch?: {
-        maxBatchSize?: number;
-        maxBatchDelayMs?: number;
-        maxBatchBytes?: number;
-        logBatches?: boolean;
-    };
-}
-/**
- * In-memory storage adapter (no persistence).
- * Useful for testing or when persistence is not needed.
- */
-export declare class MemoryStorageAdapter implements StorageAdapter {
-    private messages;
-    init(): Promise<void>;
-    saveMessage(message: StoredMessage): Promise<void>;
-    getMessages(query?: MessageQuery): Promise<StoredMessage[]>;
-    getMessageById(id: string): Promise<StoredMessage | null>;
-    updateMessageStatus(id: string, status: MessageStatus): Promise<void>;
-    getPendingMessagesForSession(agentName: string, sessionId: string): Promise<StoredMessage[]>;
-    getMaxSeqByStream(agentName: string, sessionId: string): Promise<Array<{
-        peer: string;
-        topic?: string;
-        maxSeq: number;
-    }>>;
-    close(): Promise<void>;
-}
-/**
- * Get storage configuration from environment variables.
- */
-export declare function getStorageConfigFromEnv(): StorageConfig;
-/**
- * Create a storage adapter based on configuration.
- *
- * Configuration priority:
- * 1. Explicit config passed to function
- * 2. Environment variables (AGENT_RELAY_STORAGE_TYPE, AGENT_RELAY_STORAGE_PATH, AGENT_RELAY_STORAGE_URL)
- * 3. Default: SQLite at provided dbPath
- *
- * Supported storage types:
- * - 'sqlite' (default): SQLite file-based storage
- * - 'none' or 'memory': In-memory storage (no persistence)
- * - 'postgres': PostgreSQL (requires AGENT_RELAY_STORAGE_URL) - future
- */
-export declare function createStorageAdapter(dbPath: string, config?: StorageConfig): Promise<StorageAdapter>;
-//# sourceMappingURL=adapter.d.ts.map

package/dist/storage/batched-sqlite-adapter.d.ts

@@ -1,71 +0,0 @@
-/**
- * Batched SQLite Storage Adapter
- *
- * Wraps SqliteStorageAdapter to provide batched writes for improved throughput.
- * Messages are buffered and flushed either when:
- *   - Batch size is reached
- *   - Time threshold is exceeded
- *   - Memory threshold is exceeded
- *   - close() is called
- *
- * All reads still go directly to SQLite for consistency.
- */
-import { SqliteStorageAdapter, type SqliteAdapterOptions } from './sqlite-adapter.js';
-import type { StoredMessage, MessageStatus } from './adapter.js';
-export interface BatchConfig {
-    /** Maximum messages in a batch before flush (default: 50) */
-    maxBatchSize: number;
-    /** Maximum time to wait before flush in ms (default: 100) */
-    maxBatchDelayMs: number;
-    /** Maximum bytes in memory before flush (default: 1MB) */
-    maxBatchBytes: number;
-    /** Whether to log batch operations (default: false) */
-    logBatches: boolean;
-}
-export declare const DEFAULT_BATCH_CONFIG: BatchConfig;
-export interface BatchedSqliteAdapterOptions extends SqliteAdapterOptions {
-    batch?: Partial<BatchConfig>;
-}
-export declare class BatchedSqliteAdapter extends SqliteStorageAdapter {
-    private batchConfig;
-    private pending;
-    private pendingBytes;
-    private flushTimer?;
-    private flushing;
-    private flushPromise?;
-    private metrics;
-    constructor(options: BatchedSqliteAdapterOptions);
-    /**
-     * Queue a message for batched writing.
-     * May trigger an immediate flush if thresholds are exceeded.
-     */
-    saveMessage(message: StoredMessage): Promise<void>;
-    /**
-     * Flush all pending messages to SQLite.
-     */
-    flush(): Promise<void>;
-    /**
-     * Write a batch of messages within a transaction.
-     */
-    private writeBatch;
-    /**
-     * Get batch metrics for monitoring.
-     */
-    getBatchMetrics(): typeof this.metrics & {
-        pendingCount: number;
-        pendingBytes: number;
-    };
-    /**
-     * Reset metrics (useful for testing or periodic reporting).
-     */
-    resetMetrics(): void;
-    /**
-     * Close the adapter, flushing any pending messages first.
-     */
-    close(): Promise<void>;
-    /**
-     * Update message status - goes directly to SQLite (not batched).
-     */
-    updateMessageStatus(id: string, status: MessageStatus): Promise<void>;
-}
-//# sourceMappingURL=batched-sqlite-adapter.d.ts.map