@hyperdrive.bot/paseo-server 0.2.6

package/dist/server/server/schedule/service.js

@@ -0,0 +1,628 @@
+import { randomUUID } from "node:crypto";
+import { stat } from "node:fs/promises";
+import { join } from "node:path";
+import { curateAgentActivity } from "../agent/activity-curator.js";
+import { ensureAgentLoaded } from "../agent/agent-loading.js";
+import { formatSystemNotificationPrompt } from "../agent/agent-prompt.js";
+import { resolveCreateAgentTitles } from "../agent/create-agent-title.js";
+import { ScheduleStore } from "./store.js";
+import { computeNextRunAt, validateScheduleCadence } from "./cron.js";
+const SCHEDULE_TICK_INTERVAL_MS = 1000;
+// A run failed because its target no longer exists: the agent was deleted or
+// archived, or a new-agent cwd was removed. These are permanent, so the schedule
+// is completed instead of retried until it burns down to its expiry.
+export class ScheduleTargetGoneError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "ScheduleTargetGoneError";
+    }
+}
+function trimOptionalName(value) {
+    if (typeof value !== "string") {
+        return null;
+    }
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : null;
+}
+function buildScheduleFireBody(schedule, runId) {
+    const heading = schedule.name
+        ? `Schedule "${schedule.name}" fired (id=${schedule.id}, run=${runId}).`
+        : `Schedule fired (id=${schedule.id}, run=${runId}).`;
+    return `${heading}\n${schedule.prompt}`;
+}
+function normalizePrompt(prompt) {
+    const trimmed = prompt.trim();
+    if (!trimmed) {
+        throw new Error("Schedule prompt is required");
+    }
+    return trimmed;
+}
+function applyNewAgentConfig(target, patch) {
+    const config = { ...target.config };
+    if (patch.provider !== undefined) {
+        const trimmed = patch.provider.trim();
+        if (!trimmed) {
+            throw new Error("provider cannot be empty");
+        }
+        config.provider = trimmed;
+    }
+    if (patch.cwd !== undefined) {
+        const trimmed = patch.cwd.trim();
+        if (!trimmed) {
+            throw new Error("cwd cannot be empty");
+        }
+        config.cwd = trimmed;
+    }
+    if (patch.model !== undefined) {
+        const trimmed = patch.model?.trim();
+        if (trimmed) {
+            config.model = trimmed;
+        }
+        else {
+            delete config.model;
+        }
+    }
+    if (patch.modeId !== undefined) {
+        const trimmed = patch.modeId?.trim();
+        if (trimmed) {
+            config.modeId = trimmed;
+        }
+        else {
+            delete config.modeId;
+        }
+    }
+    return { ...target, config };
+}
+function normalizeMaxRuns(value) {
+    if (value == null) {
+        return null;
+    }
+    if (!Number.isInteger(value) || value <= 0) {
+        throw new Error("maxRuns must be a positive integer");
+    }
+    return value;
+}
+function countCompletedRuns(schedule) {
+    return schedule.runs.filter((run) => run.status !== "running").length;
+}
+function shouldCompleteSchedule(schedule, now) {
+    if (schedule.expiresAt && new Date(schedule.expiresAt).getTime() <= now.getTime()) {
+        return true;
+    }
+    if (schedule.maxRuns == null) {
+        return false;
+    }
+    return countCompletedRuns(schedule) >= schedule.maxRuns;
+}
+// Sort object keys recursively so two structurally-equal configs serialize
+// identically regardless of key order. Stored configs come back from disk in Zod
+// schema order while incoming configs keep their construction order, so a plain
+// JSON.stringify comparison would wrongly treat identical targets as different.
+function canonicalize(value) {
+    if (Array.isArray(value)) {
+        return value.map(canonicalize);
+    }
+    if (value && typeof value === "object") {
+        const source = value;
+        return Object.fromEntries(Object.keys(source)
+            .sort()
+            .map((key) => [key, canonicalize(source[key])]));
+    }
+    return value;
+}
+function scheduleTargetsEqual(a, b) {
+    if (a.type === "agent" && b.type === "agent") {
+        return a.agentId === b.agentId;
+    }
+    if (a.type === "new-agent" && b.type === "new-agent") {
+        return JSON.stringify(canonicalize(a.config)) === JSON.stringify(canonicalize(b.config));
+    }
+    return false;
+}
+function completeSchedule(schedule, now) {
+    return {
+        ...schedule,
+        status: "completed",
+        nextRunAt: null,
+        pausedAt: null,
+        updatedAt: now.toISOString(),
+    };
+}
+function buildRunOutput(params) {
+    if (params.output && params.output.trim().length > 0) {
+        return params.output;
+    }
+    if (params.finalText.trim().length > 0) {
+        return params.finalText.trim();
+    }
+    if (params.timelineText.trim().length > 0) {
+        return params.timelineText.trim();
+    }
+    return null;
+}
+export class ScheduleService {
+    constructor(options) {
+        this.runningScheduleIds = new Set();
+        this.tickTimer = null;
+        this.store = new ScheduleStore(join(options.paseoHome, "schedules"));
+        this.logger = options.logger.child({ module: "schedule-service" });
+        this.agentManager = options.agentManager;
+        this.agentStorage = options.agentStorage;
+        this.createConfigResolver = options.providerSnapshotManager;
+        this.now = options.now ?? (() => new Date());
+        this.runner = options.runner ?? ((schedule, runId) => this.executeSchedule(schedule, runId));
+    }
+    async start() {
+        await this.recoverInterruptedRuns();
+        await this.sweepOrphanedSchedules();
+        if (this.tickTimer) {
+            return;
+        }
+        const timer = setInterval(() => {
+            void this.tick().catch((error) => {
+                this.logger.error({ err: error }, "Failed to process schedule tick");
+            });
+        }, SCHEDULE_TICK_INTERVAL_MS);
+        timer.unref?.();
+        this.tickTimer = timer;
+    }
+    async stop() {
+        if (this.tickTimer) {
+            clearInterval(this.tickTimer);
+            this.tickTimer = null;
+        }
+    }
+    async create(input) {
+        const now = this.now();
+        const prompt = normalizePrompt(input.prompt);
+        validateScheduleCadence(input.cadence);
+        const runOnCreate = input.runOnCreate ?? input.cadence.type === "every";
+        const nextRunAt = runOnCreate ? now : computeNextRunAt(input.cadence, now);
+        const schedule = await this.store.create({
+            name: trimOptionalName(input.name),
+            prompt,
+            cadence: input.cadence,
+            target: input.target,
+            status: "active",
+            createdAt: now.toISOString(),
+            updatedAt: now.toISOString(),
+            nextRunAt: nextRunAt.toISOString(),
+            lastRunAt: null,
+            pausedAt: null,
+            expiresAt: input.expiresAt ?? null,
+            maxRuns: normalizeMaxRuns(input.maxRuns),
+            runs: [],
+        });
+        return schedule;
+    }
+    // Idempotent create for the MCP write path: repeating a create with the same
+    // name and target (e.g. babysit-pr re-registering its heartbeat) refreshes the
+    // existing non-completed schedule in place instead of minting a duplicate.
+    async createOrReplace(input) {
+        const name = trimOptionalName(input.name);
+        if (name !== null) {
+            const existing = (await this.store.list()).find((schedule) => schedule.status !== "completed" &&
+                trimOptionalName(schedule.name) === name &&
+                scheduleTargetsEqual(schedule.target, input.target));
+            if (existing) {
+                const now = this.now();
+                const prompt = normalizePrompt(input.prompt);
+                validateScheduleCadence(input.cadence);
+                const runOnCreate = input.runOnCreate ?? input.cadence.type === "every";
+                const nextRunAt = runOnCreate ? now : computeNextRunAt(input.cadence, now);
+                const replaced = {
+                    ...existing,
+                    name,
+                    prompt,
+                    cadence: input.cadence,
+                    target: input.target,
+                    status: "active",
+                    pausedAt: null,
+                    nextRunAt: nextRunAt.toISOString(),
+                    expiresAt: input.expiresAt ?? null,
+                    maxRuns: normalizeMaxRuns(input.maxRuns),
+                    updatedAt: now.toISOString(),
+                };
+                await this.store.put(replaced);
+                return replaced;
+            }
+        }
+        return this.create(input);
+    }
+    async list() {
+        return this.store.list();
+    }
+    async inspect(id) {
+        const schedule = await this.store.get(id);
+        if (!schedule) {
+            throw new Error(`Schedule not found: ${id}`);
+        }
+        return schedule;
+    }
+    async logs(id) {
+        const schedule = await this.inspect(id);
+        return [...schedule.runs].sort((left, right) => left.startedAt.localeCompare(right.startedAt));
+    }
+    async pause(id) {
+        const schedule = await this.inspect(id);
+        if (schedule.status === "completed") {
+            throw new Error(`Schedule ${id} is already completed`);
+        }
+        if (schedule.status === "paused") {
+            return schedule;
+        }
+        const now = this.now();
+        const paused = {
+            ...schedule,
+            status: "paused",
+            nextRunAt: null,
+            pausedAt: now.toISOString(),
+            updatedAt: now.toISOString(),
+        };
+        await this.store.put(paused);
+        return paused;
+    }
+    async resume(id) {
+        const schedule = await this.inspect(id);
+        if (schedule.status === "completed") {
+            throw new Error(`Schedule ${id} is already completed`);
+        }
+        if (schedule.status === "active") {
+            return schedule;
+        }
+        const now = this.now();
+        const resumed = {
+            ...schedule,
+            status: "active",
+            pausedAt: null,
+            nextRunAt: computeNextRunAt(schedule.cadence, now).toISOString(),
+            updatedAt: now.toISOString(),
+        };
+        await this.store.put(resumed);
+        return resumed;
+    }
+    async update(input) {
+        const schedule = await this.inspect(input.id);
+        const now = this.now();
+        let updated = schedule;
+        if (input.prompt !== undefined) {
+            updated = { ...updated, prompt: normalizePrompt(input.prompt) };
+        }
+        if (input.name !== undefined) {
+            updated = { ...updated, name: trimOptionalName(input.name) };
+        }
+        if (input.cadence !== undefined) {
+            validateScheduleCadence(input.cadence);
+            const nextRunAt = updated.status === "active" ? computeNextRunAt(input.cadence, now).toISOString() : null;
+            updated = { ...updated, cadence: input.cadence, nextRunAt };
+        }
+        if (input.newAgentConfig !== undefined) {
+            if (updated.target.type !== "new-agent") {
+                throw new Error("new-agent config updates are only valid for new-agent target schedules");
+            }
+            updated = { ...updated, target: applyNewAgentConfig(updated.target, input.newAgentConfig) };
+        }
+        if (input.maxRuns !== undefined) {
+            updated = { ...updated, maxRuns: normalizeMaxRuns(input.maxRuns) };
+        }
+        if (input.expiresAt !== undefined) {
+            updated = { ...updated, expiresAt: input.expiresAt };
+        }
+        updated = { ...updated, updatedAt: now.toISOString() };
+        await this.store.put(updated);
+        return updated;
+    }
+    async delete(id) {
+        await this.store.delete(id);
+    }
+    async completeForAgent(agentId) {
+        const now = this.now();
+        const schedules = await this.store.list();
+        const matches = schedules.filter((schedule) => schedule.target.type === "agent" &&
+            schedule.target.agentId === agentId &&
+            schedule.status !== "completed");
+        const results = await Promise.allSettled(matches.map((schedule) => this.store.put(completeSchedule(schedule, now))));
+        let completed = 0;
+        for (const [index, result] of results.entries()) {
+            if (result.status === "fulfilled") {
+                completed += 1;
+            }
+            else {
+                this.logger.warn({ err: result.reason, scheduleId: matches[index].id, agentId }, "Failed to complete schedule for archived agent; continuing");
+            }
+        }
+        return completed;
+    }
+    async runOnce(id) {
+        const schedule = await this.inspect(id);
+        if (schedule.status === "completed") {
+            throw new Error(`Schedule ${id} is already completed`);
+        }
+        if (this.runningScheduleIds.has(id)) {
+            throw new Error(`Schedule ${id} is already running`);
+        }
+        await this.runSchedule(schedule, this.now(), { manual: true });
+        return this.inspect(id);
+    }
+    async tick() {
+        const now = this.now();
+        const schedules = await this.store.list();
+        for (const schedule of schedules) {
+            if (schedule.status !== "active" || !schedule.nextRunAt) {
+                continue;
+            }
+            if (this.runningScheduleIds.has(schedule.id)) {
+                continue;
+            }
+            if (shouldCompleteSchedule(schedule, now)) {
+                await this.store.put(completeSchedule(schedule, now));
+                continue;
+            }
+            if (new Date(schedule.nextRunAt).getTime() > now.getTime()) {
+                continue;
+            }
+            await this.runSchedule(schedule, now);
+        }
+    }
+    async recoverInterruptedRuns() {
+        const schedules = await this.store.list();
+        const now = this.now();
+        await Promise.all(schedules.map(async (schedule) => {
+            let updated = { ...schedule };
+            let dirty = false;
+            // Mark any in-flight runs as failed
+            const runningIndex = updated.runs.findIndex((run) => run.status === "running");
+            if (runningIndex !== -1) {
+                const runs = [...updated.runs];
+                runs[runningIndex] = {
+                    ...runs[runningIndex],
+                    status: "failed",
+                    endedAt: now.toISOString(),
+                    error: "Daemon restarted before the scheduled run completed",
+                };
+                updated = { ...updated, runs };
+                dirty = true;
+            }
+            // Advance stale nextRunAt for active schedules
+            if (updated.status === "active" &&
+                updated.nextRunAt &&
+                new Date(updated.nextRunAt).getTime() <= now.getTime()) {
+                let nextRunAt = computeNextRunAt(updated.cadence, new Date(updated.nextRunAt));
+                while (nextRunAt.getTime() <= now.getTime()) {
+                    nextRunAt = computeNextRunAt(updated.cadence, nextRunAt);
+                }
+                updated = { ...updated, nextRunAt: nextRunAt.toISOString() };
+                dirty = true;
+            }
+            if (dirty) {
+                updated = { ...updated, updatedAt: now.toISOString() };
+                await this.store.put(updated);
+            }
+        }));
+    }
+    // Orphaned agent-target schedules (agent deleted while the daemon was down, or
+    // archived before completeForAgent existed) can never fire successfully. Complete
+    // them on startup so they stop ticking and surface as ended in the UI.
+    async sweepOrphanedSchedules() {
+        const now = this.now();
+        const schedules = await this.store.list();
+        await Promise.all(schedules.map(async (schedule) => {
+            if (schedule.target.type !== "agent" || schedule.status === "completed") {
+                return;
+            }
+            const record = await this.agentStorage.get(schedule.target.agentId);
+            if (record && !record.archivedAt) {
+                return;
+            }
+            await this.store.put(completeSchedule(schedule, now));
+        }));
+    }
+    async runSchedule(schedule, now, options) {
+        const manual = options?.manual === true;
+        this.runningScheduleIds.add(schedule.id);
+        const runId = randomUUID();
+        const runningRun = {
+            id: runId,
+            scheduledFor: manual ? now.toISOString() : (schedule.nextRunAt ?? now.toISOString()),
+            startedAt: now.toISOString(),
+            endedAt: null,
+            status: "running",
+            agentId: null,
+            output: null,
+            error: null,
+        };
+        const scheduleWithRun = {
+            ...schedule,
+            updatedAt: now.toISOString(),
+            runs: [...schedule.runs, runningRun],
+        };
+        await this.store.put(scheduleWithRun);
+        try {
+            const result = await this.runner(scheduleWithRun, runId);
+            await this.finishRun({
+                scheduleId: schedule.id,
+                runId,
+                status: "succeeded",
+                agentId: result.agentId,
+                output: result.output,
+                error: null,
+                targetGone: false,
+                manual,
+            });
+        }
+        catch (error) {
+            await this.finishRun({
+                scheduleId: schedule.id,
+                runId,
+                status: "failed",
+                agentId: null,
+                output: null,
+                error: error instanceof Error ? error.message : String(error),
+                targetGone: error instanceof ScheduleTargetGoneError,
+                manual,
+            });
+        }
+        finally {
+            this.runningScheduleIds.delete(schedule.id);
+        }
+    }
+    async finishRun(params) {
+        const schedule = await this.inspect(params.scheduleId);
+        const now = this.now();
+        const completedRuns = schedule.runs.map((run) => run.id === params.runId
+            ? {
+                ...run,
+                status: params.status,
+                endedAt: now.toISOString(),
+                agentId: params.agentId,
+                output: params.output,
+                error: params.error,
+            }
+            : run);
+        let updated = {
+            ...schedule,
+            runs: completedRuns,
+            lastRunAt: now.toISOString(),
+            updatedAt: now.toISOString(),
+        };
+        if (params.targetGone) {
+            // The target is permanently gone; retrying only burns the schedule down to
+            // its expiry, so complete it now regardless of manual/scheduled origin.
+            updated = completeSchedule(updated, now);
+        }
+        else if (updated.status === "completed") {
+            // Completed concurrently (e.g. the target agent was archived mid-run);
+            // record the run outcome but leave the schedule terminal — don't advance.
+        }
+        else if (params.manual) {
+            // Manual one-shot runs do not advance the cadence or recompute completion.
+        }
+        else if (shouldCompleteSchedule(updated, now)) {
+            updated = completeSchedule(updated, now);
+        }
+        else if (updated.status === "paused") {
+            updated = {
+                ...updated,
+                nextRunAt: null,
+            };
+        }
+        else {
+            const after = new Date(schedule.nextRunAt ?? now.toISOString());
+            let nextRunAt = computeNextRunAt(updated.cadence, after);
+            while (nextRunAt.getTime() <= now.getTime()) {
+                nextRunAt = computeNextRunAt(updated.cadence, nextRunAt);
+            }
+            updated = {
+                ...updated,
+                nextRunAt: nextRunAt.toISOString(),
+            };
+        }
+        await this.store.put(updated);
+    }
+    async executeSchedule(schedule, runId) {
+        if (schedule.target.type === "agent") {
+            const wrappedPrompt = formatSystemNotificationPrompt(buildScheduleFireBody(schedule, runId));
+            const record = await this.agentStorage.get(schedule.target.agentId);
+            if (!record) {
+                throw new ScheduleTargetGoneError(`Agent ${schedule.target.agentId} no longer exists`);
+            }
+            if (record.archivedAt) {
+                throw new ScheduleTargetGoneError(`Agent ${schedule.target.agentId} is archived`);
+            }
+            const agent = await ensureAgentLoaded(schedule.target.agentId, {
+                agentManager: this.agentManager,
+                agentStorage: this.agentStorage,
+                logger: this.logger,
+            });
+            if (this.agentManager.hasInFlightRun(agent.id)) {
+                throw new Error(`Agent ${agent.id} already has an active run`);
+            }
+            const result = await this.agentManager.runAgent(agent.id, wrappedPrompt);
+            const timelineText = curateAgentActivity(result.timeline);
+            return {
+                agentId: agent.id,
+                output: buildRunOutput({
+                    output: null,
+                    timelineText,
+                    finalText: result.finalText,
+                }),
+            };
+        }
+        const targetConfig = schedule.target.config;
+        try {
+            await stat(targetConfig.cwd);
+        }
+        catch (error) {
+            if (error.code === "ENOENT") {
+                throw new ScheduleTargetGoneError(`Working directory ${targetConfig.cwd} no longer exists`);
+            }
+            throw error;
+        }
+        const resolvedUnattendedConfig = targetConfig.modeId
+            ? { modeId: targetConfig.modeId, featureValues: targetConfig.featureValues }
+            : await this.resolveProviderCreateConfig({
+                provider: targetConfig.provider,
+                cwd: targetConfig.cwd,
+                requestedMode: undefined,
+                featureValues: targetConfig.featureValues,
+                parent: null,
+                unattended: true,
+            });
+        const config = {
+            provider: targetConfig.provider,
+            cwd: targetConfig.cwd,
+            modeId: resolvedUnattendedConfig.modeId,
+            model: targetConfig.model,
+            thinkingOptionId: targetConfig.thinkingOptionId,
+            title: targetConfig.title,
+            approvalPolicy: targetConfig.approvalPolicy,
+            sandboxMode: targetConfig.sandboxMode,
+            networkAccess: targetConfig.networkAccess,
+            webSearch: targetConfig.webSearch,
+            featureValues: resolvedUnattendedConfig.featureValues,
+            extra: targetConfig.extra,
+            systemPrompt: targetConfig.systemPrompt,
+            mcpServers: targetConfig.mcpServers,
+        };
+        const { provisionalTitle } = resolveCreateAgentTitles({
+            configTitle: config.title,
+            initialPrompt: schedule.prompt,
+        });
+        const labels = {
+            "paseo.schedule-id": schedule.id,
+            "paseo.schedule-run": runId,
+        };
+        const agent = await this.agentManager.createAgent(config, undefined, {
+            labels,
+            initialPrompt: schedule.prompt,
+            initialTitle: provisionalTitle,
+        });
+        let result;
+        try {
+            result = await this.agentManager.runAgent(agent.id, schedule.prompt);
+        }
+        catch (error) {
+            try {
+                await this.agentManager.archiveAgent(agent.id);
+            }
+            catch (archiveError) {
+                this.logger.warn({ err: archiveError, agentId: agent.id, scheduleId: schedule.id, runId }, "Failed to archive scheduled agent after failed run");
+            }
+            throw error;
+        }
+        await this.agentManager.archiveAgent(agent.id);
+        const timelineText = curateAgentActivity(result.timeline);
+        return {
+            agentId: agent.id,
+            output: buildRunOutput({
+                output: null,
+                timelineText,
+                finalText: result.finalText,
+            }),
+        };
+    }
+    async resolveProviderCreateConfig(input) {
+        return this.createConfigResolver.resolveCreateConfig(input);
+    }
+}
+//# sourceMappingURL=service.js.map

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

@@ -0,0 +1,13 @@
+import { type StoredSchedule } from "@hyperdrive.bot/paseo-protocol/schedule/types";
+export declare class ScheduleStore {
+    private readonly dir;
+    constructor(dir: string);
+    private filePath;
+    private ensureDir;
+    list(): Promise<StoredSchedule[]>;
+    get(id: string): Promise<StoredSchedule | null>;
+    create(schedule: Omit<StoredSchedule, "id">): Promise<StoredSchedule>;
+    put(schedule: StoredSchedule): Promise<void>;
+    delete(id: string): Promise<void>;
+}
+//# sourceMappingURL=store.d.ts.map

package/dist/server/server/schedule/store.js

@@ -0,0 +1,57 @@
+import { randomBytes } from "node:crypto";
+import { mkdir, readFile, readdir, rm } from "node:fs/promises";
+import { join } from "node:path";
+import { StoredScheduleSchema, } from "@hyperdrive.bot/paseo-protocol/schedule/types";
+import { writeJsonFileAtomic } from "../atomic-file.js";
+function generateScheduleId() {
+    return randomBytes(4).toString("hex");
+}
+export class ScheduleStore {
+    constructor(dir) {
+        this.dir = dir;
+    }
+    filePath(id) {
+        return join(this.dir, `${id}.json`);
+    }
+    async ensureDir() {
+        await mkdir(this.dir, { recursive: true });
+    }
+    async list() {
+        await this.ensureDir();
+        const entries = await readdir(this.dir, { withFileTypes: true });
+        const schedules = await Promise.all(entries
+            .filter((entry) => entry.isFile() && entry.name.endsWith(".json"))
+            .map(async (entry) => {
+            const content = await readFile(join(this.dir, entry.name), "utf-8");
+            return StoredScheduleSchema.parse(JSON.parse(content));
+        }));
+        return schedules.sort((left, right) => left.createdAt.localeCompare(right.createdAt));
+    }
+    async get(id) {
+        await this.ensureDir();
+        try {
+            const content = await readFile(this.filePath(id), "utf-8");
+            return StoredScheduleSchema.parse(JSON.parse(content));
+        }
+        catch (error) {
+            if (error.code === "ENOENT") {
+                return null;
+            }
+            throw error;
+        }
+    }
+    async create(schedule) {
+        const created = { ...schedule, id: generateScheduleId() };
+        await this.put(created);
+        return created;
+    }
+    async put(schedule) {
+        await this.ensureDir();
+        await writeJsonFileAtomic(this.filePath(schedule.id), schedule);
+    }
+    async delete(id) {
+        await this.ensureDir();
+        await rm(this.filePath(id), { force: true });
+    }
+}
+//# sourceMappingURL=store.js.map