@raspect/workflow-sdk 0.1.0

package/dist/worker.js

@@ -0,0 +1,615 @@
+"use strict";
+// Worker - Node.js implementation for executing workflows and activities
+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.Worker = void 0;
+const kafkajs_1 = require("kafkajs");
+const aws_msk_iam_sasl_signer_js_1 = require("aws-msk-iam-sasl-signer-js");
+const os = __importStar(require("os"));
+const workflow_1 = require("./workflow");
+const activity_1 = require("./activity");
+/**
+ * Worker that executes workflows and activities.
+ *
+ * Usage:
+ *   import { Worker, workflow, activity } from '@inspectica/workflow-sdk';
+ *
+ *   const sayHello = activity.defn(async (input: { name: string }) => {
+ *     return { message: `Hello, ${input.name}!` };
+ *   });
+ *
+ *   @workflow.defn
+ *   class HelloWorldWorkflow {
+ *     @workflow.run
+ *     async run(input: { name: string }) {
+ *       return await workflow.executeActivity(sayHello, input);
+ *     }
+ *   }
+ *
+ *   const worker = new Worker({
+ *     serverUrl: 'https://workflow.example.com',
+ *     apiKey: 'wk_abc123...',
+ *   });
+ *   worker.register({ workflows: [HelloWorldWorkflow], activities: [sayHello] });
+ *   await worker.run();
+ */
+class Worker {
+    config;
+    workflows = new Map();
+    activities = new Map();
+    workerId = null;
+    instanceId = null;
+    running = false;
+    kafka = null;
+    consumer = null;
+    producer = null;
+    heartbeatInterval = null;
+    heartbeatIntervalMs = 30000;
+    resultTopic = null;
+    maxConcurrentWorkflows;
+    activeWorkflows = 0;
+    constructor(config) {
+        this.config = {
+            ...config,
+            serverUrl: config.serverUrl.replace(/\/$/, ''),
+        };
+        this.maxConcurrentWorkflows = config.maxConcurrentWorkflows || 10;
+    }
+    /**
+     * Register workflows and activities.
+     */
+    register(options) {
+        for (const wfCls of options.workflows || []) {
+            const wfName = (0, workflow_1.getWorkflowName)(wfCls);
+            this.workflows.set(wfName, wfCls);
+            console.log(`Registered workflow: ${wfName}`);
+        }
+        for (const activityFn of options.activities || []) {
+            const activityName = (0, activity_1.getActivityName)(activityFn);
+            this.activities.set(activityName, activityFn);
+            console.log(`Registered activity: ${activityName}`);
+        }
+    }
+    /**
+     * Start the worker (blocking).
+     */
+    async run() {
+        this.running = true;
+        // Setup signal handlers
+        process.on('SIGINT', () => this.stop());
+        process.on('SIGTERM', () => this.stop());
+        // Connect to server and get Kafka config
+        const serverKafkaConfig = await this.connectToServer();
+        const workerTopic = serverKafkaConfig.worker_topic;
+        const resultTopic = serverKafkaConfig.result_topic;
+        this.resultTopic = resultTopic;
+        // Create Kafka client
+        this.kafka = this.createKafkaClient(serverKafkaConfig);
+        // Create consumer
+        const consumerGroupId = this.config.groupId || `workflow-worker-${this.workerId}`;
+        this.consumer = this.kafka.consumer({ groupId: consumerGroupId });
+        // Create producer
+        this.producer = this.kafka.producer();
+        try {
+            await this.consumer.connect();
+            await this.producer.connect();
+            await this.consumer.subscribe({ topic: workerTopic, fromBeginning: false });
+            console.log(`Worker ${this.workerId} started, consuming from ${workerTopic}`);
+            console.log(`Max concurrent workflows: ${this.maxConcurrentWorkflows}`);
+            console.log(`Registered workflows: ${Array.from(this.workflows.keys()).join(', ')}`);
+            console.log(`Registered activities: ${Array.from(this.activities.keys()).join(', ')}`);
+            // Start heartbeat
+            this.startHeartbeat();
+            // Start consuming messages
+            await this.consumer.run({
+                eachMessage: async ({ message }) => {
+                    if (!this.running)
+                        return;
+                    try {
+                        const data = JSON.parse(message.value?.toString() || '{}');
+                        await this.processMessage(data, resultTopic);
+                    }
+                    catch (error) {
+                        console.error('Error processing message:', error);
+                    }
+                },
+            });
+            // Keep running until stopped
+            await new Promise((resolve) => {
+                const checkInterval = setInterval(() => {
+                    if (!this.running) {
+                        clearInterval(checkInterval);
+                        resolve();
+                    }
+                }, 100);
+            });
+        }
+        finally {
+            await this.cleanup();
+        }
+    }
+    /**
+     * Stop the worker gracefully.
+     */
+    async stop() {
+        console.log('Stopping worker...');
+        this.running = false;
+    }
+    async connectToServer() {
+        const hostname = os.hostname();
+        const connectPayload = {
+            workflows: Array.from(this.workflows.keys()),
+            activities: Array.from(this.activities.keys()),
+            hostname,
+        };
+        const response = await fetch(`${this.config.serverUrl}/workflow/api/v1/workers/connect`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'Authorization': `Bearer ${this.config.apiKey}`,
+            },
+            body: JSON.stringify(connectPayload),
+        });
+        if (!response.ok) {
+            const error = await response.text();
+            throw new Error(`Failed to connect to server: ${response.status} - ${error}`);
+        }
+        const data = await response.json();
+        this.workerId = data.worker_id;
+        this.instanceId = data.instance_id;
+        this.heartbeatIntervalMs = data.heartbeat_interval_ms || 30000;
+        console.log(`Connected to server as worker_id=${this.workerId}, instance_id=${this.instanceId}`);
+        return data.kafka;
+    }
+    createKafkaClient(kafkaConfig) {
+        const auth = kafkaConfig.auth;
+        // Server returns brokers as comma-separated string, convert to array
+        const brokers = typeof kafkaConfig.brokers === 'string'
+            ? kafkaConfig.brokers.split(',').map(b => b.trim()).filter(b => b)
+            : kafkaConfig.brokers;
+        const config = {
+            clientId: `workflow-worker-${this.workerId}`,
+            brokers,
+            logLevel: kafkajs_1.logLevel.WARN,
+        };
+        if (auth?.type === 'msk_iam') {
+            config.ssl = true;
+            config.sasl = {
+                mechanism: 'oauthbearer',
+                oauthBearerProvider: async () => {
+                    const token = await (0, aws_msk_iam_sasl_signer_js_1.generateAuthTokenFromCredentialsProvider)({
+                        region: auth.region,
+                        awsCredentialsProvider: async () => ({
+                            accessKeyId: auth.access_key_id,
+                            secretAccessKey: auth.secret_access_key,
+                        }),
+                    });
+                    return { value: token.token };
+                },
+            };
+        }
+        else if (auth?.type === 'sasl') {
+            if (auth.security_protocol?.includes('SSL')) {
+                config.ssl = true;
+            }
+            if (auth.sasl_mechanism && auth.sasl_username && auth.sasl_password) {
+                config.sasl = {
+                    mechanism: auth.sasl_mechanism.toLowerCase().replace('-', ''),
+                    username: auth.sasl_username,
+                    password: auth.sasl_password,
+                };
+            }
+        }
+        return new kafkajs_1.Kafka(config);
+    }
+    startHeartbeat() {
+        this.heartbeatInterval = setInterval(async () => {
+            if (!this.running)
+                return;
+            try {
+                const response = await fetch(`${this.config.serverUrl}/workflow/api/v1/workers/heartbeat`, {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json',
+                        'Authorization': `Bearer ${this.config.apiKey}`,
+                    },
+                    body: JSON.stringify({ instance_id: this.instanceId }),
+                });
+                if (!response.ok) {
+                    console.warn(`Heartbeat failed: ${response.status}`);
+                }
+            }
+            catch (error) {
+                console.warn('Heartbeat error:', error);
+            }
+        }, this.heartbeatIntervalMs);
+    }
+    async disconnectFromServer() {
+        if (!this.instanceId)
+            return;
+        try {
+            const response = await fetch(`${this.config.serverUrl}/workflow/api/v1/workers/disconnect`, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'Authorization': `Bearer ${this.config.apiKey}`,
+                },
+                body: JSON.stringify({ instance_id: this.instanceId }),
+            });
+            if (response.ok) {
+                console.log('Disconnected from server');
+            }
+        }
+        catch (error) {
+            console.warn('Failed to disconnect from server:', error);
+        }
+    }
+    async processMessage(data, resultTopic) {
+        // Check if this is an activity result (response from another worker via server)
+        if (data.status && data.completed_at && !data.task_type) {
+            console.debug('Received activity result on worker topic (ignored - using polling)');
+            return;
+        }
+        const taskType = data.task_type || 'activity';
+        if (taskType === 'workflow') {
+            // Process workflow in background (don't block message loop)
+            this.processWorkflowTask(data, resultTopic).catch((error) => {
+                console.error('Error processing workflow task:', error);
+            });
+        }
+        else {
+            // Activity tasks can be processed inline
+            await this.processActivityTask(data, resultTopic);
+        }
+    }
+    async processWorkflowTask(data, resultTopic) {
+        // Check concurrency limit
+        while (this.activeWorkflows >= this.maxConcurrentWorkflows) {
+            await new Promise((resolve) => setTimeout(resolve, 100));
+        }
+        this.activeWorkflows++;
+        try {
+            await this.executeWorkflow(data, resultTopic);
+        }
+        finally {
+            this.activeWorkflows--;
+        }
+    }
+    async executeWorkflow(task, resultTopic) {
+        console.log(`Received workflow task ${task.task_id}: ${task.workflow_name}`);
+        // Find the workflow class
+        const workflowCls = this.workflows.get(task.workflow_name);
+        if (!workflowCls) {
+            console.warn(`Unknown workflow: ${task.workflow_name}`);
+            await this.sendWorkflowResult(task, resultTopic, 'failed', undefined, {
+                type: 'UnknownWorkflow',
+                message: `Workflow '${task.workflow_name}' not registered`,
+            });
+            return;
+        }
+        // Find the run method
+        const runMethod = (0, workflow_1.findRunMethod)(workflowCls);
+        if (!runMethod) {
+            await this.sendWorkflowResult(task, resultTopic, 'failed', undefined, {
+                type: 'NoRunMethod',
+                message: `Workflow '${task.workflow_name}' has no run method`,
+            });
+            return;
+        }
+        // Execute the workflow
+        const startedAt = new Date();
+        try {
+            // Build completed activities map for replay
+            const completedActivitiesMap = new Map();
+            if (task.completed_activities) {
+                for (const ca of task.completed_activities) {
+                    completedActivitiesMap.set(ca.index, ca.output);
+                }
+                console.log(`Resuming workflow ${task.workflow_id} with ${completedActivitiesMap.size} completed activities`);
+            }
+            // Create workflow context
+            const ctx = new workflow_1.WorkflowContext(this.activities, task.workflow_id, this, completedActivitiesMap.size > 0 ? completedActivitiesMap : null, task.metadata);
+            // Execute within context
+            const output = await (0, workflow_1.runWithContext)(ctx, async () => {
+                return await Promise.race([
+                    runMethod(task.input),
+                    new Promise((_, reject) => setTimeout(() => reject(new Error(`Workflow timed out after ${task.timeout_ms}ms`)), task.timeout_ms)),
+                ]);
+            });
+            const completedAt = new Date();
+            const durationMs = completedAt.getTime() - startedAt.getTime();
+            console.log(`Workflow ${task.task_id} completed in ${durationMs}ms`);
+            await this.sendWorkflowResult(task, resultTopic, 'completed', output, undefined, startedAt, completedAt, durationMs);
+        }
+        catch (error) {
+            const completedAt = new Date();
+            const durationMs = completedAt.getTime() - startedAt.getTime();
+            const err = error;
+            console.error(`Workflow ${task.task_id} failed:`, err.message);
+            await this.sendWorkflowResult(task, resultTopic, 'failed', undefined, {
+                type: err.name || 'Error',
+                message: err.message,
+                stack_trace: err.stack,
+            }, startedAt, completedAt, durationMs);
+        }
+    }
+    async processActivityTask(data, resultTopic) {
+        const task = data;
+        console.log(`Received activity task ${task.task_id}: ${task.activity_name} (workflow=${task.workflow_id})`);
+        // Find the activity handler
+        const activityFn = this.activities.get(task.activity_name);
+        if (!activityFn) {
+            console.warn(`Unknown activity: ${task.activity_name}`);
+            await this.sendActivityResult(task, resultTopic, 'failed', undefined, {
+                type: 'UnknownActivity',
+                message: `Activity '${task.activity_name}' not registered`,
+            });
+            return;
+        }
+        // Execute the activity
+        const startedAt = new Date();
+        try {
+            const output = await Promise.race([
+                Promise.resolve(activityFn(task.input)),
+                new Promise((_, reject) => setTimeout(() => reject(new Error(`Activity timed out after ${task.timeout_ms}ms`)), task.timeout_ms)),
+            ]);
+            const completedAt = new Date();
+            const durationMs = completedAt.getTime() - startedAt.getTime();
+            console.log(`Activity ${task.task_id} completed in ${durationMs}ms`);
+            await this.sendActivityResult(task, resultTopic, 'completed', output, undefined, startedAt, completedAt, durationMs);
+        }
+        catch (error) {
+            const completedAt = new Date();
+            const durationMs = completedAt.getTime() - startedAt.getTime();
+            const err = error;
+            console.error(`Activity ${task.task_id} failed:`, err.message);
+            await this.sendActivityResult(task, resultTopic, 'failed', undefined, {
+                type: err.name || 'Error',
+                message: err.message,
+                stack_trace: err.stack,
+            }, startedAt, completedAt, durationMs);
+        }
+    }
+    async sendWorkflowResult(task, resultTopic, status, output, error, startedAt, completedAt, durationMs = 0) {
+        const now = new Date();
+        const result = {
+            task_id: task.task_id,
+            workflow_id: task.workflow_id,
+            workflow_name: task.workflow_name,
+            status,
+            output,
+            error,
+            started_at: (startedAt || now).toISOString(),
+            completed_at: (completedAt || now).toISOString(),
+            duration_ms: durationMs,
+            worker_id: this.workerId,
+        };
+        if (this.producer) {
+            await this.producer.send({
+                topic: resultTopic,
+                messages: [
+                    {
+                        key: task.workflow_id,
+                        value: JSON.stringify(result),
+                    },
+                ],
+            });
+            console.debug(`Sent workflow result for task ${task.task_id}`);
+        }
+    }
+    async sendActivityResult(task, resultTopic, status, output, error, startedAt, completedAt, durationMs = 0) {
+        const now = new Date();
+        const result = {
+            task_id: task.task_id,
+            workflow_id: task.workflow_id,
+            activity_name: task.activity_name,
+            activity_index: task.activity_index,
+            fan_out_index: task.fan_out_index,
+            status,
+            output,
+            error,
+            started_at: (startedAt || now).toISOString(),
+            completed_at: (completedAt || now).toISOString(),
+            duration_ms: durationMs,
+            worker_id: this.workerId,
+            requester_worker_id: task.requester_worker_id,
+            correlation_id: task.correlation_id,
+        };
+        if (this.producer) {
+            await this.producer.send({
+                topic: resultTopic,
+                messages: [
+                    {
+                        key: task.workflow_id,
+                        value: JSON.stringify(result),
+                    },
+                ],
+            });
+            console.debug(`Sent activity result for task ${task.task_id}`);
+        }
+    }
+    // WorkerInterface implementation for WorkflowContext
+    async reportLocalActivityCompletion(workflowId, activityName, activityIndex, output, durationMs) {
+        if (!this.producer || !this.resultTopic) {
+            console.debug('Cannot report local activity - producer not initialized');
+            return;
+        }
+        const completedAt = new Date();
+        const startedAt = new Date(completedAt.getTime() - durationMs);
+        const result = {
+            task_id: `local-${workflowId}-${activityIndex}`,
+            workflow_id: workflowId,
+            activity_name: activityName,
+            activity_index: activityIndex,
+            status: 'completed',
+            output,
+            started_at: startedAt.toISOString(),
+            completed_at: completedAt.toISOString(),
+            duration_ms: durationMs,
+            worker_id: this.workerId,
+        };
+        try {
+            await this.producer.send({
+                topic: this.resultTopic,
+                messages: [{ key: workflowId, value: JSON.stringify(result) }],
+            });
+            console.debug(`Reported local activity completion: workflow_id=${workflowId}, activity=${activityName}, index=${activityIndex}`);
+        }
+        catch (error) {
+            console.warn('Failed to report local activity completion:', error);
+        }
+    }
+    async reportLocalActivityFailure(workflowId, activityName, activityIndex, error, errorType, durationMs) {
+        if (!this.producer || !this.resultTopic) {
+            console.debug('Cannot report local activity failure - producer not initialized');
+            return;
+        }
+        const completedAt = new Date();
+        const startedAt = new Date(completedAt.getTime() - durationMs);
+        const result = {
+            task_id: `local-${workflowId}-${activityIndex}`,
+            workflow_id: workflowId,
+            activity_name: activityName,
+            activity_index: activityIndex,
+            status: 'failed',
+            output: null,
+            error: { type: errorType, message: error },
+            started_at: startedAt.toISOString(),
+            completed_at: completedAt.toISOString(),
+            duration_ms: durationMs,
+            worker_id: this.workerId,
+        };
+        try {
+            await this.producer.send({
+                topic: this.resultTopic,
+                messages: [{ key: workflowId, value: JSON.stringify(result) }],
+            });
+            console.debug(`Reported local activity failure: workflow_id=${workflowId}, activity=${activityName}, index=${activityIndex}`);
+        }
+        catch (error) {
+            console.warn('Failed to report local activity failure:', error);
+        }
+    }
+    async executeRemoteActivity(workflowId, activityName, activityIndex, inputData, timeoutMs) {
+        if (!this.producer || !this.resultTopic) {
+            throw new Error('Kafka producer not initialized');
+        }
+        // Send ActivityRequest to server via Kafka
+        const requestPayload = {
+            request_type: 'activity_request',
+            request_id: crypto.randomUUID(),
+            workflow_id: workflowId,
+            activity_name: activityName,
+            activity_index: activityIndex,
+            input: inputData,
+            timeout_ms: timeoutMs,
+            requester_worker_id: this.workerId,
+            correlation_id: crypto.randomUUID(),
+            created_at: new Date().toISOString(),
+        };
+        await this.producer.send({
+            topic: this.resultTopic,
+            messages: [{ key: workflowId, value: JSON.stringify(requestPayload) }],
+        });
+        console.log(`Activity request sent via Kafka: activity=${activityName}, workflow_id=${workflowId}, activity_index=${activityIndex}`);
+        // Poll server for result with exponential backoff
+        let pollInterval = 2000; // Start at 2 seconds
+        const maxPollInterval = 900000; // Max 15 minutes
+        const backoffMultiplier = 1.5;
+        const startTime = Date.now();
+        const timeoutSeconds = timeoutMs;
+        const pollUrl = `${this.config.serverUrl}/workflow/api/v1/workflows/${workflowId}/activities/${activityIndex}/result`;
+        const headers = { Authorization: `Bearer ${this.config.apiKey}` };
+        while (true) {
+            const elapsed = Date.now() - startTime;
+            if (elapsed >= timeoutSeconds) {
+                throw new Error(`Activity ${activityName} timed out after ${timeoutMs}ms`);
+            }
+            try {
+                const response = await fetch(pollUrl, { headers });
+                if (response.status === 200) {
+                    const result = await response.json();
+                    if (result.status === 'completed') {
+                        console.log(`Activity ${activityName} completed for workflow ${workflowId}`);
+                        return result.output;
+                    }
+                    else if (result.status === 'failed') {
+                        const errorMsg = result.error || 'Activity failed';
+                        console.error(`Activity ${activityName} failed: ${errorMsg}`);
+                        throw new Error(errorMsg);
+                    }
+                }
+                else if (response.status === 202) {
+                    // Still pending/running, continue polling
+                    console.debug(`Activity ${activityName} still running, polling again in ${pollInterval}ms`);
+                }
+                else if (response.status === 404) {
+                    // Activity not found yet
+                    console.debug(`Activity ${activityName} not found yet, polling again in ${pollInterval}ms`);
+                }
+                else {
+                    console.warn(`Unexpected response ${response.status} when polling activity result`);
+                }
+            }
+            catch (error) {
+                if (error.message.includes('timed out') || error.message.includes('failed')) {
+                    throw error;
+                }
+                console.warn('Error polling activity result:', error);
+            }
+            // Wait with exponential backoff
+            await new Promise((resolve) => setTimeout(resolve, pollInterval));
+            pollInterval = Math.min(pollInterval * backoffMultiplier, maxPollInterval);
+        }
+    }
+    async cleanup() {
+        // Stop heartbeat
+        if (this.heartbeatInterval) {
+            clearInterval(this.heartbeatInterval);
+        }
+        // Disconnect from server
+        await this.disconnectFromServer();
+        // Stop Kafka clients
+        if (this.consumer) {
+            await this.consumer.disconnect();
+        }
+        if (this.producer) {
+            await this.producer.disconnect();
+        }
+        console.log(`Worker ${this.workerId} stopped`);
+    }
+}
+exports.Worker = Worker;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"worker.js","sourceRoot":"","sources":["../src/worker.ts"],"names":[],"mappings":"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","sourcesContent":["// Worker - Node.js implementation for executing workflows and activities\n\nimport { Kafka, Consumer, Producer, SASLOptions, logLevel } from 'kafkajs';\nimport { generateAuthTokenFromCredentialsProvider } from 'aws-msk-iam-sasl-signer-js';\nimport * as os from 'os';\nimport type {\n  WorkerConfig,\n  ActivityHandler,\n  DecoratedActivity,\n  WorkflowClass,\n  WorkflowTask,\n  ActivityTask,\n  WorkflowResult,\n  ActivityResult,\n  WorkflowError,\n  ActivityError,\n  KafkaConfig,\n  ConnectResponse,\n} from './types';\nimport { WorkflowContext, runWithContext, getWorkflowName, findRunMethod, type WorkerInterface } from './workflow';\nimport { getActivityName } from './activity';\n\n/**\n * Worker that executes workflows and activities.\n * \n * Usage:\n *   import { Worker, workflow, activity } from '@inspectica/workflow-sdk';\n *   \n *   const sayHello = activity.defn(async (input: { name: string }) => {\n *     return { message: `Hello, ${input.name}!` };\n *   });\n *   \n *   @workflow.defn\n *   class HelloWorldWorkflow {\n *     @workflow.run\n *     async run(input: { name: string }) {\n *       return await workflow.executeActivity(sayHello, input);\n *     }\n *   }\n *   \n *   const worker = new Worker({\n *     serverUrl: 'https://workflow.example.com',\n *     apiKey: 'wk_abc123...',\n *   });\n *   worker.register({ workflows: [HelloWorldWorkflow], activities: [sayHello] });\n *   await worker.run();\n */\nexport class Worker implements WorkerInterface {\n  private config: WorkerConfig;\n  private workflows: Map<string, WorkflowClass> = new Map();\n  private activities: Map<string, ActivityHandler> = new Map();\n  \n  private workerId: string | null = null;\n  private instanceId: string | null = null;\n  private running = false;\n  private kafka: Kafka | null = null;\n  private consumer: Consumer | null = null;\n  private producer: Producer | null = null;\n  private heartbeatInterval: NodeJS.Timeout | null = null;\n  private heartbeatIntervalMs = 30000;\n  private resultTopic: string | null = null;\n  private maxConcurrentWorkflows: number;\n  private activeWorkflows = 0;\n\n  constructor(config: WorkerConfig) {\n    this.config = {\n      ...config,\n      serverUrl: config.serverUrl.replace(/\\/$/, ''),\n    };\n    this.maxConcurrentWorkflows = config.maxConcurrentWorkflows || 10;\n  }\n\n  /**\n   * Register workflows and activities.\n   */\n  register(options: {\n    workflows?: WorkflowClass[];\n    activities?: DecoratedActivity[];\n  }): void {\n    for (const wfCls of options.workflows || []) {\n      const wfName = getWorkflowName(wfCls);\n      this.workflows.set(wfName, wfCls);\n      console.log(`Registered workflow: ${wfName}`);\n    }\n\n    for (const activityFn of options.activities || []) {\n      const activityName = getActivityName(activityFn);\n      this.activities.set(activityName, activityFn);\n      console.log(`Registered activity: ${activityName}`);\n    }\n  }\n\n  /**\n   * Start the worker (blocking).\n   */\n  async run(): Promise<void> {\n    this.running = true;\n\n    // Setup signal handlers\n    process.on('SIGINT', () => this.stop());\n    process.on('SIGTERM', () => this.stop());\n\n    // Connect to server and get Kafka config\n    const serverKafkaConfig = await this.connectToServer();\n    const workerTopic = serverKafkaConfig.worker_topic;\n    const resultTopic = serverKafkaConfig.result_topic;\n    this.resultTopic = resultTopic;\n\n    // Create Kafka client\n    this.kafka = this.createKafkaClient(serverKafkaConfig);\n    \n    // Create consumer\n    const consumerGroupId = this.config.groupId || `workflow-worker-${this.workerId}`;\n    this.consumer = this.kafka.consumer({ groupId: consumerGroupId });\n    \n    // Create producer\n    this.producer = this.kafka.producer();\n\n    try {\n      await this.consumer.connect();\n      await this.producer.connect();\n      await this.consumer.subscribe({ topic: workerTopic, fromBeginning: false });\n\n      console.log(`Worker ${this.workerId} started, consuming from ${workerTopic}`);\n      console.log(`Max concurrent workflows: ${this.maxConcurrentWorkflows}`);\n      console.log(`Registered workflows: ${Array.from(this.workflows.keys()).join(', ')}`);\n      console.log(`Registered activities: ${Array.from(this.activities.keys()).join(', ')}`);\n\n      // Start heartbeat\n      this.startHeartbeat();\n\n      // Start consuming messages\n      await this.consumer.run({\n        eachMessage: async ({ message }) => {\n          if (!this.running) return;\n          \n          try {\n            const data = JSON.parse(message.value?.toString() || '{}');\n            await this.processMessage(data, resultTopic);\n          } catch (error) {\n            console.error('Error processing message:', error);\n          }\n        },\n      });\n\n      // Keep running until stopped\n      await new Promise<void>((resolve) => {\n        const checkInterval = setInterval(() => {\n          if (!this.running) {\n            clearInterval(checkInterval);\n            resolve();\n          }\n        }, 100);\n      });\n\n    } finally {\n      await this.cleanup();\n    }\n  }\n\n  /**\n   * Stop the worker gracefully.\n   */\n  async stop(): Promise<void> {\n    console.log('Stopping worker...');\n    this.running = false;\n  }\n\n  private async connectToServer(): Promise<KafkaConfig> {\n    const hostname = os.hostname();\n    \n    const connectPayload = {\n      workflows: Array.from(this.workflows.keys()),\n      activities: Array.from(this.activities.keys()),\n      hostname,\n    };\n\n    const response = await fetch(`${this.config.serverUrl}/workflow/api/v1/workers/connect`, {\n      method: 'POST',\n      headers: {\n        'Content-Type': 'application/json',\n        'Authorization': `Bearer ${this.config.apiKey}`,\n      },\n      body: JSON.stringify(connectPayload),\n    });\n\n    if (!response.ok) {\n      const error = await response.text();\n      throw new Error(`Failed to connect to server: ${response.status} - ${error}`);\n    }\n\n    const data = await response.json() as ConnectResponse;\n    \n    this.workerId = data.worker_id;\n    this.instanceId = data.instance_id;\n    this.heartbeatIntervalMs = data.heartbeat_interval_ms || 30000;\n\n    console.log(`Connected to server as worker_id=${this.workerId}, instance_id=${this.instanceId}`);\n\n    return data.kafka;\n  }\n\n  private createKafkaClient(kafkaConfig: KafkaConfig): Kafka {\n    const auth = kafkaConfig.auth;\n    \n    // Server returns brokers as comma-separated string, convert to array\n    const brokers = typeof kafkaConfig.brokers === 'string'\n      ? (kafkaConfig.brokers as string).split(',').map(b => b.trim()).filter(b => b)\n      : kafkaConfig.brokers;\n    \n    const config: any = {\n      clientId: `workflow-worker-${this.workerId}`,\n      brokers,\n      logLevel: logLevel.WARN,\n    };\n\n    if (auth?.type === 'msk_iam') {\n      config.ssl = true;\n      config.sasl = {\n        mechanism: 'oauthbearer',\n        oauthBearerProvider: async () => {\n          const token = await generateAuthTokenFromCredentialsProvider({\n            region: auth.region!,\n            awsCredentialsProvider: async () => ({\n              accessKeyId: auth.access_key_id!,\n              secretAccessKey: auth.secret_access_key!,\n            }),\n          });\n          return { value: token.token };\n        },\n      } as SASLOptions;\n    } else if (auth?.type === 'sasl') {\n      if (auth.security_protocol?.includes('SSL')) {\n        config.ssl = true;\n      }\n      if (auth.sasl_mechanism && auth.sasl_username && auth.sasl_password) {\n        config.sasl = {\n          mechanism: auth.sasl_mechanism.toLowerCase().replace('-', ''),\n          username: auth.sasl_username,\n          password: auth.sasl_password,\n        } as SASLOptions;\n      }\n    }\n\n    return new Kafka(config);\n  }\n\n  private startHeartbeat(): void {\n    this.heartbeatInterval = setInterval(async () => {\n      if (!this.running) return;\n      \n      try {\n        const response = await fetch(`${this.config.serverUrl}/workflow/api/v1/workers/heartbeat`, {\n          method: 'POST',\n          headers: {\n            'Content-Type': 'application/json',\n            'Authorization': `Bearer ${this.config.apiKey}`,\n          },\n          body: JSON.stringify({ instance_id: this.instanceId }),\n        });\n\n        if (!response.ok) {\n          console.warn(`Heartbeat failed: ${response.status}`);\n        }\n      } catch (error) {\n        console.warn('Heartbeat error:', error);\n      }\n    }, this.heartbeatIntervalMs);\n  }\n\n  private async disconnectFromServer(): Promise<void> {\n    if (!this.instanceId) return;\n\n    try {\n      const response = await fetch(`${this.config.serverUrl}/workflow/api/v1/workers/disconnect`, {\n        method: 'POST',\n        headers: {\n          'Content-Type': 'application/json',\n          'Authorization': `Bearer ${this.config.apiKey}`,\n        },\n        body: JSON.stringify({ instance_id: this.instanceId }),\n      });\n\n      if (response.ok) {\n        console.log('Disconnected from server');\n      }\n    } catch (error) {\n      console.warn('Failed to disconnect from server:', error);\n    }\n  }\n\n  private async processMessage(data: any, resultTopic: string): Promise<void> {\n    // Check if this is an activity result (response from another worker via server)\n    if (data.status && data.completed_at && !data.task_type) {\n      console.debug('Received activity result on worker topic (ignored - using polling)');\n      return;\n    }\n\n    const taskType = data.task_type || 'activity';\n\n    if (taskType === 'workflow') {\n      // Process workflow in background (don't block message loop)\n      this.processWorkflowTask(data, resultTopic).catch((error) => {\n        console.error('Error processing workflow task:', error);\n      });\n    } else {\n      // Activity tasks can be processed inline\n      await this.processActivityTask(data, resultTopic);\n    }\n  }\n\n  private async processWorkflowTask(data: WorkflowTask, resultTopic: string): Promise<void> {\n    // Check concurrency limit\n    while (this.activeWorkflows >= this.maxConcurrentWorkflows) {\n      await new Promise((resolve) => setTimeout(resolve, 100));\n    }\n    this.activeWorkflows++;\n\n    try {\n      await this.executeWorkflow(data, resultTopic);\n    } finally {\n      this.activeWorkflows--;\n    }\n  }\n\n  private async executeWorkflow(task: WorkflowTask, resultTopic: string): Promise<void> {\n    console.log(`Received workflow task ${task.task_id}: ${task.workflow_name}`);\n\n    // Find the workflow class\n    const workflowCls = this.workflows.get(task.workflow_name);\n    if (!workflowCls) {\n      console.warn(`Unknown workflow: ${task.workflow_name}`);\n      await this.sendWorkflowResult(task, resultTopic, 'failed', undefined, {\n        type: 'UnknownWorkflow',\n        message: `Workflow '${task.workflow_name}' not registered`,\n      });\n      return;\n    }\n\n    // Find the run method\n    const runMethod = findRunMethod(workflowCls);\n    if (!runMethod) {\n      await this.sendWorkflowResult(task, resultTopic, 'failed', undefined, {\n        type: 'NoRunMethod',\n        message: `Workflow '${task.workflow_name}' has no run method`,\n      });\n      return;\n    }\n\n    // Execute the workflow\n    const startedAt = new Date();\n    try {\n      // Build completed activities map for replay\n      const completedActivitiesMap = new Map<number, unknown>();\n      if (task.completed_activities) {\n        for (const ca of task.completed_activities) {\n          completedActivitiesMap.set(ca.index, ca.output);\n        }\n        console.log(\n          `Resuming workflow ${task.workflow_id} with ${completedActivitiesMap.size} completed activities`\n        );\n      }\n\n      // Create workflow context\n      const ctx = new WorkflowContext(\n        this.activities,\n        task.workflow_id,\n        this,\n        completedActivitiesMap.size > 0 ? completedActivitiesMap : null,\n        task.metadata\n      );\n\n      // Execute within context\n      const output = await runWithContext(ctx, async () => {\n        return await Promise.race([\n          runMethod(task.input),\n          new Promise<never>((_, reject) =>\n            setTimeout(\n              () => reject(new Error(`Workflow timed out after ${task.timeout_ms}ms`)),\n              task.timeout_ms\n            )\n          ),\n        ]);\n      });\n\n      const completedAt = new Date();\n      const durationMs = completedAt.getTime() - startedAt.getTime();\n\n      console.log(`Workflow ${task.task_id} completed in ${durationMs}ms`);\n\n      await this.sendWorkflowResult(\n        task,\n        resultTopic,\n        'completed',\n        output,\n        undefined,\n        startedAt,\n        completedAt,\n        durationMs\n      );\n    } catch (error) {\n      const completedAt = new Date();\n      const durationMs = completedAt.getTime() - startedAt.getTime();\n      const err = error as Error;\n\n      console.error(`Workflow ${task.task_id} failed:`, err.message);\n\n      await this.sendWorkflowResult(\n        task,\n        resultTopic,\n        'failed',\n        undefined,\n        {\n          type: err.name || 'Error',\n          message: err.message,\n          stack_trace: err.stack,\n        },\n        startedAt,\n        completedAt,\n        durationMs\n      );\n    }\n  }\n\n  private async processActivityTask(data: ActivityTask, resultTopic: string): Promise<void> {\n    const task = data;\n    console.log(\n      `Received activity task ${task.task_id}: ${task.activity_name} (workflow=${task.workflow_id})`\n    );\n\n    // Find the activity handler\n    const activityFn = this.activities.get(task.activity_name);\n    if (!activityFn) {\n      console.warn(`Unknown activity: ${task.activity_name}`);\n      await this.sendActivityResult(task, resultTopic, 'failed', undefined, {\n        type: 'UnknownActivity',\n        message: `Activity '${task.activity_name}' not registered`,\n      });\n      return;\n    }\n\n    // Execute the activity\n    const startedAt = new Date();\n    try {\n      const output = await Promise.race([\n        Promise.resolve(activityFn(task.input)),\n        new Promise<never>((_, reject) =>\n          setTimeout(\n            () => reject(new Error(`Activity timed out after ${task.timeout_ms}ms`)),\n            task.timeout_ms\n          )\n        ),\n      ]);\n\n      const completedAt = new Date();\n      const durationMs = completedAt.getTime() - startedAt.getTime();\n\n      console.log(`Activity ${task.task_id} completed in ${durationMs}ms`);\n\n      await this.sendActivityResult(\n        task,\n        resultTopic,\n        'completed',\n        output,\n        undefined,\n        startedAt,\n        completedAt,\n        durationMs\n      );\n    } catch (error) {\n      const completedAt = new Date();\n      const durationMs = completedAt.getTime() - startedAt.getTime();\n      const err = error as Error;\n\n      console.error(`Activity ${task.task_id} failed:`, err.message);\n\n      await this.sendActivityResult(\n        task,\n        resultTopic,\n        'failed',\n        undefined,\n        {\n          type: err.name || 'Error',\n          message: err.message,\n          stack_trace: err.stack,\n        },\n        startedAt,\n        completedAt,\n        durationMs\n      );\n    }\n  }\n\n  private async sendWorkflowResult(\n    task: WorkflowTask,\n    resultTopic: string,\n    status: 'completed' | 'failed',\n    output?: unknown,\n    error?: WorkflowError,\n    startedAt?: Date,\n    completedAt?: Date,\n    durationMs = 0\n  ): Promise<void> {\n    const now = new Date();\n    const result: WorkflowResult = {\n      task_id: task.task_id,\n      workflow_id: task.workflow_id,\n      workflow_name: task.workflow_name,\n      status,\n      output,\n      error,\n      started_at: (startedAt || now).toISOString(),\n      completed_at: (completedAt || now).toISOString(),\n      duration_ms: durationMs,\n      worker_id: this.workerId!,\n    };\n\n    if (this.producer) {\n      await this.producer.send({\n        topic: resultTopic,\n        messages: [\n          {\n            key: task.workflow_id,\n            value: JSON.stringify(result),\n          },\n        ],\n      });\n      console.debug(`Sent workflow result for task ${task.task_id}`);\n    }\n  }\n\n  private async sendActivityResult(\n    task: ActivityTask,\n    resultTopic: string,\n    status: 'completed' | 'failed',\n    output?: unknown,\n    error?: ActivityError,\n    startedAt?: Date,\n    completedAt?: Date,\n    durationMs = 0\n  ): Promise<void> {\n    const now = new Date();\n    const result: ActivityResult = {\n      task_id: task.task_id,\n      workflow_id: task.workflow_id,\n      activity_name: task.activity_name,\n      activity_index: task.activity_index,\n      fan_out_index: task.fan_out_index,\n      status,\n      output,\n      error,\n      started_at: (startedAt || now).toISOString(),\n      completed_at: (completedAt || now).toISOString(),\n      duration_ms: durationMs,\n      worker_id: this.workerId!,\n      requester_worker_id: task.requester_worker_id,\n      correlation_id: task.correlation_id,\n    };\n\n    if (this.producer) {\n      await this.producer.send({\n        topic: resultTopic,\n        messages: [\n          {\n            key: task.workflow_id,\n            value: JSON.stringify(result),\n          },\n        ],\n      });\n      console.debug(`Sent activity result for task ${task.task_id}`);\n    }\n  }\n\n  // WorkerInterface implementation for WorkflowContext\n\n  async reportLocalActivityCompletion(\n    workflowId: string,\n    activityName: string,\n    activityIndex: number,\n    output: unknown,\n    durationMs: number\n  ): Promise<void> {\n    if (!this.producer || !this.resultTopic) {\n      console.debug('Cannot report local activity - producer not initialized');\n      return;\n    }\n\n    const completedAt = new Date();\n    const startedAt = new Date(completedAt.getTime() - durationMs);\n\n    const result = {\n      task_id: `local-${workflowId}-${activityIndex}`,\n      workflow_id: workflowId,\n      activity_name: activityName,\n      activity_index: activityIndex,\n      status: 'completed',\n      output,\n      started_at: startedAt.toISOString(),\n      completed_at: completedAt.toISOString(),\n      duration_ms: durationMs,\n      worker_id: this.workerId,\n    };\n\n    try {\n      await this.producer.send({\n        topic: this.resultTopic,\n        messages: [{ key: workflowId, value: JSON.stringify(result) }],\n      });\n      console.debug(\n        `Reported local activity completion: workflow_id=${workflowId}, activity=${activityName}, index=${activityIndex}`\n      );\n    } catch (error) {\n      console.warn('Failed to report local activity completion:', error);\n    }\n  }\n\n  async reportLocalActivityFailure(\n    workflowId: string,\n    activityName: string,\n    activityIndex: number,\n    error: string,\n    errorType: string,\n    durationMs: number\n  ): Promise<void> {\n    if (!this.producer || !this.resultTopic) {\n      console.debug('Cannot report local activity failure - producer not initialized');\n      return;\n    }\n\n    const completedAt = new Date();\n    const startedAt = new Date(completedAt.getTime() - durationMs);\n\n    const result = {\n      task_id: `local-${workflowId}-${activityIndex}`,\n      workflow_id: workflowId,\n      activity_name: activityName,\n      activity_index: activityIndex,\n      status: 'failed',\n      output: null,\n      error: { type: errorType, message: error },\n      started_at: startedAt.toISOString(),\n      completed_at: completedAt.toISOString(),\n      duration_ms: durationMs,\n      worker_id: this.workerId,\n    };\n\n    try {\n      await this.producer.send({\n        topic: this.resultTopic,\n        messages: [{ key: workflowId, value: JSON.stringify(result) }],\n      });\n      console.debug(\n        `Reported local activity failure: workflow_id=${workflowId}, activity=${activityName}, index=${activityIndex}`\n      );\n    } catch (error) {\n      console.warn('Failed to report local activity failure:', error);\n    }\n  }\n\n  async executeRemoteActivity(\n    workflowId: string,\n    activityName: string,\n    activityIndex: number,\n    inputData: unknown,\n    timeoutMs: number\n  ): Promise<unknown> {\n    if (!this.producer || !this.resultTopic) {\n      throw new Error('Kafka producer not initialized');\n    }\n\n    // Send ActivityRequest to server via Kafka\n    const requestPayload = {\n      request_type: 'activity_request',\n      request_id: crypto.randomUUID(),\n      workflow_id: workflowId,\n      activity_name: activityName,\n      activity_index: activityIndex,\n      input: inputData,\n      timeout_ms: timeoutMs,\n      requester_worker_id: this.workerId,\n      correlation_id: crypto.randomUUID(),\n      created_at: new Date().toISOString(),\n    };\n\n    await this.producer.send({\n      topic: this.resultTopic,\n      messages: [{ key: workflowId, value: JSON.stringify(requestPayload) }],\n    });\n\n    console.log(\n      `Activity request sent via Kafka: activity=${activityName}, workflow_id=${workflowId}, activity_index=${activityIndex}`\n    );\n\n    // Poll server for result with exponential backoff\n    let pollInterval = 2000; // Start at 2 seconds\n    const maxPollInterval = 900000; // Max 15 minutes\n    const backoffMultiplier = 1.5;\n    const startTime = Date.now();\n    const timeoutSeconds = timeoutMs;\n\n    const pollUrl = `${this.config.serverUrl}/workflow/api/v1/workflows/${workflowId}/activities/${activityIndex}/result`;\n    const headers = { Authorization: `Bearer ${this.config.apiKey}` };\n\n    while (true) {\n      const elapsed = Date.now() - startTime;\n      if (elapsed >= timeoutSeconds) {\n        throw new Error(`Activity ${activityName} timed out after ${timeoutMs}ms`);\n      }\n\n      try {\n        const response = await fetch(pollUrl, { headers });\n\n        if (response.status === 200) {\n          const result = await response.json() as { status: string; output?: unknown; error?: string };\n          if (result.status === 'completed') {\n            console.log(`Activity ${activityName} completed for workflow ${workflowId}`);\n            return result.output;\n          } else if (result.status === 'failed') {\n            const errorMsg = result.error || 'Activity failed';\n            console.error(`Activity ${activityName} failed: ${errorMsg}`);\n            throw new Error(errorMsg);\n          }\n        } else if (response.status === 202) {\n          // Still pending/running, continue polling\n          console.debug(`Activity ${activityName} still running, polling again in ${pollInterval}ms`);\n        } else if (response.status === 404) {\n          // Activity not found yet\n          console.debug(`Activity ${activityName} not found yet, polling again in ${pollInterval}ms`);\n        } else {\n          console.warn(`Unexpected response ${response.status} when polling activity result`);\n        }\n      } catch (error) {\n        if ((error as Error).message.includes('timed out') || (error as Error).message.includes('failed')) {\n          throw error;\n        }\n        console.warn('Error polling activity result:', error);\n      }\n\n      // Wait with exponential backoff\n      await new Promise((resolve) => setTimeout(resolve, pollInterval));\n      pollInterval = Math.min(pollInterval * backoffMultiplier, maxPollInterval);\n    }\n  }\n\n  private async cleanup(): Promise<void> {\n    // Stop heartbeat\n    if (this.heartbeatInterval) {\n      clearInterval(this.heartbeatInterval);\n    }\n\n    // Disconnect from server\n    await this.disconnectFromServer();\n\n    // Stop Kafka clients\n    if (this.consumer) {\n      await this.consumer.disconnect();\n    }\n    if (this.producer) {\n      await this.producer.disconnect();\n    }\n\n    console.log(`Worker ${this.workerId} stopped`);\n  }\n}\n"]}