recoder-code 2.5.2 → 2.5.3

package/dist/src/services/AgentBridgeService.js

@@ -0,0 +1,253 @@
+/**
+ * Agent Bridge Service
+ *
+ * Connects recoder-code CLI to the A2A workspace system on docker-backend
+ * via WebSocket. Enables local agents to:
+ *   - Register as workspace members
+ *   - Receive task assignments in real-time
+ *   - Report task progress and results
+ *   - Participate in channel conversations
+ *
+ * Uses existing RecoderAuthService for authentication tokens.
+ * Auto-reconnects with exponential backoff (same pattern as PlatformSyncService).
+ */
+import WebSocket from 'ws';
+import { EventEmitter } from 'events';
+import os from 'node:os';
+const DOCKER_BACKEND_URL = process.env['DOCKER_BACKEND_URL'] || 'https://docker.recoder.xyz';
+// ---------------------------------------------------------------------------
+// Service
+// ---------------------------------------------------------------------------
+export class AgentBridgeService extends EventEmitter {
+    ws = null;
+    reconnectTimeout = null;
+    heartbeatInterval = null;
+    connected = false;
+    agentId;
+    workspaceId = null;
+    reconnectAttempts = 0;
+    maxReconnectDelay = 30_000;
+    getToken;
+    constructor(getToken, agentId) {
+        super();
+        this.getToken = getToken;
+        this.agentId = agentId || `recoder-code_${os.hostname()}_${process.pid}`;
+    }
+    // -----------------------------------------------------------------------
+    // Connection lifecycle
+    // -----------------------------------------------------------------------
+    async connect(workspaceId, capabilities = []) {
+        this.workspaceId = workspaceId;
+        const token = await this.getToken();
+        if (!token) {
+            console.error('Not authenticated. Please run `recoder auth login` first.');
+            return;
+        }
+        return this.connectWebSocket(token, capabilities);
+    }
+    connectWebSocket(token, capabilities = []) {
+        return new Promise((resolve) => {
+            const wsUrl = DOCKER_BACKEND_URL.replace(/^http/, 'ws');
+            const url = new URL(`${wsUrl}/agent-bridge`);
+            url.searchParams.set('token', token);
+            url.searchParams.set('agentId', this.agentId);
+            if (capabilities.length > 0) {
+                url.searchParams.set('capabilities', capabilities.join(','));
+            }
+            if (this.workspaceId) {
+                url.searchParams.set('workspaceIds', this.workspaceId);
+            }
+            try {
+                this.ws = new WebSocket(url.toString());
+                this.ws.on('open', () => {
+                    this.connected = true;
+                    this.reconnectAttempts = 0;
+                    this.startHeartbeat();
+                    this.emit('connected');
+                    resolve();
+                });
+                this.ws.on('message', (data) => {
+                    try {
+                        const msg = JSON.parse(data.toString());
+                        this.handleMessage(msg);
+                    }
+                    catch {
+                        // Ignore parse errors
+                    }
+                });
+                this.ws.on('close', (_code, _reason) => {
+                    this.connected = false;
+                    this.stopHeartbeat();
+                    this.emit('disconnected');
+                    this.scheduleReconnect(token, capabilities);
+                });
+                this.ws.on('error', (err) => {
+                    if (!this.connected) {
+                        resolve(); // Don't hang on initial connect failure
+                    }
+                    this.emit('error', err);
+                });
+                // Timeout initial connection attempt
+                setTimeout(() => {
+                    if (!this.connected) {
+                        resolve();
+                    }
+                }, 5000);
+            }
+            catch (error) {
+                console.error('Failed to connect to agent bridge:', error);
+                resolve();
+            }
+        });
+    }
+    disconnect() {
+        if (this.reconnectTimeout) {
+            clearTimeout(this.reconnectTimeout);
+            this.reconnectTimeout = null;
+        }
+        this.stopHeartbeat();
+        if (this.ws) {
+            this.ws.close(1000, 'Client disconnect');
+            this.ws = null;
+        }
+        this.connected = false;
+        this.workspaceId = null;
+        this.reconnectAttempts = 0;
+    }
+    scheduleReconnect(token, capabilities) {
+        if (this.reconnectTimeout || !this.workspaceId)
+            return;
+        // Exponential backoff: 1s, 2s, 4s, 8s, ... up to maxReconnectDelay
+        const delay = Math.min(1000 * Math.pow(2, this.reconnectAttempts), this.maxReconnectDelay);
+        this.reconnectAttempts++;
+        this.reconnectTimeout = setTimeout(() => {
+            this.reconnectTimeout = null;
+            void this.connectWebSocket(token, capabilities);
+        }, delay);
+    }
+    // -----------------------------------------------------------------------
+    // Heartbeat
+    // -----------------------------------------------------------------------
+    startHeartbeat() {
+        this.stopHeartbeat();
+        this.heartbeatInterval = setInterval(() => {
+            this.send({ type: 'heartbeat' });
+        }, 30_000);
+    }
+    stopHeartbeat() {
+        if (this.heartbeatInterval) {
+            clearInterval(this.heartbeatInterval);
+            this.heartbeatInterval = null;
+        }
+    }
+    // -----------------------------------------------------------------------
+    // Outgoing messages
+    // -----------------------------------------------------------------------
+    send(msg) {
+        if (!this.ws || this.ws.readyState !== WebSocket.OPEN)
+            return false;
+        try {
+            this.ws.send(JSON.stringify(msg));
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    joinWorkspace(workspaceId) {
+        this.workspaceId = workspaceId;
+        this.send({ type: 'join_workspace', workspaceId });
+    }
+    leaveWorkspace(workspaceId) {
+        this.send({ type: 'leave_workspace', workspaceId });
+        if (this.workspaceId === workspaceId) {
+            this.workspaceId = null;
+        }
+    }
+    sendProgress(taskId, progress, output) {
+        this.send({ type: 'task.progress', taskId, progress, output });
+    }
+    completeTask(taskId, result) {
+        this.send({ type: 'task.complete', taskId, result });
+    }
+    failTask(taskId, error) {
+        this.send({ type: 'task.failed', taskId, error });
+    }
+    sendChannelMessage(channelId, content) {
+        this.send({ type: 'channel.message', channelId, content });
+    }
+    // -----------------------------------------------------------------------
+    // Incoming message handling
+    // -----------------------------------------------------------------------
+    handleMessage(msg) {
+        switch (msg.type) {
+            case 'registered':
+                this.emit('registered', {
+                    agentId: msg.agentId,
+                    workspaces: msg.workspaces,
+                });
+                break;
+            case 'task.assigned': {
+                const assignment = {
+                    taskId: msg.taskId,
+                    prompt: msg.prompt,
+                    context: msg.context || {},
+                    worktreeBranch: msg.worktreeBranch,
+                };
+                this.emit('task.assigned', assignment);
+                break;
+            }
+            case 'task.cancelled':
+                this.emit('task.cancelled', { taskId: msg.taskId });
+                break;
+            case 'channel.message': {
+                const channelMsg = {
+                    channelId: msg.channelId,
+                    from: msg.from,
+                    content: msg.content,
+                };
+                this.emit('channel.message', channelMsg);
+                break;
+            }
+            case 'workspace.updated':
+                this.emit('workspace.updated', {
+                    workspaceId: msg.workspaceId,
+                    changes: msg.changes,
+                });
+                break;
+            case 'workspace.joined':
+                this.emit('workspace.joined', { workspaceId: msg.workspaceId });
+                break;
+            case 'workspace.left':
+                this.emit('workspace.left', { workspaceId: msg.workspaceId });
+                break;
+            case 'ping':
+                // Server keepalive, no action needed
+                break;
+            default:
+                // Emit unknown messages for extensibility
+                this.emit('message', msg);
+        }
+    }
+    // -----------------------------------------------------------------------
+    // Status
+    // -----------------------------------------------------------------------
+    isConnected() {
+        return this.connected;
+    }
+    getAgentId() {
+        return this.agentId;
+    }
+    getWorkspaceId() {
+        return this.workspaceId;
+    }
+    displayStatus() {
+        if (!this.connected) {
+            console.log('Agent Bridge: Disconnected');
+            return;
+        }
+        console.log(`Agent Bridge: Connected`);
+        console.log(`  Agent ID: ${this.agentId}`);
+        console.log(`  Workspace: ${this.workspaceId || 'None'}`);
+    }
+}

package/dist/src/services/BuiltinCommandLoader.js

@@ -56,6 +56,8 @@ import { providersCommand } from '../ui/commands/providersCommand.js';
 import { connectCommand } from '../ui/commands/connectCommand.js';
 import { modelsCommand } from '../ui/commands/modelsCommand.js';
 import { agentCommand } from '../ui/commands/agentCommand.js';
+import { workspaceCommand } from '../ui/commands/workspaceCommand.js';
+import { workflowCommand as workflowCmd, analyticsCommand, costCommand, whoamiCommand, } from '../ui/commands/workflowCommands.js';
 /**
  * Loads the core, hard-coded slash commands that are an integral part
  * of the Gemini CLI application.
@@ -132,6 +134,11 @@ export class BuiltinCommandLoader {
             connectCommand,
             modelsCommand,
             agentCommand,
+            workspaceCommand,
+            workflowCmd,
+            analyticsCommand,
+            costCommand,
+            whoamiCommand,
         ];
         return allDefinitions.filter((cmd) => cmd !== null);
     }

package/dist/src/services/PlatformSyncService.d.ts

@@ -0,0 +1,154 @@
+/**
+ * Platform Sync Service
+ * Handles bidirectional sync between recoder-code CLI and recoder.xyz web platform
+ * Detects if running inside recoder.xyz container and auto-connects
+ */
+import { EventEmitter } from 'events';
+export interface FileChange {
+    type: 'create' | 'modify' | 'delete';
+    path: string;
+    content?: string;
+    timestamp: number;
+}
+export interface PlatformInfo {
+    isContainer: boolean;
+    isLinked: boolean;
+    projectId?: string;
+    previewUrl?: string;
+    backendUrl?: string;
+    webUrl?: string;
+    workingDir?: string;
+}
+export declare class PlatformSyncService extends EventEmitter {
+    private ws;
+    private reconnectTimeout;
+    private platformInfo;
+    private connected;
+    private fileWatcher;
+    private pendingChanges;
+    private syncEnabled;
+    /**
+     * Detect platform environment (container or local linked project)
+     */
+    detectPlatform(workingDir?: string): Promise<PlatformInfo>;
+    /**
+     * Detect linked project from .recoder-web file
+     */
+    private detectLinkedProject;
+    /**
+     * Check if we're inside a recoder container
+     */
+    private isInRecoderContainer;
+    /**
+     * Extract project ID from container context
+     */
+    private detectProjectId;
+    /**
+     * Get preview URL - constructed from env vars
+     * Preview is proxied through docker-backend at /preview/{projectId}
+     */
+    private detectPreviewUrl;
+    /**
+     * Auto-initialize when running in container or linked project
+     * Call this on CLI startup
+     */
+    autoInitialize(): Promise<void>;
+    /**
+     * Connect to platform sync WebSocket
+     */
+    connect(): Promise<boolean>;
+    /**
+     * Connect to file sync WebSocket
+     */
+    private connectWebSocket;
+    /**
+     * Handle incoming sync messages
+     */
+    private handleMessage;
+    /**
+     * Schedule reconnection attempt
+     */
+    private scheduleReconnect;
+    /**
+     * Send file change to platform (with offline queuing)
+     */
+    notifyFileChange(change: FileChange): Promise<void>;
+    /**
+     * Flush pending changes when reconnected
+     */
+    private flushPendingChanges;
+    /**
+     * Get count of pending offline changes
+     */
+    getPendingChangesCount(): number;
+    /**
+     * Track file versions for conflict detection
+     */
+    private fileVersions;
+    /**
+     * Check if a remote change conflicts with local changes
+     */
+    private detectConflict;
+    /**
+     * Handle conflict resolution
+     * Returns: 'local' | 'remote' | 'merge' | 'skip'
+     */
+    resolveConflict(filePath: string, localContent: string, remoteContent: string, callback: (choice: 'local' | 'remote' | 'skip') => void): Promise<void>;
+    /**
+     * Start watching local files for changes
+     */
+    startFileWatcher(): void;
+    /**
+     * Stop file watcher
+     */
+    stopFileWatcher(): void;
+    /**
+     * Request file from platform
+     */
+    requestFile(filePath: string): Promise<void>;
+    /**
+     * Request file list from platform
+     */
+    requestFileList(directory?: string): Promise<void>;
+    /**
+     * Delete file via platform
+     */
+    deleteFile(filePath: string): Promise<void>;
+    /**
+     * Disconnect from platform
+     */
+    disconnect(): void;
+    /**
+     * Get connection status
+     */
+    isConnected(): boolean;
+    /**
+     * Get platform info
+     */
+    getPlatformInfo(): PlatformInfo | null;
+    /**
+     * Enable/disable sync
+     */
+    setSyncEnabled(enabled: boolean): void;
+    /**
+     * Display platform status
+     */
+    displayStatus(): void;
+    /**
+     * Save chat message to platform (for CLI-web chat sync)
+     */
+    saveChatMessage(message: {
+        role: 'user' | 'assistant';
+        content: string;
+        id?: string;
+    }): Promise<void>;
+    /**
+     * Load chat history from platform
+     */
+    loadChatHistory(): Promise<any[]>;
+    /**
+     * Get the web URL for the current project
+     */
+    getWebProjectUrl(): string | undefined;
+}
+export declare const platformSync: PlatformSyncService;