@atolis-hq/wake 0.2.97 → 0.3.0

package/dist/src/core/quota-backoff.js

@@ -1,69 +0,0 @@
-function applyTimeOfDay(input) {
-    let hours = input.hours;
-    if (hours === 12) {
-        hours = 0;
-    }
-    if (input.meridiem === 'pm') {
-        hours += 12;
-    }
-    const reset = new Date(input.now);
-    if (input.useUtc) {
-        reset.setUTCHours(hours, input.minutes, 0, 0);
-        if (reset.getTime() <= input.now.getTime()) {
-            reset.setUTCDate(reset.getUTCDate() + 1);
-        }
-    }
-    else {
-        reset.setHours(hours, input.minutes, 0, 0);
-        if (reset.getTime() <= input.now.getTime()) {
-            reset.setDate(reset.getDate() + 1);
-        }
-    }
-    return reset.toISOString();
-}
-// CLIs report quota resets in prose, e.g. Claude's "resets 1:10am (UTC)" or
-// Codex's "try again at 2:29 PM" (no zone marker at all). Only trust a time as
-// UTC when the message says so explicitly; an unlabeled time is the CLI
-// provider's local clock, not ours, but treating it as this machine's local
-// time is the closest honest guess without a zone — better than silently
-// assuming UTC and pausing for the wrong duration.
-const utcResetPattern = /(?:resets?|try again at)\s+(\d{1,2})(?::(\d{2}))?\s*(am|pm)\s*(?:\(utc\)|utc)/i;
-const localResetPattern = /(?:resets?|try again at)\s+(\d{1,2})(?::(\d{2}))?\s*(am|pm)\b/i;
-// A cap on the exponential-backoff guess used when no reset time is reported
-// (see below). Kept well under a working day so a stuck-forever pause is
-// never possible even if the guess is wrong - worst case, Wake retries hourly.
-const maxEstimatedPauseMs = 60 * 60_000;
-export function resolveQuotaPauseUntil(input) {
-    const utcMatch = utcResetPattern.exec(input.result);
-    if (utcMatch !== null) {
-        return {
-            pausedUntil: applyTimeOfDay({
-                hours: Number(utcMatch[1]),
-                minutes: Number(utcMatch[2] ?? 0),
-                meridiem: utcMatch[3]?.toLowerCase(),
-                now: input.now,
-                useUtc: true,
-            }),
-            source: 'reported',
-        };
-    }
-    const localMatch = localResetPattern.exec(input.result);
-    if (localMatch !== null) {
-        return {
-            pausedUntil: applyTimeOfDay({
-                hours: Number(localMatch[1]),
-                minutes: Number(localMatch[2] ?? 0),
-                meridiem: localMatch[3]?.toLowerCase(),
-                now: input.now,
-                useUtc: false,
-            }),
-            source: 'reported',
-        };
-    }
-    const boundedFailureCount = Math.max(1, Math.min(input.failureCount, 6));
-    const delayMs = Math.min(15 * 60_000 * 2 ** (boundedFailureCount - 1), maxEstimatedPauseMs);
-    return {
-        pausedUntil: new Date(input.now.getTime() + delayMs).toISOString(),
-        source: 'estimated',
-    };
-}

package/dist/src/core/run-lease.js

@@ -1,38 +0,0 @@
-import { randomUUID } from 'node:crypto';
-export const runLeaseDurationMs = 60_000;
-export const runLeaseRenewalIntervalMs = 20_000;
-export function createRunLease(input) {
-    const acquiredAt = input.clock.now();
-    const expiresAt = new Date(acquiredAt.getTime() + runLeaseDurationMs);
-    return {
-        leaseId: `lease-${randomUUID()}`,
-        ownerInstanceId: input.ownerInstanceId,
-        acquiredAt: acquiredAt.toISOString(),
-        lastRenewedAt: acquiredAt.toISOString(),
-        expiresAt: expiresAt.toISOString(),
-    };
-}
-export function isRunLeaseExpired(record, now) {
-    if (record.lease === undefined) {
-        return true;
-    }
-    return Date.parse(record.lease.expiresAt) <= now.getTime();
-}
-export async function renewRunLease(input) {
-    const now = input.clock.now();
-    const renewed = await input.stateStore.updateRunRecordIf(input.runId, {
-        expect: (record) => record.status === 'running' &&
-            record.lifecycle !== 'TERMINAL' &&
-            record.lease?.leaseId === input.leaseId &&
-            record.lease.ownerInstanceId === input.ownerInstanceId,
-        update: (record) => ({
-            ...record,
-            lease: {
-                ...record.lease,
-                lastRenewedAt: now.toISOString(),
-                expiresAt: new Date(now.getTime() + runLeaseDurationMs).toISOString(),
-            },
-        }),
-    });
-    return renewed !== null;
-}

package/dist/src/core/scheduled-workflow-source.js

@@ -1,199 +0,0 @@
-import { createUnkeyedEventEnvelope } from '../lib/event-log.js';
-import { buildResourceUri } from '../domain/resource-uri.js';
-import { readJsonFile, writeJsonFile } from '../lib/json-file.js';
-import { createWakePaths } from '../lib/paths.js';
-import { isMissingPathError } from '../lib/state-health.js';
-const syntheticRepo = 'wake/internal';
-const syntheticIssueNumber = 1;
-function parseCronField(raw, min, max) {
-    const allowed = new Set();
-    for (const part of raw.split(',')) {
-        const trimmed = part.trim();
-        if (trimmed.length === 0) {
-            throw new Error(`invalid cron field "${raw}"`);
-        }
-        const stepMatch = /^(.*)\/(\d+)$/.exec(trimmed);
-        const base = stepMatch?.[1] ?? trimmed;
-        const step = stepMatch === null ? 1 : Number(stepMatch[2]);
-        if (!Number.isInteger(step) || step <= 0) {
-            throw new Error(`invalid cron step "${trimmed}"`);
-        }
-        const range = base === '*'
-            ? [min, max]
-            : (() => {
-                const match = /^(\d+)(?:-(\d+))?$/.exec(base);
-                if (match === null) {
-                    throw new Error(`invalid cron segment "${trimmed}"`);
-                }
-                const start = Number(match[1]);
-                const end = match[2] === undefined ? start : Number(match[2]);
-                if (start < min || end > max || start > end) {
-                    throw new Error(`cron segment "${trimmed}" is outside ${min}-${max}`);
-                }
-                return [start, end];
-            })();
-        for (let value = range[0]; value <= range[1]; value += step) {
-            allowed.add(value);
-        }
-    }
-    return { matches: (value) => allowed.has(value) };
-}
-function parseCron(cron) {
-    const fields = cron.trim().split(/\s+/);
-    if (fields.length !== 5) {
-        throw new Error(`cron schedule must have five fields: ${cron}`);
-    }
-    return [
-        parseCronField(fields[0], 0, 59),
-        parseCronField(fields[1], 0, 23),
-        parseCronField(fields[2], 1, 31),
-        parseCronField(fields[3], 1, 12),
-        parseCronField(fields[4], 0, 6),
-    ];
-}
-function matchesCron(date, cron) {
-    return (cron[0].matches(date.getUTCMinutes()) &&
-        cron[1].matches(date.getUTCHours()) &&
-        cron[2].matches(date.getUTCDate()) &&
-        cron[3].matches(date.getUTCMonth() + 1) &&
-        cron[4].matches(date.getUTCDay()));
-}
-function floorToMinute(date) {
-    const copy = new Date(date);
-    copy.setUTCSeconds(0, 0);
-    return copy;
-}
-export function previousMatchingSlot(input) {
-    const parsed = parseCron(input.cron);
-    const slot = floorToMinute(input.now);
-    const afterMs = input.after === undefined ? undefined : Date.parse(input.after);
-    const lookbackMinutes = 366 * 24 * 60;
-    for (let checked = 0; checked < lookbackMinutes; checked += 1) {
-        const slotIso = slot.toISOString();
-        if (afterMs !== undefined && slot.getTime() <= afterMs) {
-            return null;
-        }
-        if (matchesCron(slot, parsed)) {
-            return slotIso;
-        }
-        slot.setUTCMinutes(slot.getUTCMinutes() - 1);
-    }
-    return null;
-}
-function triggerStateFile(wakeRoot, workflow) {
-    return `${createWakePaths(wakeRoot).dataRoot}/triggers/${workflow}.json`;
-}
-async function readTriggerState(wakeRoot, workflow) {
-    try {
-        const raw = await readJsonFile(triggerStateFile(wakeRoot, workflow));
-        if (raw === null || typeof raw !== 'object') {
-            return null;
-        }
-        const record = raw;
-        return record.schemaVersion === 1 &&
-            record.workflow === workflow &&
-            typeof record.lastFiredSlot === 'string' &&
-            typeof record.updatedAt === 'string'
-            ? {
-                schemaVersion: 1,
-                workflow,
-                lastFiredSlot: record.lastFiredSlot,
-                updatedAt: record.updatedAt,
-            }
-            : null;
-    }
-    catch (error) {
-        if (isMissingPathError(error)) {
-            return null;
-        }
-        throw error;
-    }
-}
-function scheduledEventId(workflow, slot) {
-    return `scheduled-workflow-${workflow}-${slot.replace(/[^a-z0-9]+/gi, '-')}`;
-}
-function scheduledResourceUri(workflow, slot) {
-    return buildResourceUri('wake', 'schedule', `${workflow}@${slot}`);
-}
-function syntheticTicket(input) {
-    const eventId = scheduledEventId(input.workflow, input.slot);
-    const resourceUri = scheduledResourceUri(input.workflow, input.slot);
-    const url = `https://wake.local/schedules/${encodeURIComponent(input.workflow)}/${encodeURIComponent(input.slot)}`;
-    return createUnkeyedEventEnvelope({
-        eventId,
-        streamScope: 'global-intake',
-        direction: 'inbound',
-        sourceSystem: 'wake',
-        sourceEventType: 'ticket.upsert',
-        sourceRefs: {
-            repo: syntheticRepo,
-            issueNumber: syntheticIssueNumber,
-            sourceUrl: url,
-            resourceUri,
-        },
-        occurredAt: input.slot,
-        ingestedAt: input.now,
-        trigger: 'immediate',
-        payload: {
-            ticket: {
-                repo: syntheticRepo,
-                number: syntheticIssueNumber,
-                title: `Scheduled workflow: ${input.workflow}`,
-                body: `Wake fired scheduled workflow "${input.workflow}" for cron slot ${input.slot}.`,
-                labels: ['wake:scheduled-workflow', `wake:workflow.${input.workflow}`],
-                assignees: [],
-                isPullRequest: false,
-                state: 'open',
-                url,
-                createdAt: input.slot,
-                updatedAt: input.slot,
-            },
-            workflow: input.workflow,
-            trigger: {
-                kind: 'schedule',
-                slot: input.slot,
-                idempotencyKey: eventId,
-            },
-            providerEventType: 'wake.schedule.fired',
-        },
-        derivedHints: {
-            workflow: input.workflow,
-        },
-    });
-}
-export function createScheduledWorkflowSource(deps) {
-    return {
-        async pollEvents() {
-            const events = [];
-            const now = deps.now();
-            const nowIso = now.toISOString();
-            for (const [workflow, definition] of Object.entries(deps.config.workflows)) {
-                const cron = definition.trigger?.schedule?.cron;
-                if (cron === undefined) {
-                    continue;
-                }
-                const state = await readTriggerState(deps.config.paths.wakeRoot, workflow);
-                const slot = previousMatchingSlot({
-                    cron,
-                    now,
-                    ...(state?.lastFiredSlot === undefined ? {} : { after: state.lastFiredSlot }),
-                });
-                if (slot === null) {
-                    continue;
-                }
-                const eventId = scheduledEventId(workflow, slot);
-                if ((await deps.stateStore.readEventEnvelope(eventId)) !== null) {
-                    await writeJsonFile(triggerStateFile(deps.config.paths.wakeRoot, workflow), {
-                        schemaVersion: 1,
-                        workflow,
-                        lastFiredSlot: slot,
-                        updatedAt: nowIso,
-                    });
-                    continue;
-                }
-                events.push(syntheticTicket({ workflow, slot, now: nowIso }));
-            }
-            return events;
-        },
-    };
-}

package/dist/src/core/sink-router.js

@@ -1,107 +0,0 @@
-import { LABELS_REQUESTED_EVENT, PUBLISH_INTENT_REQUESTED_EVENT } from '../domain/event-types.js';
-export function createWorkSourceFanIn(sources) {
-    return {
-        async pollEvents(input) {
-            const batches = await Promise.all(sources.map((source) => source.pollEvents(input)));
-            return batches.flat();
-        },
-        async refreshForDispatch(input) {
-            for (const source of sources) {
-                if (source.refreshForDispatch === undefined) {
-                    continue;
-                }
-                const result = await source.refreshForDispatch(input);
-                if (result !== null) {
-                    return result;
-                }
-            }
-            return null;
-        },
-    };
-}
-function intentKind(event) {
-    if (event.sourceEventType !== PUBLISH_INTENT_REQUESTED_EVENT) {
-        return null;
-    }
-    return typeof event.payload.kind === 'string' ? event.payload.kind : null;
-}
-function isTerminalStageIntent(event) {
-    const stage = event.derivedHints?.stage;
-    return stage === 'done' || event.payload.sentinel === 'BLOCKED';
-}
-function subscriptionMatches(event, subscription) {
-    if (subscription === intentKind(event)) {
-        return true;
-    }
-    return subscription === 'stage.terminal' && isTerminalStageIntent(event);
-}
-function sinkNameForResourceUri(resourceUri, fallback) {
-    const [provider, kind] = resourceUri.split(':');
-    if (provider === undefined || kind === undefined) {
-        return fallback;
-    }
-    return kind === 'pr' || kind === 'pr-review-thread' ? `${provider}-pr` : fallback;
-}
-function withSinkRef(event, sink) {
-    return {
-        ...event,
-        sourceRefs: {
-            ...event.sourceRefs,
-            sink: event.sourceRefs.sink ?? sink,
-        },
-    };
-}
-function targetSinksForEvent(input) {
-    const targetSinks = new Set();
-    const origin = typeof input.event.payload.origin === 'string' ? input.event.payload.origin : undefined;
-    const sourceOrigin = input.event.sourceRefs.sink ?? origin;
-    if (input.event.sourceEventType === LABELS_REQUESTED_EVENT) {
-        const projectionOrigin = typeof input.event.payload.origin === 'string' ? input.event.payload.origin : undefined;
-        if (projectionOrigin !== undefined) {
-            targetSinks.add(projectionOrigin);
-        }
-    }
-    const resourceUri = input.event.sourceRefs.resourceUri;
-    if (input.event.sourceEventType === PUBLISH_INTENT_REQUESTED_EVENT &&
-        sourceOrigin !== undefined) {
-        const resourceSink = resourceUri === undefined ? sourceOrigin : sinkNameForResourceUri(resourceUri, sourceOrigin);
-        targetSinks.add(input.sinksByName.has(resourceSink) ? resourceSink : sourceOrigin);
-    }
-    for (const [sinkName, sinkConfig] of Object.entries(input.config.sinks ?? {})) {
-        if (sinkConfig.subscribe.some((subscription) => subscriptionMatches(input.event, subscription))) {
-            targetSinks.add(sinkName);
-        }
-    }
-    return targetSinks;
-}
-export function createOutboundSinkRouter(input) {
-    const sinksByName = new Map(input.sinks.map((sink) => [sink.sink, sink]));
-    return {
-        async deliverIntent({ event }) {
-            const targetSinks = targetSinksForEvent({ event, sinksByName, config: input.config });
-            const deliveryEvents = [];
-            for (const sinkName of targetSinks) {
-                const sink = sinksByName.get(sinkName);
-                if (sink === undefined) {
-                    continue;
-                }
-                const sinkDeliveryEvents = await sink.deliverIntent({ event });
-                deliveryEvents.push(...sinkDeliveryEvents.map((deliveryEvent) => withSinkRef(deliveryEvent, sinkName)));
-            }
-            return deliveryEvents;
-        },
-        async reconcileIntent({ event }) {
-            const targetSinks = targetSinksForEvent({ event, sinksByName, config: input.config });
-            const deliveryEvents = [];
-            for (const sinkName of targetSinks) {
-                const sink = sinksByName.get(sinkName);
-                if (sink?.reconcileIntent === undefined) {
-                    continue;
-                }
-                const sinkDeliveryEvents = await sink.reconcileIntent({ event });
-                deliveryEvents.push(...sinkDeliveryEvents.map((deliveryEvent) => withSinkRef(deliveryEvent, sinkName)));
-            }
-            return deliveryEvents;
-        },
-    };
-}