@questionbase/deskfree 0.3.0-alpha.8 → 0.4.0-alpha.1

package/dist/gateway.js

@@ -1,770 +0,0 @@
-// Use ESM imports for Node.js built-in modules
-import { DeskFreeClient } from './client';
-import { deliverMessageToAgent } from './deliver';
-import { initErrorReporter, reportError } from './error-reporter';
-import { resolvePluginStorePath } from './paths';
-import { getDeskFreeRuntime } from './runtime';
-import { PLUGIN_VERSION } from './version';
-import { resolveWorkspacePath } from './workspace';
-import { spawn } from 'node:child_process';
-import { mkdirSync, readFileSync, writeFileSync } from 'node:fs';
-import { dirname } from 'node:path';
-import WebSocket from 'ws';
-// ── Active Task Tracking ──────────────────────────────────────────────
-// Tracks the currently active task so outbound messages can be
-// automatically threaded into it without explicit taskId parameters.
-let activeTaskId = null;
-export function setActiveTaskId(taskId) {
-    activeTaskId = taskId;
-}
-export function getActiveTaskId() {
-    return activeTaskId;
-}
-// ── Workspace S3 Sync Helpers ─────────────────────────────────────────
-/**
- * Helper function to get AWS credentials from DeskFree and run an S3 command.
- * Replaces the previous API-based workspace sync approach with direct AWS CLI usage.
- */
-async function runS3CommandWithCredentials(client, buildCommand, workspacePath, log) {
-    try {
-        // Get short-lived credentials + S3 location from DeskFree
-        const creds = await client.workspaceCredentials();
-        const command = buildCommand(creds.s3Uri);
-        // Set up environment with temporary credentials
-        const env = {
-            ...process.env,
-            AWS_ACCESS_KEY_ID: creds.accessKeyId,
-            AWS_SECRET_ACCESS_KEY: creds.secretAccessKey,
-            AWS_SESSION_TOKEN: creds.sessionToken,
-            AWS_DEFAULT_REGION: creds.region,
-        };
-        return new Promise((resolve, reject) => {
-            const child = spawn('aws', command, {
-                env,
-                cwd: workspacePath,
-                stdio: 'pipe',
-            });
-            let stdout = '';
-            let stderr = '';
-            child.stdout?.on('data', (data) => {
-                stdout += data.toString();
-            });
-            child.stderr?.on('data', (data) => {
-                stderr += data.toString();
-            });
-            child.on('close', (code) => {
-                if (code === 0) {
-                    log.info(`S3 command succeeded: ${command.join(' ')}`);
-                    if (stdout.trim()) {
-                        log.debug(`S3 stdout: ${stdout.trim()}`);
-                    }
-                    resolve(true);
-                }
-                else {
-                    log.warn(`S3 command failed (exit ${code}): ${command.join(' ')}`);
-                    if (stderr.trim()) {
-                        log.warn(`S3 stderr: ${stderr.trim()}`);
-                    }
-                    reject(new Error(`AWS CLI command failed with exit code ${code}: ${stderr}`));
-                }
-            });
-            child.on('error', (err) => {
-                log.warn(`S3 command spawn error: ${err.message}`);
-                reject(err);
-            });
-        });
-    }
-    catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        log.warn(`Failed to get S3 credentials or run command: ${message}`);
-        reportError('warn', `S3 workspace command failed: ${message}`, {
-            component: 'gateway',
-            event: 'workspace_sync_failed',
-        });
-        return false;
-    }
-}
-const PING_INTERVAL_MS = 5 * 60 * 1000; // 5 minutes (API GW idle timeout = 10 min)
-const POLL_FALLBACK_INTERVAL_MS = 30 * 1000; // 30s fallback when WS is down
-const WS_CONNECTION_TIMEOUT_MS = 30 * 1000; // 30s timeout for initial connection
-const WS_PONG_TIMEOUT_MS = 10 * 1000; // 10s timeout waiting for pong response
-const BACKOFF_INITIAL_MS = 2000;
-const BACKOFF_MAX_MS = 30000;
-const BACKOFF_FACTOR = 1.8;
-const HEALTH_LOG_INTERVAL_MS = 30 * 60 * 1000; // 30 minutes
-const MAX_CONSECUTIVE_POLL_FAILURES = 5; // Switch to longer backoff after this many
-// Dedup set to prevent re-delivering messages due to cursor precision issues
-// (Postgres microsecond timestamps vs JS millisecond Date precision)
-const deliveredMessageIds = new Set();
-// Module-level health state persists across reconnects
-const healthState = new Map();
-function initializeHealth(accountId) {
-    if (!healthState.has(accountId)) {
-        healthState.set(accountId, {
-            connectionStartTime: Date.now(),
-            totalReconnects: 0,
-            lastReconnectAt: null,
-            avgReconnectInterval: 0,
-            totalMessagesDelivered: 0,
-            lastMessageAt: null,
-            currentMode: 'websocket',
-        });
-    }
-}
-function updateHealthMode(accountId, mode) {
-    const health = healthState.get(accountId);
-    if (health) {
-        health.currentMode = mode;
-    }
-}
-function recordReconnect(accountId) {
-    const health = healthState.get(accountId);
-    if (health) {
-        const now = Date.now();
-        if (health.lastReconnectAt) {
-            const interval = now - health.lastReconnectAt;
-            health.avgReconnectInterval =
-                (health.avgReconnectInterval * health.totalReconnects + interval) /
-                    (health.totalReconnects + 1);
-        }
-        health.totalReconnects++;
-        health.lastReconnectAt = now;
-    }
-}
-function recordMessageDelivery(accountId, count) {
-    const health = healthState.get(accountId);
-    if (health) {
-        health.totalMessagesDelivered += count;
-        health.lastMessageAt = Date.now();
-    }
-}
-function formatDuration(ms) {
-    const seconds = Math.floor(ms / 1000);
-    const minutes = Math.floor(seconds / 60);
-    const hours = Math.floor(minutes / 60);
-    if (hours > 0) {
-        return `${hours}h${minutes % 60}m`;
-    }
-    else if (minutes > 0) {
-        return `${minutes}m${seconds % 60}s`;
-    }
-    else {
-        return `${seconds}s`;
-    }
-}
-function logHealthSummary(accountId, log) {
-    const health = healthState.get(accountId);
-    if (!health)
-        return;
-    const uptime = Date.now() - health.connectionStartTime;
-    log.info(`DeskFree health: uptime=${formatDuration(uptime)}, ` +
-        `reconnects=${health.totalReconnects}, ` +
-        `messages=${health.totalMessagesDelivered}, ` +
-        `mode=${health.currentMode}`);
-}
-// Serialize poll operations per account to prevent duplicate message delivery.
-// Each account gets its own promise-chain mutex so polls don't block across accounts.
-const pollChains = new Map();
-function enqueuePoll(client, ctx, getCursor, setCursor, log, account) {
-    const accountId = ctx.accountId;
-    const prev = pollChains.get(accountId) ?? Promise.resolve();
-    const next = prev
-        .then(async () => {
-        const newCursor = await pollAndDeliver(client, ctx, getCursor(), log, account);
-        if (newCursor)
-            setCursor(newCursor);
-    })
-        .catch((err) => {
-        const message = err instanceof Error ? err.message : String(err);
-        log.error(`Poll error: ${message}`);
-    });
-    pollChains.set(accountId, next);
-}
-function nextBackoff(state) {
-    const delay = Math.min(BACKOFF_INITIAL_MS * Math.pow(BACKOFF_FACTOR, state.attempt), BACKOFF_MAX_MS);
-    const jitter = delay * 0.25 * Math.random();
-    state.attempt++;
-    return delay + jitter;
-}
-function resetBackoff(state) {
-    state.attempt = 0;
-}
-// Clean up abort listener to prevent memory leak
-function sleepWithAbort(ms, signal) {
-    return new Promise((resolve) => {
-        const onAbort = () => {
-            clearTimeout(timer);
-            resolve();
-        };
-        const timer = setTimeout(() => {
-            signal.removeEventListener('abort', onAbort);
-            resolve();
-        }, ms);
-        signal.addEventListener('abort', onAbort, { once: true });
-    });
-}
-/**
- * Persistent cursor management.
- * Stores cursor on disk so we can resume from the right position after restart.
- */
-function loadCursor(ctx) {
-    try {
-        const cursorPath = resolvePluginStorePath(`cursors/${ctx.accountId}/cursor`);
-        return readFileSync(cursorPath, 'utf-8').trim() || null;
-    }
-    catch {
-        return null;
-    }
-}
-function saveCursor(ctx, cursor, log) {
-    try {
-        const filePath = resolvePluginStorePath(`cursors/${ctx.accountId}/cursor`);
-        const dir = dirname(filePath);
-        mkdirSync(dir, { recursive: true });
-        writeFileSync(filePath, cursor, 'utf-8');
-    }
-    catch (err) {
-        // Non-fatal — we'll just re-process some messages on restart
-        const message = err instanceof Error ? err.message : String(err);
-        log?.warn(`Failed to persist cursor: ${message}`);
-    }
-}
-/**
- * Main entry point for the DeskFree channel gateway.
- * Called by OpenClaw's channel manager via gateway.startAccount().
- *
- * Maintains a WebSocket connection for real-time notifications
- * and polls the messages endpoint for actual data.
- * Falls back to interval-based polling if WebSocket is unavailable.
- */
-export async function startDeskFreeConnection(ctx) {
-    const account = ctx.account;
-    const client = new DeskFreeClient(account.botToken, account.apiUrl);
-    const log = ctx.log ?? getDeskFreeRuntime().logging.createLogger('deskfree');
-    let cursor = loadCursor(ctx);
-    const backoff = { attempt: 0 };
-    let totalReconnects = 0;
-    // Initialize health tracking for this account
-    initializeHealth(ctx.accountId);
-    // Initialize the global error reporter so all modules can report errors
-    const errorReporter = initErrorReporter(client, log);
-    log.info(`Starting DeskFree connection for account ${ctx.accountId}` +
-        (cursor ? ` (resuming from cursor ${cursor})` : ' (fresh start)'));
-    // Start health logging timer
-    const healthInterval = setInterval(() => {
-        if (!ctx.abortSignal.aborted) {
-            logHealthSummary(ctx.accountId, log);
-        }
-    }, HEALTH_LOG_INTERVAL_MS);
-    // Clean up health interval on shutdown
-    ctx.abortSignal.addEventListener('abort', () => {
-        clearInterval(healthInterval);
-    }, { once: true });
-    // Outer reconnection loop — runs until OpenClaw shuts down
-    while (!ctx.abortSignal.aborted) {
-        try {
-            const { ticket, wsUrl } = await client.getWsTicket();
-            resetBackoff(backoff);
-            if (totalReconnects > 0) {
-                log.info(`Got WS ticket, reconnecting to ${wsUrl}... (reconnect #${totalReconnects})`);
-                recordReconnect(ctx.accountId);
-            }
-            else {
-                log.info(`Got WS ticket, connecting to ${wsUrl}...`);
-            }
-            updateHealthMode(ctx.accountId, 'websocket');
-            cursor = await runWebSocketConnection({
-                ticket,
-                wsUrl,
-                client,
-                ctx,
-                cursor,
-                log,
-                account,
-            });
-            // Connection closed cleanly — will reconnect
-            totalReconnects++;
-        }
-        catch (err) {
-            totalReconnects++;
-            const message = err instanceof Error ? err.message : String(err);
-            // If ticket fetch fails, fall back to polling
-            if (message.includes('API error') ||
-                message.includes('authentication failed') ||
-                message.includes('server error')) {
-                log.warn(`Ticket fetch failed (attempt #${totalReconnects}): ${message}. Falling back to polling.`);
-                reportError('error', `WS ticket fetch failed: ${message}`, {
-                    component: 'gateway',
-                    event: 'ticket_fetch_failed',
-                    attempt: totalReconnects,
-                });
-                recordReconnect(ctx.accountId);
-                updateHealthMode(ctx.accountId, 'polling');
-                cursor = await runPollingFallback({ client, ctx, cursor, log });
-            }
-            else {
-                log.warn(`Connection error (attempt #${totalReconnects}): ${message}`);
-                reportError('warn', `WS connection error: ${message}`, {
-                    component: 'gateway',
-                    event: 'connection_error',
-                    attempt: totalReconnects,
-                });
-                recordReconnect(ctx.accountId);
-            }
-            if (ctx.abortSignal.aborted)
-                break;
-            const delay = nextBackoff(backoff);
-            log.info(`Reconnecting in ${Math.round(delay)}ms (attempt #${totalReconnects + 1})...`);
-            await sleepWithAbort(delay, ctx.abortSignal);
-        }
-    }
-    // Flush any remaining errors before shutdown
-    await errorReporter.flush();
-    errorReporter.dispose();
-    log.info(`DeskFree connection loop exited after ${totalReconnects} reconnect(s).`);
-}
-/**
- * Runs a single WebSocket connection session.
- * Returns the latest cursor when the connection closes.
- */
-async function runWebSocketConnection(opts) {
-    const { ticket, wsUrl, client, ctx, log, account } = opts;
-    let cursor = opts.cursor;
-    return new Promise((resolve, reject) => {
-        const ws = new WebSocket(`${wsUrl}?ticket=${ticket}`);
-        let pingInterval;
-        let connectionTimer;
-        let pongTimer;
-        let isConnected = false;
-        // Centralized cleanup to prevent timer leaks
-        const cleanup = () => {
-            if (pingInterval !== undefined) {
-                clearInterval(pingInterval);
-                pingInterval = undefined;
-            }
-            if (connectionTimer !== undefined) {
-                clearTimeout(connectionTimer);
-                connectionTimer = undefined;
-            }
-            if (pongTimer !== undefined) {
-                clearTimeout(pongTimer);
-                pongTimer = undefined;
-            }
-        };
-        // Connection timeout - if no 'open' event within timeout, fail
-        connectionTimer = setTimeout(() => {
-            if (!isConnected) {
-                cleanup();
-                try {
-                    ws.close();
-                }
-                catch {
-                    // Ignore close errors during timeout cleanup
-                }
-                reject(new Error(`WebSocket connection timeout after ${WS_CONNECTION_TIMEOUT_MS}ms`));
-            }
-        }, WS_CONNECTION_TIMEOUT_MS);
-        ws.on('open', async () => {
-            isConnected = true;
-            if (connectionTimer !== undefined) {
-                clearTimeout(connectionTimer);
-                connectionTimer = undefined;
-            }
-            ctx.setStatus({ running: true, lastStartAt: Date.now() });
-            log.info('WebSocket connected.');
-            // Keepalive ping every 5 minutes with pong timeout handling
-            pingInterval = setInterval(() => {
-                if (ws.readyState === WebSocket.OPEN) {
-                    try {
-                        ws.send(JSON.stringify({ action: 'ping' }));
-                        // Start pong timeout
-                        pongTimer = setTimeout(() => {
-                            log.warn('Pong timeout - closing WebSocket connection');
-                            try {
-                                ws.close(1002, 'pong timeout');
-                            }
-                            catch (closeErr) {
-                                const closeMsg = closeErr instanceof Error
-                                    ? closeErr.message
-                                    : String(closeErr);
-                                log.warn(`Error closing WebSocket on pong timeout: ${closeMsg}`);
-                            }
-                        }, WS_PONG_TIMEOUT_MS);
-                    }
-                    catch (err) {
-                        const message = err instanceof Error ? err.message : String(err);
-                        log.warn(`Failed to send ping: ${message}`);
-                    }
-                }
-            }, PING_INTERVAL_MS);
-            // Report plugin + OpenClaw versions on connect
-            const openclawVersion = getDeskFreeRuntime().version;
-            client
-                .statusUpdate({
-                status: 'idle',
-                activeSubAgents: [],
-                pluginVersion: PLUGIN_VERSION,
-                openclawVersion,
-            })
-                .catch((err) => {
-                const msg = err instanceof Error ? err.message : String(err);
-                log.warn(`Failed to send statusUpdate: ${msg}`);
-            });
-            // Upload local workspace files to S3 on startup (backup local → S3)
-            try {
-                const cfg = getDeskFreeRuntime().config.loadConfig();
-                const workspacePath = resolveWorkspacePath(cfg);
-                if (workspacePath) {
-                    const success = await runS3CommandWithCredentials(client, (s3Uri) => ['s3', 'sync', '.', s3Uri, '--only-show-errors'], workspacePath, log);
-                    if (success) {
-                        log.info(`Workspace sync: uploaded files from ${workspacePath} to S3`);
-                    }
-                    else {
-                        log.warn('Workspace sync: failed to upload files to S3');
-                    }
-                }
-                else {
-                    log.debug('Workspace sync: no workspace path configured (agents.defaults.workspace)');
-                }
-            }
-            catch (err) {
-                const msg = err instanceof Error ? err.message : String(err);
-                log.warn(`Workspace sync failed: ${msg}`);
-            }
-            // NOTE: DeskFree directives are now injected via before_agent_start hook
-            // (see index.ts) instead of writing to AGENTS.md/HEARTBEAT.md files.
-            // Enqueue initial catch-up poll through mutex
-            enqueuePoll(client, ctx, () => cursor, (c) => {
-                cursor = c ?? cursor;
-            }, log, account);
-        });
-        ws.on('message', async (data) => {
-            try {
-                const raw = data.toString();
-                if (!raw || raw.length > 65536) {
-                    log.warn(`Ignoring oversized or empty WS message (${raw?.length ?? 0} bytes)`);
-                    return;
-                }
-                const msg = JSON.parse(raw);
-                if (!msg || typeof msg.action !== 'string') {
-                    log.warn('Ignoring WS message with missing or invalid action field');
-                    return;
-                }
-                if (msg.action === 'notify') {
-                    const notifyMsg = msg;
-                    // Handle workspace file changes from human edits
-                    if (notifyMsg.hint === 'workspace.fileChanged') {
-                        const paths = notifyMsg.paths ?? [];
-                        log.info(`Workspace file(s) changed by human: ${paths.join(', ') || '(all)'}`);
-                        // Download changed files using aws s3 cp
-                        try {
-                            const cfg = getDeskFreeRuntime().config.loadConfig();
-                            const workspacePath = resolveWorkspacePath(cfg);
-                            if (workspacePath && paths.length > 0) {
-                                for (const filePath of paths) {
-                                    try {
-                                        // Use aws s3 cp to download the specific changed file
-                                        const success = await runS3CommandWithCredentials(client, (s3Uri) => [
-                                            's3',
-                                            'cp',
-                                            `${s3Uri}/${filePath}`,
-                                            filePath,
-                                            '--only-show-errors',
-                                        ], workspacePath, log);
-                                        if (success) {
-                                            log.info(`Updated local file: ${filePath}`);
-                                        }
-                                        else {
-                                            log.warn(`Failed to download workspace file: ${filePath}`);
-                                        }
-                                    }
-                                    catch (err) {
-                                        const errMsg = err instanceof Error ? err.message : String(err);
-                                        log.warn(`Failed to download workspace file ${filePath}: ${errMsg}`);
-                                    }
-                                }
-                            }
-                            else if (!workspacePath) {
-                                log.warn('Cannot sync workspace files: workspace path not configured');
-                            }
-                        }
-                        catch (err) {
-                            const errMsg = err instanceof Error ? err.message : String(err);
-                            log.warn(`Workspace file change handling failed: ${errMsg}`);
-                        }
-                    }
-                    // Handle workspace upload requests (upload local → S3)
-                    if (notifyMsg.hint === 'workspace.uploadRequested') {
-                        log.info('Workspace upload requested');
-                        try {
-                            const cfg = getDeskFreeRuntime().config.loadConfig();
-                            const workspacePath = resolveWorkspacePath(cfg);
-                            if (workspacePath) {
-                                const success = await runS3CommandWithCredentials(client, (s3Uri) => ['s3', 'sync', '.', s3Uri, '--only-show-errors'], workspacePath, log);
-                                if (success) {
-                                    log.info(`Workspace upload: synced ${workspacePath} to S3`);
-                                }
-                                else {
-                                    log.warn('Workspace upload: failed to sync to S3');
-                                }
-                            }
-                            else {
-                                log.warn('Cannot upload workspace: workspace path not configured');
-                            }
-                        }
-                        catch (err) {
-                            const errMsg = err instanceof Error ? err.message : String(err);
-                            log.warn(`Workspace upload failed: ${errMsg}`);
-                        }
-                    }
-                    // Enqueue notification-triggered poll through mutex
-                    enqueuePoll(client, ctx, () => cursor, (c) => {
-                        cursor = c ?? cursor;
-                    }, log);
-                }
-                else if (msg.action === 'pong') {
-                    // Clear pong timeout - connection is healthy
-                    if (pongTimer !== undefined) {
-                        clearTimeout(pongTimer);
-                        pongTimer = undefined;
-                    }
-                    log.debug('Received pong - connection healthy');
-                }
-                // Ignore other message types
-            }
-            catch (err) {
-                const message = err instanceof Error ? err.message : String(err);
-                log.warn(`Error processing WS message: ${message}`);
-            }
-        });
-        ws.on('close', (code, reason) => {
-            cleanup();
-            isConnected = false;
-            ctx.setStatus({ running: false, lastStopAt: Date.now() });
-            // Classify close codes for better logging and error handling
-            if (code === 1000) {
-                log.info(`WebSocket closed normally: ${code} ${reason.toString()}`);
-            }
-            else if (code === 1001) {
-                log.info(`WebSocket closed - endpoint going away: ${code} ${reason.toString()}`);
-            }
-            else if (code >= 1002 && code <= 1011) {
-                log.warn(`WebSocket closed with error: ${code} ${reason.toString()}`);
-                reportError('error', `WebSocket closed with error: ${code} ${reason.toString()}`, {
-                    component: 'gateway',
-                    event: 'ws_close_error',
-                    closeCode: code,
-                });
-                ctx.setStatus({
-                    running: false,
-                    lastStopAt: Date.now(),
-                    lastError: `WebSocket closed with code ${code}: ${reason.toString()}`,
-                });
-            }
-            else if (code >= 4000) {
-                log.warn(`WebSocket closed with application error: ${code} ${reason.toString()}`);
-                reportError('error', `WebSocket application error: ${code} ${reason.toString()}`, {
-                    component: 'gateway',
-                    event: 'ws_close_app_error',
-                    closeCode: code,
-                });
-                ctx.setStatus({
-                    running: false,
-                    lastStopAt: Date.now(),
-                    lastError: `Application error ${code}: ${reason.toString()}`,
-                });
-            }
-            else {
-                log.info(`WebSocket closed: ${code} ${reason.toString()}`);
-            }
-            resolve(cursor);
-        });
-        ws.on('error', (err) => {
-            cleanup();
-            isConnected = false;
-            const errorMessage = err instanceof Error ? err.message : String(err);
-            log.error(`WebSocket error: ${errorMessage}`);
-            reportError('error', `WebSocket error: ${errorMessage}`, {
-                component: 'gateway',
-                event: 'ws_error',
-            });
-            ctx.setStatus({
-                running: false,
-                lastError: errorMessage,
-                lastStopAt: Date.now(),
-            });
-            reject(err);
-        });
-        // Clean shutdown - register abort handler before potential errors
-        ctx.abortSignal.addEventListener('abort', () => {
-            log.info('Shutdown requested - closing WebSocket');
-            cleanup();
-            try {
-                if (ws.readyState === WebSocket.OPEN ||
-                    ws.readyState === WebSocket.CONNECTING) {
-                    ws.close(1000, 'shutdown');
-                }
-            }
-            catch (err) {
-                const message = err instanceof Error ? err.message : String(err);
-                log.warn(`Error closing WebSocket during shutdown: ${message}`);
-            }
-        }, { once: true });
-    });
-}
-/**
- * Fallback polling loop when WebSocket is unavailable.
- * Polls every 30s until aborted or until we should retry WebSocket.
- */
-async function runPollingFallback(opts) {
-    const { client, ctx, log } = opts;
-    let cursor = opts.cursor;
-    let iterations = 0;
-    const maxIterations = 10; // After 10 polls (~5 min), try WebSocket again
-    ctx.setStatus({ running: true, lastStartAt: Date.now() });
-    log.info('Running in polling fallback mode.');
-    let consecutiveFailures = 0;
-    while (!ctx.abortSignal.aborted && iterations < maxIterations) {
-        const newCursor = await pollAndDeliver(client, ctx, cursor, log);
-        if (newCursor) {
-            cursor = newCursor;
-            consecutiveFailures = 0;
-        }
-        else if (newCursor === null && cursor) {
-            // null return with existing cursor means poll succeeded but no new messages - fine
-            consecutiveFailures = 0;
-        }
-        else {
-            consecutiveFailures++;
-            if (consecutiveFailures >= MAX_CONSECUTIVE_POLL_FAILURES) {
-                log.warn(`${consecutiveFailures} consecutive poll failures, breaking out to retry WebSocket`);
-                reportError('error', `${consecutiveFailures} consecutive poll failures, switching to WebSocket retry`, {
-                    component: 'gateway',
-                    event: 'poll_max_failures',
-                    consecutiveFailures,
-                });
-                break;
-            }
-        }
-        iterations++;
-        // Add jitter to poll interval to avoid thundering herd
-        const jitter = Math.random() * POLL_FALLBACK_INTERVAL_MS * 0.2;
-        await sleepWithAbort(POLL_FALLBACK_INTERVAL_MS + jitter, ctx.abortSignal);
-    }
-    ctx.setStatus({ running: false, lastStopAt: Date.now() });
-    return cursor;
-}
-/**
- * Poll the messages endpoint and deliver new messages to the OpenClaw agent.
- * Returns the new cursor, or null if no messages.
- *
- * On first run (cursor is null), we skip delivering old messages and just
- * seed the cursor so we only receive messages from this point forward.
- */
-async function pollAndDeliver(client, ctx, cursor, log, account) {
-    try {
-        // SEED is a sentinel value indicating we've completed the first-run
-        // flow but had no real cursor (empty inbox). Don't send it to the API
-        // since it's not a valid datetime cursor.
-        const SEED = 'SEED';
-        const isFirstRun = !cursor || cursor === SEED;
-        const apiCursor = cursor && cursor !== SEED ? cursor : undefined;
-        const response = await client.listMessages({
-            ...(apiCursor ? { cursor: apiCursor } : {}),
-        });
-        // On first run, don't deliver old messages — just seed the cursor
-        // and send a welcome message so the user knows the connection is live.
-        if (isFirstRun) {
-            if (response.cursor) {
-                log.info(`First run: skipping ${response.items.length} existing message(s), seeding cursor.`);
-                saveCursor(ctx, response.cursor, log);
-            }
-            else {
-                log.info('First run: no messages yet (empty inbox).');
-            }
-            log.info('Connected to DeskFree. Ready to receive messages and tasks.');
-            // Send welcome message to trigger the first agent session.
-            // This ensures workspace files get scaffolded on fresh instances.
-            try {
-                const botName = account?.botName;
-                const humanName = account?.humanName;
-                const welcomeContent = botName && humanName
-                    ? `Hi! I'm ${humanName}. Your name is ${botName}. Welcome to DeskFree — read your BOOTSTRAP.md to get started, then check for any tasks.`
-                    : "DeskFree plugin installed! Read your BOOTSTRAP.md if you haven't already, then check for any tasks.";
-                const welcomeMessage = {
-                    messageId: `welcome-${Date.now()}`,
-                    botId: '',
-                    humanId: 'system',
-                    authorType: 'user',
-                    content: welcomeContent,
-                    createdAt: new Date().toISOString(),
-                    userName: humanName ?? 'System',
-                };
-                await deliverMessageToAgent(ctx, welcomeMessage, client);
-                log.info('Sent welcome message to agent.');
-            }
-            catch (err) {
-                const msg = err instanceof Error ? err.message : String(err);
-                log.warn(`Failed to send welcome message: ${msg}`);
-            }
-            // Return the API cursor, or SEED as sentinel when API returns null
-            // (empty inbox) so subsequent polls don't re-trigger first-run flow.
-            return response.cursor ?? SEED;
-        }
-        if (response.items.length === 0)
-            return null;
-        // Filter out already-delivered messages (handles cursor precision issues
-        // where Postgres microsecond timestamps round-trip through JS millisecond Date)
-        const newItems = response.items.filter((m) => !deliveredMessageIds.has(m.messageId));
-        if (newItems.length === 0) {
-            log.debug(`Poll returned ${response.items.length} item(s), all already delivered.`);
-            // Still advance cursor even if all items were duplicates
-            if (response.cursor) {
-                saveCursor(ctx, response.cursor, log);
-            }
-            return response.cursor;
-        }
-        log.info(`Received ${newItems.length} new message(s) (${response.items.length - newItems.length} duplicate(s) skipped).`);
-        // Save cursor after each successful delivery so a mid-batch
-        // failure doesn't cause the entire batch to be re-delivered on retry.
-        let deliveredCount = 0;
-        for (const message of newItems) {
-            // Skip bot's own messages to prevent echo loops
-            if (message.authorType === 'bot') {
-                log.debug(`Skipping bot message ${message.messageId}`);
-                deliveredMessageIds.add(message.messageId);
-                continue;
-            }
-            await deliverMessageToAgent(ctx, message, client);
-            deliveredMessageIds.add(message.messageId);
-            deliveredCount++;
-        }
-        // Cap the dedup set to prevent unbounded memory growth
-        if (deliveredMessageIds.size > 1000) {
-            const entries = Array.from(deliveredMessageIds);
-            deliveredMessageIds.clear();
-            for (const id of entries.slice(-500)) {
-                deliveredMessageIds.add(id);
-            }
-        }
-        // Record message delivery in health stats
-        if (deliveredCount > 0) {
-            recordMessageDelivery(ctx.accountId, deliveredCount);
-        }
-        // Persist cursor
-        if (response.cursor) {
-            saveCursor(ctx, response.cursor, log);
-        }
-        return response.cursor;
-    }
-    catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        log.warn(`Poll failed: ${message}`);
-        reportError('warn', `Message poll failed: ${message}`, {
-            component: 'gateway',
-            event: 'poll_failed',
-        });
-        return null;
-    }
-}
-//# sourceMappingURL=gateway.js.map