agent-tempo 1.0.1

package/dist/workflows/scheduler-signals.d.ts

@@ -0,0 +1,10 @@
+import type { ScheduleEntry } from '../types';
+export type { ScheduleEntry } from '../types';
+export declare const addScheduleSignal: import("@temporalio/workflow").SignalDefinition<[ScheduleEntry], string>;
+export declare const removeScheduleSignal: import("@temporalio/workflow").SignalDefinition<[string], string>;
+/** Rewrite schedule targets from oldName to newName (fired on player rename). */
+export declare const updateScheduleTargetSignal: import("@temporalio/workflow").SignalDefinition<[string, string], string>;
+/** Pause or resume the scheduler. When paused, due fires are skipped. */
+export declare const setSchedulerPausedSignal: import("@temporalio/workflow").SignalDefinition<[boolean], string>;
+export declare const getSchedulesQuery: import("@temporalio/workflow").QueryDefinition<ScheduleEntry[], [], string>;
+export declare const getScheduleQuery: import("@temporalio/workflow").QueryDefinition<ScheduleEntry | null, [string], string>;

package/dist/workflows/scheduler-signals.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getScheduleQuery = exports.getSchedulesQuery = exports.setSchedulerPausedSignal = exports.updateScheduleTargetSignal = exports.removeScheduleSignal = exports.addScheduleSignal = void 0;
+const workflow_1 = require("@temporalio/workflow");
+// ── Scheduler Signals ──
+exports.addScheduleSignal = (0, workflow_1.defineSignal)('addSchedule');
+exports.removeScheduleSignal = (0, workflow_1.defineSignal)('removeSchedule');
+/** Rewrite schedule targets from oldName to newName (fired on player rename). */
+exports.updateScheduleTargetSignal = (0, workflow_1.defineSignal)('updateScheduleTarget');
+/** Pause or resume the scheduler. When paused, due fires are skipped. */
+exports.setSchedulerPausedSignal = (0, workflow_1.defineSignal)('setSchedulerPaused');
+// ── Scheduler Queries ──
+exports.getSchedulesQuery = (0, workflow_1.defineQuery)('getSchedules');
+exports.getScheduleQuery = (0, workflow_1.defineQuery)('getSchedule');

package/dist/workflows/scheduler.d.ts

@@ -0,0 +1,17 @@
+import type { ScheduleEntry } from '../types';
+export interface SchedulerInput {
+    ensemble: string;
+    /** Restored from continue-as-new. */
+    entries?: ScheduleEntry[];
+    /** Restored from continue-as-new: paused state. */
+    paused?: boolean;
+    /**
+     * Milliseconds to wait for new entries before the workflow self-terminates when the
+     * entries list is empty. Defaults to {@link DEFAULT_GRACE_PERIOD_MS} — 30s in production.
+     * Tests override (e.g. to 100ms) to keep the "self-terminates when empty" case fast;
+     * `setupTestEnv` uses `createLocal()` so this delay is real wall-clock time.
+     * Always propagated via continue-as-new so behavior stays consistent across re-entries.
+     */
+    gracePeriodMs?: number;
+}
+export declare function agentSchedulerWorkflow(input: SchedulerInput): Promise<void>;

package/dist/workflows/scheduler.js

@@ -0,0 +1,143 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.agentSchedulerWorkflow = agentSchedulerWorkflow;
+const workflow_1 = require("@temporalio/workflow");
+const scheduler_signals_1 = require("./scheduler-signals");
+const { fireSchedule, computeNextCronFire } = (0, workflow_1.proxyActivities)({
+    startToCloseTimeout: '30 seconds',
+    retry: { maximumAttempts: 3 },
+});
+/** Default self-termination grace period — 30 000 ms (see §scheduler "empty self-terminate"). */
+const DEFAULT_GRACE_PERIOD_MS = 30_000;
+async function agentSchedulerWorkflow(input) {
+    let entries = input.entries ?? [];
+    let dirty = false; // flag to wake the loop when signals arrive
+    let schedulerPaused = input.paused ?? false;
+    let skippedWhilePaused = 0;
+    const gracePeriodMs = input.gracePeriodMs ?? DEFAULT_GRACE_PERIOD_MS;
+    // ── Signal Handlers ──
+    (0, workflow_1.setHandler)(scheduler_signals_1.addScheduleSignal, (entry) => {
+        // Replace existing entry with same name, or add new
+        const idx = entries.findIndex((e) => e.name === entry.name);
+        if (idx >= 0) {
+            entries[idx] = entry;
+        }
+        else {
+            entries.push(entry);
+        }
+        dirty = true;
+    });
+    (0, workflow_1.setHandler)(scheduler_signals_1.removeScheduleSignal, (name) => {
+        entries = entries.filter((e) => e.name !== name);
+        dirty = true;
+    });
+    (0, workflow_1.setHandler)(scheduler_signals_1.updateScheduleTargetSignal, (oldName, newName) => {
+        for (const entry of entries) {
+            if (entry.target === oldName) {
+                entry.target = newName;
+            }
+            if (entry.createdBy === oldName) {
+                entry.createdBy = newName;
+            }
+        }
+        dirty = true;
+    });
+    (0, workflow_1.setHandler)(scheduler_signals_1.setSchedulerPausedSignal, (value) => {
+        schedulerPaused = value;
+        dirty = true; // wake the loop to handle the state change
+    });
+    // ── Query Handlers ──
+    (0, workflow_1.setHandler)(scheduler_signals_1.getSchedulesQuery, () => entries);
+    (0, workflow_1.setHandler)(scheduler_signals_1.getScheduleQuery, (name) => entries.find((e) => e.name === name) ?? null);
+    // ── Main Loop ──
+    while (true) {
+        // Self-terminate when empty
+        if (entries.length === 0) {
+            // Wait `gracePeriodMs` for new entries to arrive before terminating.
+            // Production default is 30s; tests override via `SchedulerInput.gracePeriodMs`
+            // because `TestWorkflowEnvironment.createLocal()` does NOT time-skip.
+            dirty = false;
+            await (0, workflow_1.condition)(() => dirty, gracePeriodMs);
+            if (entries.length === 0)
+                break;
+        }
+        // Sort by nextFireAt ascending
+        entries.sort((a, b) => a.nextFireAt.localeCompare(b.nextFireAt));
+        const now = Date.now();
+        const earliest = new Date(entries[0].nextFireAt).getTime();
+        const sleepMs = Math.max(earliest - now, 0);
+        if (sleepMs > 0) {
+            // Sleep until next fire time, or wake early if a signal arrives
+            dirty = false;
+            await (0, workflow_1.condition)(() => dirty, `${sleepMs} milliseconds`);
+            // If woken by signal, re-check from top (entries may have changed)
+            if (dirty)
+                continue;
+        }
+        // Fire all due entries
+        const fireTime = Date.now();
+        const due = entries.filter((e) => new Date(e.nextFireAt).getTime() <= fireTime);
+        for (const entry of due) {
+            // When paused, skip firing but still reschedule/remove below
+            if (!schedulerPaused) {
+                try {
+                    await fireSchedule({
+                        ensemble: input.ensemble,
+                        scheduleName: entry.name,
+                        message: entry.message,
+                        target: entry.target,
+                        createdBy: entry.createdBy,
+                    });
+                }
+                catch (err) {
+                    // Activity retries exhausted — log but don't crash the workflow
+                    // The entry will be rescheduled or removed below
+                }
+            }
+            else {
+                skippedWhilePaused += 1;
+            }
+            entry.firedCount += 1;
+            // Decrement remaining count
+            if (entry.remainingCount !== undefined) {
+                entry.remainingCount -= 1;
+            }
+            // Determine if entry should be removed or rescheduled
+            const expired = entry.until && new Date(entry.until).getTime() <= Date.now();
+            const exhausted = entry.remainingCount !== undefined && entry.remainingCount <= 0;
+            if (entry.type === 'once' || expired || exhausted) {
+                entries = entries.filter((e) => e.name !== entry.name);
+            }
+            else if (entry.type === 'interval' && entry.interval) {
+                entry.nextFireAt = new Date(Date.now() + entry.interval).toISOString();
+            }
+            else if ((0, workflow_1.patched)('v0.12-cron-schedule') && entry.type === 'cron' && entry.cronExpression) {
+                const nextFire = await computeNextCronFire({
+                    cronExpression: entry.cronExpression,
+                    timezone: entry.timezone,
+                });
+                if (nextFire) {
+                    entry.nextFireAt = nextFire;
+                }
+                else {
+                    entries = entries.filter((e) => e.name !== entry.name);
+                }
+            }
+        }
+        // Prevent unbounded history growth
+        const info = (0, workflow_1.workflowInfo)();
+        if (info.continueAsNewSuggested) {
+            await (0, workflow_1.condition)(workflow_1.allHandlersFinished);
+            await (0, workflow_1.continueAsNew)({
+                ensemble: input.ensemble,
+                entries,
+                paused: schedulerPaused,
+                // Propagate the configured grace period — omitting this would silently
+                // revert tests that set a short window back to the 30s default on re-entry.
+                gracePeriodMs: input.gracePeriodMs,
+            });
+        }
+    }
+    // Graceful shutdown — wait for in-flight handlers
+    await (0, workflow_1.condition)(workflow_1.allHandlersFinished);
+}

package/dist/workflows/session.d.ts

@@ -0,0 +1,2 @@
+import { SessionInput } from './signals';
+export declare function agentSessionWorkflow(input: SessionInput): Promise<void>;