claude-chrome-parallel 1.0.0

package/dist/tools/orchestration.js

@@ -0,0 +1,746 @@
+"use strict";
+/**
+ * Orchestration Tools - MCP tools for Chrome-Sisyphus workflow management
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerOrchestrationTools = registerOrchestrationTools;
+const dns = __importStar(require("dns"));
+const util_1 = require("util");
+const mcp_server_1 = require("../mcp-server");
+const workflow_engine_1 = require("../orchestration/workflow-engine");
+const connection_pool_1 = require("../cdp/connection-pool");
+const tool_manifest_1 = require("../types/tool-manifest");
+const plan_registry_1 = require("../orchestration/plan-registry");
+const plan_executor_1 = require("../orchestration/plan-executor");
+const dnsResolve = (0, util_1.promisify)(dns.resolve);
+// ============================================
+// workflow_init - Initialize a new workflow
+// ============================================
+const workflowInitDefinition = {
+    name: 'workflow_init',
+    description: `Initialize a Chrome-Sisyphus workflow with multiple workers.
+Creates isolated browser contexts for each worker and sets up scratchpad files.
+
+Use this to prepare parallel browser operations before launching worker agents.`,
+    inputSchema: {
+        type: 'object',
+        properties: {
+            name: {
+                type: 'string',
+                description: 'Name of the workflow (e.g., "Price comparison")',
+            },
+            workers: {
+                type: 'array',
+                description: 'List of workers to create',
+                items: {
+                    type: 'object',
+                    properties: {
+                        name: {
+                            type: 'string',
+                            description: 'Worker name (e.g., "coupang", "11st")',
+                        },
+                        url: {
+                            type: 'string',
+                            description: 'Initial URL to navigate to',
+                        },
+                        task: {
+                            type: 'string',
+                            description: 'Task description for the worker',
+                        },
+                        successCriteria: {
+                            type: 'string',
+                            description: 'Criteria for task completion',
+                        },
+                        shareCookies: {
+                            type: 'boolean',
+                            description: 'If true, worker shares cookies from existing Chrome session instead of isolated context (default: false)',
+                        },
+                    },
+                    required: ['name', 'url', 'task'],
+                },
+            },
+            workerTimeoutMs: {
+                type: 'number',
+                description: 'Maximum execution time per worker in milliseconds (default: 60000). Workers exceeding this limit are force-completed with PARTIAL status.',
+            },
+            maxStaleIterations: {
+                type: 'number',
+                description: 'Maximum consecutive worker updates with no data change before circuit breaker triggers (default: 5). Prevents runaway workers stuck in retry loops.',
+            },
+            globalTimeoutMs: {
+                type: 'number',
+                description: 'Maximum total workflow execution time in milliseconds (default: 300000). All running workers are force-completed when exceeded.',
+            },
+        },
+        required: ['name', 'workers'],
+    },
+};
+const workflowInitHandler = async (sessionId, args) => {
+    const engine = (0, workflow_engine_1.getWorkflowEngine)();
+    const name = args.name;
+    const workerTimeoutMs = args.workerTimeoutMs;
+    const maxStaleIterations = args.maxStaleIterations;
+    const globalTimeoutMs = args.globalTimeoutMs;
+    const workerDefs = args.workers;
+    // DNS pre-resolution: resolve all worker hostnames in parallel
+    // This saves ~200ms per site by warming the DNS cache before navigation
+    const uniqueHostnames = [...new Set(workerDefs
+            .map(w => {
+            try {
+                return new URL(w.url.startsWith('http') ? w.url : `https://${w.url}`).hostname;
+            }
+            catch {
+                return null;
+            }
+        })
+            .filter((h) => h !== null))];
+    if (uniqueHostnames.length > 0) {
+        await Promise.allSettled(uniqueHostnames.map(hostname => dnsResolve(hostname).catch(() => { })));
+    }
+    try {
+        // Pre-warm connection pool in parallel with DNS resolution
+        const pool = (0, connection_pool_1.getCDPConnectionPool)();
+        const preWarmPromise = pool.preWarmForWorkflow(workerDefs.length).catch((err) => {
+            console.error('[Orchestration] Pool pre-warm failed (non-fatal):', err);
+            return { warmed: 0, durationMs: 0 };
+        });
+        await preWarmPromise;
+        // Create workflow definition
+        const workflow = {
+            id: `wf-${Date.now()}`,
+            name,
+            steps: workerDefs.map((w, i) => {
+                if (w.shareCookies === undefined) {
+                    console.error(`[Orchestration] Worker "${w.name}": shareCookies not specified, defaulting to true (shared context for faster init)`);
+                }
+                return {
+                    workerId: `worker-${w.name}`,
+                    workerName: w.name,
+                    url: w.url,
+                    task: w.task,
+                    successCriteria: w.successCriteria || 'Task completed successfully',
+                    shareCookies: w.shareCookies ?? true, // Default to shared cookies for faster context creation
+                };
+            }),
+            parallel: true,
+            maxRetries: 3,
+            timeout: workerTimeoutMs || 60000,
+            maxStaleIterations: maxStaleIterations || 5,
+            globalTimeoutMs: globalTimeoutMs || 300000,
+        };
+        // Initialize workflow
+        const result = await engine.initWorkflow(sessionId, workflow);
+        // Generate tool manifest for worker agents (Shared Tool Registry)
+        // Workers receive pre-loaded tool schemas so they can skip ToolSearch calls
+        let manifestTools;
+        try {
+            const mcpServer = (0, mcp_server_1.getMCPServer)();
+            const manifest = mcpServer.getToolManifest();
+            const workerToolConfig = { workerType: 'extraction' };
+            manifestTools = (0, tool_manifest_1.filterToolsForWorker)(manifest, workerToolConfig);
+            console.error(`[Orchestration] Tool manifest generated: ${manifestTools.length} tools for extraction workers (v${manifest.version})`);
+        }
+        catch (err) {
+            console.error(`[Orchestration] Tool manifest generation failed (non-fatal, using fallback): ${err instanceof Error ? err.message : String(err)}`);
+            manifestTools = undefined;
+        }
+        // Generate worker prompts for reference
+        const workerPrompts = result.workers.map((w, i) => ({
+            workerName: w.workerName,
+            tabId: w.tabId,
+            prompt: engine.generateWorkerPrompt(w.workerId, w.workerName, w.tabId, workflow.steps[i].task, workflow.steps[i].successCriteria, manifestTools, workflow.steps[i].url),
+        }));
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: JSON.stringify({
+                        orchestrationId: result.orchestrationId,
+                        status: 'INITIALIZED',
+                        workers: result.workers.map((w, i) => ({
+                            workerId: w.workerId,
+                            workerName: w.workerName,
+                            tabId: w.tabId,
+                            task: workflow.steps[i].task,
+                        })),
+                        scratchpadDir: '.agent/chrome-sisyphus',
+                        message: `Workflow initialized with ${result.workers.length} workers. Launch Background Tasks for each worker using the Task tool with run_in_background: true.`,
+                        workerPrompts,
+                    }, null, 2),
+                },
+            ],
+        };
+    }
+    catch (error) {
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `Error initializing workflow: ${error instanceof Error ? error.message : String(error)}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+};
+// ============================================
+// workflow_status - Get workflow status
+// ============================================
+const workflowStatusDefinition = {
+    name: 'workflow_status',
+    description: `Get the current status of a Chrome-Sisyphus workflow.
+Returns orchestration state and all worker states.`,
+    inputSchema: {
+        type: 'object',
+        properties: {
+            includeWorkerDetails: {
+                type: 'boolean',
+                description: 'Include full worker scratchpad details (default: false)',
+            },
+        },
+        required: [],
+    },
+};
+const workflowStatusHandler = async (_sessionId, args) => {
+    const engine = (0, workflow_engine_1.getWorkflowEngine)();
+    const includeWorkerDetails = args.includeWorkerDetails ?? false;
+    try {
+        const orch = await engine.getOrchestrationStatus();
+        if (!orch) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify({ status: 'NO_WORKFLOW', message: 'No active workflow found' }),
+                    },
+                ],
+            };
+        }
+        const result = {
+            orchestrationId: orch.orchestrationId,
+            status: orch.status,
+            task: orch.task,
+            workers: orch.workers,
+            completedWorkers: orch.completedWorkers,
+            failedWorkers: orch.failedWorkers,
+            duration: Date.now() - orch.createdAt,
+        };
+        if (includeWorkerDetails) {
+            const workerStates = await engine.getAllWorkerStates();
+            result.workerDetails = workerStates.map(w => ({
+                workerName: w.workerName,
+                status: w.status,
+                iteration: w.iteration,
+                progressLog: w.progressLog,
+                extractedData: w.extractedData,
+                errors: w.errors,
+            }));
+        }
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: JSON.stringify(result, null, 2),
+                },
+            ],
+        };
+    }
+    catch (error) {
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `Error getting workflow status: ${error instanceof Error ? error.message : String(error)}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+};
+// ============================================
+// workflow_collect - Collect workflow results
+// ============================================
+const workflowCollectDefinition = {
+    name: 'workflow_collect',
+    description: `Collect and aggregate results from all workers in the workflow.
+Use this after all worker Background Tasks have completed.`,
+    inputSchema: {
+        type: 'object',
+        properties: {},
+        required: [],
+    },
+};
+const workflowCollectHandler = async (_sessionId, _args) => {
+    const engine = (0, workflow_engine_1.getWorkflowEngine)();
+    try {
+        const results = await engine.collectResults();
+        if (!results) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify({ status: 'NO_RESULTS', message: 'No workflow results found' }),
+                    },
+                ],
+            };
+        }
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: JSON.stringify(results, null, 2),
+                },
+            ],
+        };
+    }
+    catch (error) {
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `Error collecting results: ${error instanceof Error ? error.message : String(error)}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+};
+// ============================================
+// workflow_cleanup - Cleanup workflow resources
+// ============================================
+const workflowCleanupDefinition = {
+    name: 'workflow_cleanup',
+    description: `Clean up workflow resources including workers, tabs, and scratchpad files.
+Use this after workflow completion or to abort a workflow.`,
+    inputSchema: {
+        type: 'object',
+        properties: {},
+        required: [],
+    },
+};
+const workflowCleanupHandler = async (sessionId, _args) => {
+    const engine = (0, workflow_engine_1.getWorkflowEngine)();
+    try {
+        await engine.cleanupWorkflow(sessionId);
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: JSON.stringify({
+                        status: 'CLEANED',
+                        message: 'Workflow resources cleaned up successfully',
+                    }),
+                },
+            ],
+        };
+    }
+    catch (error) {
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `Error cleaning up workflow: ${error instanceof Error ? error.message : String(error)}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+};
+// ============================================
+// worker_update - Update worker progress
+// ============================================
+const workerUpdateDefinition = {
+    name: 'worker_update',
+    description: `Update a worker's progress in the orchestration scratchpad.
+Call this from worker agents to report progress.`,
+    inputSchema: {
+        type: 'object',
+        properties: {
+            workerName: {
+                type: 'string',
+                description: 'Name of the worker',
+            },
+            status: {
+                type: 'string',
+                enum: ['INIT', 'IN_PROGRESS', 'SUCCESS', 'PARTIAL', 'FAIL'],
+                description: 'Worker status',
+            },
+            iteration: {
+                type: 'number',
+                description: 'Current iteration number',
+            },
+            action: {
+                type: 'string',
+                description: 'Action being performed',
+            },
+            result: {
+                type: 'string',
+                enum: ['SUCCESS', 'FAIL', 'IN_PROGRESS'],
+                description: 'Result of the action',
+            },
+            extractedData: {
+                type: 'object',
+                description: 'Data extracted so far',
+            },
+            error: {
+                type: 'string',
+                description: 'Error message if any',
+            },
+        },
+        required: ['workerName'],
+    },
+};
+const workerUpdateHandler = async (_sessionId, args) => {
+    const engine = (0, workflow_engine_1.getWorkflowEngine)();
+    const workerName = args.workerName;
+    try {
+        await engine.updateWorkerProgress(workerName, {
+            status: args.status,
+            iteration: args.iteration,
+            action: args.action,
+            result: args.result,
+            extractedData: args.extractedData,
+            error: args.error,
+        });
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: JSON.stringify({
+                        status: 'UPDATED',
+                        workerName,
+                        message: `Worker ${workerName} progress updated`,
+                    }),
+                },
+            ],
+        };
+    }
+    catch (error) {
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `Error updating worker: ${error instanceof Error ? error.message : String(error)}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+};
+// ============================================
+// worker_complete - Mark worker as complete
+// ============================================
+const workerCompleteDefinition = {
+    name: 'worker_complete',
+    description: `Mark a worker as complete with final results.
+Call this from worker agents when task is done.`,
+    inputSchema: {
+        type: 'object',
+        properties: {
+            workerName: {
+                type: 'string',
+                description: 'Name of the worker',
+            },
+            status: {
+                type: 'string',
+                enum: ['SUCCESS', 'PARTIAL', 'FAIL'],
+                description: 'Final status',
+            },
+            resultSummary: {
+                type: 'string',
+                description: 'Brief summary of results (max 100 chars)',
+            },
+            extractedData: {
+                type: 'object',
+                description: 'Final extracted data',
+            },
+        },
+        required: ['workerName', 'status', 'resultSummary'],
+    },
+};
+const workerCompleteHandler = async (_sessionId, args) => {
+    const engine = (0, workflow_engine_1.getWorkflowEngine)();
+    const workerName = args.workerName;
+    const status = args.status;
+    const resultSummary = args.resultSummary;
+    const extractedData = args.extractedData;
+    try {
+        await engine.completeWorker(workerName, status, resultSummary, extractedData);
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: JSON.stringify({
+                        status: 'COMPLETED',
+                        workerName,
+                        workerStatus: status,
+                        message: `Worker ${workerName} marked as ${status}`,
+                    }),
+                },
+            ],
+        };
+    }
+    catch (error) {
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `Error completing worker: ${error instanceof Error ? error.message : String(error)}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+};
+// ============================================
+// workflow_collect_partial - Collect completed results without waiting
+// ============================================
+const workflowCollectPartialDefinition = {
+    name: 'workflow_collect_partial',
+    description: `Collect results from completed workers without waiting for all workers to finish.
+Returns only workers that have already reported SUCCESS, PARTIAL, or FAIL status.
+Use this to stream results as they become available instead of waiting for the slowest worker.`,
+    inputSchema: {
+        type: 'object',
+        properties: {
+            onlySuccessful: {
+                type: 'boolean',
+                description: 'If true, only return workers with SUCCESS or PARTIAL status (default: false)',
+            },
+        },
+        required: [],
+    },
+};
+const workflowCollectPartialHandler = async (_sessionId, args) => {
+    const engine = (0, workflow_engine_1.getWorkflowEngine)();
+    const onlySuccessful = args.onlySuccessful ?? false;
+    try {
+        const orch = await engine.getOrchestrationStatus();
+        if (!orch) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify({ status: 'NO_WORKFLOW', message: 'No active workflow found' }),
+                    },
+                ],
+            };
+        }
+        // Get all worker states
+        const workerStates = await engine.getAllWorkerStates();
+        // Filter to completed workers only
+        const completedStatuses = onlySuccessful
+            ? ['SUCCESS', 'PARTIAL']
+            : ['SUCCESS', 'PARTIAL', 'FAIL'];
+        const completedWorkers = workerStates.filter(w => completedStatuses.includes(w.status));
+        const pendingWorkers = workerStates.filter(w => !['SUCCESS', 'PARTIAL', 'FAIL'].includes(w.status));
+        const results = {
+            orchestrationId: orch.orchestrationId,
+            overallStatus: orch.status,
+            progress: {
+                total: orch.workers.length,
+                completed: orch.completedWorkers,
+                failed: orch.failedWorkers,
+                pending: orch.workers.length - orch.completedWorkers - orch.failedWorkers,
+            },
+            completedWorkers: completedWorkers.map(w => ({
+                workerName: w.workerName,
+                status: w.status,
+                extractedData: w.extractedData,
+                iterations: w.iteration,
+                errors: w.errors,
+            })),
+            pendingWorkerNames: pendingWorkers.map(w => w.workerName),
+            duration: Date.now() - orch.createdAt,
+        };
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: JSON.stringify(results, null, 2),
+                },
+            ],
+        };
+    }
+    catch (error) {
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `Error collecting partial results: ${error instanceof Error ? error.message : String(error)}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+};
+// ============================================
+// execute_plan - Execute a cached compiled plan
+// ============================================
+const executePlanDefinition = {
+    name: 'execute_plan',
+    description: `Execute a cached compiled plan by ID, bypassing per-step agent LLM round-trips.
+The plan's tool calls are chained internally on the server side.
+Use this for repeated task patterns (e.g., tweet extraction) where the tool sequence is known.
+Falls back gracefully — returns an error result if the plan fails, allowing the agent to retry manually.`,
+    inputSchema: {
+        type: 'object',
+        properties: {
+            planId: {
+                type: 'string',
+                description: 'ID of the compiled plan to execute (e.g., "x-tweet-extraction-v1")',
+            },
+            tabId: {
+                type: 'string',
+                description: 'Tab ID to execute the plan against',
+            },
+            params: {
+                type: 'object',
+                description: 'Additional runtime parameters to pass to the plan (merged with plan defaults)',
+            },
+        },
+        required: ['planId', 'tabId'],
+    },
+};
+const executePlanHandler = async (sessionId, args) => {
+    const planId = args.planId;
+    const tabId = args.tabId;
+    const runtimeParams = args.params || {};
+    if (!planId || !tabId) {
+        return {
+            content: [{ type: 'text', text: 'Error: planId and tabId are required' }],
+            isError: true,
+        };
+    }
+    try {
+        const registry = (0, plan_registry_1.getPlanRegistry)();
+        const entry = registry.getEntry(planId);
+        if (!entry) {
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({
+                            status: 'PLAN_NOT_FOUND',
+                            planId,
+                            availablePlans: registry.getEntries().map(e => e.id),
+                            message: `No plan found with ID "${planId}". Use workflow_init for manual execution.`,
+                        }),
+                    }],
+                isError: true,
+            };
+        }
+        // Check confidence threshold
+        if (entry.confidence < entry.minConfidenceToUse) {
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({
+                            status: 'LOW_CONFIDENCE',
+                            planId,
+                            confidence: entry.confidence,
+                            threshold: entry.minConfidenceToUse,
+                            message: `Plan confidence (${entry.confidence.toFixed(2)}) is below threshold (${entry.minConfidenceToUse}). Use manual execution.`,
+                        }),
+                    }],
+                isError: true,
+            };
+        }
+        const plan = registry.loadPlan(entry);
+        if (!plan) {
+            return {
+                content: [{
+                        type: 'text',
+                        text: JSON.stringify({
+                            status: 'PLAN_LOAD_FAILED',
+                            planId,
+                            message: `Failed to load plan file for "${planId}".`,
+                        }),
+                    }],
+                isError: true,
+            };
+        }
+        // Create executor with MCPServer's tool resolver
+        const mcpServer = (0, mcp_server_1.getMCPServer)();
+        const executor = new plan_executor_1.PlanExecutor((toolName) => mcpServer.getToolHandler(toolName));
+        // Execute the plan
+        const mergedParams = { tabId, ...runtimeParams };
+        const result = await executor.execute(plan, sessionId, mergedParams);
+        // Update stats
+        registry.updateStats(planId, result.success, result.durationMs);
+        return {
+            content: [{
+                    type: 'text',
+                    text: JSON.stringify({
+                        status: result.success ? 'SUCCESS' : 'FAILED',
+                        planId: result.planId,
+                        stepsExecuted: result.stepsExecuted,
+                        totalSteps: result.totalSteps,
+                        durationMs: result.durationMs,
+                        data: result.data,
+                        error: result.error,
+                        message: result.success
+                            ? `Plan "${planId}" executed successfully in ${result.durationMs}ms (${result.stepsExecuted}/${result.totalSteps} steps)`
+                            : `Plan "${planId}" failed: ${result.error}. Consider manual execution.`,
+                    }, null, 2),
+                }],
+            isError: !result.success,
+        };
+    }
+    catch (error) {
+        return {
+            content: [{
+                    type: 'text',
+                    text: `Error executing plan "${planId}": ${error instanceof Error ? error.message : String(error)}`,
+                }],
+            isError: true,
+        };
+    }
+};
+// ============================================
+// Register all orchestration tools
+// ============================================
+function registerOrchestrationTools(server) {
+    server.registerTool('workflow_init', workflowInitHandler, workflowInitDefinition);
+    server.registerTool('workflow_status', workflowStatusHandler, workflowStatusDefinition);
+    server.registerTool('workflow_collect', workflowCollectHandler, workflowCollectDefinition);
+    server.registerTool('workflow_collect_partial', workflowCollectPartialHandler, workflowCollectPartialDefinition);
+    server.registerTool('workflow_cleanup', workflowCleanupHandler, workflowCleanupDefinition);
+    server.registerTool('worker_update', workerUpdateHandler, workerUpdateDefinition);
+    server.registerTool('worker_complete', workerCompleteHandler, workerCompleteDefinition);
+    server.registerTool('execute_plan', executePlanHandler, executePlanDefinition);
+    console.error('[Orchestration] Registered 8 orchestration tools (including execute_plan)');
+}
+//# sourceMappingURL=orchestration.js.map