recoder-code 2.5.2 → 2.5.3

package/dist/src/commands/web/watch.js

@@ -0,0 +1,360 @@
+/**
+ * 'recoder web watch' command
+ * Live sync - watch for local changes and sync to web in real-time
+ */
+import path from 'node:path';
+import fs from 'node:fs/promises';
+import { watch } from 'node:fs';
+import { RecoderWebService } from '../../services/RecoderWebService.js';
+import { RecoderAuthService } from '../../services/RecoderAuthService.js';
+const DOCKER_BACKEND_URL = process.env['RECODER_DOCKER_URL'] || 'https://docker.recoder.xyz';
+// Directories and files to ignore
+const IGNORED_DIRS = new Set([
+    'node_modules',
+    '.git',
+    'dist',
+    'build',
+    '.next',
+    '.vercel',
+    '.cache',
+    'coverage',
+    '__pycache__',
+]);
+const IGNORED_FILES = new Set([
+    '.DS_Store',
+    '.env',
+    '.env.local',
+    '.env.production',
+    '.recoder-web',
+    'package-lock.json',
+    'yarn.lock',
+    'pnpm-lock.yaml',
+]);
+export const watchCommand = {
+    command: 'watch [urlId]',
+    describe: 'Live sync - watch for changes and sync to web in real-time',
+    builder: (yargs) => yargs
+        .positional('urlId', {
+        type: 'string',
+        description: 'Project URL ID (optional, will read from .recoder-web if present)',
+    })
+        .option('directory', {
+        type: 'string',
+        alias: 'd',
+        description: 'Directory to watch (defaults to current directory)',
+        default: process.cwd(),
+    })
+        .option('push-only', {
+        type: 'boolean',
+        description: 'Only push local changes to web (no pull)',
+        default: false,
+    })
+        .option('pull-only', {
+        type: 'boolean',
+        description: 'Only pull web changes to local (no push)',
+        default: false,
+    })
+        .option('interval', {
+        type: 'number',
+        alias: 'i',
+        description: 'Debounce interval in milliseconds',
+        default: 500,
+    })
+        .check((argv) => {
+        if (argv['push-only'] && argv['pull-only']) {
+            throw new Error('Cannot use both --push-only and --pull-only');
+        }
+        return true;
+    }),
+    handler: async (argv) => {
+        const webService = new RecoderWebService();
+        const authService = new RecoderAuthService();
+        try {
+            // Check authentication
+            const isAuth = await authService.isAuthenticated();
+            if (!isAuth) {
+                console.error('Not authenticated');
+                console.log('Run: recoder auth login');
+                process.exit(1);
+            }
+            const targetDir = path.resolve(argv.directory || process.cwd());
+            let urlId = argv.urlId;
+            // Try to read .recoder-web metadata if no urlId provided
+            if (!urlId) {
+                try {
+                    const metadataPath = path.join(targetDir, '.recoder-web');
+                    const metadata = JSON.parse(await fs.readFile(metadataPath, 'utf-8'));
+                    urlId = metadata.urlId || metadata.projectId;
+                    console.log(`Found project ID from .recoder-web: ${urlId}`);
+                }
+                catch {
+                    console.error('No project ID provided and no .recoder-web file found');
+                    console.log('Usage: recoder web watch <urlId>');
+                    console.log('   Or run from a linked directory (use recoder web link first)');
+                    process.exit(1);
+                }
+            }
+            // Get token
+            const token = await authService.getAccessToken();
+            if (!token) {
+                console.error('Failed to get access token');
+                process.exit(1);
+            }
+            // Generate a unique client ID for this watch session
+            const clientId = `cli-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+            console.log('\n' + '='.repeat(60));
+            console.log('             RECODER LIVE SYNC');
+            console.log('='.repeat(60));
+            console.log(`Project: ${urlId}`);
+            console.log(`Directory: ${targetDir}`);
+            console.log(`Mode: ${argv['push-only'] ? 'Push only' : argv['pull-only'] ? 'Pull only' : 'Bidirectional'}`);
+            console.log(`Client ID: ${clientId.substring(0, 16)}...`);
+            console.log('='.repeat(60));
+            console.log('\nWatching for changes... (Press Ctrl+C to stop)\n');
+            // Track pending changes with debouncing
+            const pendingChanges = new Map();
+            let syncTimeout = null;
+            // Function to sync pending changes
+            const syncPendingChanges = async () => {
+                if (pendingChanges.size === 0)
+                    return;
+                const changes = Array.from(pendingChanges.values());
+                pendingChanges.clear();
+                console.log(`\nSyncing ${changes.length} changes...`);
+                try {
+                    // Group by type
+                    const added = [];
+                    const modified = [];
+                    const deleted = [];
+                    for (const change of changes) {
+                        if (change.type === 'unlink') {
+                            deleted.push(change.path);
+                        }
+                        else if (change.type === 'add') {
+                            added.push(change.path);
+                        }
+                        else {
+                            modified.push(change.path);
+                        }
+                    }
+                    // Read file contents for added and modified files
+                    const files = {};
+                    for (const filePath of [...added, ...modified]) {
+                        try {
+                            const fullPath = path.join(targetDir, filePath);
+                            const content = await fs.readFile(fullPath, 'utf-8');
+                            files[filePath] = content;
+                        }
+                        catch {
+                            // File might have been deleted since we recorded the change
+                        }
+                    }
+                    // Push to backend
+                    const response = await fetch(`${DOCKER_BACKEND_URL}/api/sync/${urlId}/push`, {
+                        method: 'POST',
+                        headers: {
+                            'Authorization': `Bearer ${token}`,
+                            'Content-Type': 'application/json',
+                        },
+                        body: JSON.stringify({
+                            files,
+                            clientId,
+                        }),
+                    });
+                    if (response.ok) {
+                        const data = await response.json();
+                        const { applied } = data;
+                        const total = applied.added + applied.modified + applied.deleted;
+                        if (total > 0) {
+                            const parts = [];
+                            if (applied.added > 0)
+                                parts.push(`+${applied.added}`);
+                            if (applied.modified > 0)
+                                parts.push(`~${applied.modified}`);
+                            if (applied.deleted > 0)
+                                parts.push(`-${applied.deleted}`);
+                            console.log(`  Synced: ${parts.join(', ')} files`);
+                        }
+                    }
+                    else {
+                        const error = await response.json().catch(() => ({ error: 'Unknown error' }));
+                        console.error(`  Sync failed: ${error.error}`);
+                        // If container not found, try to push via web API
+                        if (error.error?.includes('Container not found')) {
+                            console.log('  Container not running. Pushing via web API...');
+                            await webService.uploadProject(urlId, files);
+                            console.log('  Uploaded to web API');
+                        }
+                    }
+                }
+                catch (error) {
+                    console.error(`  Sync error: ${error.message}`);
+                }
+            };
+            // Schedule sync with debouncing
+            const schedulSync = () => {
+                if (syncTimeout) {
+                    clearTimeout(syncTimeout);
+                }
+                syncTimeout = setTimeout(syncPendingChanges, argv.interval);
+            };
+            // Check if a path should be ignored
+            const shouldIgnore = (filePath) => {
+                const parts = filePath.split(path.sep);
+                // Check if any parent directory is ignored
+                for (const part of parts) {
+                    if (IGNORED_DIRS.has(part)) {
+                        return true;
+                    }
+                }
+                // Check if file itself is ignored
+                const fileName = path.basename(filePath);
+                if (IGNORED_FILES.has(fileName)) {
+                    return true;
+                }
+                return false;
+            };
+            // Get relative path from target directory
+            const getRelativePath = (fullPath) => {
+                return path.relative(targetDir, fullPath);
+            };
+            // Set up file watcher
+            // Using recursive watch (works on macOS and Windows, limited on Linux)
+            const watcher = watch(targetDir, { recursive: true }, async (eventType, filename) => {
+                if (!filename)
+                    return;
+                if (argv['pull-only'])
+                    return;
+                const relativePath = filename.toString().replace(/\\/g, '/');
+                if (shouldIgnore(relativePath)) {
+                    return;
+                }
+                const fullPath = path.join(targetDir, relativePath);
+                try {
+                    const stats = await fs.stat(fullPath);
+                    if (stats.isDirectory()) {
+                        return; // Skip directory events
+                    }
+                    // Determine change type
+                    let changeType = 'change';
+                    // Check if this is a new file
+                    const existingChange = pendingChanges.get(relativePath);
+                    if (!existingChange) {
+                        // Try to determine if it's new or modified
+                        // This is a heuristic - if file was created in last 100ms, consider it new
+                        const mtime = stats.mtimeMs;
+                        const ctime = stats.ctimeMs;
+                        if (Math.abs(mtime - ctime) < 100) {
+                            changeType = 'add';
+                        }
+                    }
+                    pendingChanges.set(relativePath, {
+                        path: relativePath,
+                        type: changeType,
+                        timestamp: Date.now(),
+                    });
+                    const icon = changeType === 'add' ? '+' : '~';
+                    console.log(`  ${icon} ${relativePath}`);
+                    schedulSync();
+                }
+                catch (error) {
+                    // File was deleted
+                    if (error.code === 'ENOENT') {
+                        pendingChanges.set(relativePath, {
+                            path: relativePath,
+                            type: 'unlink',
+                            timestamp: Date.now(),
+                        });
+                        console.log(`  - ${relativePath}`);
+                        schedulSync();
+                    }
+                }
+            });
+            // Set up WebSocket for receiving remote changes (bidirectional sync)
+            let ws = null;
+            if (!argv['push-only']) {
+                try {
+                    const wsUrl = DOCKER_BACKEND_URL.replace('http', 'ws');
+                    ws = new WebSocket(`${wsUrl}/cli-sync/${urlId}?clientId=${clientId}`);
+                    ws.onopen = () => {
+                        console.log('Connected to live sync server');
+                    };
+                    ws.onmessage = async (event) => {
+                        try {
+                            const data = JSON.parse(event.data.toString());
+                            if (data.type === 'file-change' && data.source !== 'cli') {
+                                // Remote change - apply to local
+                                const filePath = data.path;
+                                const content = data.content;
+                                const fullPath = path.join(targetDir, filePath);
+                                if (content !== undefined) {
+                                    // File created or modified
+                                    const dir = path.dirname(fullPath);
+                                    await fs.mkdir(dir, { recursive: true });
+                                    await fs.writeFile(fullPath, content, 'utf-8');
+                                    console.log(`  < ${filePath} (from web)`);
+                                }
+                                else {
+                                    // File deleted
+                                    try {
+                                        await fs.unlink(fullPath);
+                                        console.log(`  < ${filePath} (deleted from web)`);
+                                    }
+                                    catch {
+                                        // File doesn't exist locally, that's fine
+                                    }
+                                }
+                            }
+                            if (data.type === 'connected') {
+                                console.log('Bidirectional sync enabled');
+                            }
+                        }
+                        catch {
+                            // Ignore parse errors
+                        }
+                    };
+                    ws.onerror = () => {
+                        console.log('WebSocket connection failed - running in push-only mode');
+                    };
+                    ws.onclose = () => {
+                        console.log('Disconnected from live sync server');
+                    };
+                }
+                catch {
+                    console.log('Could not connect to live sync server - running in push-only mode');
+                }
+            }
+            // Handle graceful shutdown
+            const cleanup = () => {
+                console.log('\n\nStopping watch...');
+                watcher.close();
+                if (ws) {
+                    ws.close();
+                }
+                if (syncTimeout) {
+                    clearTimeout(syncTimeout);
+                }
+                // Sync any remaining changes
+                if (pendingChanges.size > 0) {
+                    console.log('Syncing remaining changes...');
+                    syncPendingChanges().then(() => {
+                        console.log('Watch stopped.');
+                        process.exit(0);
+                    });
+                }
+                else {
+                    console.log('Watch stopped.');
+                    process.exit(0);
+                }
+            };
+            process.on('SIGINT', cleanup);
+            process.on('SIGTERM', cleanup);
+            // Keep the process running
+            await new Promise(() => { });
+        }
+        catch (error) {
+            console.error(`${error.message}`);
+            process.exit(1);
+        }
+    },
+};

package/dist/src/commands/web.js

@@ -7,19 +7,31 @@ import { downloadCommand } from './web/download.js';
 import { openCommand } from './web/open.js';
 import { infoCommand } from './web/info.js';
 import { pushCommand } from './web/push.js';
+import { pullCommand } from './web/pull.js';
 import { syncCommand } from './web/sync.js';
 import { launchCommand } from './web/launch.js';
+import { linkCommand } from './web/link.js';
+import { unlinkCommand } from './web/unlink.js';
+import { statusCommand } from './web/status.js';
+import { diffCommand } from './web/diff.js';
+import { watchCommand } from './web/watch.js';
 export const webCommand = {
     command: 'web',
     describe: 'Manage projects from web IDE',
     builder: (yargs) => yargs
         .command(launchCommand)
+        .command(linkCommand)
+        .command(unlinkCommand)
+        .command(statusCommand)
         .command(listCommand)
         .command(downloadCommand)
         .command(openCommand)
         .command(infoCommand)
         .command(pushCommand)
+        .command(pullCommand)
         .command(syncCommand)
+        .command(diffCommand)
+        .command(watchCommand)
         .demandCommand(1, 'You need at least one command. Try: recoder web launch')
         .version(false),
     handler: () => {

package/dist/src/config/config.js

@@ -23,6 +23,7 @@ import { hintsCommand } from '../commands/hints.js';
 import { modelsCommand } from '../commands/models-cmd.js';
 import { configureCommand } from '../commands/configure.js';
 import { connectCommand } from '../commands/connect-cmd.js';
+import { parallelCommand, parallelFinishCommand } from '../commands/parallel.js';
 import { resolvePath } from '../utils/resolvePath.js';
 import { getCliVersion } from '../utils/version.js';
 import { annotateActiveExtensions } from './extension.js';
@@ -280,7 +281,10 @@ export async function parseArguments(settings) {
         // Register configure command for interactive setup
         .command(configureCommand)
         // Register connect command for custom providers
-        .command(connectCommand);
+        .command(connectCommand)
+        // Register parallel mode commands for git worktree-based parallel execution
+        .command(parallelCommand)
+        .command(parallelFinishCommand);
     if (settings?.experimental?.extensionManagement ?? false) {
         yargsInstance.command(extensionsCommand);
     }
@@ -296,7 +300,7 @@ export async function parseArguments(settings) {
     // Handle case where MCP subcommands are executed - they should exit the process
     // and not return to main CLI logic
     if (result._.length > 0 &&
-        (result._[0] === 'mcp' || result._[0] === 'extensions' || result._[0] === 'auth' || result._[0] === 'ai' || result._[0] === 'web' || result._[0] === 'init' || result._[0] === 'plan')) {
+        (result._[0] === 'mcp' || result._[0] === 'extensions' || result._[0] === 'auth' || result._[0] === 'ai' || result._[0] === 'web' || result._[0] === 'init' || result._[0] === 'plan' || result._[0] === 'parallel' || result._[0] === 'parallel-finish')) {
         // Subcommands handle their own execution and process exit
         process.exit(0);
     }

package/dist/src/config/defaultMcpServers.d.ts

@@ -17,6 +17,7 @@ export declare function getEssentialMcpServers(): Record<string, MCPServerConfig
  */
 export declare function getExtendedMcpServers(): Record<string, MCPServerConfig>;
 export declare const MCP_SERVER_CATEGORIES: {
+    readonly 'built-in': readonly ["eternos"];
     readonly essential: readonly ["github", "filesystem", "gitmcp-docs"];
     readonly automation: readonly ["playwright", "puppeteer"];
     readonly 'problem-solving': readonly ["sequential-thinking"];

package/dist/src/config/defaultMcpServers.js

@@ -3,11 +3,55 @@
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
+import { createRequire } from 'node:module';
+import { join, dirname } from 'node:path';
+import { existsSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+/**
+ * Resolves the path to the mcp-eternos dist/index.js entry point.
+ * Tries multiple resolution strategies:
+ * 1. npm workspace resolution (via require.resolve)
+ * 2. Relative path from CLI package (sibling package in monorepo)
+ * 3. Global npx fallback
+ */
+function getMcpEternosPath() {
+    // Strategy 1: Try npm/workspace resolution
+    try {
+        const require = createRequire(import.meta.url);
+        const resolved = require.resolve('mcp-eternos/dist/index.js');
+        return resolved;
+    }
+    catch {
+        // Not installed as a dependency, try other strategies
+    }
+    // Strategy 2: Relative path from CLI package (monorepo sibling)
+    const thisDir = dirname(fileURLToPath(import.meta.url));
+    // From packages/cli/dist/src/config/ -> packages/mcp-eternos/dist/index.js
+    const monorepoPath = join(thisDir, '..', '..', '..', '..', 'mcp-eternos', 'dist', 'index.js');
+    if (existsSync(monorepoPath)) {
+        return monorepoPath;
+    }
+    // Strategy 3: From source location (during development)
+    const devPath = join(thisDir, '..', '..', '..', 'mcp-eternos', 'dist', 'index.js');
+    if (existsSync(devPath)) {
+        return devPath;
+    }
+    // Fallback: assume it's globally installed
+    return 'mcp-eternos';
+}
 /**
  * Default MCP servers that come pre-configured with Recoder Code.
  * All servers listed here have been tested and confirmed working.
  */
 export const DEFAULT_MCP_SERVERS = {
+    // Eternos MCP - Recoder's built-in MCP server with 107+ tools
+    eternos: {
+        command: 'node',
+        args: [getMcpEternosPath()],
+        description: `Eternos - Recoder's built-in MCP server with 107+ tools including web, file, data, and agent-to-agent communication.`,
+        trust: true,
+        timeout: 30000,
+    },
     // GitHub MCP - Repository management (26 tools)
     github: {
         command: 'npx',
@@ -141,6 +185,7 @@ export function getDefaultMcpServers() {
 }
 export function getEssentialMcpServers() {
     return {
+        eternos: DEFAULT_MCP_SERVERS.eternos,
         github: DEFAULT_MCP_SERVERS.github,
         playwright: DEFAULT_MCP_SERVERS.playwright,
         filesystem: DEFAULT_MCP_SERVERS.filesystem,
@@ -194,6 +239,7 @@ export function getExtendedMcpServers() {
     };
 }
 export const MCP_SERVER_CATEGORIES = {
+    'built-in': ['eternos'],
     essential: ['github', 'filesystem', 'gitmcp-docs'],
     automation: ['playwright', 'puppeteer'],
     'problem-solving': ['sequential-thinking'],

package/dist/src/gemini.js

@@ -147,6 +147,16 @@ export async function main() {
         }
     }
     // ===== END AUTH GUARD =====
+    // ===== RECODER.XYZ PLATFORM INTEGRATION =====
+    // Auto-detect if running in recoder.xyz container and show preview URL
+    try {
+        const { platformSync } = await import('./services/PlatformSyncService.js');
+        await platformSync.autoInitialize();
+    }
+    catch (e) {
+        // Silently ignore - platform integration is optional
+    }
+    // ===== END PLATFORM INTEGRATION =====
     // Check if API key is configured before proceeding
     const { isApiKeyConfigured, checkAndSetupApiKey } = await import('./setup/apiKeySetup.js');
     if (!isApiKeyConfigured()) {

package/dist/src/parallel/git-utils.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Git utilities for parallel mode
+ * Based on Kilo Code (Apache-2.0 License)
+ */
+export interface GitInfo {
+    branch: string | null;
+    isClean: boolean;
+    isRepo: boolean;
+}
+/**
+ * Get Git repository information for a given directory
+ */
+export declare function getGitInfo(cwd: string): Promise<GitInfo>;
+/**
+ * Get just the branch name (faster than full git info)
+ */
+export declare function getGitBranch(cwd: string): Promise<string | null>;
+/**
+ * Check if a branch exists in the repository
+ */
+export declare function branchExists(cwd: string, branchName: string): Promise<boolean>;
+/**
+ * Generate a valid git branch name from a prompt
+ * Sanitizes the prompt to create a safe branch name
+ */
+export declare function generateBranchName(prompt: string): string;
+/**
+ * Check if a directory is a git worktree
+ */
+export declare function isGitWorktree(cwd: string): Promise<boolean>;
+/**
+ * Create a git worktree
+ */
+export declare function createWorktree(cwd: string, worktreePath: string, branchName: string, isNewBranch: boolean): Promise<void>;
+/**
+ * Remove a git worktree
+ */
+export declare function removeWorktree(cwd: string, worktreePath: string): Promise<void>;
+/**
+ * List all worktrees for a repository
+ */
+export declare function listWorktrees(cwd: string): Promise<string[]>;