@cjhyy/code-shell-core 0.5.0-rc.1 → 0.5.0-rc.2

package/dist/automation/cron-expr.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Minimal 5-field cron expression parser + timezone-aware next-trigger
+ * calculator. No third-party dependency (core keeps its dep set tight).
+ *
+ * Fields:  minute(0-59) hour(0-23) dayOfMonth(1-31) month(1-12) dayOfWeek(0-6, 0=Sun)
+ * Syntax per field:  star | star-slash-n | a | a-b | a-b-slash-n | comma-lists of those.
+ *
+ * Timezone handling uses Intl.DateTimeFormat with a timeZone option to derive
+ * the wall-clock parts of a candidate UTC instant in the target zone — correct
+ * across DST without a tz library. nextCronTime steps minute-by-minute from the
+ * reference and returns the first future instant whose wall-clock parts (in tz)
+ * match every field. Bounded to ~2 years so an unsatisfiable expression can't
+ * loop forever.
+ */
+export interface ParsedCron {
+    minutes: Set<number>;
+    hours: Set<number>;
+    daysOfMonth: Set<number>;
+    months: Set<number>;
+    daysOfWeek: Set<number>;
+}
+/** Cheap check: is this string a 5-field cron expression (vs an interval like "5m")? */
+export declare function isCronExpression(s: string): boolean;
+/** Parse a 5-field cron expression into per-field value sets. Throws on invalid input. */
+export declare function parseCronExpression(expr: string): ParsedCron;
+/**
+ * Return the next UTC instant (ms) strictly after `fromMs` whose wall-clock
+ * time in `timeZone` matches `cron`. Returns null if none within ~2 years
+ * (e.g. an impossible expression like Feb 30).
+ */
+export declare function nextCronTime(cron: ParsedCron, timeZone: string, fromMs: number): number | null;

package/dist/automation/cron-expr.js

@@ -0,0 +1,151 @@
+/**
+ * Minimal 5-field cron expression parser + timezone-aware next-trigger
+ * calculator. No third-party dependency (core keeps its dep set tight).
+ *
+ * Fields:  minute(0-59) hour(0-23) dayOfMonth(1-31) month(1-12) dayOfWeek(0-6, 0=Sun)
+ * Syntax per field:  star | star-slash-n | a | a-b | a-b-slash-n | comma-lists of those.
+ *
+ * Timezone handling uses Intl.DateTimeFormat with a timeZone option to derive
+ * the wall-clock parts of a candidate UTC instant in the target zone — correct
+ * across DST without a tz library. nextCronTime steps minute-by-minute from the
+ * reference and returns the first future instant whose wall-clock parts (in tz)
+ * match every field. Bounded to ~2 years so an unsatisfiable expression can't
+ * loop forever.
+ */
+const SPECS = [
+    { min: 0, max: 59 }, // minute
+    { min: 0, max: 23 }, // hour
+    { min: 1, max: 31 }, // day of month
+    { min: 1, max: 12 }, // month
+    { min: 0, max: 6 }, // day of week
+];
+/** Cheap check: is this string a 5-field cron expression (vs an interval like "5m")? */
+export function isCronExpression(s) {
+    if (typeof s !== "string")
+        return false;
+    const parts = s.trim().split(/\s+/);
+    if (parts.length !== 5)
+        return false;
+    // Every field must contain only cron field characters.
+    return parts.every((p) => /^[\d*/,-]+$/.test(p));
+}
+function parseField(field, spec) {
+    const out = new Set();
+    for (const part of field.split(",")) {
+        // Split optional step: "a-b/n" or "*/n" or "a/n"
+        const [rangePart, stepPart] = part.split("/");
+        const step = stepPart === undefined ? 1 : parseInt(stepPart, 10);
+        if (!Number.isInteger(step) || step <= 0) {
+            throw new Error(`Invalid cron step in "${field}"`);
+        }
+        let lo;
+        let hi;
+        if (rangePart === "*") {
+            lo = spec.min;
+            hi = spec.max;
+        }
+        else if (rangePart.includes("-")) {
+            const [a, b] = rangePart.split("-");
+            lo = parseInt(a, 10);
+            hi = parseInt(b, 10);
+        }
+        else {
+            lo = parseInt(rangePart, 10);
+            hi = lo;
+        }
+        if (!Number.isInteger(lo) || !Number.isInteger(hi)) {
+            throw new Error(`Invalid cron field "${field}"`);
+        }
+        if (lo < spec.min || hi > spec.max || lo > hi) {
+            throw new Error(`cron field "${field}" out of range [${spec.min}-${spec.max}]`);
+        }
+        for (let v = lo; v <= hi; v += step)
+            out.add(v);
+    }
+    return out;
+}
+/** Parse a 5-field cron expression into per-field value sets. Throws on invalid input. */
+export function parseCronExpression(expr) {
+    const parts = expr.trim().split(/\s+/);
+    if (parts.length !== 5) {
+        throw new Error(`cron expression must have 5 fields, got ${parts.length}: "${expr}"`);
+    }
+    return {
+        minutes: parseField(parts[0], SPECS[0]),
+        hours: parseField(parts[1], SPECS[1]),
+        daysOfMonth: parseField(parts[2], SPECS[2]),
+        months: parseField(parts[3], SPECS[3]),
+        daysOfWeek: parseField(parts[4], SPECS[4]),
+    };
+}
+// Cache one formatter per timezone — constructing Intl.DateTimeFormat is costly.
+const formatterCache = new Map();
+function getFormatter(timeZone) {
+    let fmt = formatterCache.get(timeZone);
+    if (!fmt) {
+        fmt = new Intl.DateTimeFormat("en-US", {
+            timeZone,
+            hour12: false,
+            year: "numeric",
+            month: "2-digit",
+            day: "2-digit",
+            hour: "2-digit",
+            minute: "2-digit",
+            weekday: "short",
+        });
+        formatterCache.set(timeZone, fmt);
+    }
+    return fmt;
+}
+const WEEKDAY_INDEX = {
+    Sun: 0,
+    Mon: 1,
+    Tue: 2,
+    Wed: 3,
+    Thu: 4,
+    Fri: 5,
+    Sat: 6,
+};
+/** Derive the wall-clock parts of a UTC instant `ms` as seen in `timeZone`. */
+function wallClockInZone(ms, timeZone) {
+    const parts = getFormatter(timeZone).formatToParts(new Date(ms));
+    const get = (type) => parts.find((p) => p.type === type)?.value ?? "";
+    // hour can come back as "24" at midnight in some environments; normalize.
+    let hour = parseInt(get("hour"), 10);
+    if (hour === 24)
+        hour = 0;
+    return {
+        minute: parseInt(get("minute"), 10),
+        hour,
+        dayOfMonth: parseInt(get("day"), 10),
+        month: parseInt(get("month"), 10),
+        dayOfWeek: WEEKDAY_INDEX[get("weekday")] ?? 0,
+    };
+}
+function matches(cron, wc) {
+    return (cron.minutes.has(wc.minute) &&
+        cron.hours.has(wc.hour) &&
+        cron.daysOfMonth.has(wc.dayOfMonth) &&
+        cron.months.has(wc.month) &&
+        cron.daysOfWeek.has(wc.dayOfWeek));
+}
+const MINUTE_MS = 60_000;
+// ~2 years of minutes — bounds the search for an unsatisfiable expression.
+const MAX_STEPS = 2 * 366 * 24 * 60;
+/**
+ * Return the next UTC instant (ms) strictly after `fromMs` whose wall-clock
+ * time in `timeZone` matches `cron`. Returns null if none within ~2 years
+ * (e.g. an impossible expression like Feb 30).
+ */
+export function nextCronTime(cron, timeZone, fromMs) {
+    // Start at the next whole minute strictly after fromMs (cron has minute
+    // granularity; we never return the reference instant itself).
+    let candidate = Math.floor(fromMs / MINUTE_MS) * MINUTE_MS + MINUTE_MS;
+    for (let i = 0; i < MAX_STEPS; i++) {
+        const wc = wallClockInZone(candidate, timeZone);
+        if (matches(cron, wc))
+            return candidate;
+        candidate += MINUTE_MS;
+    }
+    return null;
+}

package/dist/automation/index.d.ts

@@ -0,0 +1,41 @@
+/**
+ * automation/ — zero-environment-dependency scheduling module.
+ *
+ * Hosts (Electron main, future CLI server) load this module and inject their
+ * own store + runner. The module imports nothing from Electron/Ink and makes
+ * no GUI/TTY assumptions, so the same code runs in any host
+ * (docs/automation-plan-2026-05-31.md, D1).
+ */
+import { CronScheduler } from "./scheduler.js";
+import { type CronRunner, type RunSubmitter } from "./runner.js";
+import type { CronStore } from "./store.js";
+export interface StartAutomationDeps {
+    /** Persistence backend (injected; module never picks a path itself). */
+    store: CronStore;
+    /**
+     * Execution backend. Provide exactly one:
+     *   - `runner`: a one-shot run callback (Phase 1 direct-Engine path).
+     *   - `runManager`: a RunManager submitter (Phase 2 — runs land in RunStore
+     *     with full history/checkpoint/resume).
+     */
+    runner?: CronRunner;
+    runManager?: RunSubmitter;
+}
+export interface AutomationHandle {
+    scheduler: CronScheduler;
+    /** Halt all timers and release the scheduler. Idempotent. */
+    stop(): void;
+}
+/**
+ * Wire a scheduler to a host-provided store + execution backend and restore
+ * persisted jobs. Returns a handle the host keeps for its lifetime. Prefers
+ * `runManager` when both are supplied (it gives run history).
+ */
+export declare function startAutomation(deps: StartAutomationDeps): AutomationHandle;
+export { CronScheduler, cronScheduler, type CronJob } from "./scheduler.js";
+export { CronStore, defaultCronStorePath } from "./store.js";
+export { bindCronToEngine, bindCronToRunManager, type CronRunner, type CronRunRequest, type CronRunResult, type RunSubmitter, } from "./runner.js";
+export { isCronExpression, parseCronExpression, nextCronTime, type ParsedCron, } from "./cron-expr.js";
+export type { CronPermissionLevel, CreateJobOptions, UpdateJobPatch } from "./scheduler.js";
+export { resolveWritePolicy, wrapUntrustedInput, type WritePolicy, } from "./write-policy.js";
+export { runWriteJobInWorktree, type WriteJobGitOps, type RunWriteJobInput, type RunWriteJobResult, } from "./write-run.js";

package/dist/automation/index.js

@@ -0,0 +1,39 @@
+/**
+ * automation/ — zero-environment-dependency scheduling module.
+ *
+ * Hosts (Electron main, future CLI server) load this module and inject their
+ * own store + runner. The module imports nothing from Electron/Ink and makes
+ * no GUI/TTY assumptions, so the same code runs in any host
+ * (docs/automation-plan-2026-05-31.md, D1).
+ */
+import { CronScheduler } from "./scheduler.js";
+import { bindCronToEngine, bindCronToRunManager, } from "./runner.js";
+/**
+ * Wire a scheduler to a host-provided store + execution backend and restore
+ * persisted jobs. Returns a handle the host keeps for its lifetime. Prefers
+ * `runManager` when both are supplied (it gives run history).
+ */
+export function startAutomation(deps) {
+    const scheduler = new CronScheduler(deps.store);
+    if (deps.runManager) {
+        bindCronToRunManager(scheduler, deps.runManager);
+    }
+    else if (deps.runner) {
+        bindCronToEngine(scheduler, deps.runner);
+    }
+    else {
+        throw new Error("startAutomation requires either a runner or a runManager");
+    }
+    scheduler.loadJobs();
+    return {
+        scheduler,
+        stop: () => scheduler.stopAll(),
+    };
+}
+// Re-export the building blocks so hosts import everything from one place.
+export { CronScheduler, cronScheduler } from "./scheduler.js";
+export { CronStore, defaultCronStorePath } from "./store.js";
+export { bindCronToEngine, bindCronToRunManager, } from "./runner.js";
+export { isCronExpression, parseCronExpression, nextCronTime, } from "./cron-expr.js";
+export { resolveWritePolicy, wrapUntrustedInput, } from "./write-policy.js";
+export { runWriteJobInWorktree, } from "./write-run.js";

package/dist/automation/runner.d.ts

@@ -0,0 +1,67 @@
+/**
+ * cron-runtime — wire the CronScheduler's executor to a real run backend.
+ *
+ * B1 fix: `CronScheduler.setExecutor` was never called in production, so cron
+ * jobs were created and ticked but did nothing on fire. `bindCronToEngine`
+ * installs an executor that, for each fired job, hands a one-shot headless run
+ * request to the caller-supplied `runner`.
+ *
+ * Security contract: cron runs unattended, so each job's permission tier
+ * (`job.permissionLevel`) is resolved through `resolveWritePolicy`, which maps
+ * the tier to a permissionMode + approval backend (see write-policy.ts). The
+ * mode stays "default" so the classifier doesn't add its own acceptEdits
+ * auto-allow rules ahead of the backend — the backend is the single source of
+ * truth for what a tier permits. An undefined/unknown tier falls back to the
+ * read-only backend.
+ */
+import type { CronJob } from "./scheduler.js";
+import type { CronScheduler } from "./scheduler.js";
+import type { PermissionMode } from "../types.js";
+import type { ApprovalBackend } from "../tool-system/permission.js";
+/** What the executor hands to the run backend for one fired job. */
+export interface CronRunRequest {
+    job: CronJob;
+    /** The prompt to run — `job.prompt`, surfaced for convenience. */
+    prompt: string;
+    /** Permission mode the run must use (see security contract above). */
+    permissionMode: PermissionMode;
+    /** Approval backend the run must install (resolved from the job's tier). */
+    approvalBackend: ApprovalBackend;
+    /** Abort signal for the run — tripped by `CronScheduler.abort(jobId)` when
+     *  the run must be cancelled mid-flight (e.g. the user deletes its session
+     *  while it's still executing). Forward to `Engine.run({ signal })`. */
+    signal?: AbortSignal;
+}
+export interface CronRunResult {
+    text: string;
+    reason: string;
+}
+/** The pluggable run backend. Production wires this to a headless Engine run;
+ *  tests pass a stub. Phase 5 will swap this for a RunManager.submit() path. */
+export type CronRunner = (req: CronRunRequest) => Promise<CronRunResult>;
+/**
+ * Install the cron executor. After this call, a fired job invokes `runner`
+ * with a run request whose permission tier comes from the job. Errors from
+ * `runner` are swallowed by the
+ * scheduler's existing try/catch (scheduler.ts) so one bad run never stops
+ * future ticks — we still log here so failures are visible.
+ */
+export declare function bindCronToEngine(scheduler: CronScheduler, runner: CronRunner): void;
+/** Minimal structural view of RunManager.submit the executor needs. */
+export interface RunSubmitter {
+    submit(input: {
+        objective: string;
+        cwd?: string;
+        metadata?: Record<string, unknown>;
+    }): Promise<{
+        runId: string;
+    }>;
+}
+/**
+ * Wire the scheduler to submit each fired job into a RunManager. Records the
+ * resulting runId back onto the job (`lastRunId`) so the UI can link a job to
+ * its latest run in the RunStore. Read-only is enforced at the RunManager level
+ * by the host injecting `approvalBackend: HeadlessApprovalBackend("approve-read-only")`
+ * into createRunManager (Phase 2) until sandbox+write tiers land (Phase 4/5).
+ */
+export declare function bindCronToRunManager(scheduler: CronScheduler, runManager: RunSubmitter): void;

package/dist/automation/runner.js

@@ -0,0 +1,56 @@
+/**
+ * cron-runtime — wire the CronScheduler's executor to a real run backend.
+ *
+ * B1 fix: `CronScheduler.setExecutor` was never called in production, so cron
+ * jobs were created and ticked but did nothing on fire. `bindCronToEngine`
+ * installs an executor that, for each fired job, hands a one-shot headless run
+ * request to the caller-supplied `runner`.
+ *
+ * Security contract: cron runs unattended, so each job's permission tier
+ * (`job.permissionLevel`) is resolved through `resolveWritePolicy`, which maps
+ * the tier to a permissionMode + approval backend (see write-policy.ts). The
+ * mode stays "default" so the classifier doesn't add its own acceptEdits
+ * auto-allow rules ahead of the backend — the backend is the single source of
+ * truth for what a tier permits. An undefined/unknown tier falls back to the
+ * read-only backend.
+ */
+import { AUTOMATION_RUN_SOURCE } from "../run/EngineRunner.js";
+import { resolveWritePolicy } from "./write-policy.js";
+/**
+ * Install the cron executor. After this call, a fired job invokes `runner`
+ * with a run request whose permission tier comes from the job. Errors from
+ * `runner` are swallowed by the
+ * scheduler's existing try/catch (scheduler.ts) so one bad run never stops
+ * future ticks — we still log here so failures are visible.
+ */
+export function bindCronToEngine(scheduler, runner) {
+    scheduler.setExecutor(async (job, signal) => {
+        const policy = resolveWritePolicy(job.permissionLevel);
+        const req = {
+            job,
+            prompt: job.prompt,
+            permissionMode: policy.permissionMode,
+            approvalBackend: policy.approvalBackend,
+            signal,
+        };
+        await runner(req);
+    });
+}
+/**
+ * Wire the scheduler to submit each fired job into a RunManager. Records the
+ * resulting runId back onto the job (`lastRunId`) so the UI can link a job to
+ * its latest run in the RunStore. Read-only is enforced at the RunManager level
+ * by the host injecting `approvalBackend: HeadlessApprovalBackend("approve-read-only")`
+ * into createRunManager (Phase 2) until sandbox+write tiers land (Phase 4/5).
+ */
+export function bindCronToRunManager(scheduler, runManager) {
+    scheduler.setExecutor(async (job, _signal) => {
+        const snapshot = await runManager.submit({
+            objective: job.prompt,
+            cwd: job.cwd,
+            metadata: { source: AUTOMATION_RUN_SOURCE, cronJobId: job.id, cronJobName: job.name },
+        });
+        // Record the run id on the job so the UI can link to run history.
+        job.lastRunId = snapshot.runId;
+    });
+}

package/dist/automation/scheduler.d.ts

@@ -0,0 +1,156 @@
+/**
+ * Cron scheduler — schedule and manage recurring agent tasks.
+ *
+ * Supports simple cron-like intervals. Each job runs the Engine
+ * with a predefined prompt on schedule.
+ */
+import type { CronStore } from "./store.js";
+/** Permission tier a scheduled job runs under (Phase 5 enforces write tiers). */
+export type CronPermissionLevel = "read-only" | "workspace-write" | "full";
+export interface CronJob {
+    id: string;
+    name: string;
+    schedule: string;
+    prompt: string;
+    enabled: boolean;
+    lastRun?: number;
+    nextRun?: number;
+    runCount: number;
+    createdAt: number;
+    /** Working directory the job runs in (the project it monitors/edits). */
+    cwd?: string;
+    /** IANA timezone for cron-expression schedules (e.g. "Asia/Shanghai"). Default "UTC". */
+    timezone?: string;
+    /** Permission tier; defaults to read-only when unset. */
+    permissionLevel?: CronPermissionLevel;
+    /** RunStore run id of the most recent execution (Phase 2 RunManager path). */
+    lastRunId?: string;
+}
+/** Optional metadata accepted by create(). */
+export interface CreateJobOptions {
+    cwd?: string;
+    timezone?: string;
+    permissionLevel?: CronPermissionLevel;
+}
+/** Fields editable via update(). Any omitted field is left unchanged. */
+export interface UpdateJobPatch {
+    name?: string;
+    prompt?: string;
+    schedule?: string;
+    timezone?: string;
+    cwd?: string;
+    permissionLevel?: CronPermissionLevel;
+}
+export declare class CronScheduler {
+    private jobs;
+    private timers;
+    /** Job ids with an execution currently in flight — prevents a tick from
+     *  starting a second run of a job whose previous run hasn't finished. */
+    private running;
+    /** In-flight runs keyed by job id: the AbortController that cancels the run,
+     *  plus `done` — a promise that resolves when the run has FULLY settled
+     *  (executor returned, including any post-abort bookkeeping like Engine's
+     *  final saveState). The re-entrancy guard (`running`) ensures at most one
+     *  run per job, so one entry per job id is sufficient. `abort(jobId)` trips
+     *  the controller and returns `done` so callers can wait for the run to
+     *  actually stop before acting (e.g. deleting its session dir without racing
+     *  a final write that would recreate it). */
+    private runningControllers;
+    private nextId;
+    private onExecute?;
+    /** Optional persistence backend. When set, every create/delete/pause/resume
+     *  writes the full job set to disk so jobs survive a restart. */
+    private store?;
+    /** When false, the scheduler persists + tracks jobs but NEVER arms timers
+     *  (so it can't execute). Used by the desktop agent worker, a separate
+     *  process from the main process that owns execution. Default true. */
+    private executionEnabled;
+    constructor(store?: CronStore);
+    /**
+     * Disable (or re-enable) timer arming / execution. A host that only needs to
+     * persist + read jobs — never run them — calls setExecutionEnabled(false).
+     * Stops any timers already armed when turning off.
+     */
+    setExecutionEnabled(enabled: boolean): void;
+    /** Attach (or replace) the persistence backend. Used to give the shared
+     *  singleton a store at runtime startup without changing its identity. */
+    setStore(store: CronStore): void;
+    setExecutor(fn: (job: CronJob, signal: AbortSignal) => Promise<void>): void;
+    /**
+     * Abort the in-flight run of `jobId`, if any. Aborts the AbortSignal handed
+     * to the executor (which Engine.run cooperates with — it resolves with
+     * reason "aborted_streaming" rather than throwing). Returns false when the
+     * job has no run currently in flight (already settled, never started, or
+     * unknown id). The run's own finally block clears the controller, so a
+     * settled run is a no-op here.
+     */
+    abort(jobId: string): Promise<boolean>;
+    /**
+     * Restore persisted jobs and rebuild their timers. Call once at startup
+     * after `setStore`. nextRun is recomputed forward from now — we do NOT
+     * catch up on runs missed while the process was down (avoids a restart
+     * thundering-herd; aligns with Codex's stateless philosophy). Disabled
+     * jobs are restored without a timer.
+     */
+    /**
+     * Reconcile in-memory jobs against the on-disk store (the store is the source
+     * of truth). Safe to call repeatedly — used both at startup and as a periodic
+     * re-sync when another process (e.g. the desktop agent worker) may have
+     * created/deleted/changed jobs through the same store. Reconciliation:
+     *   - jobs on disk but not in memory  → added (and armed if enabled)
+     *   - jobs in memory but not on disk  → removed + timer cleared
+     *   - jobs whose schedule/enabled differ → re-armed to match disk
+     *
+     * Pass `{ arm: false }` in a host that must NOT execute jobs (the worker —
+     * separate process from the one that owns execution); it still tracks +
+     * persists but starts no timers, so jobs never run twice across processes.
+     */
+    loadJobs(opts?: {
+        arm?: boolean;
+    }): void;
+    private reconcileJobs;
+    private nextPersistedId;
+    /** Recompute nextRun without arming a timer (for display in disabled/no-arm hosts). */
+    private refreshNextRunForDisplay;
+    private persist;
+    private persistRunStats;
+    create(name: string, schedule: string, prompt: string, opts?: CreateJobOptions): CronJob;
+    delete(id: string): boolean;
+    list(): CronJob[];
+    get(id: string): CronJob | undefined;
+    pause(id: string): boolean;
+    resume(id: string): boolean;
+    /**
+     * Edit an existing job's fields (name/prompt/schedule/timezone/cwd/
+     * permissionLevel) without recreating it. A changed schedule is validated up
+     * front (throws on invalid, leaving the job untouched), then the timer is
+     * re-armed so the new schedule takes effect immediately. Enabled state is
+     * preserved — a paused job stays paused (no timer). Returns the updated job,
+     * or null if the id is unknown.
+     */
+    update(id: string, patch: UpdateJobPatch): CronJob | null;
+    stopAll(): void;
+    /**
+     * Fire a job immediately, out of band of its schedule (the "Run now" button).
+     * Respects the re-entrancy guard (no-op if a run is already in flight) and
+     * does not disturb the existing timer. Returns false if the id is unknown.
+     */
+    runNow(id: string): boolean;
+    /**
+     * Arm a job's timer. Interval schedules ("5m") use setInterval; cron-
+     * expression schedules ("0 9 * * 1-5") compute the next trigger in the
+     * job's timezone and use setTimeout, re-arming after each fire. nextRun is
+     * updated to reflect the scheduled instant.
+     */
+    private arm;
+    private refreshIntervalNextRun;
+    private armCron;
+    private clearTimer;
+    /**
+     * Shared fire path for both schedule kinds. Re-entrancy guard, run-stat
+     * bookkeeping, persistence, then the executor. `afterStats` updates nextRun
+     * for the next occurrence (interval: now+interval; cron: re-armed inside).
+     */
+    private fire;
+}
+export declare const cronScheduler: CronScheduler;