@polpo-ai/server 0.15.44 → 0.15.46

package/dist/routes/schedules.js

@@ -1,193 +1,697 @@
 import { OpenAPIHono, createRoute, z } from "@hono/zod-openapi";
-// ── Schemas ───────────────────────────────────────────────────────────
-const CreateScheduleSchema = z.object({
+import { ScheduleConflictError, ScheduleInvalidStateError, ScheduleNotFoundError, translateLegacyMissionSchedule, } from "@polpo-ai/core/scheduling";
+import { ScheduleServiceError, } from "../services/schedules.js";
+import { legacyMissionScheduleId } from "../services/schedules-migration.js";
+const MetadataSchema = z.record(z.string(), z.unknown());
+const TimingSchema = z.discriminatedUnion("kind", [
+    z.object({
+        kind: z.literal("cron"),
+        expression: z.string().min(1),
+        timezone: z.string().min(1),
+    }).passthrough(),
+    z.object({
+        kind: z.literal("once"),
+        at: z.string().min(1),
+        timezone: z.string().min(1),
+    }).passthrough(),
+]);
+const InvocationSchema = z.discriminatedUnion("surface", [
+    z.object({ surface: z.literal("agent") }).passthrough(),
+    z.object({ surface: z.literal("task") }).passthrough(),
+    z.object({ surface: z.literal("channel") }).passthrough(),
+    z.object({ surface: z.literal("webhook") }).passthrough(),
+    z.object({ surface: z.literal("legacy_mission") }).passthrough(),
+]);
+const PolicySchema = z.object({
+    catchUp: z.enum(["skip", "latest"]).optional(),
+    misfireGraceSeconds: z.number().int().nonnegative().optional(),
+    maxConcurrency: z.number().int().positive().optional(),
+}).passthrough();
+const V2CreateScheduleSchema = z.object({
+    id: z.string().min(1).optional(),
+    name: z.string().min(1).optional(),
+    description: z.string().min(1).optional(),
+    timing: TimingSchema,
+    invocation: InvocationSchema,
+    status: z.enum(["active", "paused"]).optional(),
+    policy: PolicySchema.optional(),
+    metadata: MetadataSchema.optional(),
+}).passthrough();
+const LegacyCreateScheduleSchema = z.object({
     missionId: z.string().min(1),
     expression: z.string().min(1),
     recurring: z.boolean().optional(),
     endDate: z.string().datetime().optional(),
-});
-const UpdateScheduleSchema = z.object({
+}).strict();
+const V2UpdateScheduleSchema = z.object({
+    name: z.string().min(1).nullable().optional(),
+    description: z.string().min(1).nullable().optional(),
+    timing: TimingSchema.optional(),
+    invocation: InvocationSchema.optional(),
+    status: z.enum(["active", "paused", "completed"]).optional(),
+    policy: PolicySchema.optional(),
+    metadata: MetadataSchema.optional(),
+}).passthrough();
+const LegacyUpdateScheduleSchema = z.object({
     expression: z.string().min(1).optional(),
     recurring: z.boolean().optional(),
     enabled: z.boolean().optional(),
     endDate: z.string().datetime().nullable().optional(),
+}).strict().refine((value) => Object.keys(value).length > 0, {
+    message: "Schedule update must include at least one field",
+});
+const ScheduleIdParams = z.object({ scheduleId: z.string().min(1) });
+const RevisionHeaders = z.object({ "if-match": z.string().optional() });
+const SuccessSchema = z.object({ ok: z.literal(true), data: z.any() });
+const ErrorSchema = z.object({
+    ok: z.literal(false),
+    error: z.string(),
+    code: z.string(),
+    retryable: z.boolean().optional(),
 });
-// ── Route definitions ─────────────────────────────────────────────────
-const listSchedulesRoute = createRoute({
+const commonErrors = {
+    400: {
+        content: { "application/json": { schema: ErrorSchema } },
+        description: "Invalid request",
+    },
+    404: {
+        content: { "application/json": { schema: ErrorSchema } },
+        description: "Schedule not found",
+    },
+    409: {
+        content: { "application/json": { schema: ErrorSchema } },
+        description: "Schedule conflict",
+    },
+    500: {
+        content: { "application/json": { schema: ErrorSchema } },
+        description: "Schedule operation failed",
+    },
+    503: {
+        content: { "application/json": { schema: ErrorSchema } },
+        description: "Schedule service unavailable",
+    },
+};
+const listRoute = createRoute({
     method: "get",
     path: "/",
     tags: ["Schedules"],
     summary: "List schedules",
+    request: {
+        query: z.object({
+            status: z.enum(["active", "paused", "completed", "deleted"]).optional(),
+            surface: z.enum([
+                "agent",
+                "task",
+                "channel",
+                "webhook",
+                "legacy_mission",
+            ]).optional(),
+            includeDeleted: z.enum(["true", "false"]).optional(),
+        }),
+    },
     responses: {
         200: {
-            content: { "application/json": { schema: z.object({ ok: z.boolean(), data: z.array(z.any()) }) } },
-            description: "List of schedule entries",
+            content: { "application/json": { schema: SuccessSchema } },
+            description: "Schedules",
         },
+        ...commonErrors,
     },
 });
-const createScheduleRoute = createRoute({
+const createRouteDefinition = createRoute({
     method: "post",
     path: "/",
     tags: ["Schedules"],
-    summary: "Create schedule",
+    summary: "Create a schedule",
     request: {
-        body: { content: { "application/json": { schema: CreateScheduleSchema } } },
+        body: {
+            content: {
+                "application/json": {
+                    schema: z.union([
+                        V2CreateScheduleSchema,
+                        LegacyCreateScheduleSchema,
+                    ]),
+                },
+            },
+        },
     },
     responses: {
         201: {
-            content: { "application/json": { schema: z.object({ ok: z.boolean(), data: z.any() }) } },
+            content: { "application/json": { schema: SuccessSchema } },
             description: "Schedule created",
         },
-        400: {
-            content: { "application/json": { schema: z.object({ ok: z.boolean(), error: z.string(), code: z.string() }) } },
-            description: "Invalid expression or scheduler unavailable",
-        },
-        404: {
-            content: { "application/json": { schema: z.object({ ok: z.boolean(), error: z.string(), code: z.string() }) } },
-            description: "Mission not found",
+        ...commonErrors,
+    },
+});
+const getRoute = createRoute({
+    method: "get",
+    path: "/{scheduleId}",
+    tags: ["Schedules"],
+    summary: "Get a schedule",
+    request: { params: ScheduleIdParams },
+    responses: {
+        200: {
+            content: { "application/json": { schema: SuccessSchema } },
+            description: "Schedule",
         },
+        ...commonErrors,
     },
 });
-const updateScheduleRoute = createRoute({
+const updateRoute = createRoute({
     method: "patch",
-    path: "/{missionId}",
+    path: "/{scheduleId}",
     tags: ["Schedules"],
-    summary: "Update schedule",
+    summary: "Update a schedule",
     request: {
-        params: z.object({ missionId: z.string() }),
-        body: { content: { "application/json": { schema: UpdateScheduleSchema } } },
+        params: ScheduleIdParams,
+        headers: RevisionHeaders,
+        body: {
+            content: {
+                "application/json": {
+                    schema: z.union([
+                        LegacyUpdateScheduleSchema,
+                        V2UpdateScheduleSchema,
+                    ]),
+                },
+            },
+        },
     },
     responses: {
         200: {
-            content: { "application/json": { schema: z.object({ ok: z.boolean(), data: z.any() }) } },
+            content: { "application/json": { schema: SuccessSchema } },
             description: "Schedule updated",
         },
-        404: {
-            content: { "application/json": { schema: z.object({ ok: z.boolean(), error: z.string(), code: z.string() }) } },
-            description: "Schedule not found",
-        },
+        ...commonErrors,
     },
 });
-const deleteScheduleRoute = createRoute({
+const deleteRoute = createRoute({
     method: "delete",
-    path: "/{missionId}",
+    path: "/{scheduleId}",
+    tags: ["Schedules"],
+    summary: "Delete a schedule",
+    request: { params: ScheduleIdParams, headers: RevisionHeaders },
+    responses: {
+        200: {
+            content: { "application/json": { schema: SuccessSchema } },
+            description: "Schedule deleted",
+        },
+        ...commonErrors,
+    },
+});
+const lifecycleRoute = (action) => createRoute({
+    method: "post",
+    path: `/{scheduleId}/${action}`,
+    tags: ["Schedules"],
+    summary: `${action === "pause" ? "Pause" : "Resume"} a schedule`,
+    request: { params: ScheduleIdParams, headers: RevisionHeaders },
+    responses: {
+        200: {
+            content: { "application/json": { schema: SuccessSchema } },
+            description: `Schedule ${action}d`,
+        },
+        ...commonErrors,
+    },
+});
+const pauseRoute = lifecycleRoute("pause");
+const resumeRoute = lifecycleRoute("resume");
+const listRunsRoute = createRoute({
+    method: "get",
+    path: "/{scheduleId}/runs",
     tags: ["Schedules"],
-    summary: "Delete schedule",
+    summary: "List schedule runs",
     request: {
-        params: z.object({ missionId: z.string() }),
+        params: ScheduleIdParams,
+        query: z.object({
+            status: z.enum([
+                "pending",
+                "claimed",
+                "running",
+                "succeeded",
+                "failed",
+                "skipped",
+                "cancelled",
+            ]).optional(),
+            limit: z.string().regex(/^\d+$/).refine((value) => Number(value) >= 1 && Number(value) <= 1_000, "Run history limit must be between 1 and 1000").optional(),
+            order: z.enum(["asc", "desc"]).optional(),
+        }),
     },
     responses: {
         200: {
-            content: { "application/json": { schema: z.object({ ok: z.boolean(), data: z.object({ deleted: z.boolean() }) }) } },
-            description: "Schedule deleted",
+            content: { "application/json": { schema: SuccessSchema } },
+            description: "Schedule runs",
         },
-        404: {
-            content: { "application/json": { schema: z.object({ ok: z.boolean(), error: z.string(), code: z.string() }) } },
-            description: "Schedule not found",
+        ...commonErrors,
+    },
+});
+const triggerRoute = createRoute({
+    method: "post",
+    path: "/{scheduleId}/runs",
+    tags: ["Schedules"],
+    summary: "Create an idempotent manual schedule run",
+    request: {
+        params: ScheduleIdParams,
+        body: {
+            content: {
+                "application/json": {
+                    schema: z.object({
+                        idempotencyKey: z.string().min(1),
+                    }).strict(),
+                },
+            },
         },
     },
+    responses: {
+        202: {
+            content: { "application/json": { schema: SuccessSchema } },
+            description: "Run accepted",
+        },
+        ...commonErrors,
+    },
 });
-// ── Route handlers ────────────────────────────────────────────────────
 export function scheduleRoutes(getDeps) {
     const app = new OpenAPIHono();
-    // GET /schedules — list all schedule entries
-    app.openapi(listSchedulesRoute, (c) => {
+    app.openapi(listRoute, async (c) => {
         const deps = getDeps();
-        const schedules = deps.getScheduler()?.getAllSchedules() ?? [];
-        return c.json({ ok: true, data: schedules });
+        if (!deps.scheduleService)
+            return legacyList(c, deps);
+        try {
+            const query = c.req.valid("query");
+            const filter = {
+                ...(query.status === undefined ? {} : { status: query.status }),
+                ...(query.surface === undefined ? {} : { surface: query.surface }),
+                includeDeleted: query.includeDeleted === "true",
+            };
+            const schedules = await deps.scheduleService.list(filter);
+            return c.json({
+                ok: true,
+                data: schedules.map(withLegacyCompatibility),
+            }, 200);
+        }
+        catch (error) {
+            return scheduleError(c, error);
+        }
     });
-    // POST /schedules — create a schedule for a mission
-    app.openapi(createScheduleRoute, async (c) => {
+    app.openapi(createRouteDefinition, async (c) => {
         const deps = getDeps();
-        const scheduler = deps.getScheduler();
-        if (!scheduler) {
-            return c.json({ ok: false, error: "Scheduler not available", code: "SCHEDULER_UNAVAILABLE" }, 400);
-        }
         const body = c.req.valid("json");
-        const mission = await deps.getMission(body.missionId);
-        if (!mission) {
-            return c.json({ ok: false, error: `Mission "${body.missionId}" not found`, code: "NOT_FOUND" }, 404);
-        }
-        const isRecurring = body.recurring ?? false;
-        const newStatus = isRecurring ? "recurring" : "scheduled";
-        const missionUpdate = {
-            schedule: body.expression,
-            status: newStatus,
-        };
-        if (body.endDate !== undefined) {
-            missionUpdate.endDate = body.endDate;
-        }
-        const updatedMission = await deps.updateMission(body.missionId, missionUpdate);
-        const entry = scheduler.registerMission(updatedMission);
-        if (!entry) {
-            return c.json({ ok: false, error: "Could not create schedule. Expression may be invalid or timestamp is in the past.", code: "INVALID_EXPRESSION" }, 400);
-        }
-        return c.json({ ok: true, data: entry }, 201);
+        if (isLegacyCreate(body)) {
+            if (!deps.scheduleService)
+                return legacyCreate(c, deps, body);
+            try {
+                const mission = await deps.getMission?.(body.missionId);
+                if (!mission)
+                    throw new ScheduleNotFoundError("Schedule", body.missionId);
+                const translated = translateLegacyRequest(body);
+                const created = await deps.scheduleService.create({
+                    ...translated,
+                    id: legacyMissionScheduleId(body.missionId),
+                });
+                return c.json({
+                    ok: true,
+                    data: withLegacyCompatibility(created),
+                }, 201);
+            }
+            catch (error) {
+                return scheduleError(c, error);
+            }
+        }
+        const service = deps.scheduleService;
+        if (!service)
+            return unavailable(c);
+        try {
+            const created = await service.create(body);
+            return c.json({ ok: true, data: created }, 201);
+        }
+        catch (error) {
+            return scheduleError(c, error);
+        }
     });
-    // PATCH /schedules/:missionId — update a schedule
-    app.openapi(updateScheduleRoute, async (c) => {
+    app.openapi(getRoute, async (c) => {
         const deps = getDeps();
-        const scheduler = deps.getScheduler();
-        if (!scheduler) {
-            return c.json({ ok: false, error: "Scheduler not available", code: "SCHEDULER_UNAVAILABLE" }, 404);
+        const service = deps.scheduleService;
+        if (!service)
+            return unavailable(c);
+        try {
+            const schedule = await resolveSchedule(service, c.req.valid("param").scheduleId);
+            return c.json({
+                ok: true,
+                data: withLegacyCompatibility(schedule),
+            }, 200);
         }
-        const { missionId } = c.req.valid("param");
-        const existing = scheduler.getScheduleByMissionId(missionId);
-        if (!existing) {
-            return c.json({ ok: false, error: `No schedule found for mission "${missionId}"`, code: "NOT_FOUND" }, 404);
+        catch (error) {
+            return scheduleError(c, error);
         }
+    });
+    app.openapi(updateRoute, async (c) => {
+        const deps = getDeps();
         const body = c.req.valid("json");
-        if (body.expression !== undefined) {
-            const mission = await deps.getMission(missionId);
-            if (!mission) {
-                return c.json({ ok: false, error: `Mission "${missionId}" not found`, code: "NOT_FOUND" }, 404);
+        const { scheduleId } = c.req.valid("param");
+        if (!deps.scheduleService) {
+            if (isLegacyUpdate(body))
+                return legacyUpdate(c, deps, scheduleId, body);
+            return unavailable(c);
+        }
+        try {
+            const expectedRevision = parseRevision(c.req.header("if-match"));
+            if (isLegacyUpdate(body)) {
+                const existing = await resolveSchedule(deps.scheduleService, scheduleId);
+                if (existing.invocation.surface !== "legacy_mission") {
+                    throw new ScheduleServiceError("INVALID_REQUEST", `Schedule "${scheduleId}" is not a legacy mission schedule`, false);
+                }
+                const patch = legacyUpdatePatch(existing, body);
+                const updated = await deps.scheduleService.update(existing.id, patch, expectedRevision === undefined ? {} : { expectedRevision });
+                return c.json({
+                    ok: true,
+                    data: withLegacyCompatibility(updated),
+                }, 200);
             }
-            const isRecurring = body.recurring ?? existing.recurring;
-            const newStatus = isRecurring ? "recurring" : "scheduled";
-            const updated = await deps.updateMission(missionId, {
-                schedule: body.expression,
-                status: newStatus,
-            });
-            scheduler.unregisterMission(missionId);
-            scheduler.registerMission(updated);
-        }
-        if (body.recurring !== undefined && body.expression === undefined) {
-            const isRecurring = body.recurring;
-            existing.recurring = isRecurring;
-            const newStatus = isRecurring ? "recurring" : "scheduled";
-            await deps.updateMission(missionId, { status: newStatus });
-            const mission = await deps.getMission(missionId);
-            if (mission) {
-                scheduler.unregisterMission(missionId);
-                scheduler.registerMission(mission);
+            const updated = await deps.scheduleService.update(scheduleId, body, expectedRevision === undefined ? {} : { expectedRevision });
+            return c.json({ ok: true, data: updated }, 200);
+        }
+        catch (error) {
+            return scheduleError(c, error);
+        }
+    });
+    app.openapi(deleteRoute, async (c) => {
+        const deps = getDeps();
+        const { scheduleId } = c.req.valid("param");
+        if (!deps.scheduleService)
+            return legacyDelete(c, deps, scheduleId);
+        try {
+            const expectedRevision = parseRevision(c.req.header("if-match"));
+            const existing = await resolveSchedule(deps.scheduleService, scheduleId);
+            const deleted = await deps.scheduleService.delete(existing.id, expectedRevision === undefined ? {} : { expectedRevision });
+            if (existing.invocation.surface === "legacy_mission") {
+                return c.json({
+                    ok: true,
+                    data: { deleted: true, schedule: withLegacyCompatibility(deleted) },
+                }, 200);
             }
+            return c.json({ ok: true, data: deleted }, 200);
+        }
+        catch (error) {
+            return scheduleError(c, error);
         }
-        if (body.enabled !== undefined) {
-            existing.enabled = body.enabled;
+    });
+    app.openapi(pauseRoute, async (c) => {
+        const service = getDeps().scheduleService;
+        if (!service)
+            return unavailable(c);
+        try {
+            const expectedRevision = parseRevision(c.req.header("if-match"));
+            const paused = await service.pause(c.req.valid("param").scheduleId, expectedRevision === undefined ? {} : { expectedRevision });
+            return c.json({ ok: true, data: paused }, 200);
         }
-        if (body.endDate !== undefined) {
-            const endDate = body.endDate ?? undefined;
-            await deps.updateMission(missionId, { endDate });
+        catch (error) {
+            return scheduleError(c, error);
         }
-        const updated = scheduler.getScheduleByMissionId(missionId);
-        return c.json({ ok: true, data: updated }, 200);
     });
-    // DELETE /schedules/:missionId — delete a schedule
-    app.openapi(deleteScheduleRoute, async (c) => {
-        const deps = getDeps();
-        const scheduler = deps.getScheduler();
-        if (!scheduler) {
-            return c.json({ ok: false, error: "Scheduler not available", code: "SCHEDULER_UNAVAILABLE" }, 404);
-        }
-        const { missionId } = c.req.valid("param");
-        const deleted = scheduler.unregisterMission(missionId);
-        if (!deleted) {
-            return c.json({ ok: false, error: `No schedule found for mission "${missionId}"`, code: "NOT_FOUND" }, 404);
-        }
-        // Clear schedule from mission and reset status to draft
-        await deps.updateMission(missionId, { schedule: undefined, status: "draft" });
-        return c.json({ ok: true, data: { deleted: true } }, 200);
+    app.openapi(resumeRoute, async (c) => {
+        const service = getDeps().scheduleService;
+        if (!service)
+            return unavailable(c);
+        try {
+            const expectedRevision = parseRevision(c.req.header("if-match"));
+            const resumed = await service.resume(c.req.valid("param").scheduleId, expectedRevision === undefined ? {} : { expectedRevision });
+            return c.json({ ok: true, data: resumed }, 200);
+        }
+        catch (error) {
+            return scheduleError(c, error);
+        }
+    });
+    app.openapi(listRunsRoute, async (c) => {
+        const service = getDeps().scheduleService;
+        if (!service)
+            return unavailable(c);
+        try {
+            const query = c.req.valid("query");
+            const filter = {
+                ...(query.status === undefined ? {} : { status: query.status }),
+                ...(query.limit === undefined ? {} : { limit: Number(query.limit) }),
+                ...(query.order === undefined ? {} : { order: query.order }),
+            };
+            const runs = await service.listRuns(c.req.valid("param").scheduleId, filter);
+            return c.json({ ok: true, data: runs }, 200);
+        }
+        catch (error) {
+            return scheduleError(c, error);
+        }
+    });
+    app.openapi(triggerRoute, async (c) => {
+        const service = getDeps().scheduleService;
+        if (!service)
+            return unavailable(c);
+        try {
+            const run = await service.trigger(c.req.valid("param").scheduleId, c.req.valid("json"));
+            return c.json({ ok: true, data: run }, 202);
+        }
+        catch (error) {
+            return scheduleError(c, error);
+        }
     });
     return app;
 }
+function isLegacyCreate(body) {
+    return "missionId" in body;
+}
+function isLegacyUpdate(body) {
+    return ["expression", "recurring", "enabled", "endDate"]
+        .some((key) => key in body);
+}
+async function resolveSchedule(service, idOrMissionId) {
+    try {
+        return await service.get(idOrMissionId);
+    }
+    catch (error) {
+        if (!(error instanceof ScheduleNotFoundError))
+            throw error;
+    }
+    const legacy = (await service.list({ surface: "legacy_mission" }))
+        .find((schedule) => schedule.invocation.surface === "legacy_mission"
+        && schedule.invocation.missionId === idOrMissionId);
+    if (!legacy)
+        throw new ScheduleNotFoundError("Schedule", idOrMissionId);
+    return legacy;
+}
+function withLegacyCompatibility(schedule) {
+    if (schedule.invocation.surface !== "legacy_mission")
+        return schedule;
+    const compatibility = compatibilityMetadata(schedule);
+    return {
+        ...schedule,
+        missionId: schedule.invocation.missionId,
+        expression: timingExpression(schedule),
+        recurring: compatibility.recurring === true,
+        enabled: schedule.status === "active",
+        ...(schedule.nextOccurrenceAt === undefined
+            ? {}
+            : { nextRunAt: schedule.nextOccurrenceAt }),
+        ...(schedule.lastOccurrenceAt === undefined
+            ? {}
+            : { lastRunAt: schedule.lastOccurrenceAt }),
+    };
+}
+function legacyUpdatePatch(existing, body) {
+    if (existing.invocation.surface !== "legacy_mission") {
+        throw new ScheduleServiceError("INVALID_REQUEST", "Legacy update requires a legacy mission invocation", false);
+    }
+    const missionId = existing.invocation.missionId;
+    const currentCompatibility = compatibilityMetadata(existing);
+    const expression = body.expression ?? timingExpression(existing);
+    const recurring = body.recurring
+        ?? (currentCompatibility.recurring === true);
+    const endDate = body.endDate === undefined
+        ? stringValue(currentCompatibility.endDate)
+        : body.endDate ?? undefined;
+    const translated = translateLegacyRequest({
+        missionId,
+        expression,
+        recurring,
+        ...(endDate === undefined ? {} : { endDate }),
+    }, { allowPastOnce: true });
+    return {
+        ...(body.expression === undefined && body.recurring === undefined
+            ? {}
+            : { timing: translated.timing }),
+        invocation: translated.invocation,
+        metadata: {
+            ...existing.metadata,
+            ...translated.metadata,
+        },
+        ...(body.enabled === undefined
+            ? {}
+            : { status: body.enabled ? "active" : "paused" }),
+    };
+}
+function compatibilityMetadata(schedule) {
+    const value = schedule.metadata.compatibility;
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return {};
+    return value;
+}
+function timingExpression(schedule) {
+    return schedule.timing.kind === "cron"
+        ? schedule.timing.expression
+        : schedule.timing.at;
+}
+function stringValue(value) {
+    return typeof value === "string" ? value : undefined;
+}
+function parseRevision(value) {
+    if (value === undefined)
+        return undefined;
+    const normalized = value.trim().replace(/^W\//, "").replace(/^"|"$/g, "");
+    if (!/^[1-9]\d*$/.test(normalized)) {
+        throw new ScheduleServiceError("INVALID_REQUEST", "If-Match must contain a positive schedule revision", false);
+    }
+    const revision = Number(normalized);
+    if (!Number.isSafeInteger(revision)) {
+        throw new ScheduleServiceError("INVALID_REQUEST", "If-Match must contain a safe positive schedule revision", false);
+    }
+    return revision;
+}
+function unavailable(c) {
+    return c.json({
+        ok: false,
+        error: "Schedule service is not enabled on this host",
+        code: "SCHEDULE_SERVICE_UNAVAILABLE",
+    }, 503);
+}
+function scheduleError(c, error) {
+    if (error instanceof ScheduleNotFoundError
+        || (error instanceof ScheduleServiceError && error.code === "NOT_FOUND")) {
+        return c.json({
+            ok: false,
+            error: error.message,
+            code: "NOT_FOUND",
+            retryable: false,
+        }, 404);
+    }
+    if (error instanceof ScheduleConflictError) {
+        return c.json({
+            ok: false,
+            error: error.message,
+            code: "CONFLICT",
+            retryable: false,
+        }, 409);
+    }
+    if (error instanceof ScheduleInvalidStateError
+        || (error instanceof ScheduleServiceError && error.code === "INVALID_STATE")) {
+        return c.json({
+            ok: false,
+            error: error.message,
+            code: "INVALID_STATE",
+            retryable: false,
+        }, 409);
+    }
+    if (error instanceof ScheduleServiceError) {
+        return c.json({
+            ok: false,
+            error: error.message,
+            code: error.code,
+            retryable: error.retryable,
+        }, 400);
+    }
+    return c.json({
+        ok: false,
+        error: "Schedule operation failed",
+        code: "SCHEDULE_OPERATION_FAILED",
+    }, 500);
+}
+function translateLegacyRequest(value, options = {}) {
+    try {
+        return translateLegacyMissionSchedule(value, options);
+    }
+    catch (cause) {
+        throw new ScheduleServiceError("INVALID_REQUEST", cause instanceof Error ? cause.message : "Invalid legacy schedule request", false, { cause });
+    }
+}
+async function legacyList(c, deps) {
+    const schedules = deps.getScheduler?.()?.getAllSchedules() ?? [];
+    return c.json({ ok: true, data: schedules }, 200);
+}
+async function legacyCreate(c, deps, body) {
+    const scheduler = deps.getScheduler?.();
+    if (!scheduler)
+        return unavailable(c);
+    const mission = await deps.getMission?.(body.missionId);
+    if (!mission) {
+        return c.json({
+            ok: false,
+            error: `Mission "${body.missionId}" not found`,
+            code: "NOT_FOUND",
+        }, 404);
+    }
+    const updatedMission = await deps.updateMission?.(body.missionId, {
+        schedule: body.expression,
+        status: body.recurring ? "recurring" : "scheduled",
+        ...(body.endDate === undefined ? {} : { endDate: body.endDate }),
+    });
+    const entry = scheduler.registerMission(updatedMission);
+    if (!entry) {
+        return c.json({
+            ok: false,
+            error: "Could not create schedule",
+            code: "INVALID_EXPRESSION",
+        }, 400);
+    }
+    return c.json({ ok: true, data: entry }, 201);
+}
+async function legacyUpdate(c, deps, missionId, body) {
+    const scheduler = deps.getScheduler?.();
+    if (!scheduler)
+        return unavailable(c);
+    const existing = scheduler.getScheduleByMissionId(missionId);
+    if (!existing) {
+        return c.json({
+            ok: false,
+            error: `No schedule found for mission "${missionId}"`,
+            code: "NOT_FOUND",
+        }, 404);
+    }
+    if (body.expression !== undefined || body.recurring !== undefined) {
+        const mission = await deps.getMission?.(missionId);
+        if (!mission) {
+            return c.json({
+                ok: false,
+                error: `Mission "${missionId}" not found`,
+                code: "NOT_FOUND",
+            }, 404);
+        }
+        const recurring = body.recurring ?? existing.recurring;
+        const updated = await deps.updateMission?.(missionId, {
+            schedule: body.expression ?? existing.expression,
+            status: recurring ? "recurring" : "scheduled",
+        });
+        scheduler.unregisterMission(missionId);
+        scheduler.registerMission(updated);
+    }
+    if (body.enabled !== undefined)
+        existing.enabled = body.enabled;
+    if (body.endDate !== undefined) {
+        await deps.updateMission?.(missionId, {
+            endDate: body.endDate ?? undefined,
+        });
+    }
+    return c.json({
+        ok: true,
+        data: scheduler.getScheduleByMissionId(missionId),
+    }, 200);
+}
+async function legacyDelete(c, deps, missionId) {
+    const scheduler = deps.getScheduler?.();
+    if (!scheduler)
+        return unavailable(c);
+    if (!scheduler.unregisterMission(missionId)) {
+        return c.json({
+            ok: false,
+            error: `No schedule found for mission "${missionId}"`,
+            code: "NOT_FOUND",
+        }, 404);
+    }
+    await deps.updateMission?.(missionId, {
+        schedule: undefined,
+        status: "draft",
+    });
+    return c.json({ ok: true, data: { deleted: true } }, 200);
+}
 //# sourceMappingURL=schedules.js.map