@hyperdrive.bot/fleet-server 0.3.99

package/dist/server/server/resolve-worktree-creation-intent.js

@@ -0,0 +1,121 @@
+export class MissingCheckoutTargetError extends Error {
+    constructor() {
+        super('action "checkout" requires refName or githubPrNumber');
+        this.action = "checkout";
+        this.name = "MissingCheckoutTargetError";
+    }
+}
+export async function resolveWorktreeCreationIntent(input, repoRoot, deps) {
+    if (input.action === "branch-off") {
+        return {
+            kind: "branch-off",
+            baseBranch: input.refName?.trim() || (await resolveDefaultBranch(repoRoot, deps)),
+            branchName: input.branchName ?? input.worktreeSlug,
+        };
+    }
+    if (input.action === "checkout") {
+        if (input.githubPrNumber !== undefined) {
+            return resolveGitHubPrCheckoutIntent({
+                refName: input.refName,
+                githubPrNumber: input.githubPrNumber,
+                repoRoot,
+                deps,
+            });
+        }
+        const branchName = input.refName?.trim();
+        if (branchName) {
+            return {
+                kind: "checkout-branch",
+                branchName,
+            };
+        }
+        throw new MissingCheckoutTargetError();
+    }
+    if (input.githubPrNumber !== undefined) {
+        return resolveGitHubPrCheckoutIntent({
+            refName: input.refName,
+            githubPrNumber: input.githubPrNumber,
+            repoRoot,
+            deps,
+        });
+    }
+    if (input.refName?.trim()) {
+        return {
+            kind: "branch-off",
+            baseBranch: input.refName.trim(),
+            branchName: input.branchName ?? input.worktreeSlug,
+        };
+    }
+    return {
+        kind: "branch-off",
+        baseBranch: await resolveDefaultBranch(repoRoot, deps),
+        branchName: input.branchName ?? input.worktreeSlug,
+    };
+}
+async function resolveGitHubPrCheckoutIntent(params) {
+    const checkoutTarget = await resolveGitHubPrCheckoutTarget(params);
+    const headRef = await resolveGitHubPrHeadRef({
+        refName: params.refName,
+        githubPrNumber: params.githubPrNumber,
+        checkoutTarget,
+        repoRoot: params.repoRoot,
+        deps: params.deps,
+    });
+    const baseRefName = checkoutTarget?.baseRefName?.trim() ||
+        (await resolveDefaultBranch(params.repoRoot, params.deps));
+    const localBranchName = buildGitHubPrLocalBranchName({ headRef, checkoutTarget });
+    const pushRemoteUrl = checkoutTarget?.isCrossRepository
+        ? checkoutTarget.headRepositorySshUrl || checkoutTarget.headRepositoryUrl || undefined
+        : undefined;
+    const trackOriginHead = checkoutTarget ? !checkoutTarget.isCrossRepository : false;
+    return {
+        kind: "checkout-github-pr",
+        githubPrNumber: params.githubPrNumber,
+        headRef,
+        baseRefName,
+        ...(localBranchName !== headRef ? { localBranchName } : {}),
+        ...(pushRemoteUrl ? { pushRemoteUrl } : {}),
+        ...(trackOriginHead ? { trackOriginHead } : {}),
+    };
+}
+async function resolveGitHubPrCheckoutTarget(params) {
+    if (!params.deps.github.getPullRequestCheckoutTarget) {
+        return null;
+    }
+    return params.deps.github.getPullRequestCheckoutTarget({
+        cwd: params.repoRoot,
+        number: params.githubPrNumber,
+    });
+}
+async function resolveDefaultBranch(repoRoot, deps) {
+    const baseBranch = await deps.resolveDefaultBranch(repoRoot);
+    if (!baseBranch) {
+        throw new Error("Unable to resolve repository default branch");
+    }
+    return baseBranch;
+}
+async function resolveGitHubPrHeadRef(params) {
+    const trimmedRefName = params.refName?.trim();
+    if (trimmedRefName) {
+        return trimmedRefName;
+    }
+    const checkoutTargetHeadRef = params.checkoutTarget?.headRefName.trim();
+    if (checkoutTargetHeadRef) {
+        return checkoutTargetHeadRef;
+    }
+    return params.deps.github.getPullRequestHeadRef({
+        cwd: params.repoRoot,
+        number: params.githubPrNumber,
+    });
+}
+function buildGitHubPrLocalBranchName(params) {
+    const owner = params.checkoutTarget?.isCrossRepository
+        ? normalizeGitHubOwnerForBranch(params.checkoutTarget.headOwnerLogin)
+        : null;
+    return owner ? `${owner}/${params.headRef}` : params.headRef;
+}
+function normalizeGitHubOwnerForBranch(owner) {
+    const normalized = owner?.trim().toLowerCase() ?? "";
+    return /^[a-z0-9-]+$/.test(normalized) ? normalized : null;
+}
+//# sourceMappingURL=resolve-worktree-creation-intent.js.map

package/dist/server/server/restart-manifest.d.ts

@@ -0,0 +1,83 @@
+import type { Logger } from "pino";
+import { z } from "zod";
+/**
+ * The set of agents that were mid-turn when the daemon went down, handed from
+ * the shutdown that ended them to the boot that brings them back.
+ *
+ * A daemon restart closes every live agent on the box, and boot deliberately
+ * does not reload any of them: the registry is read for metadata only and
+ * agents initialize on demand. For an idle agent that is exactly right -
+ * `ensureAgentLoaded` restores it losslessly, for free, the moment anything
+ * touches it, so eagerly reloading all of them would buy nothing.
+ *
+ * It is not right for an agent that was RUNNING. Its turn was cut off
+ * mid-sentence and nothing ever tells it so: the next thing that agent sees is
+ * whatever message arrives next, minutes or hours later, with no indication
+ * that the run it was in the middle of never finished.
+ *
+ * So this manifest records that set and only that set. Nudging every loaded
+ * agent instead would mean one provider turn per agent on every restart -
+ * including the routine ones, like a version bump - which costs real money and
+ * makes idle agents do surprising unattended work nobody asked for.
+ */
+declare const RESTART_MANIFEST_SCHEMA: z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    writtenAt: z.ZodString;
+    reason: z.ZodString;
+    agentIds: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+export type RestartManifest = z.infer<typeof RESTART_MANIFEST_SCHEMA>;
+export declare const RESTART_MANIFEST_FILENAME = "restart-manifest.json";
+/**
+ * Past a day, "resume what you were doing" is likelier to confuse than help:
+ * the world has moved and the agent will be picked up on demand anyway. This
+ * bounds a manifest left behind by a daemon that stayed down.
+ */
+export declare const RESTART_MANIFEST_MAX_AGE_MS: number;
+/**
+ * Resolve the manifest path from an ALREADY-RESOLVED paseo home.
+ *
+ * Callers pass the home in; this module never reads `process.env.PASEO_HOME`
+ * itself. Re-deriving the home in a second place is precisely how PTY recording
+ * silently stopped for 14 days: `paseo daemon restart` replaced the daemon with
+ * a detached process that did not inherit the systemd unit's `Environment=`, so
+ * one half of the system resolved a different home than the other and nothing
+ * logged a word about it. Write and read must agree by construction, not by
+ * both happening to call the same getter.
+ */
+export declare function restartManifestPath(paseoHome: string): string;
+export interface WriteRestartManifestParams {
+    paseoHome: string;
+    agentIds: readonly string[];
+    reason: string;
+    logger: Logger;
+    now?: Date;
+}
+/**
+ * Record the in-flight set on the way down. Never throws: a daemon must always
+ * be able to finish shutting down, and losing the nudge is a far smaller
+ * failure than hanging the stop path.
+ */
+export declare function writeRestartManifest({ paseoHome, agentIds, reason, logger, now, }: WriteRestartManifestParams): Promise<void>;
+export interface ClearRestartManifestParams {
+    paseoHome: string;
+    logger: Logger;
+}
+export declare function clearRestartManifest({ paseoHome, logger, }: ClearRestartManifestParams): Promise<void>;
+export interface ReadRestartManifestParams {
+    paseoHome: string;
+    logger: Logger;
+    now?: Date;
+    maxAgeMs?: number;
+}
+/**
+ * Read the manifest and delete it in the same breath, BEFORE any agent is
+ * resumed.
+ *
+ * Clearing first is what stops a resume that crashes the daemon from replaying
+ * itself on every boot forever. The nudge is best-effort by design: losing it
+ * costs one message, replaying it costs an unbounded crash-loop.
+ */
+export declare function readAndClearRestartManifest({ paseoHome, logger, now, maxAgeMs, }: ReadRestartManifestParams): Promise<RestartManifest | null>;
+export {};
+//# sourceMappingURL=restart-manifest.d.ts.map

package/dist/server/server/restart-manifest.js

@@ -0,0 +1,122 @@
+import { promises as fs } from "node:fs";
+import path from "node:path";
+import { z } from "zod";
+import { writeJsonFileAtomic } from "./atomic-file.js";
+/**
+ * The set of agents that were mid-turn when the daemon went down, handed from
+ * the shutdown that ended them to the boot that brings them back.
+ *
+ * A daemon restart closes every live agent on the box, and boot deliberately
+ * does not reload any of them: the registry is read for metadata only and
+ * agents initialize on demand. For an idle agent that is exactly right -
+ * `ensureAgentLoaded` restores it losslessly, for free, the moment anything
+ * touches it, so eagerly reloading all of them would buy nothing.
+ *
+ * It is not right for an agent that was RUNNING. Its turn was cut off
+ * mid-sentence and nothing ever tells it so: the next thing that agent sees is
+ * whatever message arrives next, minutes or hours later, with no indication
+ * that the run it was in the middle of never finished.
+ *
+ * So this manifest records that set and only that set. Nudging every loaded
+ * agent instead would mean one provider turn per agent on every restart -
+ * including the routine ones, like a version bump - which costs real money and
+ * makes idle agents do surprising unattended work nobody asked for.
+ */
+const RESTART_MANIFEST_SCHEMA = z.object({
+    version: z.literal(1),
+    writtenAt: z.string(),
+    reason: z.string(),
+    agentIds: z.array(z.string()),
+});
+export const RESTART_MANIFEST_FILENAME = "restart-manifest.json";
+/**
+ * Past a day, "resume what you were doing" is likelier to confuse than help:
+ * the world has moved and the agent will be picked up on demand anyway. This
+ * bounds a manifest left behind by a daemon that stayed down.
+ */
+export const RESTART_MANIFEST_MAX_AGE_MS = 24 * 60 * 60 * 1000;
+/**
+ * Resolve the manifest path from an ALREADY-RESOLVED paseo home.
+ *
+ * Callers pass the home in; this module never reads `process.env.PASEO_HOME`
+ * itself. Re-deriving the home in a second place is precisely how PTY recording
+ * silently stopped for 14 days: `paseo daemon restart` replaced the daemon with
+ * a detached process that did not inherit the systemd unit's `Environment=`, so
+ * one half of the system resolved a different home than the other and nothing
+ * logged a word about it. Write and read must agree by construction, not by
+ * both happening to call the same getter.
+ */
+export function restartManifestPath(paseoHome) {
+    return path.join(paseoHome, RESTART_MANIFEST_FILENAME);
+}
+/**
+ * Record the in-flight set on the way down. Never throws: a daemon must always
+ * be able to finish shutting down, and losing the nudge is a far smaller
+ * failure than hanging the stop path.
+ */
+export async function writeRestartManifest({ paseoHome, agentIds, reason, logger, now = new Date(), }) {
+    if (agentIds.length === 0) {
+        // Nothing was mid-turn. Clear any manifest from an earlier shutdown so a
+        // stale one cannot resurrect agents that have since finished.
+        await clearRestartManifest({ paseoHome, logger });
+        return;
+    }
+    const manifest = {
+        version: 1,
+        writtenAt: now.toISOString(),
+        reason,
+        agentIds: [...agentIds],
+    };
+    try {
+        await writeJsonFileAtomic(restartManifestPath(paseoHome), manifest);
+        logger.info({ count: agentIds.length, reason, path: restartManifestPath(paseoHome) }, "Recorded in-flight agents for resume after restart");
+    }
+    catch (err) {
+        logger.warn({ err, reason }, "Failed to record in-flight agents; resume will be skipped");
+    }
+}
+export async function clearRestartManifest({ paseoHome, logger, }) {
+    try {
+        await fs.rm(restartManifestPath(paseoHome), { force: true });
+    }
+    catch (err) {
+        logger.warn({ err }, "Failed to clear restart manifest");
+    }
+}
+/**
+ * Read the manifest and delete it in the same breath, BEFORE any agent is
+ * resumed.
+ *
+ * Clearing first is what stops a resume that crashes the daemon from replaying
+ * itself on every boot forever. The nudge is best-effort by design: losing it
+ * costs one message, replaying it costs an unbounded crash-loop.
+ */
+export async function readAndClearRestartManifest({ paseoHome, logger, now = new Date(), maxAgeMs = RESTART_MANIFEST_MAX_AGE_MS, }) {
+    const manifestPath = restartManifestPath(paseoHome);
+    let raw;
+    try {
+        raw = await fs.readFile(manifestPath, "utf8");
+    }
+    catch (err) {
+        if (err.code !== "ENOENT") {
+            logger.warn({ err, path: manifestPath }, "Failed to read restart manifest");
+        }
+        return null;
+    }
+    await clearRestartManifest({ paseoHome, logger });
+    let manifest;
+    try {
+        manifest = RESTART_MANIFEST_SCHEMA.parse(JSON.parse(raw));
+    }
+    catch (err) {
+        logger.warn({ err, path: manifestPath }, "Restart manifest is unreadable; ignoring it");
+        return null;
+    }
+    const ageMs = now.getTime() - new Date(manifest.writtenAt).getTime();
+    if (!Number.isFinite(ageMs) || ageMs > maxAgeMs) {
+        logger.info({ ageMs, writtenAt: manifest.writtenAt, count: manifest.agentIds.length }, "Restart manifest is too old to act on; agents will resume on demand");
+        return null;
+    }
+    return manifest;
+}
+//# sourceMappingURL=restart-manifest.js.map

package/dist/server/server/resume-after-restart.d.ts

@@ -0,0 +1,50 @@
+import type { Logger } from "pino";
+import type { AgentManager } from "./agent/agent-manager.js";
+import type { AgentStorage } from "./agent/agent-storage.js";
+/**
+ * What the resumed agent is told.
+ *
+ * It deliberately does more than announce the restart. An interrupted turn may
+ * have half-completed whatever it was doing - a file written but not committed,
+ * a request sent but its response never read - and the agent has no way to tell
+ * from its own transcript which side of that line it stopped on. Telling it to
+ * re-check state before continuing is the difference between resuming the work
+ * and confidently repeating or skipping a step.
+ */
+export declare const RESTART_RESUME_PROMPT_BODY: string;
+/**
+ * Narrow view of AgentManager, so the scope rule can be tested without standing
+ * up a whole manager. The scope IS the expensive decision here: widening this
+ * from "was running" to "was loaded" turns one nudge into one per live agent on
+ * the box, on every restart.
+ */
+export interface InFlightAgentSource {
+    listAgents(): ReadonlyArray<{
+        id: string;
+    }>;
+    hasInFlightRun(agentId: string): boolean;
+}
+/** The agents a restart actually interrupted: running, not merely loaded. */
+export declare function collectInFlightAgentIds(source: InFlightAgentSource): string[];
+export interface ResumeAgentsAfterRestartParams {
+    paseoHome: string;
+    agentManager: AgentManager;
+    agentStorage: AgentStorage;
+    logger: Logger;
+}
+export interface ResumeAgentsAfterRestartResult {
+    attempted: number;
+    resumed: number;
+    skipped: number;
+    failed: number;
+}
+/**
+ * Reload the agents that were mid-turn when the daemon went down and tell each
+ * one it was interrupted.
+ *
+ * Best-effort throughout: this runs after the HTTP server is listening and must
+ * never be able to take the daemon down with it. Every failure is logged and
+ * the remaining agents still get their turn.
+ */
+export declare function resumeAgentsAfterRestart({ paseoHome, agentManager, agentStorage, logger, }: ResumeAgentsAfterRestartParams): Promise<ResumeAgentsAfterRestartResult>;
+//# sourceMappingURL=resume-after-restart.d.ts.map

package/dist/server/server/resume-after-restart.js

@@ -0,0 +1,108 @@
+import { ensureAgentLoaded } from "./agent/agent-loading.js";
+import { formatSystemNotificationPrompt } from "./agent/agent-prompt.js";
+import { readAndClearRestartManifest } from "./restart-manifest.js";
+/**
+ * What the resumed agent is told.
+ *
+ * It deliberately does more than announce the restart. An interrupted turn may
+ * have half-completed whatever it was doing - a file written but not committed,
+ * a request sent but its response never read - and the agent has no way to tell
+ * from its own transcript which side of that line it stopped on. Telling it to
+ * re-check state before continuing is the difference between resuming the work
+ * and confidently repeating or skipping a step.
+ */
+export const RESTART_RESUME_PROMPT_BODY = [
+    "The paseo daemon restarted and interrupted the turn you were in the middle of.",
+    "Your session history is intact - nothing before the interruption was lost.",
+    "",
+    "Pick up where you left off. Before continuing, re-check the state of whatever you",
+    "were working on rather than assuming the last step finished: the turn was cut off",
+    "mid-flight, so an action you had started may have half-completed.",
+].join("\n");
+/**
+ * How many agents are nudged at once.
+ *
+ * Each nudge is a full provider turn. Firing every one simultaneously at boot
+ * is a self-inflicted load spike on the exact surface where saturation is a
+ * known failure mode - a saturated daemon refuses agent-create - and it lands
+ * in the first seconds of uptime, when clients are reconnecting.
+ */
+const RESUME_CONCURRENCY = 3;
+/** The agents a restart actually interrupted: running, not merely loaded. */
+export function collectInFlightAgentIds(source) {
+    return source
+        .listAgents()
+        .filter((agent) => source.hasInFlightRun(agent.id))
+        .map((agent) => agent.id);
+}
+/**
+ * Reload the agents that were mid-turn when the daemon went down and tell each
+ * one it was interrupted.
+ *
+ * Best-effort throughout: this runs after the HTTP server is listening and must
+ * never be able to take the daemon down with it. Every failure is logged and
+ * the remaining agents still get their turn.
+ */
+export async function resumeAgentsAfterRestart({ paseoHome, agentManager, agentStorage, logger, }) {
+    const result = {
+        attempted: 0,
+        resumed: 0,
+        skipped: 0,
+        failed: 0,
+    };
+    const manifest = await readAndClearRestartManifest({ paseoHome, logger });
+    if (!manifest || manifest.agentIds.length === 0) {
+        return result;
+    }
+    result.attempted = manifest.agentIds.length;
+    logger.info({ count: manifest.agentIds.length, reason: manifest.reason, writtenAt: manifest.writtenAt }, "Resuming agents interrupted by the previous shutdown");
+    const prompt = formatSystemNotificationPrompt(RESTART_RESUME_PROMPT_BODY);
+    const queue = [...manifest.agentIds];
+    const worker = async () => {
+        for (;;) {
+            const agentId = queue.shift();
+            if (!agentId) {
+                return;
+            }
+            try {
+                // An agent archived (or deleted) while the daemon was down must not be
+                // resurrected by a manifest written before that happened.
+                const record = await agentStorage.get(agentId);
+                if (!record) {
+                    logger.info({ agentId }, "Skipping resume: agent no longer exists");
+                    result.skipped += 1;
+                    continue;
+                }
+                if (record.archivedAt) {
+                    logger.info({ agentId }, "Skipping resume: agent is archived");
+                    result.skipped += 1;
+                    continue;
+                }
+                const agent = await ensureAgentLoaded(agentId, {
+                    agentManager,
+                    agentStorage,
+                    logger,
+                });
+                // Something already woke this agent between boot and now - a client
+                // opening it, a schedule firing. Its own turn is the live one; a nudge
+                // on top would collide with work already under way.
+                if (agentManager.hasInFlightRun(agent.id)) {
+                    logger.info({ agentId }, "Skipping resume: agent already has an active run");
+                    result.skipped += 1;
+                    continue;
+                }
+                await agentManager.runAgent(agent.id, prompt);
+                result.resumed += 1;
+                logger.info({ agentId }, "Resumed agent after restart");
+            }
+            catch (err) {
+                result.failed += 1;
+                logger.warn({ err, agentId }, "Failed to resume agent after restart");
+            }
+        }
+    };
+    await Promise.all(Array.from({ length: Math.min(RESUME_CONCURRENCY, manifest.agentIds.length) }, () => worker()));
+    logger.info(result, "Finished resuming agents interrupted by the previous shutdown");
+    return result;
+}
+//# sourceMappingURL=resume-after-restart.js.map

package/dist/server/server/schedule/create-cadence.d.ts

@@ -0,0 +1,22 @@
+import type { ScheduleCadence } from "@hyperdrive.bot/fleet-protocol/schedule/types";
+export declare function normalizeScheduleCadenceArg(value: string | undefined): string | undefined;
+export declare function normalizeScheduleTimeZoneArg(value: string | undefined): string | undefined;
+export interface ScheduleCreateCadenceArgs {
+    at?: string;
+    every?: string;
+    cron?: string;
+    timezone?: string;
+}
+export interface ResolvedScheduleCreateCadence {
+    cadence: ScheduleCadence;
+    /**
+     * `at` is a one-off. It lowers to an `every` cadence whose interval is the
+     * distance to the instant, pinned to a single run. An `every` schedule stores
+     * the computed `nextRunAt`, so a daemon that was down at that moment fires it
+     * late on the next tick, which is what a reminder wants. A pinned cron would
+     * instead skip silently to the next calendar match a year away.
+     */
+    oneOff: boolean;
+}
+export declare function resolveScheduleCreateCadence(input: ScheduleCreateCadenceArgs, now: Date): ResolvedScheduleCreateCadence;
+//# sourceMappingURL=create-cadence.d.ts.map

package/dist/server/server/schedule/create-cadence.js

@@ -0,0 +1,70 @@
+import { parseDurationString } from "../agent/mcp-shared.js";
+// Cadence resolution for every surface that CREATES a schedule: the
+// create_schedule / create_heartbeat MCP tools, and the durable-agent routine
+// that create_agent attaches to a freshly created agent.
+//
+// It lives here rather than in paseo-tools.ts because the durable-agent path
+// runs inside createAgentCommand, which paseo-tools.ts already imports. Leaving
+// the resolver in the tools module would have meant either a genuine import
+// cycle (tools -> create -> routine -> tools) or a second copy of the "exactly
+// one of at, every or cron" rules, and a second copy is how two surfaces start
+// disagreeing about what "90m" means.
+export function normalizeScheduleCadenceArg(value) {
+    if (value === undefined) {
+        return undefined;
+    }
+    const trimmed = value.trim();
+    if (!trimmed) {
+        return undefined;
+    }
+    return trimmed;
+}
+export function normalizeScheduleTimeZoneArg(value) {
+    return normalizeScheduleCadenceArg(value);
+}
+// A duration ("90m", "2h30m", "45" seconds) rather than a timestamp. Checked
+// first so `at` can accept both without Date parsing guessing at bare numbers.
+const SCHEDULE_DURATION_ONLY_PATTERN = /^(?:\d+|(?:\d+[smhd])+)$/;
+function resolveScheduleAtInstant(at, now) {
+    if (SCHEDULE_DURATION_ONLY_PATTERN.test(at)) {
+        return new Date(now.getTime() + parseDurationString(at));
+    }
+    const parsed = new Date(at);
+    if (Number.isNaN(parsed.getTime())) {
+        throw new Error(`Invalid at value: ${at}. Use an ISO 8601 instant (2026-08-21T21:30:00-03:00) or a duration from now (90m).`);
+    }
+    return parsed;
+}
+export function resolveScheduleCreateCadence(input, now) {
+    const at = normalizeScheduleCadenceArg(input.at);
+    const every = normalizeScheduleCadenceArg(input.every);
+    const cron = normalizeScheduleCadenceArg(input.cron);
+    const timeZone = normalizeScheduleTimeZoneArg(input.timezone);
+    const provided = [at, every, cron].filter((value) => value !== undefined);
+    if (provided.length !== 1) {
+        throw new Error("Specify exactly one of at, every, or cron");
+    }
+    if (timeZone !== undefined && cron === undefined) {
+        throw new Error("timezone can only be used with cron");
+    }
+    if (at !== undefined) {
+        const instant = resolveScheduleAtInstant(at, now);
+        const everyMs = instant.getTime() - now.getTime();
+        if (everyMs <= 0) {
+            throw new Error(`at must be in the future: ${instant.toISOString()} is not after ${now.toISOString()}`);
+        }
+        return { cadence: { type: "every", everyMs }, oneOff: true };
+    }
+    if (every !== undefined) {
+        return { cadence: { type: "every", everyMs: parseDurationString(every) }, oneOff: false };
+    }
+    return {
+        cadence: {
+            type: "cron",
+            expression: cron,
+            ...(timeZone !== undefined ? { timezone: timeZone } : {}),
+        },
+        oneOff: false,
+    };
+}
+//# sourceMappingURL=create-cadence.js.map

package/dist/server/server/schedule/cron.d.ts

@@ -0,0 +1,8 @@
+import type { ScheduleCadence } from "@hyperdrive.bot/fleet-protocol/schedule/types";
+export interface CadenceResolvers {
+    sourceExists?: (sourceId: string) => boolean;
+    filterExists?: (filterId: string) => boolean;
+}
+export declare function validateScheduleCadence(cadence: ScheduleCadence, resolvers?: CadenceResolvers): void;
+export declare function computeNextRunAt(cadence: ScheduleCadence, after: Date): Date | null;
+//# sourceMappingURL=cron.d.ts.map