@dcrays/scheduled-task 0.1.0

package/src/manager.js

@@ -0,0 +1,452 @@
+import { createHash } from 'node:crypto';
+import { assertMinimumCronInterval, CronExpressionError, MIN_CRON_INTERVAL_SECONDS, nextCronOccurrence, validTimeZone } from './cron.js';
+import { CronAutomationInputError } from './protocol.js';
+import { CronAutomationRepository } from './repository.js';
+const MAX_TIMER_DELAY_MS = 2_147_483_647;
+function automationId(agentId, requestId) {
+    return `cron-${createHash('sha256').update(`${agentId}\0${requestId}`).digest('hex').slice(0, 24)}`;
+}
+function cloneJob(job) {
+    return structuredClone(job);
+}
+function dshAgentIdFor(job) {
+    return job.dshSessionId ?? job.agentId;
+}
+function timezoneFor(schedule) {
+    return schedule.tz ?? Intl.DateTimeFormat().resolvedOptions().timeZone ?? 'UTC';
+}
+function atTimestamp(schedule) {
+    if (typeof schedule.atMs === 'number')
+        return schedule.atMs;
+    return typeof schedule.at === 'string' ? Date.parse(schedule.at) : Number.NaN;
+}
+function assertMinimumScheduleInterval(schedule) {
+    if (schedule.kind === 'at')
+        return;
+    if (schedule.kind === 'every') {
+        if (schedule.everyMs < MIN_CRON_INTERVAL_SECONDS * 1_000) {
+            throw new CronAutomationInputError('invalid_cron', `schedule interval must be at least ${MIN_CRON_INTERVAL_SECONDS} seconds (${MIN_CRON_INTERVAL_SECONDS / 60} minutes)`);
+        }
+        return;
+    }
+    try {
+        assertMinimumCronInterval(schedule.expr);
+    }
+    catch (error) {
+        throw new CronAutomationInputError('invalid_cron', error instanceof Error ? error.message : 'invalid cron expression');
+    }
+}
+function disableIfTooFrequent(job) {
+    if (!job.enabled)
+        return false;
+    try {
+        assertMinimumScheduleInterval(job.schedule);
+        return false;
+    }
+    catch (error) {
+        if (!(error instanceof CronAutomationInputError))
+            throw error;
+        job.enabled = false;
+        delete job.state.runningAtMs;
+        delete job.state.nextRunAtMs;
+        return true;
+    }
+}
+function nextOccurrence(afterEpochMs, schedule) {
+    if (schedule.kind === 'at') {
+        const at = atTimestamp(schedule);
+        return Number.isFinite(at) && at > afterEpochMs ? at : undefined;
+    }
+    if (schedule.kind === 'every') {
+        const anchor = schedule.anchorMs ?? afterEpochMs;
+        if (anchor > afterEpochMs)
+            return anchor;
+        return anchor + (Math.floor((afterEpochMs - anchor) / schedule.everyMs) + 1) * schedule.everyMs;
+    }
+    try {
+        return nextCronOccurrence(afterEpochMs, schedule.expr, timezoneFor(schedule));
+    }
+    catch (error) {
+        if (error instanceof CronExpressionError)
+            throw new CronAutomationInputError('invalid_cron', error.message);
+        throw error;
+    }
+}
+function initialOccurrence(job, now) {
+    return job.schedule.kind === 'at' ? atTimestamp(job.schedule) : nextOccurrence(now, job.schedule);
+}
+function setNextOccurrence(job, value) {
+    if (value === undefined)
+        delete job.state.nextRunAtMs;
+    else
+        job.state.nextRunAtMs = value;
+}
+function sameRequest(job, envelope) {
+    return (job.name === envelope.name &&
+        job.payload.message === envelope.prompt &&
+        job.schedule.kind === 'cron' &&
+        job.schedule.expr === envelope.cron &&
+        timezoneFor(job.schedule) === envelope.timezone);
+}
+export class CronAutomationManager {
+    repository;
+    options;
+    jobs = new Map();
+    blockedAgents = new Set();
+    now;
+    started;
+    tail = Promise.resolve();
+    timer;
+    stopping = false;
+    constructor(repository, options) {
+        this.repository = repository;
+        this.options = options;
+        this.now = options.now ?? Date.now;
+    }
+    start() {
+        return (this.started ??= this.initialize());
+    }
+    async initialize() {
+        const loaded = await this.repository.load();
+        const changed = [];
+        const now = this.now();
+        for (const job of loaded) {
+            let jobChanged = disableIfTooFrequent(job);
+            if (job.state.runningAtMs !== undefined) {
+                delete job.state.runningAtMs;
+                jobChanged = true;
+            }
+            if (job.enabled && job.state.nextRunAtMs === undefined) {
+                setNextOccurrence(job, initialOccurrence(job, now));
+                jobChanged = true;
+            }
+            if (jobChanged)
+                changed.push(job);
+            this.jobs.set(job.id, job);
+        }
+        await this.repository.upsert(changed);
+        this.arm();
+    }
+    async stop() {
+        this.stopping = true;
+        if (this.timer)
+            clearTimeout(this.timer);
+        this.timer = undefined;
+        try {
+            await this.tail;
+        }
+        finally {
+            this.repository.close();
+        }
+    }
+    async create(agentId, envelope) {
+        await this.start();
+        return this.enqueue(async () => {
+            if (this.stopping)
+                throw new Error('cron automation manager is stopping');
+            const id = automationId(agentId, envelope.requestId);
+            const existing = this.jobs.get(id);
+            if (existing) {
+                if (!sameRequest(existing, envelope)) {
+                    throw new CronAutomationInputError('request_id_conflict', 'requestId was already used for a different cron automation');
+                }
+                return cloneJob(existing);
+            }
+            if (envelope.prompt.length > this.options.maxPromptChars) {
+                throw new CronAutomationInputError('invalid_prompt', `prompt must not exceed ${this.options.maxPromptChars} characters`);
+            }
+            const now = this.now();
+            const schedule = { kind: 'cron', expr: envelope.cron, tz: envelope.timezone };
+            assertMinimumScheduleInterval(schedule);
+            const nextRunAtMs = nextOccurrence(now, schedule);
+            const job = {
+                id,
+                name: envelope.name,
+                description: envelope.prompt,
+                enabled: true,
+                createdAtMs: now,
+                updatedAtMs: now,
+                schedule,
+                payload: { kind: 'agentTurn', message: envelope.prompt, timeoutSeconds: 600 },
+                agentId,
+                dshSessionId: agentId,
+                sessionTarget: 'isolated',
+                wakeMode: 'now',
+                delivery: { mode: 'announce', bestEffort: true },
+                state: { ...(nextRunAtMs === undefined ? {} : { nextRunAtMs }) }
+            };
+            this.jobs.set(job.id, job);
+            try {
+                await this.repository.upsert([job]);
+            }
+            catch (error) {
+                this.jobs.delete(job.id);
+                throw error;
+            }
+            this.options.onCreated?.(cloneJob(job));
+            this.arm();
+            return cloneJob(job);
+        });
+    }
+    async update(jobId, patch) {
+        await this.start();
+        return this.enqueue(async () => {
+            const current = this.jobs.get(jobId);
+            if (!current)
+                return undefined;
+            const patchKeys = Object.keys(patch);
+            if (patchKeys.length === 0)
+                throw new CronAutomationInputError('invalid_envelope', 'at least one editable field is required');
+            if (patchKeys.length === 1 && patch.enabled === current.enabled)
+                return cloneJob(current);
+            const next = cloneJob(current);
+            if (patch.name !== undefined) {
+                if (patch.name.trim() !== patch.name || patch.name.length < 1 || patch.name.length > 120) {
+                    throw new CronAutomationInputError('invalid_name', 'name must contain 1-120 characters without surrounding whitespace');
+                }
+                next.name = patch.name;
+            }
+            if (patch.prompt !== undefined) {
+                if (patch.prompt.trim() !== patch.prompt ||
+                    patch.prompt.length < 1 ||
+                    patch.prompt.length > this.options.maxPromptChars) {
+                    throw new CronAutomationInputError('invalid_prompt', `prompt must contain 1-${this.options.maxPromptChars} characters without surrounding whitespace`);
+                }
+                next.payload.message = patch.prompt;
+                next.description = patch.prompt;
+            }
+            if (patch.cron !== undefined) {
+                try {
+                    assertMinimumCronInterval(patch.cron);
+                }
+                catch (error) {
+                    throw new CronAutomationInputError('invalid_cron', error instanceof Error ? error.message : 'invalid cron expression');
+                }
+            }
+            if (patch.timezone !== undefined && !validTimeZone(patch.timezone)) {
+                throw new CronAutomationInputError('invalid_timezone', 'timezone must be a valid IANA time zone');
+            }
+            if (patch.sessionKey !== undefined) {
+                if (!patch.sessionKey.trim() || patch.sessionKey.trim() !== patch.sessionKey) {
+                    throw new CronAutomationInputError('invalid_envelope', 'sessionKey must be non-empty without surrounding whitespace');
+                }
+                next.sessionKey = patch.sessionKey;
+                next.delivery = {
+                    ...next.delivery,
+                    mode: 'announce',
+                    to: `dcg-cron:${patch.sessionKey}`,
+                    channel: 'dcgchat',
+                    bestEffort: true
+                };
+            }
+            for (const key of ['agentId', 'dshSessionId']) {
+                if (patch[key] !== undefined) {
+                    if (!patch[key]?.trim() || patch[key]?.trim() !== patch[key]) {
+                        throw new CronAutomationInputError('invalid_envelope', `${key} must be non-empty without surrounding whitespace`);
+                    }
+                    next[key] = patch[key];
+                }
+            }
+            if (patch.cron !== undefined || patch.timezone !== undefined) {
+                const currentCron = next.schedule.kind === 'cron' ? next.schedule.expr : undefined;
+                const currentTimezone = next.schedule.kind === 'cron' ? timezoneFor(next.schedule) : undefined;
+                if (!patch.cron && !currentCron)
+                    throw new CronAutomationInputError('invalid_cron', 'changing a non-cron schedule requires a cron expression');
+                next.schedule = {
+                    kind: 'cron',
+                    expr: patch.cron ?? currentCron ?? '',
+                    tz: patch.timezone ?? currentTimezone ?? 'UTC'
+                };
+            }
+            const now = this.now();
+            if (patch.enabled !== undefined) {
+                next.enabled = patch.enabled;
+                delete next.state.runningAtMs;
+            }
+            if (next.enabled)
+                assertMinimumScheduleInterval(next.schedule);
+            if (patch.enabled === true) {
+                setNextOccurrence(next, initialOccurrence(next, now));
+            }
+            else if (patch.cron !== undefined || patch.timezone !== undefined) {
+                setNextOccurrence(next, nextOccurrence(now, next.schedule));
+            }
+            next.updatedAtMs = now;
+            this.jobs.set(jobId, next);
+            try {
+                await this.repository.upsert([next]);
+            }
+            catch (error) {
+                this.jobs.set(jobId, current);
+                throw error;
+            }
+            if (patch.enabled || dshAgentIdFor(current) !== dshAgentIdFor(next)) {
+                this.blockedAgents.delete(dshAgentIdFor(current));
+                this.blockedAgents.delete(dshAgentIdFor(next));
+            }
+            this.options.onChanged?.(cloneJob(next));
+            this.arm();
+            return cloneJob(next);
+        });
+    }
+    async delete(jobId) {
+        await this.start();
+        return this.enqueue(async () => {
+            const job = this.jobs.get(jobId);
+            if (!job)
+                return false;
+            this.jobs.delete(jobId);
+            this.blockedAgents.delete(dshAgentIdFor(job));
+            try {
+                await this.repository.delete(jobId);
+            }
+            catch (error) {
+                this.jobs.set(jobId, job);
+                throw error;
+            }
+            this.options.onChanged?.(cloneJob(job));
+            this.arm();
+            return true;
+        });
+    }
+    async runOnceStatus(jobId) {
+        await this.start();
+        return this.enqueue(async () => {
+            const job = this.jobs.get(jobId);
+            if (!job)
+                return 'not_found';
+            if (job.state.runningAtMs !== undefined)
+                return 'already_running';
+            const occurrenceAtMs = this.now();
+            job.state.runningAtMs = occurrenceAtMs;
+            job.updatedAtMs = occurrenceAtMs;
+            await this.repository.upsert([job]);
+            const delivered = await this.deliver(job, occurrenceAtMs);
+            delete job.state.runningAtMs;
+            job.state.lastRunAtMs = occurrenceAtMs;
+            job.state.lastRunStatus = delivered ? 'ok' : 'skipped';
+            job.updatedAtMs = this.now();
+            await this.repository.upsert([job]);
+            if (delivered) {
+                this.options.onDispatched?.(cloneJob(job), new Date(occurrenceAtMs).toISOString());
+                return 'dispatched';
+            }
+            this.options.onChanged?.(cloneJob(job));
+            return 'delivery_unavailable';
+        });
+    }
+    async runOnce(jobId) {
+        return (await this.runOnceStatus(jobId)) === 'dispatched';
+    }
+    async list(agentId) {
+        await this.start();
+        await this.tail;
+        return [...this.jobs.values()]
+            .filter((job) => agentId === undefined || dshAgentIdFor(job) === agentId)
+            .sort((left, right) => left.createdAtMs - right.createdAtMs || left.id.localeCompare(right.id))
+            .map(cloneJob);
+    }
+    notifyAgentAvailable(agentId) {
+        if (!this.blockedAgents.delete(agentId))
+            return;
+        this.requestDispatch();
+    }
+    /** Import each source job once. Existing ids win so DSH bindings stay intact. */
+    async importFrom(source, incoming) {
+        await this.start();
+        return this.enqueue(async () => {
+            const prepared = [];
+            for (const job of incoming) {
+                const next = cloneJob(job);
+                delete next.state.runningAtMs;
+                disableIfTooFrequent(next);
+                if (next.enabled && next.state.nextRunAtMs === undefined) {
+                    setNextOccurrence(next, initialOccurrence(next, this.now()));
+                }
+                prepared.push(next);
+            }
+            const { added } = await this.repository.import(source, prepared);
+            if (added.length === 0)
+                return added;
+            for (const job of added) {
+                this.jobs.set(job.id, cloneJob(job));
+                this.options.onCreated?.(cloneJob(job));
+            }
+            this.arm();
+            return added.map(cloneJob);
+        });
+    }
+    async deliver(job, occurrenceAtMs) {
+        try {
+            return await this.options.deliver(cloneJob(job), new Date(occurrenceAtMs).toISOString());
+        }
+        catch (error) {
+            this.options.onError?.(error);
+            return false;
+        }
+    }
+    enqueue(operation) {
+        const run = this.tail.then(operation);
+        this.tail = run.then(() => undefined, () => undefined);
+        return run;
+    }
+    requestDispatch() {
+        void this.enqueue(() => this.dispatchDue()).catch((error) => this.options.onError?.(error));
+    }
+    arm() {
+        if (this.stopping)
+            return;
+        if (this.timer)
+            clearTimeout(this.timer);
+        this.timer = undefined;
+        const now = this.now();
+        const target = [...this.jobs.values()]
+            .filter((job) => job.enabled && job.state.runningAtMs === undefined && !this.blockedAgents.has(dshAgentIdFor(job)))
+            .map((job) => job.state.nextRunAtMs)
+            .filter((value) => value !== undefined)
+            .reduce((earliest, candidate) => (earliest === undefined || candidate < earliest ? candidate : earliest), undefined);
+        if (target === undefined)
+            return;
+        const delay = Math.max(0, Math.min(target - now, MAX_TIMER_DELAY_MS));
+        this.timer = setTimeout(() => {
+            this.timer = undefined;
+            this.requestDispatch();
+        }, delay);
+        this.timer.unref();
+    }
+    async dispatchDue() {
+        if (this.stopping)
+            return;
+        const now = this.now();
+        const due = [...this.jobs.values()]
+            .filter((job) => job.enabled && job.state.nextRunAtMs !== undefined && job.state.nextRunAtMs <= now)
+            .sort((left, right) => (left.state.nextRunAtMs ?? 0) - (right.state.nextRunAtMs ?? 0) || left.createdAtMs - right.createdAtMs);
+        for (const job of due) {
+            const occurrenceAtMs = job.state.nextRunAtMs ?? now;
+            job.state.runningAtMs = now;
+            job.updatedAtMs = now;
+            await this.repository.upsert([job]);
+            const delivered = await this.deliver(job, occurrenceAtMs);
+            delete job.state.runningAtMs;
+            job.state.lastRunAtMs = now;
+            job.state.lastRunStatus = delivered ? 'ok' : 'skipped';
+            job.updatedAtMs = now;
+            if (!delivered) {
+                this.blockedAgents.add(dshAgentIdFor(job));
+                await this.repository.upsert([job]);
+                this.options.onChanged?.(cloneJob(job));
+                continue;
+            }
+            if (job.deleteAfterRun === true || job.schedule.kind === 'at') {
+                this.jobs.delete(job.id);
+                await this.repository.delete(job.id);
+            }
+            else {
+                setNextOccurrence(job, nextOccurrence(now, job.schedule));
+                await this.repository.upsert([job]);
+            }
+            this.options.onDispatched?.(cloneJob(job), new Date(occurrenceAtMs).toISOString());
+        }
+        this.arm();
+    }
+}

package/src/openclaw-sqlite.d.ts

@@ -0,0 +1,40 @@
+import { type StoredCronAutomation } from "./repository.js";
+export declare const DEFAULT_OPENCLAW_SQLITE: string;
+interface CronJobRow {
+    job_id: string;
+    name: string;
+    description: string | null;
+    enabled: number;
+    delete_after_run: number | null;
+    created_at_ms: number;
+    updated_at: number;
+    agent_id: string | null;
+    session_key: string | null;
+    schedule_kind: string;
+    schedule_expr: string | null;
+    schedule_tz: string | null;
+    every_ms: number | null;
+    anchor_ms: number | null;
+    at: string | null;
+    session_target: string;
+    wake_mode: string;
+    payload_kind: string;
+    payload_message: string | null;
+    payload_timeout_seconds: number | null;
+    delivery_mode: string | null;
+    delivery_channel: string | null;
+    delivery_to: string | null;
+    delivery_account_id: string | null;
+    delivery_best_effort: number | null;
+    next_run_at_ms: number | null;
+    running_at_ms: number | null;
+    last_run_at_ms: number | null;
+    last_run_status: string | null;
+    job_json: string;
+    state_json: string;
+}
+export declare function jobFromOpenClawRow(row: CronJobRow): StoredCronAutomation;
+export declare function loadOpenClawSqliteJobs(sqlitePath: string): StoredCronAutomation[];
+export declare function resolveOpenClawSqlitePath(configured?: string): string;
+export declare function openClawImportSource(sqlitePath: string): string;
+export {};

package/src/openclaw-sqlite.js

@@ -0,0 +1,136 @@
+import { existsSync, realpathSync } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { DatabaseSync } from "node:sqlite";
+import { decodeJob } from "./repository.js";
+export const DEFAULT_OPENCLAW_SQLITE = path.join(os.homedir(), ".mobook", "state", "openclaw.sqlite");
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function parseJson(raw, label) {
+    try {
+        return JSON.parse(raw);
+    }
+    catch {
+        throw new Error(`OpenClaw ${label} is not valid JSON`);
+    }
+}
+function scheduleFromRow(row) {
+    if (row.schedule_kind === "every") {
+        return {
+            kind: "every",
+            everyMs: row.every_ms,
+            ...(row.anchor_ms === null ? {} : { anchorMs: row.anchor_ms })
+        };
+    }
+    if (row.schedule_kind === "at") {
+        return { kind: "at", ...(row.at === null ? {} : { at: row.at }) };
+    }
+    return {
+        kind: "cron",
+        expr: row.schedule_expr,
+        ...(row.schedule_tz === null ? {} : { tz: row.schedule_tz })
+    };
+}
+function jobFromColumns(row, state) {
+    return {
+        id: row.job_id,
+        name: row.name,
+        ...(row.description ? { description: row.description } : {}),
+        enabled: row.enabled === 1,
+        createdAtMs: row.created_at_ms,
+        updatedAtMs: row.updated_at,
+        schedule: scheduleFromRow(row),
+        payload: {
+            kind: row.payload_kind || "agentTurn",
+            message: row.payload_message ?? "",
+            ...(row.payload_timeout_seconds === null ? {} : { timeoutSeconds: row.payload_timeout_seconds })
+        },
+        agentId: row.agent_id ?? "main",
+        ...(row.session_key ? { sessionKey: row.session_key } : {}),
+        sessionTarget: row.session_target || "isolated",
+        wakeMode: row.wake_mode || "now",
+        ...(row.delete_after_run === 1 ? { deleteAfterRun: true } : {}),
+        delivery: {
+            mode: row.delivery_mode ?? "announce",
+            ...(row.delivery_channel ? { channel: row.delivery_channel } : {}),
+            ...(row.delivery_to ? { to: row.delivery_to } : {}),
+            ...(row.delivery_account_id ? { accountId: row.delivery_account_id } : {}),
+            bestEffort: row.delivery_best_effort !== 0
+        },
+        state
+    };
+}
+function overlayState(row, jobState, tableState) {
+    const state = {
+        ...(isRecord(jobState) ? jobState : {}),
+        ...(isRecord(tableState) ? tableState : {})
+    };
+    if (row.next_run_at_ms !== null)
+        state.nextRunAtMs = row.next_run_at_ms;
+    if (row.running_at_ms !== null)
+        state.runningAtMs = row.running_at_ms;
+    if (row.last_run_at_ms !== null)
+        state.lastRunAtMs = row.last_run_at_ms;
+    if (row.last_run_status)
+        state.lastRunStatus = row.last_run_status;
+    return state;
+}
+export function jobFromOpenClawRow(row) {
+    const tableState = parseJson(row.state_json || "{}", "state_json");
+    try {
+        const parsed = parseJson(row.job_json, "job_json");
+        if (!isRecord(parsed))
+            throw new Error("job_json must be an object");
+        return decodeJob({
+            ...parsed,
+            id: typeof parsed.id === "string" && parsed.id ? parsed.id : row.job_id,
+            updatedAtMs: typeof parsed.updatedAtMs === "number" ? parsed.updatedAtMs : row.updated_at,
+            createdAtMs: typeof parsed.createdAtMs === "number" ? parsed.createdAtMs : row.created_at_ms,
+            state: overlayState(row, parsed.state, tableState)
+        });
+    }
+    catch {
+        return decodeJob(jobFromColumns(row, overlayState(row, {}, tableState)));
+    }
+}
+export function loadOpenClawSqliteJobs(sqlitePath) {
+    if (!existsSync(sqlitePath))
+        return [];
+    const database = new DatabaseSync(sqlitePath, { readOnly: true, timeout: 5_000 });
+    try {
+        const table = database.prepare("SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = 'cron_jobs'").get();
+        if (!table)
+            return [];
+        // SELECT * deliberately tolerates OpenClaw schema additions and older schemas
+        // that omit newer nullable projection columns. job_json remains authoritative.
+        const rows = database.prepare("SELECT * FROM cron_jobs ORDER BY updated_at ASC, job_id ASC").all();
+        const jobs = new Map();
+        for (const row of rows) {
+            try {
+                const job = jobFromOpenClawRow(row);
+                const previous = jobs.get(job.id);
+                if (!previous || job.updatedAtMs >= previous.updatedAtMs)
+                    jobs.set(job.id, job);
+            }
+            catch {
+                // Skip a corrupt row so one bad job cannot block the rest of the import.
+            }
+        }
+        return [...jobs.values()];
+    }
+    finally {
+        database.close();
+    }
+}
+export function resolveOpenClawSqlitePath(configured) {
+    const explicit = configured?.trim() || process.env.OPENCLAW_SQLITE?.trim();
+    if (explicit)
+        return path.resolve(explicit);
+    return DEFAULT_OPENCLAW_SQLITE;
+}
+export function openClawImportSource(sqlitePath) {
+    const resolved = path.resolve(sqlitePath);
+    const canonical = existsSync(resolved) ? realpathSync.native(resolved) : resolved;
+    return `openclaw-sqlite:${canonical}`;
+}

package/src/protocol.d.ts

@@ -0,0 +1,24 @@
+import type { UserMessage } from "@deepseek-ai/dsh-llm";
+export declare const CRON_CREATE_TYPE: "dsh/cron.create";
+export declare const CRON_LIST_TYPE: "dsh/cron.list";
+export interface CronCreateEnvelope {
+    type: typeof CRON_CREATE_TYPE;
+    requestId: string;
+    name: string;
+    prompt: string;
+    cron: string;
+    timezone: string;
+}
+export interface CronEditorRequest {
+    id: string;
+    text: string;
+}
+export declare class CronAutomationInputError extends Error {
+    readonly code: "invalid_envelope" | "invalid_request_id" | "invalid_name" | "invalid_prompt" | "invalid_cron" | "invalid_timezone" | "request_id_conflict";
+    constructor(code: "invalid_envelope" | "invalid_request_id" | "invalid_name" | "invalid_prompt" | "invalid_cron" | "invalid_timezone" | "request_id_conflict", message: string);
+}
+export declare function decodeCronCreateEnvelope(value: unknown): CronCreateEnvelope;
+/** Parse a cron control envelope carried as the sole text block of a direct user message. */
+export declare function parseCronAutomationMessage(message: UserMessage): CronCreateEnvelope | undefined;
+/** Recognize the stable prompt prefix emitted by the Mobook scheduled-task editor. */
+export declare function parseCronEditorRequest(message: UserMessage): CronEditorRequest | undefined;