capacitor-mobile-claw 2.0.0 → 2.0.2

package/dist/esm/agent/heartbeat-manager.js

@@ -1,711 +0,0 @@
-import { AgentRunner } from './agent-runner';
-import { SessionStore } from './session-store';
-const DEFAULT_HEARTBEAT_PROMPT = 'Read HEARTBEAT.md if it exists (workspace context). Follow it strictly. Do not infer or repeat old tasks from prior chats. If nothing needs attention, reply HEARTBEAT_OK.';
-const HEARTBEAT_OK_TOKENS = ['HEARTBEAT_OK', 'heartbeat_ok', 'ok', 'OK', '✓', '👍'];
-const ERROR_BACKOFF_MS = [30_000, 60_000, 300_000, 900_000, 3_600_000];
-const DEDUP_WINDOW_MS = 24 * 60 * 60 * 1000;
-const WORKER_BRIDGE_TIMEOUT_MS = 10_000;
-export class HeartbeatManager {
-    config;
-    wakeInFlight = false;
-    heartbeatConsecutiveErrors = 0;
-    sessionStore = new SessionStore();
-    _cronTimer = null;
-    _cronApprovalResolvers = new Map();
-    constructor(config) {
-        this.config = config;
-    }
-    /** Resolve a pending cron approval request (called from engine). */
-    respondToCronApproval(requestId, approved) {
-        const pending = this._cronApprovalResolvers.get(requestId);
-        if (pending) {
-            pending.resolve(approved);
-            this._cronApprovalResolvers.delete(requestId);
-        }
-    }
-    /** Kick off the self-rearming cron timer. Call once after init. */
-    startCronTimer() {
-        this._armCronTimer();
-    }
-    async handleWake(source, opts = {}) {
-        if (this.wakeInFlight) {
-            this._emit('heartbeat.skipped', { reason: 'busy' });
-            return;
-        }
-        this.wakeInFlight = true;
-        const startedAt = Date.now();
-        try {
-            const scheduler = await this.config.cronDb.getSchedulerConfig();
-            const isManual = source === 'manual' || opts.force === true;
-            if (!isManual && !scheduler.enabled) {
-                this._emit('heartbeat.skipped', { reason: 'scheduler_disabled' });
-                await this._emitSchedulerStatus();
-                return;
-            }
-            if (!isManual && this.config.isUserAgentRunning()) {
-                this._emit('heartbeat.skipped', { reason: 'user_active' });
-                await this._emitSchedulerStatus();
-                return;
-            }
-            this._emit('heartbeat.started', { source });
-            const now = Date.now();
-            const heartbeatResult = await this._runHeartbeatCycle({
-                source,
-                now,
-                force: isManual,
-                forceSessionKey: opts.forceSessionKey,
-            });
-            await this._runDueCronJobs({
-                source,
-                now,
-                forceJobId: opts.forceJobId,
-            });
-            const durationMs = Date.now() - startedAt;
-            if (heartbeatResult.status === 'skipped') {
-                this._emit('heartbeat.skipped', { reason: heartbeatResult.reason || 'not_due' });
-            }
-            else {
-                this._emit('heartbeat.completed', {
-                    status: heartbeatResult.status,
-                    reason: heartbeatResult.reason,
-                    durationMs,
-                    ...(heartbeatResult.responsePreview ? { responsePreview: heartbeatResult.responsePreview } : {}),
-                });
-            }
-            await this._emitSchedulerStatus();
-        }
-        catch (err) {
-            this._emit('heartbeat.completed', {
-                status: 'error',
-                reason: err?.message || 'heartbeat_failed',
-                durationMs: Date.now() - startedAt,
-            });
-        }
-        finally {
-            this.wakeInFlight = false;
-            this._armCronTimer();
-        }
-    }
-    /**
-     * Self-rearming timer (mirrors OpenClaw's armTimer pattern).
-     * After each wake completes, check for the next due job and schedule
-     * a setTimeout to fire it. Clamped to 60s max to prevent drift.
-     * Native WorkManager handles background wakes; this handles foreground.
-     */
-    _armCronTimer() {
-        if (this._cronTimer) {
-            clearTimeout(this._cronTimer);
-            this._cronTimer = null;
-        }
-        this.config.cronDb.getDueJobs(Date.now() + 120_000).then((upcoming) => {
-            if (!upcoming.length)
-                return;
-            const now = Date.now();
-            const earliest = Math.min(...upcoming.map((j) => j.nextRunAt ?? Infinity));
-            if (!Number.isFinite(earliest))
-                return;
-            const delay = Math.max(earliest - now, 1_000);
-            const clamped = Math.min(delay, 60_000);
-            this._cronTimer = setTimeout(() => {
-                this._cronTimer = null;
-                this.handleWake('timer').catch((err) => {
-                    console.warn('[HeartbeatManager] Timer wake failed:', err?.message);
-                });
-            }, clamped);
-        }).catch(() => {
-            // DB error — will retry on next native wake
-        });
-    }
-    async _runHeartbeatCycle(params) {
-        const config = await this.config.cronDb.getHeartbeatConfig();
-        const startedAt = params.now;
-        const everyMs = Number(config.everyMs) || 1_800_000;
-        if (!params.force && !config.enabled) {
-            return { status: 'skipped', reason: 'heartbeat_disabled' };
-        }
-        if (!params.force && config.nextRunAt && startedAt < config.nextRunAt) {
-            return { status: 'skipped', reason: 'not_due' };
-        }
-        if (!isWithinActiveHours(config.activeHours?.start, config.activeHours?.end, config.activeHours?.tz, startedAt)) {
-            await this.config.cronDb.setHeartbeatConfig({
-                nextRunAt: startedAt + Math.max(15_000, everyMs),
-            });
-            return { status: 'skipped', reason: 'outside_active_hours' };
-        }
-        const heartbeatSkill = await this._resolveSkill(config.skillId);
-        const eventSessionKey = params.forceSessionKey || this.config.getCurrentSessionKey() || 'main';
-        const pendingEvents = await this.config.cronDb.peekPendingEvents(eventSessionKey);
-        const prompt = buildHeartbeatPrompt(config.prompt || DEFAULT_HEARTBEAT_PROMPT, pendingEvents);
-        try {
-            const sessionKey = params.announceToMain ? eventSessionKey : `heartbeat/${startedAt}`;
-            const result = await this._runAgentTurn({
-                prompt,
-                skill: heartbeatSkill,
-                sessionKey,
-                dispatchToEngine: params.announceToMain,
-            });
-            const trimmed = result.text.trim();
-            const hash = fnv1aHash(trimmed);
-            const isOk = isHeartbeatOk(trimmed);
-            const isDuplicate = !!trimmed &&
-                !!config.lastHash &&
-                config.lastHash === hash &&
-                !!config.lastSentAt &&
-                startedAt - config.lastSentAt < DEDUP_WINDOW_MS;
-            if (!trimmed || isOk || isDuplicate) {
-                await this._consumePendingEvents(pendingEvents);
-                await this.config.cronDb.setHeartbeatConfig({
-                    nextRunAt: startedAt + everyMs,
-                });
-                this.heartbeatConsecutiveErrors = 0;
-                if (isDuplicate)
-                    return { status: 'deduped', reason: 'duplicate' };
-                if (isOk)
-                    return { status: 'suppressed', reason: 'heartbeat_ok' };
-                return { status: 'suppressed', reason: 'empty' };
-            }
-            await this._persistSession(result);
-            await this._consumePendingEvents(pendingEvents);
-            await this.config.cronDb.setHeartbeatConfig({
-                nextRunAt: startedAt + everyMs,
-                lastHash: hash,
-                lastSentAt: startedAt,
-            });
-            this.heartbeatConsecutiveErrors = 0;
-            this._emit('cron.notification', {
-                title: 'Sentinel heartbeat',
-                body: trimmed,
-                source: 'heartbeat',
-            });
-            return {
-                status: 'ok',
-                responsePreview: trimmed.slice(0, 240),
-            };
-        }
-        catch (err) {
-            this.heartbeatConsecutiveErrors += 1;
-            const normalNext = startedAt + everyMs;
-            const backoffNext = startedAt + errorBackoffMs(this.heartbeatConsecutiveErrors);
-            await this.config.cronDb.setHeartbeatConfig({
-                nextRunAt: Math.max(normalNext, backoffNext),
-            });
-            return {
-                status: 'error',
-                reason: err?.message || 'heartbeat_error',
-            };
-        }
-    }
-    async _runDueCronJobs(params) {
-        const skills = await this.config.cronDb.listCronSkills();
-        const skillById = new Map(skills.map((skill) => [skill.id, skill]));
-        const allJobs = await this.config.cronDb.listCronJobs();
-        const dueJobs = params.forceJobId
-            ? allJobs.filter((job) => job.id === params.forceJobId)
-            : await this.config.cronDb.getDueJobs(params.now);
-        for (const job of dueJobs) {
-            const startedAt = Date.now();
-            const skill = skillById.get(job.skillId) || null;
-            if (!job.enabled)
-                continue;
-            if (!isWithinActiveHours(job.activeHours?.start, job.activeHours?.end, job.activeHours?.tz, startedAt)) {
-                await this.config.cronDb.updateCronJob(job.id, {
-                    lastRunAt: startedAt,
-                    nextRunAt: computeNextRunAt(job, startedAt),
-                    lastRunStatus: 'skipped',
-                });
-                await this.config.cronDb.insertCronRun({
-                    jobId: job.id,
-                    startedAt,
-                    endedAt: Date.now(),
-                    status: 'skipped',
-                    wakeSource: params.source,
-                });
-                continue;
-            }
-            this._emit('cron.job.started', { jobId: job.id, jobName: job.name });
-            try {
-                if (job.sessionTarget === 'main') {
-                    const sessionKey = this.config.getCurrentSessionKey() || 'main';
-                    await this.config.cronDb.enqueueSystemEvent(sessionKey, `cron:${job.id}:${startedAt}`, job.prompt);
-                    if (job.wakeMode === 'now' || params.forceJobId === job.id) {
-                        await this._runHeartbeatCycle({
-                            source: `cron:${job.id}`,
-                            now: Date.now(),
-                            force: true,
-                            forceSessionKey: sessionKey,
-                        });
-                    }
-                    const runEndedAt = Date.now();
-                    await this.config.cronDb.updateCronJob(job.id, {
-                        lastRunAt: startedAt,
-                        nextRunAt: computeNextRunAt(job, startedAt),
-                        lastRunStatus: 'ok',
-                        lastError: null,
-                        lastDurationMs: runEndedAt - startedAt,
-                        consecutiveErrors: 0,
-                    });
-                    await this.config.cronDb.insertCronRun({
-                        jobId: job.id,
-                        startedAt,
-                        endedAt: runEndedAt,
-                        status: 'ok',
-                        responseText: 'Enqueued to main session heartbeat.',
-                        delivered: false,
-                        wakeSource: params.source,
-                    });
-                    this._emit('cron.job.completed', {
-                        jobId: job.id,
-                        status: 'ok',
-                        durationMs: runEndedAt - startedAt,
-                        responsePreview: 'Queued for heartbeat',
-                    });
-                    continue;
-                }
-                const result = await this._runAgentTurn({
-                    prompt: job.prompt,
-                    skill,
-                    sessionKey: `cron/${job.id}/${startedAt}`,
-                    cronJob: job,
-                });
-                const trimmed = result.text.trim();
-                const hash = fnv1aHash(trimmed);
-                const heartbeatOk = isHeartbeatOk(trimmed);
-                const isDeduped = !!trimmed &&
-                    !!job.lastResponseHash &&
-                    job.lastResponseHash === hash &&
-                    !!job.lastResponseSentAt &&
-                    startedAt - job.lastResponseSentAt < DEDUP_WINDOW_MS;
-                const status = !trimmed ? 'suppressed' : heartbeatOk ? 'suppressed' : isDeduped ? 'deduped' : 'ok';
-                let delivered = false;
-                if (status === 'ok') {
-                    delivered = await this._deliverCronResult(job, trimmed);
-                    await this._persistSession(result);
-                    // Announce: enqueue result as system event in main session
-                    const mainSessionKey = this.config.getCurrentSessionKey() || 'main';
-                    await this.config.cronDb.enqueueSystemEvent(mainSessionKey, `cron:${job.id}:${startedAt}`, `[Scheduled task "${job.name}" completed]\n\n${trimmed}`);
-                    // Surface to main agent if user is idle
-                    if (!this.config.isUserAgentRunning()) {
-                        try {
-                            await this._runHeartbeatCycle({
-                                source: `cron:announce:${job.id}`,
-                                now: Date.now(),
-                                force: true,
-                                forceSessionKey: mainSessionKey,
-                                announceToMain: true,
-                            });
-                        }
-                        catch (announceErr) {
-                            console.warn('[HeartbeatManager] Announce heartbeat failed:', announceErr?.message);
-                        }
-                    }
-                }
-                const runEndedAt = Date.now();
-                await this.config.cronDb.updateCronJob(job.id, {
-                    lastRunAt: startedAt,
-                    nextRunAt: computeNextRunAt(job, startedAt),
-                    lastRunStatus: status,
-                    lastError: null,
-                    lastDurationMs: runEndedAt - startedAt,
-                    lastResponseHash: trimmed ? hash : job.lastResponseHash,
-                    lastResponseSentAt: delivered ? runEndedAt : job.lastResponseSentAt,
-                    consecutiveErrors: 0,
-                });
-                await this.config.cronDb.insertCronRun({
-                    jobId: job.id,
-                    startedAt,
-                    endedAt: runEndedAt,
-                    status,
-                    durationMs: runEndedAt - startedAt,
-                    responseText: trimmed || null,
-                    wasHeartbeatOk: heartbeatOk,
-                    wasDeduped: isDeduped,
-                    delivered,
-                    wakeSource: params.source,
-                });
-                this._emit('cron.job.completed', {
-                    jobId: job.id,
-                    status,
-                    durationMs: runEndedAt - startedAt,
-                    ...(trimmed ? { responsePreview: trimmed.slice(0, 200) } : {}),
-                });
-            }
-            catch (err) {
-                const nextConsecutiveErrors = (job.consecutiveErrors || 0) + 1;
-                const normalNext = computeNextRunAt(job, startedAt);
-                const backoffNext = startedAt + errorBackoffMs(nextConsecutiveErrors);
-                const nextRunAt = normalNext ? Math.max(normalNext, backoffNext) : backoffNext;
-                await this.config.cronDb.updateCronJob(job.id, {
-                    lastRunAt: startedAt,
-                    nextRunAt,
-                    lastRunStatus: 'error',
-                    lastError: err?.message || 'cron_error',
-                    lastDurationMs: Date.now() - startedAt,
-                    consecutiveErrors: nextConsecutiveErrors,
-                });
-                await this.config.cronDb.insertCronRun({
-                    jobId: job.id,
-                    startedAt,
-                    endedAt: Date.now(),
-                    status: 'error',
-                    error: err?.message || 'cron_error',
-                    wakeSource: params.source,
-                });
-                this._emit('cron.job.error', {
-                    jobId: job.id,
-                    error: err?.message || 'cron_error',
-                    consecutiveErrors: nextConsecutiveErrors,
-                });
-            }
-        }
-    }
-    async _runAgentTurn(params) {
-        const provider = 'anthropic';
-        const authResult = await withTimeout(this.config.getAuth(provider, 'main'), WORKER_BRIDGE_TIMEOUT_MS, 'auth.getToken timeout');
-        if (!authResult.apiKey) {
-            throw new Error('No API provider configured');
-        }
-        const promptResult = await withTimeout(this.config.getSystemPrompt('main'), WORKER_BRIDGE_TIMEOUT_MS, 'system_prompt.get timeout');
-        let agentError = null;
-        const localApprovals = new Map();
-        // Timeout pause/resume for approval waits
-        const model = params.skill?.model || 'claude-sonnet-4-5';
-        const totalTimeoutMs = Math.max(1_000, Number(params.skill?.timeoutMs) || 60_000);
-        let remaining = totalTimeoutMs;
-        let timerStart = Date.now();
-        let timer = null;
-        let rejectTimeout = null;
-        let runner = null;
-        const clearTimer = () => {
-            if (timer) {
-                clearTimeout(timer);
-                timer = null;
-            }
-        };
-        const startTimer = () => {
-            clearTimer();
-            timerStart = Date.now();
-            timer = setTimeout(() => {
-                runner?.abort();
-                rejectTimeout?.(new Error(`Agent run timed out after ${totalTimeoutMs}ms`));
-            }, remaining);
-        };
-        const pauseTimer = () => {
-            clearTimer();
-            remaining -= Date.now() - timerStart;
-            if (remaining < 0)
-                remaining = 0;
-        };
-        const resumeTimer = () => {
-            timerStart = Date.now();
-            startTimer();
-        };
-        // Build middleware for cron jobs (approval forwarding + _cronContext injection)
-        const cronJob = params.cronJob;
-        const middleware = cronJob
-            ? async (ctx, execute, signal) => {
-                const requestId = `${cronJob.id}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
-                const cronContext = { jobId: cronJob.id, jobName: cronJob.name, requestId };
-                const argsWithContext = { ...ctx.args, _cronContext: cronContext };
-                const needsApproval = this.config.needsApproval?.(ctx.name) ?? false;
-                if (!needsApproval) {
-                    return execute(argsWithContext);
-                }
-                // Emit approval request to main session UI
-                this._emit('cron.approval_request', {
-                    requestId,
-                    jobId: cronJob.id,
-                    jobName: cronJob.name,
-                    toolName: ctx.name,
-                    toolCallId: ctx.toolCallId,
-                    args: ctx.args,
-                    _cronContext: cronContext,
-                });
-                // Pause timeout while waiting for user
-                pauseTimer();
-                try {
-                    const approved = await new Promise((resolve) => {
-                        localApprovals.set(requestId, { resolve });
-                        this._cronApprovalResolvers.set(requestId, { resolve });
-                        signal?.addEventListener('abort', () => {
-                            localApprovals.delete(requestId);
-                            this._cronApprovalResolvers.delete(requestId);
-                            resolve(false);
-                        });
-                    });
-                    if (!approved) {
-                        return {
-                            content: [{ type: 'text', text: `Tool "${ctx.name}" execution was denied by user.` }],
-                            details: { denied: true, reason: 'user_denied' },
-                        };
-                    }
-                    return execute(argsWithContext);
-                }
-                finally {
-                    localApprovals.delete(requestId);
-                    this._cronApprovalResolvers.delete(requestId);
-                    resumeTimer();
-                }
-            }
-            : undefined;
-        runner = new AgentRunner({
-            dispatch: (msg) => {
-                if (msg.type === 'agent.error') {
-                    agentError = typeof msg.error === 'string' ? msg.error : 'Agent execution failed';
-                }
-                if (params.dispatchToEngine) {
-                    this.config.dispatch(msg);
-                }
-            },
-            toolProxy: this.config.toolProxy,
-            ...(middleware ? { toolMiddleware: middleware } : {}),
-        });
-        try {
-            await Promise.race([
-                runner.run({
-                    prompt: params.prompt,
-                    agentId: 'main',
-                    sessionKey: params.sessionKey,
-                    apiKey: authResult.apiKey,
-                    provider,
-                    systemPrompt: params.skill?.systemPrompt || promptResult.systemPrompt,
-                    model,
-                    maxTurns: params.skill?.maxTurns ?? 3,
-                    allowedTools: params.skill?.allowedTools,
-                    extraTools: this.config.extraTools,
-                }),
-                new Promise((_, reject) => {
-                    rejectTimeout = reject;
-                    startTimer();
-                }),
-            ]);
-        }
-        finally {
-            clearTimer();
-            // Stale approval cleanup: resolve all pending as denied, notify UI
-            for (const [requestId] of localApprovals) {
-                const pending = this._cronApprovalResolvers.get(requestId);
-                if (pending) {
-                    pending.resolve(false);
-                    this._cronApprovalResolvers.delete(requestId);
-                }
-                this._emit('cron.approval_expired', { requestId });
-            }
-            localApprovals.clear();
-        }
-        if (agentError) {
-            throw new Error(agentError);
-        }
-        const messages = runner.currentAgent?.state.messages || [];
-        return {
-            text: extractLastAssistantText(messages),
-            sessionKey: params.sessionKey,
-            messages,
-            model,
-        };
-    }
-    async _persistSession(result) {
-        if (!result.messages.length)
-            return;
-        try {
-            await this.sessionStore.saveSession({
-                sessionKey: result.sessionKey,
-                agentId: 'main',
-                messages: result.messages,
-                model: `anthropic/${result.model}`,
-                startTime: Date.now(),
-            });
-        }
-        catch (err) {
-            console.warn('[HeartbeatManager] Failed to persist session:', err?.message);
-        }
-    }
-    async _deliverCronResult(job, text) {
-        if (!text || job.deliveryMode === 'none')
-            return false;
-        if (job.deliveryMode === 'webhook' && job.deliveryWebhookUrl) {
-            try {
-                const response = await fetch(job.deliveryWebhookUrl, {
-                    method: 'POST',
-                    headers: { 'Content-Type': 'application/json' },
-                    body: JSON.stringify({
-                        jobId: job.id,
-                        jobName: job.name,
-                        text,
-                        sentAt: Date.now(),
-                    }),
-                });
-                if (response.ok)
-                    return true;
-            }
-            catch {
-                // Fall back to a local notification event.
-            }
-        }
-        this._emit('cron.notification', {
-            title: job.deliveryNotificationTitle || job.name,
-            body: text,
-            jobId: job.id,
-            source: 'cron',
-        });
-        return true;
-    }
-    async _resolveSkill(skillId) {
-        if (!skillId)
-            return null;
-        const skills = await this.config.cronDb.listCronSkills();
-        return skills.find((skill) => skill.id === skillId) || null;
-    }
-    async _emitSchedulerStatus() {
-        const scheduler = await this.config.cronDb.getSchedulerConfig();
-        const heartbeat = await this.config.cronDb.getHeartbeatConfig();
-        const dueJobs = await this.config.cronDb.getDueJobs(Date.now());
-        this._emit('scheduler.status', {
-            enabled: scheduler.enabled,
-            mode: scheduler.schedulingMode || 'balanced',
-            heartbeatNext: heartbeat.nextRunAt,
-            nextDueAt: dueJobs[0]?.nextRunAt,
-        });
-    }
-    async _consumePendingEvents(events) {
-        if (!events.length)
-            return;
-        await this.config.cronDb.consumePendingEvents(events.map((event) => event.id));
-    }
-    _emit(type, payload = {}) {
-        this.config.dispatch({ type, ...payload });
-    }
-}
-async function withTimeout(promise, timeoutMs, message) {
-    let timer = null;
-    try {
-        return await Promise.race([
-            promise,
-            new Promise((_, reject) => {
-                timer = setTimeout(() => reject(new Error(message)), timeoutMs);
-            }),
-        ]);
-    }
-    finally {
-        if (timer)
-            clearTimeout(timer);
-    }
-}
-export function extractLastAssistantText(messages) {
-    for (let i = messages.length - 1; i >= 0; i -= 1) {
-        const message = messages[i];
-        if (message?.role !== 'assistant')
-            continue;
-        if (typeof message.content === 'string')
-            return message.content;
-        if (!Array.isArray(message.content))
-            continue;
-        const text = message.content
-            .filter((part) => part?.type === 'text')
-            .map((part) => part?.text || '')
-            .join('')
-            .trim();
-        if (text)
-            return text;
-    }
-    return '';
-}
-export function buildHeartbeatPrompt(basePrompt, pendingEvents) {
-    if (!pendingEvents.length)
-        return basePrompt;
-    const lines = pendingEvents.map((event) => {
-        const timestamp = new Date(event.createdAt).toISOString();
-        const contextKey = event.contextKey ? ` (${event.contextKey})` : '';
-        return `- [${timestamp}]${contextKey} ${event.text}`;
-    });
-    return `${basePrompt}\n\nSystem events:\n${lines.join('\n')}`;
-}
-export function computeNextRunAt(job, nowMs) {
-    const schedule = job.schedule || {};
-    if (schedule.kind === 'every') {
-        const everyMs = Number(schedule.everyMs) || 0;
-        return everyMs > 0 ? nowMs + everyMs : null;
-    }
-    if (schedule.kind === 'at') {
-        const atMs = Number(schedule.atMs) || 0;
-        return atMs > nowMs ? atMs : null;
-    }
-    return null;
-}
-export function isHeartbeatOk(text) {
-    const trimmed = (text || '').trim();
-    if (!trimmed)
-        return true;
-    return HEARTBEAT_OK_TOKENS.some((token) => trimmed === token || trimmed.startsWith(`${token}\n`));
-}
-export function fnv1aHash(str) {
-    let hash = 0x811c9dc5;
-    for (let i = 0; i < str.length; i += 1) {
-        hash ^= str.charCodeAt(i);
-        hash = Math.imul(hash, 0x01000193);
-    }
-    return (hash >>> 0).toString(16).padStart(8, '0');
-}
-export function errorBackoffMs(consecutiveErrors) {
-    const index = Math.min(consecutiveErrors - 1, ERROR_BACKOFF_MS.length - 1);
-    return ERROR_BACKOFF_MS[Math.max(0, index)];
-}
-function parseActiveHoursMinutes(raw, allow24 = false) {
-    if (typeof raw !== 'string')
-        return null;
-    const match = raw.trim().match(/^(\d{2}):(\d{2})$/);
-    if (!match)
-        return null;
-    const hour = Number(match[1]);
-    const minute = Number(match[2]);
-    if (!Number.isFinite(hour) || !Number.isFinite(minute))
-        return null;
-    if (hour === 24) {
-        if (!allow24 || minute !== 0)
-            return null;
-        return 24 * 60;
-    }
-    if (hour < 0 || hour > 23 || minute < 0 || minute > 59)
-        return null;
-    return hour * 60 + minute;
-}
-function resolveMinutesInTimeZone(nowMs, tz) {
-    try {
-        const parts = new Intl.DateTimeFormat('en-US', {
-            timeZone: tz || 'UTC',
-            hour: '2-digit',
-            minute: '2-digit',
-            hourCycle: 'h23',
-        }).formatToParts(new Date(nowMs));
-        const values = {};
-        for (const part of parts) {
-            if (part.type !== 'literal')
-                values[part.type] = part.value;
-        }
-        const hour = Number(values.hour);
-        const minute = Number(values.minute);
-        if (!Number.isFinite(hour) || !Number.isFinite(minute))
-            return null;
-        return hour * 60 + minute;
-    }
-    catch {
-        return null;
-    }
-}
-export function isWithinActiveHours(start, end, tz, nowMs = Date.now()) {
-    if (!start || !end)
-        return true;
-    const startMin = parseActiveHoursMinutes(start, false);
-    const endMin = parseActiveHoursMinutes(end, true);
-    if (startMin === null || endMin === null)
-        return true;
-    if (startMin === endMin)
-        return false;
-    const currentMin = resolveMinutesInTimeZone(nowMs, tz || 'UTC');
-    if (currentMin === null)
-        return true;
-    if (endMin > startMin) {
-        return currentMin >= startMin && currentMin < endMin;
-    }
-    return currentMin >= startMin || currentMin < endMin;
-}
-//# sourceMappingURL=heartbeat-manager.js.map