@botbotgo/agent-harness 0.0.475 → 0.0.476

package/dist/runtime/scheduling/system-schedule-manager.js

@@ -1,532 +1,11 @@
-import { mkdir, readFile, readdir, rm, writeFile } from "node:fs/promises";
-import { existsSync } from "node:fs";
-import os from "node:os";
-import path from "node:path";
-import { fileURLToPath } from "node:url";
-import { createPersistentId } from "../../utils/id.js";
-const MANAGED_PREFIX = "agent-harness";
-const SCHEDULES_DIR = "schedules";
-const CRON_BEGIN_PREFIX = "# agent-harness schedule begin ";
-const CRON_END_PREFIX = "# agent-harness schedule end ";
-const WEEKDAY_ORDER = ["sun", "mon", "tue", "wed", "thu", "fri", "sat"];
-function shellEscapePosix(value) {
-    return `'${value.replaceAll("'", `'\"'\"'`)}'`;
-}
-function shellEscapeWindows(value) {
-    return `"${value.replaceAll('"', '\\"')}"`;
-}
-function resolveFrameworkRoot() {
-    return path.resolve(fileURLToPath(new URL("../../..", import.meta.url)));
-}
-function resolveDefaultCliPath() {
-    const frameworkRoot = resolveFrameworkRoot();
-    const distCliPath = path.join(frameworkRoot, "dist", "cli.js");
-    if (existsSync(distCliPath)) {
-        return distCliPath;
-    }
-    throw new Error(`System scheduling requires a built CLI at ${distCliPath}. Run the build before creating schedules.`);
-}
-async function defaultRunCommand(command, args, options = {}) {
-    const { spawn } = await import("node:child_process");
-    return new Promise((resolve, reject) => {
-        const child = spawn(command, args, {
-            stdio: ["pipe", "pipe", "pipe"],
-        });
-        let stdout = "";
-        let stderr = "";
-        child.stdout.on("data", (chunk) => {
-            stdout += String(chunk);
-        });
-        child.stderr.on("data", (chunk) => {
-            stderr += String(chunk);
-        });
-        child.on("error", reject);
-        child.on("close", (exitCode) => {
-            resolve({
-                stdout,
-                stderr,
-                exitCode: exitCode ?? 0,
-            });
-        });
-        if (typeof options.input === "string") {
-            child.stdin.write(options.input);
-        }
-        child.stdin.end();
-    });
-}
-function parseScheduleTime(value) {
-    const match = /^(\d{2}):(\d{2})$/.exec(value.trim());
-    if (!match) {
-        throw new Error(`Invalid schedule time '${value}'. Use HH:mm.`);
-    }
-    const hour = Number.parseInt(match[1], 10);
-    const minute = Number.parseInt(match[2], 10);
-    if (hour < 0 || hour > 23 || minute < 0 || minute > 59) {
-        throw new Error(`Invalid schedule time '${value}'. Use HH:mm.`);
-    }
-    return { hour, minute };
-}
-function normalizeWeeklyDays(days) {
-    const normalized = Array.from(new Set(days
-        .map((day) => day.trim().toLowerCase().slice(0, 3))
-        .filter((day) => WEEKDAY_ORDER.includes(day))));
-    if (normalized.length === 0) {
-        throw new Error("Weekly schedules require at least one valid weekday.");
-    }
-    return WEEKDAY_ORDER.filter((day) => normalized.includes(day));
-}
-function validateIntervalMinutes(value) {
-    if (!Number.isInteger(value) || value <= 0) {
-        throw new Error("Interval schedules require a positive integer everyMinutes value.");
-    }
-    return value;
-}
-function validateScheduleDefinition(definition, platform) {
-    if (definition.type === "cron") {
-        const fields = definition.expression.trim().split(/\s+/u);
-        if (fields.length !== 5) {
-            throw new Error(`Invalid cron expression '${definition.expression}'. Expected 5 fields.`);
-        }
-        if (platform === "win32") {
-            throw new Error("Cron expressions are not supported on Windows system schedules.");
-        }
-        return {
-            type: "cron",
-            expression: fields.join(" "),
-        };
-    }
-    if (definition.type === "interval") {
-        const everyMinutes = validateIntervalMinutes(definition.everyMinutes);
-        if (platform !== "win32" && 60 % everyMinutes !== 0) {
-            throw new Error("Crontab interval schedules currently require everyMinutes to divide evenly into 60.");
-        }
-        return {
-            type: "interval",
-            everyMinutes,
-        };
-    }
-    const time = parseScheduleTime(definition.time);
-    if (definition.type === "daily") {
-        return {
-            type: "daily",
-            time: `${String(time.hour).padStart(2, "0")}:${String(time.minute).padStart(2, "0")}`,
-        };
-    }
-    return {
-        type: "weekly",
-        time: `${String(time.hour).padStart(2, "0")}:${String(time.minute).padStart(2, "0")}`,
-        days: normalizeWeeklyDays(definition.days),
-    };
-}
-function buildCommandLine(input) {
-    const quote = input.platform === "win32" ? shellEscapeWindows : shellEscapePosix;
-    return [
-        quote(input.nodePath),
-        quote(input.cliPath),
-        "runtime",
-        "scheduled-run",
-        "--workspace",
-        quote(input.workspaceRoot),
-        "--schedule",
-        quote(input.scheduleId),
-    ].join(" ");
-}
-function matchesFilter(record, filter) {
-    if (!filter) {
-        return true;
-    }
-    if (filter.scheduleId && record.scheduleId !== filter.scheduleId) {
-        return false;
-    }
-    if (filter.name && record.name !== filter.name) {
-        return false;
-    }
-    if (filter.agentId && record.agentId !== filter.agentId) {
-        return false;
-    }
-    if (filter.source && record.source !== filter.source) {
-        return false;
-    }
-    if (filter.status && record.status !== filter.status) {
-        return false;
-    }
-    if (filter.query) {
-        const query = filter.query.trim().toLowerCase();
-        const haystack = [
-            record.scheduleId,
-            record.name,
-            record.agentId ?? "",
-            record.instruction,
-            record.source,
-            record.schedule.type,
-            "everyMinutes" in record.schedule ? String(record.schedule.everyMinutes) : "",
-            "expression" in record.schedule ? record.schedule.expression : "",
-            "time" in record.schedule ? record.schedule.time : "",
-            "days" in record.schedule ? record.schedule.days.join(",") : "",
-        ].join("\n").toLowerCase();
-        if (!haystack.includes(query)) {
-            return false;
-        }
-    }
-    return true;
-}
-function stringifySchedule(record) {
-    if (record.schedule.type === "cron") {
-        return `cron ${record.schedule.expression}`;
-    }
-    if (record.schedule.type === "interval") {
-        return `every ${record.schedule.everyMinutes} minute(s)`;
-    }
-    if (record.schedule.type === "daily") {
-        return `daily ${record.schedule.time}`;
-    }
-    return `weekly ${record.schedule.days.join(",")} ${record.schedule.time}`;
-}
-async function safeReadManifest(filePath) {
-    try {
-        return JSON.parse(await readFile(filePath, "utf8"));
-    }
-    catch {
-        return null;
-    }
-}
-class CrontabAdapter {
-    runCommand;
-    source = "crontab";
-    constructor(runCommand) {
-        this.runCommand = runCommand;
-    }
-    buildCronExpression(definition) {
-        if (definition.type === "cron") {
-            return definition.expression;
-        }
-        if (definition.type === "interval") {
-            return `*/${validateIntervalMinutes(definition.everyMinutes)} * * * *`;
-        }
-        const { hour, minute } = parseScheduleTime(definition.time);
-        if (definition.type === "daily") {
-            return `${minute} ${hour} * * *`;
-        }
-        const days = normalizeWeeklyDays(definition.days).map((day) => WEEKDAY_ORDER.indexOf(day)).join(",");
-        return `${minute} ${hour} * * ${days}`;
-    }
-    scheduleBlock(record, commandLine) {
-        return [
-            `${CRON_BEGIN_PREFIX}${record.scheduleId}`,
-            `${this.buildCronExpression(record.schedule)} ${commandLine}`,
-            `${CRON_END_PREFIX}${record.scheduleId}`,
-        ].join("\n");
-    }
-    stripScheduleBlock(crontabText, scheduleId) {
-        const lines = crontabText.split(/\r?\n/u);
-        const result = [];
-        let skipping = false;
-        for (const line of lines) {
-            if (line === `${CRON_BEGIN_PREFIX}${scheduleId}`) {
-                skipping = true;
-                continue;
-            }
-            if (line === `${CRON_END_PREFIX}${scheduleId}`) {
-                skipping = false;
-                continue;
-            }
-            if (!skipping) {
-                result.push(line);
-            }
-        }
-        return result.join("\n").replace(/\n{3,}/gu, "\n\n").trim();
-    }
-    async readCrontab() {
-        const result = await this.runCommand("crontab", ["-l"]);
-        if (result.exitCode === 0) {
-            return result.stdout.trim();
-        }
-        const errorText = `${result.stdout}\n${result.stderr}`.toLowerCase();
-        if (errorText.includes("no crontab")) {
-            return "";
-        }
-        throw new Error(result.stderr.trim() || result.stdout.trim() || "Failed to read crontab.");
-    }
-    async writeCrontab(contents) {
-        const result = await this.runCommand("crontab", ["-"], { input: contents.trim() ? `${contents.trim()}\n` : "" });
-        if (result.exitCode !== 0) {
-            throw new Error(result.stderr.trim() || result.stdout.trim() || "Failed to write crontab.");
-        }
-    }
-    async install(record, commandLine) {
-        const current = await this.readCrontab();
-        const stripped = this.stripScheduleBlock(current, record.scheduleId);
-        const next = [stripped, this.scheduleBlock(record, commandLine)].filter((part) => part.trim().length > 0).join("\n\n");
-        await this.writeCrontab(next);
-    }
-    async remove(record) {
-        const current = await this.readCrontab();
-        await this.writeCrontab(this.stripScheduleBlock(current, record.scheduleId));
-    }
-    async exists(record) {
-        const current = await this.readCrontab();
-        return current.includes(`${CRON_BEGIN_PREFIX}${record.scheduleId}`);
-    }
-}
-class WindowsTaskSchedulerAdapter {
-    runCommand;
-    source = "schtasks";
-    constructor(runCommand) {
-        this.runCommand = runCommand;
-    }
-    taskName(record) {
-        return `${MANAGED_PREFIX}-${record.scheduleId}`;
-    }
-    createArgs(record, commandLine) {
-        if (record.schedule.type === "cron") {
-            throw new Error("Cron expressions are not supported on Windows system schedules.");
-        }
-        if (record.schedule.type === "interval") {
-            return [
-                "/Create",
-                "/TN",
-                this.taskName(record),
-                "/TR",
-                commandLine,
-                "/SC",
-                "MINUTE",
-                "/MO",
-                String(validateIntervalMinutes(record.schedule.everyMinutes)),
-                "/F",
-            ];
-        }
-        const args = [
-            "/Create",
-            "/TN",
-            this.taskName(record),
-            "/TR",
-            commandLine,
-            "/F",
-        ];
-        if (record.schedule.type === "daily") {
-            args.push("/SC", "DAILY", "/ST", record.schedule.time);
-            return args;
-        }
-        args.push("/SC", "WEEKLY", "/ST", record.schedule.time, "/D", normalizeWeeklyDays(record.schedule.days).map((day) => day.toUpperCase()).join(","));
-        return args;
-    }
-    async install(record, commandLine) {
-        const result = await this.runCommand("schtasks", this.createArgs(record, commandLine));
-        if (result.exitCode !== 0) {
-            throw new Error(result.stderr.trim() || result.stdout.trim() || "Failed to create Windows scheduled task.");
-        }
-    }
-    async remove(record) {
-        const result = await this.runCommand("schtasks", ["/Delete", "/TN", this.taskName(record), "/F"]);
-        const output = `${result.stdout}\n${result.stderr}`.toLowerCase();
-        if (result.exitCode !== 0 && !output.includes("cannot find")) {
-            throw new Error(result.stderr.trim() || result.stdout.trim() || "Failed to delete Windows scheduled task.");
-        }
-    }
-    async exists(record) {
-        const result = await this.runCommand("schtasks", ["/Query", "/TN", this.taskName(record)]);
-        return result.exitCode === 0;
-    }
-}
-export class SystemScheduleManager {
-    options;
-    schedulesRoot;
-    platform;
-    nodePath;
-    cliPath;
-    adapter;
-    constructor(options) {
-        this.options = options;
-        this.schedulesRoot = path.join(options.runtimeRoot, SCHEDULES_DIR);
-        this.platform = options.platform ?? os.platform();
-        this.nodePath = options.nodePath ?? process.execPath;
-        this.cliPath = options.cliPath ?? resolveDefaultCliPath();
-        const runCommand = options.runCommand ?? defaultRunCommand;
-        this.adapter = this.platform === "win32" ? new WindowsTaskSchedulerAdapter(runCommand) : new CrontabAdapter(runCommand);
-    }
-    manifestPath(scheduleId) {
-        return path.join(this.schedulesRoot, `${scheduleId}.json`);
-    }
-    async ensureSchedulesRoot() {
-        await mkdir(this.schedulesRoot, { recursive: true });
-    }
-    async writeManifest(record) {
-        await this.ensureSchedulesRoot();
-        await writeFile(this.manifestPath(record.scheduleId), JSON.stringify(record, null, 2), "utf8");
-    }
-    toPublicRecord(record, status) {
-        return {
-            scheduleId: record.scheduleId,
-            name: record.name,
-            instruction: record.instruction,
-            ...(record.agentId ? { agentId: record.agentId } : {}),
-            schedule: record.schedule,
-            source: record.source,
-            platform: record.platform,
-            status,
-            systemId: record.systemId,
-            createdAt: record.createdAt,
-            updatedAt: record.updatedAt,
-            ...(record.metadata ? { metadata: record.metadata } : {}),
-        };
-    }
-    async loadStoredRecord(scheduleId) {
-        return safeReadManifest(this.manifestPath(scheduleId));
-    }
-    async resolveStatus(record) {
-        return (await this.adapter.exists(record)) ? "active" : "missing";
-    }
-    async getSchedule(scheduleId) {
-        const stored = await this.loadStoredRecord(scheduleId);
-        if (!stored) {
-            return null;
-        }
-        return this.toPublicRecord(stored, await this.resolveStatus(stored));
-    }
-    async listStoredRecords() {
-        try {
-            const entries = await readdir(this.schedulesRoot, { withFileTypes: true });
-            const loaded = await Promise.all(entries
-                .filter((entry) => entry.isFile() && entry.name.endsWith(".json"))
-                .map((entry) => safeReadManifest(path.join(this.schedulesRoot, entry.name))));
-            return loaded.filter((entry) => entry !== null);
-        }
-        catch {
-            return [];
-        }
-    }
-    async createSchedule(input) {
-        if (!input.name?.trim()) {
-            throw new Error("schedule_task create requires name.");
-        }
-        if (!input.instruction?.trim()) {
-            throw new Error("schedule_task create requires instruction.");
-        }
-        if (!input.schedule) {
-            throw new Error("schedule_task create requires schedule.");
-        }
-        const now = new Date().toISOString();
-        const scheduleId = `${MANAGED_PREFIX}-${createPersistentId()}`;
-        const validatedSchedule = validateScheduleDefinition(input.schedule, this.platform);
-        const stored = {
-            scheduleId,
-            name: input.name.trim(),
-            instruction: input.instruction.trim(),
-            ...(input.agentId?.trim() ? { agentId: input.agentId.trim() } : {}),
-            schedule: validatedSchedule,
-            source: this.adapter.source,
-            platform: this.platform,
-            systemId: `${MANAGED_PREFIX}:${scheduleId}`,
-            createdAt: now,
-            updatedAt: now,
-            workspaceRoot: this.options.workspaceRoot,
-            ...(input.metadata ? { metadata: input.metadata } : {}),
-        };
-        const commandLine = buildCommandLine({
-            platform: this.platform,
-            nodePath: this.nodePath,
-            cliPath: this.cliPath,
-            workspaceRoot: this.options.workspaceRoot,
-            scheduleId,
-        });
-        await this.adapter.install(stored, commandLine);
-        await this.writeManifest(stored);
-        return {
-            ok: true,
-            operation: "create",
-            schedule: this.toPublicRecord(stored, "active"),
-        };
-    }
-    async listSchedules(filter) {
-        const records = await this.listStoredRecords();
-        const resolved = await Promise.all(records.map(async (record) => this.toPublicRecord(record, await this.resolveStatus(record))));
-        const items = resolved.filter((record) => matchesFilter(record, filter));
-        return {
-            ok: true,
-            operation: "list",
-            items,
-            total: items.length,
-        };
-    }
-    async updateSchedule(input) {
-        if (!input.scheduleId?.trim()) {
-            throw new Error("schedule_task update requires scheduleId.");
-        }
-        const current = await this.loadStoredRecord(input.scheduleId.trim());
-        if (!current) {
-            throw new Error(`Unknown schedule '${input.scheduleId}'.`);
-        }
-        const updated = {
-            ...current,
-            ...(input.name?.trim() ? { name: input.name.trim() } : {}),
-            ...(input.instruction?.trim() ? { instruction: input.instruction.trim() } : {}),
-            ...(input.agentId !== undefined ? { agentId: input.agentId.trim() || undefined } : {}),
-            ...(input.schedule ? { schedule: validateScheduleDefinition(input.schedule, this.platform) } : {}),
-            ...(input.metadata !== undefined ? { metadata: input.metadata } : {}),
-            updatedAt: new Date().toISOString(),
-        };
-        const commandLine = buildCommandLine({
-            platform: this.platform,
-            nodePath: this.nodePath,
-            cliPath: this.cliPath,
-            workspaceRoot: this.options.workspaceRoot,
-            scheduleId: updated.scheduleId,
-        });
-        await this.adapter.install(updated, commandLine);
-        await this.writeManifest(updated);
-        return {
-            ok: true,
-            operation: "update",
-            schedule: this.toPublicRecord(updated, "active"),
-        };
-    }
-    async deleteSchedule(input) {
-        if (!input.scheduleId?.trim()) {
-            throw new Error("schedule_task delete requires scheduleId.");
-        }
-        const current = await this.loadStoredRecord(input.scheduleId.trim());
-        if (!current) {
-            throw new Error(`Unknown schedule '${input.scheduleId}'.`);
-        }
-        await this.adapter.remove(current);
-        await rm(this.manifestPath(current.scheduleId), { force: true });
-        return {
-            ok: true,
-            operation: "delete",
-            scheduleId: current.scheduleId,
-        };
-    }
-    async manageSchedule(input) {
-        const operation = input.operation ?? "create";
-        if (operation === "create") {
-            return this.createSchedule(input);
-        }
-        if (operation === "list") {
-            return this.listSchedules(input.filters);
-        }
-        if (operation === "get") {
-            if (!input.scheduleId?.trim()) {
-                throw new Error("schedule_task get requires scheduleId.");
-            }
-            const schedule = await this.getSchedule(input.scheduleId.trim());
-            if (!schedule) {
-                throw new Error(`Unknown schedule '${input.scheduleId}'.`);
-            }
-            return {
-                ok: true,
-                operation: "get",
-                schedule,
-            };
-        }
-        if (operation === "update") {
-            return this.updateSchedule(input);
-        }
-        if (operation === "delete") {
-            return this.deleteSchedule(input);
-        }
-        throw new Error(`Unsupported schedule_task operation '${operation}'.`);
-    }
-    describeSchedule(record) {
-        return `${record.scheduleId} ${record.name} ${stringifySchedule(record)} status=${record.status}`;
-    }
-}
+import{mkdir as g,readFile as k,readdir as C,rm as R,writeFile as E}from"node:fs/promises";import{existsSync as v}from"node:fs";import P from"node:os";import u from"node:path";import{fileURLToPath as b}from"node:url";import{createPersistentId as x}from"../../utils/id.js";const d="agent-harness",N="schedules",c="# agent-harness schedule begin ",f="# agent-harness schedule end ",l=["sun","mon","tue","wed","thu","fri","sat"];function A(s){return`'${s.replaceAll("'",`'"'"'`)}'`}function M(s){return`"${s.replaceAll('"','\\"')}"`}function j(){return u.resolve(b(new URL("../../..",import.meta.url)))}function F(){const s=j(),e=u.join(s,"dist","cli.js");if(v(e))return e;throw new Error(`System scheduling requires a built CLI at ${e}. Run the build before creating schedules.`)}async function T(s,e,t={}){const{spawn:r}=await import("node:child_process");return new Promise((a,n)=>{const i=r(s,e,{stdio:["pipe","pipe","pipe"]});let w="",p="";i.stdout.on("data",o=>{w+=String(o)}),i.stderr.on("data",o=>{p+=String(o)}),i.on("error",n),i.on("close",o=>{a({stdout:w,stderr:p,exitCode:o??0})}),typeof t.input=="string"&&i.stdin.write(t.input),i.stdin.end()})}function y(s){const e=/^(\d{2}):(\d{2})$/.exec(s.trim());if(!e)throw new Error(`Invalid schedule time '${s}'. Use HH:mm.`);const t=Number.parseInt(e[1],10),r=Number.parseInt(e[2],10);if(t<0||t>23||r<0||r>59)throw new Error(`Invalid schedule time '${s}'. Use HH:mm.`);return{hour:t,minute:r}}function h(s){const e=Array.from(new Set(s.map(t=>t.trim().toLowerCase().slice(0,3)).filter(t=>l.includes(t))));if(e.length===0)throw new Error("Weekly schedules require at least one valid weekday.");return l.filter(t=>e.includes(t))}function m(s){if(!Number.isInteger(s)||s<=0)throw new Error("Interval schedules require a positive integer everyMinutes value.");return s}function I(s,e){if(s.type==="cron"){const r=s.expression.trim().split(/\s+/u);if(r.length!==5)throw new Error(`Invalid cron expression '${s.expression}'. Expected 5 fields.`);if(e==="win32")throw new Error("Cron expressions are not supported on Windows system schedules.");return{type:"cron",expression:r.join(" ")}}if(s.type==="interval"){const r=m(s.everyMinutes);if(e!=="win32"&&60%r!==0)throw new Error("Crontab interval schedules currently require everyMinutes to divide evenly into 60.");return{type:"interval",everyMinutes:r}}const t=y(s.time);return s.type==="daily"?{type:"daily",time:`${String(t.hour).padStart(2,"0")}:${String(t.minute).padStart(2,"0")}`}:{type:"weekly",time:`${String(t.hour).padStart(2,"0")}:${String(t.minute).padStart(2,"0")}`,days:h(s.days)}}function S(s){const e=s.platform==="win32"?M:A;return[e(s.nodePath),e(s.cliPath),"runtime","scheduled-run","--workspace",e(s.workspaceRoot),"--schedule",e(s.scheduleId)].join(" ")}function q(s,e){if(!e)return!0;if(e.scheduleId&&s.scheduleId!==e.scheduleId||e.name&&s.name!==e.name||e.agentId&&s.agentId!==e.agentId||e.source&&s.source!==e.source||e.status&&s.status!==e.status)return!1;if(e.query){const t=e.query.trim().toLowerCase();if(![s.scheduleId,s.name,s.agentId??"",s.instruction,s.source,s.schedule.type,"everyMinutes"in s.schedule?String(s.schedule.everyMinutes):"","expression"in s.schedule?s.schedule.expression:"","time"in s.schedule?s.schedule.time:"","days"in s.schedule?s.schedule.days.join(","):""].join(`
+`).toLowerCase().includes(t))return!1}return!0}function D(s){return s.schedule.type==="cron"?`cron ${s.schedule.expression}`:s.schedule.type==="interval"?`every ${s.schedule.everyMinutes} minute(s)`:s.schedule.type==="daily"?`daily ${s.schedule.time}`:`weekly ${s.schedule.days.join(",")} ${s.schedule.time}`}async function $(s){try{return JSON.parse(await k(s,"utf8"))}catch{return null}}class _{runCommand;source="crontab";constructor(e){this.runCommand=e}buildCronExpression(e){if(e.type==="cron")return e.expression;if(e.type==="interval")return`*/${m(e.everyMinutes)} * * * *`;const{hour:t,minute:r}=y(e.time);if(e.type==="daily")return`${r} ${t} * * *`;const a=h(e.days).map(n=>l.indexOf(n)).join(",");return`${r} ${t} * * ${a}`}scheduleBlock(e,t){return[`${c}${e.scheduleId}`,`${this.buildCronExpression(e.schedule)} ${t}`,`${f}${e.scheduleId}`].join(`
+`)}stripScheduleBlock(e,t){const r=e.split(/\r?\n/u),a=[];let n=!1;for(const i of r){if(i===`${c}${t}`){n=!0;continue}if(i===`${f}${t}`){n=!1;continue}n||a.push(i)}return a.join(`
+`).replace(/\n{3,}/gu,`
+
+`).trim()}async readCrontab(){const e=await this.runCommand("crontab",["-l"]);if(e.exitCode===0)return e.stdout.trim();if(`${e.stdout}
+${e.stderr}`.toLowerCase().includes("no crontab"))return"";throw new Error(e.stderr.trim()||e.stdout.trim()||"Failed to read crontab.")}async writeCrontab(e){const t=await this.runCommand("crontab",["-"],{input:e.trim()?`${e.trim()}
+`:""});if(t.exitCode!==0)throw new Error(t.stderr.trim()||t.stdout.trim()||"Failed to write crontab.")}async install(e,t){const r=await this.readCrontab(),n=[this.stripScheduleBlock(r,e.scheduleId),this.scheduleBlock(e,t)].filter(i=>i.trim().length>0).join(`
+
+`);await this.writeCrontab(n)}async remove(e){const t=await this.readCrontab();await this.writeCrontab(this.stripScheduleBlock(t,e.scheduleId))}async exists(e){return(await this.readCrontab()).includes(`${c}${e.scheduleId}`)}}class L{runCommand;source="schtasks";constructor(e){this.runCommand=e}taskName(e){return`${d}-${e.scheduleId}`}createArgs(e,t){if(e.schedule.type==="cron")throw new Error("Cron expressions are not supported on Windows system schedules.");if(e.schedule.type==="interval")return["/Create","/TN",this.taskName(e),"/TR",t,"/SC","MINUTE","/MO",String(m(e.schedule.everyMinutes)),"/F"];const r=["/Create","/TN",this.taskName(e),"/TR",t,"/F"];return e.schedule.type==="daily"?(r.push("/SC","DAILY","/ST",e.schedule.time),r):(r.push("/SC","WEEKLY","/ST",e.schedule.time,"/D",h(e.schedule.days).map(a=>a.toUpperCase()).join(",")),r)}async install(e,t){const r=await this.runCommand("schtasks",this.createArgs(e,t));if(r.exitCode!==0)throw new Error(r.stderr.trim()||r.stdout.trim()||"Failed to create Windows scheduled task.")}async remove(e){const t=await this.runCommand("schtasks",["/Delete","/TN",this.taskName(e),"/F"]),r=`${t.stdout}
+${t.stderr}`.toLowerCase();if(t.exitCode!==0&&!r.includes("cannot find"))throw new Error(t.stderr.trim()||t.stdout.trim()||"Failed to delete Windows scheduled task.")}async exists(e){return(await this.runCommand("schtasks",["/Query","/TN",this.taskName(e)])).exitCode===0}}class Y{options;schedulesRoot;platform;nodePath;cliPath;adapter;constructor(e){this.options=e,this.schedulesRoot=u.join(e.runtimeRoot,N),this.platform=e.platform??P.platform(),this.nodePath=e.nodePath??process.execPath,this.cliPath=e.cliPath??F();const t=e.runCommand??T;this.adapter=this.platform==="win32"?new L(t):new _(t)}manifestPath(e){return u.join(this.schedulesRoot,`${e}.json`)}async ensureSchedulesRoot(){await g(this.schedulesRoot,{recursive:!0})}async writeManifest(e){await this.ensureSchedulesRoot(),await E(this.manifestPath(e.scheduleId),JSON.stringify(e,null,2),"utf8")}toPublicRecord(e,t){return{scheduleId:e.scheduleId,name:e.name,instruction:e.instruction,...e.agentId?{agentId:e.agentId}:{},schedule:e.schedule,source:e.source,platform:e.platform,status:t,systemId:e.systemId,createdAt:e.createdAt,updatedAt:e.updatedAt,...e.metadata?{metadata:e.metadata}:{}}}async loadStoredRecord(e){return $(this.manifestPath(e))}async resolveStatus(e){return await this.adapter.exists(e)?"active":"missing"}async getSchedule(e){const t=await this.loadStoredRecord(e);return t?this.toPublicRecord(t,await this.resolveStatus(t)):null}async listStoredRecords(){try{const e=await C(this.schedulesRoot,{withFileTypes:!0});return(await Promise.all(e.filter(r=>r.isFile()&&r.name.endsWith(".json")).map(r=>$(u.join(this.schedulesRoot,r.name))))).filter(r=>r!==null)}catch{return[]}}async createSchedule(e){if(!e.name?.trim())throw new Error("schedule_task create requires name.");if(!e.instruction?.trim())throw new Error("schedule_task create requires instruction.");if(!e.schedule)throw new Error("schedule_task create requires schedule.");const t=new Date().toISOString(),r=`${d}-${x()}`,a=I(e.schedule,this.platform),n={scheduleId:r,name:e.name.trim(),instruction:e.instruction.trim(),...e.agentId?.trim()?{agentId:e.agentId.trim()}:{},schedule:a,source:this.adapter.source,platform:this.platform,systemId:`${d}:${r}`,createdAt:t,updatedAt:t,workspaceRoot:this.options.workspaceRoot,...e.metadata?{metadata:e.metadata}:{}},i=S({platform:this.platform,nodePath:this.nodePath,cliPath:this.cliPath,workspaceRoot:this.options.workspaceRoot,scheduleId:r});return await this.adapter.install(n,i),await this.writeManifest(n),{ok:!0,operation:"create",schedule:this.toPublicRecord(n,"active")}}async listSchedules(e){const t=await this.listStoredRecords(),a=(await Promise.all(t.map(async n=>this.toPublicRecord(n,await this.resolveStatus(n))))).filter(n=>q(n,e));return{ok:!0,operation:"list",items:a,total:a.length}}async updateSchedule(e){if(!e.scheduleId?.trim())throw new Error("schedule_task update requires scheduleId.");const t=await this.loadStoredRecord(e.scheduleId.trim());if(!t)throw new Error(`Unknown schedule '${e.scheduleId}'.`);const r={...t,...e.name?.trim()?{name:e.name.trim()}:{},...e.instruction?.trim()?{instruction:e.instruction.trim()}:{},...e.agentId!==void 0?{agentId:e.agentId.trim()||void 0}:{},...e.schedule?{schedule:I(e.schedule,this.platform)}:{},...e.metadata!==void 0?{metadata:e.metadata}:{},updatedAt:new Date().toISOString()},a=S({platform:this.platform,nodePath:this.nodePath,cliPath:this.cliPath,workspaceRoot:this.options.workspaceRoot,scheduleId:r.scheduleId});return await this.adapter.install(r,a),await this.writeManifest(r),{ok:!0,operation:"update",schedule:this.toPublicRecord(r,"active")}}async deleteSchedule(e){if(!e.scheduleId?.trim())throw new Error("schedule_task delete requires scheduleId.");const t=await this.loadStoredRecord(e.scheduleId.trim());if(!t)throw new Error(`Unknown schedule '${e.scheduleId}'.`);return await this.adapter.remove(t),await R(this.manifestPath(t.scheduleId),{force:!0}),{ok:!0,operation:"delete",scheduleId:t.scheduleId}}async manageSchedule(e){const t=e.operation??"create";if(t==="create")return this.createSchedule(e);if(t==="list")return this.listSchedules(e.filters);if(t==="get"){if(!e.scheduleId?.trim())throw new Error("schedule_task get requires scheduleId.");const r=await this.getSchedule(e.scheduleId.trim());if(!r)throw new Error(`Unknown schedule '${e.scheduleId}'.`);return{ok:!0,operation:"get",schedule:r}}if(t==="update")return this.updateSchedule(e);if(t==="delete")return this.deleteSchedule(e);throw new Error(`Unsupported schedule_task operation '${t}'.`)}describeSchedule(e){return`${e.scheduleId} ${e.name} ${D(e)} status=${e.status}`}}export{Y as SystemScheduleManager};