@lobu/connector-worker 6.0.1

package/dist/daemon/client.js

@@ -0,0 +1,152 @@
+/**
+ * Worker API Client
+ *
+ * HTTP client for communicating with the backend worker API endpoints.
+ * Updated for V1 integration platform: runs-based job model.
+ */
+function trimTrailingSlashes(value) {
+    let end = value.length;
+    while (end > 0 && value.charCodeAt(end - 1) === 47)
+        end--;
+    return end === value.length ? value : value.slice(0, end);
+}
+/**
+ * Worker API Client
+ */
+export class WorkerClient {
+    apiUrl;
+    workerId;
+    capabilities;
+    authToken;
+    version;
+    constructor(config) {
+        this.apiUrl = trimTrailingSlashes(config.apiUrl);
+        this.workerId = config.workerId;
+        this.capabilities = config.capabilities;
+        this.authToken = config.authToken?.trim() || undefined;
+        this.version = config.version ?? '1.0.0';
+    }
+    authHeaders() {
+        if (!this.authToken)
+            return {};
+        return { Authorization: `Bearer ${this.authToken}` };
+    }
+    async requestJson(path, body) {
+        const response = await fetch(`${this.apiUrl}${path}`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                ...this.authHeaders(),
+            },
+            body: JSON.stringify(body),
+        });
+        if (!response.ok) {
+            const responseText = await response.text();
+            throw new Error(`${path} failed: ${response.status} ${response.statusText} ${responseText}`);
+        }
+        return response.json();
+    }
+    async requestVoid(path, body) {
+        const response = await fetch(`${this.apiUrl}${path}`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                ...this.authHeaders(),
+            },
+            body: JSON.stringify(body),
+        });
+        if (!response.ok) {
+            const responseText = await response.text();
+            throw new Error(`${path} failed: ${response.status} ${response.statusText} ${responseText}`);
+        }
+    }
+    /**
+     * Poll for available runs
+     */
+    async poll() {
+        return this.requestJson('/api/workers/poll', {
+            worker_id: this.workerId,
+            capabilities: this.capabilities,
+            version: this.version,
+        });
+    }
+    /**
+     * Send heartbeat for active run
+     */
+    async heartbeat(runId, progress) {
+        await this.requestVoid('/api/workers/heartbeat', {
+            run_id: runId,
+            worker_id: this.workerId,
+            progress,
+        });
+    }
+    /**
+     * Stream content batch to backend
+     */
+    async stream(batch) {
+        await this.requestVoid('/api/workers/stream', batch);
+    }
+    /**
+     * Report sync run completion
+     */
+    async complete(req) {
+        await this.requestVoid('/api/workers/complete', req);
+    }
+    /**
+     * Report action run completion
+     */
+    async completeAction(req) {
+        await this.requestVoid('/api/workers/complete-action', req);
+    }
+    /**
+     * Fetch events needing embeddings
+     */
+    async fetchEventsForEmbedding(eventIds) {
+        const result = await this.requestJson('/api/workers/fetch-events', {
+            event_ids: eventIds,
+        });
+        return result.events;
+    }
+    /**
+     * Submit generated embeddings
+     */
+    async completeEmbeddings(req) {
+        await this.requestVoid('/api/workers/complete-embeddings', req);
+    }
+    /**
+     * Emit an auth artifact (QR, redirect URL, prompt) for the UI to render.
+     */
+    async emitAuthArtifact(req) {
+        await this.requestVoid('/api/workers/emit-auth-artifact', req);
+    }
+    /**
+     * Poll for a signal sent by the UI (OAuth callback, form submit, cancel).
+     */
+    async pollAuthSignal(req) {
+        return this.requestJson('/api/workers/poll-auth-signal', req);
+    }
+    /**
+     * Report auth run completion — writes credentials + metadata to auth_profiles.
+     */
+    async completeAuth(req) {
+        await this.requestVoid('/api/workers/complete-auth', req);
+    }
+    /**
+     * Health check
+     */
+    async healthCheck() {
+        try {
+            const response = await fetch(`${this.apiUrl}/api/health`, {
+                headers: this.authHeaders(),
+            });
+            return response.ok;
+        }
+        catch {
+            return false;
+        }
+    }
+    get id() {
+        return this.workerId;
+    }
+}
+//# sourceMappingURL=client.js.map

package/dist/daemon/client.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.js","sourceRoot":"","sources":["../../src/daemon/client.ts"],"names":[],"mappings":"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"}

package/dist/daemon/executor.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Run Executor
+ *
+ * Executes sync and action runs via subprocess execution with compiled connector code.
+ * Generates embeddings and streams results.
+ */
+import type { Env } from '../types.js';
+import type { ExecutorClient, PollResponse } from './client.js';
+export interface ExecutorConfig {
+    batchSize: number;
+    heartbeatIntervalMs: number;
+    generateEmbeddings: boolean;
+    timeoutMs: number;
+    maxOldSpaceSize: number;
+}
+/**
+ * Execute a run (sync, action, or watcher).
+ *
+ * Dispatches to sync, action, or watcher execution based on run_type.
+ */
+export declare function executeRun(client: ExecutorClient, job: PollResponse, env: Env, config?: Partial<ExecutorConfig>): Promise<{
+    itemsCollected: number;
+    error?: string;
+}>;
+//# sourceMappingURL=executor.d.ts.map

package/dist/daemon/executor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"executor.d.ts","sourceRoot":"","sources":["../../src/daemon/executor.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAUH,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,aAAa,CAAC;AACvC,OAAO,KAAK,EAAe,cAAc,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAE7E,MAAM,WAAW,cAAc;IAC7B,SAAS,EAAE,MAAM,CAAC;IAClB,mBAAmB,EAAE,MAAM,CAAC;IAC5B,kBAAkB,EAAE,OAAO,CAAC;IAC5B,SAAS,EAAE,MAAM,CAAC;IAClB,eAAe,EAAE,MAAM,CAAC;CACzB;AAUD;;;;GAIG;AACH,wBAAsB,UAAU,CAC9B,MAAM,EAAE,cAAc,EACtB,GAAG,EAAE,YAAY,EACjB,GAAG,EAAE,GAAG,EACR,MAAM,GAAE,OAAO,CAAC,cAAc,CAAM,GACnC,OAAO,CAAC;IAAE,cAAc,EAAE,MAAM,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC,CA2BrD"}

package/dist/daemon/executor.js

@@ -0,0 +1,492 @@
+/**
+ * Run Executor
+ *
+ * Executes sync and action runs via subprocess execution with compiled connector code.
+ * Generates embeddings and streams results.
+ */
+import { generateEmbedding } from '../embeddings.js';
+import { executeCompiledConnector, getActionOutput, normalizeEventEnvelope, } from '../executor/runtime.js';
+import { SubprocessExecutor } from '../executor/subprocess.js';
+const DEFAULT_CONFIG = {
+    batchSize: 10,
+    heartbeatIntervalMs: 30000,
+    generateEmbeddings: true,
+    timeoutMs: 600000,
+    maxOldSpaceSize: 1024,
+};
+/**
+ * Execute a run (sync, action, or watcher).
+ *
+ * Dispatches to sync, action, or watcher execution based on run_type.
+ */
+export async function executeRun(client, job, env, config = {}) {
+    const cfg = { ...DEFAULT_CONFIG, ...config };
+    if (job.run_type === 'action') {
+        return executeActionRun(client, job, env, cfg);
+    }
+    if (job.run_type === 'watcher') {
+        // Watcher reactions now execute inline in the API process (complete_window).
+        // If a legacy pending watcher run is polled, mark it as completed to clean up.
+        // Note: stuck runs older than the poll interval will be picked up here automatically.
+        console.error(`[executor] Cleaning up legacy watcher run ${job.run_id} — reactions now execute inline`);
+        await client.complete({
+            run_id: job.run_id,
+            worker_id: client.id,
+            status: 'success',
+            items_collected: 0,
+        });
+        return { itemsCollected: 0 };
+    }
+    if (job.run_type === 'embed_backfill') {
+        return executeEmbedBackfillRun(client, job, env);
+    }
+    if (job.run_type === 'auth') {
+        return executeAuthRun(client, job, env, cfg);
+    }
+    return executeSyncRun(client, job, env, cfg);
+}
+/**
+ * Execute a sync run (feed data ingestion)
+ */
+async function executeSyncRun(client, job, env, cfg) {
+    const subprocessExecutor = new SubprocessExecutor({
+        timeoutMs: cfg.timeoutMs,
+        maxOldSpaceSize: cfg.maxOldSpaceSize,
+    });
+    const { run_id, connector_key, feed_key, config: feedConfig, checkpoint, credentials, compiled_code, } = job;
+    if (!run_id || !connector_key) {
+        throw new Error('Invalid run: missing run_id or connector_key');
+    }
+    if (!compiled_code) {
+        throw new Error(`Run ${run_id} (${connector_key}): No compiled code available. ` +
+            'Ensure the connector has a compiled version.');
+    }
+    console.error(`[executor] Starting sync run ${run_id} (${connector_key}/${feed_key})`);
+    // Set up heartbeat interval
+    let heartbeatInterval;
+    let itemsCollectedSoFar = 0;
+    const startHeartbeat = () => {
+        heartbeatInterval = setInterval(async () => {
+            try {
+                await client.heartbeat(run_id, {
+                    items_collected_so_far: itemsCollectedSoFar,
+                });
+            }
+            catch (err) {
+                console.error('[executor] Heartbeat failed:', err);
+            }
+        }, cfg.heartbeatIntervalMs);
+    };
+    const stopHeartbeat = () => {
+        if (heartbeatInterval) {
+            clearInterval(heartbeatInterval);
+            heartbeatInterval = undefined;
+        }
+    };
+    startHeartbeat();
+    try {
+        let batch = [];
+        let lastCheckpoint = checkpoint;
+        const flushBatch = async () => {
+            if (batch.length === 0)
+                return;
+            try {
+                await client.stream({
+                    type: 'batch',
+                    run_id,
+                    items: batch,
+                    checkpoint: lastCheckpoint ?? undefined,
+                });
+            }
+            catch (streamErr) {
+                const batchIds = batch.map((b) => b.id);
+                console.error(`[executor] Stream batch failed for run ${run_id} (${batchIds.length} items lost: ${batchIds.join(', ')}):`, streamErr);
+                const msg = streamErr instanceof Error ? streamErr.message : String(streamErr);
+                throw new Error(`Stream batch failed: ${msg} (lost ${batchIds.length} items: ${batchIds.join(', ')})`);
+            }
+            batch = [];
+        };
+        const result = await executeCompiledConnector({
+            mode: 'sync',
+            compiledCode: compiled_code,
+            config: (feedConfig ?? {}),
+            checkpoint: checkpoint,
+            env,
+            connectionCredentials: (job.connection_credentials ??
+                null),
+            sessionState: (job.session_state ?? null),
+            credentials,
+            feedKey: feed_key,
+            entityIds: job.entity_ids ?? [],
+            apiType: 'api',
+            executor: subprocessExecutor,
+            hooks: {
+                collectContents: false,
+                onCheckpointUpdate: async (nextCheckpoint) => {
+                    lastCheckpoint = nextCheckpoint;
+                    if (!lastCheckpoint)
+                        return;
+                    try {
+                        await client.stream({
+                            type: 'batch',
+                            run_id,
+                            items: [],
+                            checkpoint: lastCheckpoint,
+                        });
+                    }
+                    catch (err) {
+                        console.error('[executor] Checkpoint flush failed:', err);
+                    }
+                },
+                onContentChunk: async (items) => {
+                    for (const item of items) {
+                        const contentItem = await processContent(item, cfg.generateEmbeddings);
+                        batch.push(contentItem);
+                        itemsCollectedSoFar++;
+                        if (batch.length >= cfg.batchSize) {
+                            await flushBatch();
+                        }
+                    }
+                },
+            },
+        });
+        lastCheckpoint = result.checkpoint;
+        await flushBatch();
+        stopHeartbeat();
+        await client.complete({
+            run_id,
+            worker_id: client.id,
+            status: 'success',
+            items_collected: itemsCollectedSoFar,
+            checkpoint: lastCheckpoint ?? undefined,
+            auth_update: result.auth_update ?? undefined,
+        });
+        console.error(`[executor] Sync run ${run_id} completed: ${itemsCollectedSoFar} items`);
+        return { itemsCollected: itemsCollectedSoFar };
+    }
+    catch (error) {
+        stopHeartbeat();
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        console.error(`[executor] Sync run ${run_id} failed:`, errorMessage);
+        const diag = extractSubprocessDiagnostics(error);
+        await client.complete({
+            run_id,
+            worker_id: client.id,
+            status: 'failed',
+            items_collected: itemsCollectedSoFar,
+            error_message: errorMessage,
+            ...(diag ?? {}),
+        });
+        return { itemsCollected: itemsCollectedSoFar, error: errorMessage };
+    }
+}
+/**
+ * Pull diagnostic fields off a SubprocessError-shaped error so the worker
+ * can persist them on the failed run row. Returns `undefined` when the
+ * thrown value isn't a subprocess failure (e.g. a stream/HTTP error).
+ */
+function extractSubprocessDiagnostics(error) {
+    if (!error || typeof error !== 'object')
+        return undefined;
+    const e = error;
+    if (!e.exitReason && e.exitCode === undefined && !e.outputTail)
+        return undefined;
+    return {
+        output_tail: e.outputTail || undefined,
+        exit_code: e.exitCode ?? null,
+        exit_signal: e.exitSignal ?? null,
+        exit_reason: e.exitReason,
+    };
+}
+/**
+ * Execute an action run (async action with approval)
+ */
+async function executeActionRun(client, job, env, cfg) {
+    const subprocessExecutor = new SubprocessExecutor({
+        timeoutMs: cfg.timeoutMs,
+        maxOldSpaceSize: cfg.maxOldSpaceSize,
+    });
+    const { run_id, connector_key, action_key, action_input, credentials, compiled_code } = job;
+    if (!run_id || !connector_key || !action_key) {
+        throw new Error('Invalid action run: missing run_id, connector_key, or action_key');
+    }
+    if (!compiled_code) {
+        throw new Error(`Action run ${run_id}: No compiled code available.`);
+    }
+    console.error(`[executor] Starting action run ${run_id} (${connector_key}/${action_key})`);
+    try {
+        const result = await executeCompiledConnector({
+            mode: 'action',
+            compiledCode: compiled_code,
+            actionKey: action_key,
+            actionInput: (action_input ?? {}),
+            env,
+            connectionCredentials: (job.connection_credentials ??
+                null),
+            credentials,
+            apiType: 'api',
+            executor: subprocessExecutor,
+        });
+        // For actions, the "contents" array may contain a single result envelope
+        const actionOutput = getActionOutput(result);
+        await client.completeAction({
+            run_id,
+            worker_id: client.id,
+            status: 'success',
+            action_output: actionOutput,
+        });
+        console.error(`[executor] Action run ${run_id} completed`);
+        return { itemsCollected: 0 };
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        console.error(`[executor] Action run ${run_id} failed:`, errorMessage);
+        await client.completeAction({
+            run_id,
+            worker_id: client.id,
+            status: 'failed',
+            error_message: errorMessage,
+        });
+        return { itemsCollected: 0, error: errorMessage };
+    }
+}
+/**
+ * Execute an 'auth' run: drive connector.authenticate() and stream artifacts
+ * to the UI via the API. On success, credentials land on the auth profile.
+ */
+async function executeAuthRun(client, job, env, cfg) {
+    // Interactive auth runs wait on human input (QR scans, OTP entry, OAuth
+    // redirects) — a fixed subprocess timeout would kill the pairing mid-flow.
+    // Terminate via the UI cancel signal instead.
+    const subprocessExecutor = new SubprocessExecutor({
+        timeoutMs: 0,
+        maxOldSpaceSize: cfg.maxOldSpaceSize,
+    });
+    const { run_id, connector_key, compiled_code, previous_credentials } = job;
+    if (!run_id || !connector_key) {
+        throw new Error('Invalid auth run: missing run_id or connector_key');
+    }
+    if (!compiled_code) {
+        throw new Error(`Auth run ${run_id}: No compiled code available.`);
+    }
+    console.error(`[executor] Starting auth run ${run_id} (${connector_key})`);
+    // Heartbeat so the API doesn't time us out while the user is scanning.
+    const heartbeatInterval = setInterval(async () => {
+        try {
+            await client.heartbeat(run_id);
+        }
+        catch (err) {
+            console.error('[executor] Auth heartbeat failed:', err);
+        }
+    }, cfg.heartbeatIntervalMs);
+    try {
+        const result = await executeCompiledConnector({
+            mode: 'authenticate',
+            compiledCode: compiled_code,
+            previousCredentials: previous_credentials ?? null,
+            env,
+            executor: subprocessExecutor,
+            apiType: 'api',
+            hooks: {
+                collectContents: false,
+                onAuthArtifact: async (artifact) => {
+                    try {
+                        await client.emitAuthArtifact({
+                            run_id,
+                            worker_id: client.id,
+                            artifact,
+                        });
+                    }
+                    catch (err) {
+                        console.error('[executor] emitAuthArtifact failed:', err);
+                    }
+                },
+                onAwaitAuthSignal: async (name, opts) => {
+                    const deadline = opts?.timeoutMs ? Date.now() + opts.timeoutMs : null;
+                    while (true) {
+                        if (deadline !== null && Date.now() > deadline) {
+                            throw new Error(`awaitSignal('${name}') timed out`);
+                        }
+                        const resp = await client.pollAuthSignal({
+                            run_id,
+                            worker_id: client.id,
+                            signal_name: name,
+                        });
+                        if (resp.signal)
+                            return resp.signal;
+                        await delay(1500);
+                    }
+                },
+            },
+        });
+        clearInterval(heartbeatInterval);
+        if (!result.auth_result?.credentials) {
+            await client.completeAuth({
+                run_id,
+                worker_id: client.id,
+                status: 'failed',
+                error_message: 'authenticate() returned no credentials',
+            });
+            return { itemsCollected: 0, error: 'no credentials' };
+        }
+        await client.completeAuth({
+            run_id,
+            worker_id: client.id,
+            status: 'success',
+            credentials: result.auth_result.credentials,
+            metadata: result.auth_result.metadata,
+        });
+        console.error(`[executor] Auth run ${run_id} completed`);
+        return { itemsCollected: 0 };
+    }
+    catch (error) {
+        clearInterval(heartbeatInterval);
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        console.error(`[executor] Auth run ${run_id} failed:`, errorMessage);
+        const diag = extractSubprocessDiagnostics(error);
+        try {
+            await client.completeAuth({
+                run_id,
+                worker_id: client.id,
+                status: 'failed',
+                error_message: errorMessage,
+                ...(diag ?? {}),
+            });
+        }
+        catch (completeErr) {
+            console.error('[executor] completeAuth after failure errored:', completeErr);
+        }
+        return { itemsCollected: 0, error: errorMessage };
+    }
+}
+function delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+/**
+ * Execute an embed_backfill run (generate embeddings for events missing them)
+ */
+async function executeEmbedBackfillRun(client, job, _env) {
+    const { run_id, action_input } = job;
+    if (!run_id) {
+        throw new Error('Invalid embed_backfill run: missing run_id');
+    }
+    // Parse event_ids from action_input
+    let input;
+    if (typeof action_input === 'string') {
+        try {
+            input = JSON.parse(action_input);
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            console.error(`[executor] Embed backfill run ${run_id}: invalid action_input JSON:`, msg);
+            await client.complete({
+                run_id,
+                worker_id: client.id,
+                status: 'failed',
+                error_message: `Invalid action_input JSON: ${msg}`,
+            });
+            return { itemsCollected: 0, error: `Invalid action_input JSON: ${msg}` };
+        }
+    }
+    else {
+        input = action_input;
+    }
+    const eventIds = input?.event_ids ?? [];
+    if (eventIds.length === 0) {
+        console.error(`[executor] Embed backfill run ${run_id}: no event_ids`);
+        await client.complete({
+            run_id,
+            worker_id: client.id,
+            status: 'failed',
+            error_message: 'No event_ids in action_input',
+        });
+        return { itemsCollected: 0, error: 'No event_ids' };
+    }
+    console.error(`[executor] Starting embed_backfill run ${run_id} for ${eventIds.length} events`);
+    try {
+        // Fetch event content from the API
+        const events = await client.fetchEventsForEmbedding(eventIds);
+        if (events.length === 0) {
+            console.error(`[executor] Embed backfill run ${run_id}: all events already have embeddings`);
+            await client.completeEmbeddings({
+                run_id,
+                worker_id: client.id,
+                embeddings: [],
+                error_message: 'All events already have embeddings',
+            });
+            return { itemsCollected: 0 };
+        }
+        // Generate embeddings for each event
+        const results = [];
+        for (const event of events) {
+            try {
+                const textForEmbedding = [event.title, event.content].filter(Boolean).join(' ').trim();
+                if (textForEmbedding) {
+                    const embedding = await generateEmbedding(textForEmbedding);
+                    if (embedding) {
+                        results.push({ event_id: event.id, embedding });
+                    }
+                }
+            }
+            catch (err) {
+                console.error(`[executor] Embedding failed for event ${event.id}:`, err);
+            }
+        }
+        // Submit embeddings back to the API
+        await client.completeEmbeddings({
+            run_id,
+            worker_id: client.id,
+            embeddings: results,
+        });
+        console.error(`[executor] Embed backfill run ${run_id} completed: ${results.length}/${events.length} embeddings`);
+        return { itemsCollected: results.length };
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        console.error(`[executor] Embed backfill run ${run_id} failed:`, errorMessage);
+        await client.complete({
+            run_id,
+            worker_id: client.id,
+            status: 'failed',
+            error_message: errorMessage,
+        });
+        return { itemsCollected: 0, error: errorMessage };
+    }
+}
+/**
+ * Process a content item - convert to ContentItem and optionally generate embedding
+ */
+async function processContent(item, generateEmbeddings) {
+    const normalized = normalizeEventEnvelope(item);
+    const contentItem = {
+        id: normalized.origin_id,
+        title: normalized.title,
+        payload_text: normalized.payload_text,
+        author_name: normalized.author_name,
+        occurred_at: normalized.occurred_at instanceof Date
+            ? normalized.occurred_at.toISOString()
+            : normalized.occurred_at,
+        source_url: normalized.source_url,
+        score: normalized.score,
+        metadata: normalized.metadata,
+        origin_parent_id: normalized.origin_parent_id || undefined,
+        origin_type: normalized.origin_type,
+        semantic_type: normalized.semantic_type,
+    };
+    if (generateEmbeddings) {
+        try {
+            const textForEmbedding = [normalized.title, normalized.payload_text]
+                .filter(Boolean)
+                .join(' ')
+                .trim();
+            if (textForEmbedding) {
+                contentItem.embedding = await generateEmbedding(textForEmbedding);
+            }
+        }
+        catch (err) {
+            console.error(`[executor] Embedding generation failed for ${normalized.origin_id}:`, err);
+        }
+    }
+    return contentItem;
+}
+//# sourceMappingURL=executor.js.map