pretticlaw 0.1.0

package/dist/config/loader.js

@@ -0,0 +1,55 @@
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+import { DEFAULT_CONFIG } from "./schema.js";
+import { getDataPath } from "../utils/helpers.js";
+export function getConfigPath() {
+    return path.join(os.homedir(), ".pretticlaw", "config.json");
+}
+export function getDataDir() {
+    return getDataPath();
+}
+function deepMerge(base, patch) {
+    if (!patch || typeof patch !== "object")
+        return base;
+    const out = Array.isArray(base) ? [...base] : { ...base };
+    for (const [k, v] of Object.entries(patch)) {
+        if (v && typeof v === "object" && !Array.isArray(v) && out[k] && typeof out[k] === "object" && !Array.isArray(out[k])) {
+            out[k] = deepMerge(out[k], v);
+        }
+        else {
+            out[k] = v;
+        }
+    }
+    return out;
+}
+function migrateConfig(data) {
+    const tools = data.tools ?? {};
+    const exec = tools.exec ?? {};
+    if ("restrictToWorkspace" in exec && !("restrictToWorkspace" in tools)) {
+        tools.restrictToWorkspace = exec.restrictToWorkspace;
+        delete exec.restrictToWorkspace;
+    }
+    tools.exec = exec;
+    data.tools = tools;
+    return data;
+}
+export function loadConfig(configPath) {
+    const p = configPath ?? getConfigPath();
+    if (!fs.existsSync(p))
+        return structuredClone(DEFAULT_CONFIG);
+    try {
+        const raw = fs.readFileSync(p, "utf8");
+        const parsed = migrateConfig(JSON.parse(raw));
+        return deepMerge(structuredClone(DEFAULT_CONFIG), parsed);
+    }
+    catch (err) {
+        console.warn(`Warning: Failed to load config from ${p}: ${String(err)}`);
+        return structuredClone(DEFAULT_CONFIG);
+    }
+}
+export function saveConfig(config, configPath) {
+    const p = configPath ?? getConfigPath();
+    fs.mkdirSync(path.dirname(p), { recursive: true });
+    fs.writeFileSync(p, JSON.stringify(config, null, 2), "utf8");
+}

package/dist/config/schema.d.ts

@@ -0,0 +1,246 @@
+export interface ProviderConfig {
+    apiKey: string;
+    apiBase: string | null;
+    extraHeaders: Record<string, string> | null;
+}
+export interface ChannelsConfig {
+    sendProgress: boolean;
+    sendToolHints: boolean;
+    whatsapp: {
+        enabled: boolean;
+        bridgeUrl: string;
+        bridgeToken: string;
+        allowFrom: string[];
+    };
+    telegram: {
+        enabled: boolean;
+        token: string;
+        allowFrom: string[];
+        proxy: string | null;
+        replyToMessage: boolean;
+    };
+    discord: {
+        enabled: boolean;
+        token: string;
+        allowFrom: string[];
+        gatewayUrl: string;
+        intents: number;
+    };
+    feishu: {
+        enabled: boolean;
+        appId: string;
+        appSecret: string;
+        allowFrom: string[];
+    };
+    mochat: {
+        enabled: boolean;
+        baseUrl: string;
+        allowFrom: string[];
+    };
+    dingtalk: {
+        enabled: boolean;
+        clientId: string;
+        clientSecret: string;
+        allowFrom: string[];
+    };
+    email: {
+        enabled: boolean;
+        consentGranted: boolean;
+        imapHost: string;
+        allowFrom: string[];
+    };
+    slack: {
+        enabled: boolean;
+        botToken: string;
+        appToken: string;
+        groupPolicy: string;
+        groupAllowFrom: string[];
+    };
+    qq: {
+        enabled: boolean;
+        appId: string;
+        secret: string;
+        allowFrom: string[];
+    };
+    matrix: {
+        enabled: boolean;
+        homeserver: string;
+        accessToken: string;
+        userId: string;
+        deviceId: string;
+        allowFrom: string[];
+    };
+}
+export interface Config {
+    agents: {
+        defaults: {
+            workspace: string;
+            model: string;
+            provider: string;
+            maxTokens: number;
+            temperature: number;
+            maxToolIterations: number;
+            memoryWindow: number;
+        };
+    };
+    channels: ChannelsConfig;
+    providers: Record<string, ProviderConfig>;
+    gateway: {
+        host: string;
+        port: number;
+        heartbeat: {
+            enabled: boolean;
+            intervalS: number;
+        };
+    };
+    tools: {
+        web: {
+            search: {
+                apiKey: string;
+                maxResults: number;
+            };
+        };
+        exec: {
+            timeout: number;
+            pathAppend: string;
+        };
+        restrictToWorkspace: boolean;
+        mcpServers: Record<string, {
+            command: string;
+            args: string[];
+            env: Record<string, string>;
+            url: string;
+            headers: Record<string, string>;
+            toolTimeout: number;
+        }>;
+    };
+}
+export declare const PROVIDERS: readonly [{
+    readonly name: "custom";
+    readonly keywords: readonly [];
+    readonly isOauth: false;
+    readonly isGateway: false;
+    readonly isLocal: false;
+    readonly defaultApiBase: "";
+}, {
+    readonly name: "openrouter";
+    readonly keywords: readonly ["openrouter"];
+    readonly isOauth: false;
+    readonly isGateway: true;
+    readonly isLocal: false;
+    readonly defaultApiBase: "https://openrouter.ai/api/v1";
+    readonly detectByKeyPrefix: "sk-or-";
+    readonly detectByBaseKeyword: "openrouter";
+}, {
+    readonly name: "aihubmix";
+    readonly keywords: readonly ["aihubmix"];
+    readonly isOauth: false;
+    readonly isGateway: true;
+    readonly isLocal: false;
+    readonly defaultApiBase: "https://aihubmix.com/v1";
+    readonly detectByBaseKeyword: "aihubmix";
+}, {
+    readonly name: "siliconflow";
+    readonly keywords: readonly ["siliconflow"];
+    readonly isOauth: false;
+    readonly isGateway: true;
+    readonly isLocal: false;
+    readonly defaultApiBase: "https://api.siliconflow.cn/v1";
+    readonly detectByBaseKeyword: "siliconflow";
+}, {
+    readonly name: "volcengine";
+    readonly keywords: readonly ["volcengine", "volces", "ark"];
+    readonly isOauth: false;
+    readonly isGateway: true;
+    readonly isLocal: false;
+    readonly defaultApiBase: "https://ark.cn-beijing.volces.com/api/v3";
+    readonly detectByBaseKeyword: "volces";
+}, {
+    readonly name: "anthropic";
+    readonly keywords: readonly ["anthropic", "claude"];
+    readonly isOauth: false;
+    readonly isGateway: false;
+    readonly isLocal: false;
+    readonly defaultApiBase: "";
+}, {
+    readonly name: "openai";
+    readonly keywords: readonly ["openai", "gpt"];
+    readonly isOauth: false;
+    readonly isGateway: false;
+    readonly isLocal: false;
+    readonly defaultApiBase: "";
+}, {
+    readonly name: "openai_codex";
+    readonly keywords: readonly ["openai-codex", "codex"];
+    readonly isOauth: true;
+    readonly isGateway: false;
+    readonly isLocal: false;
+    readonly defaultApiBase: "https://chatgpt.com/backend-api";
+}, {
+    readonly name: "github_copilot";
+    readonly keywords: readonly ["github_copilot", "copilot"];
+    readonly isOauth: true;
+    readonly isGateway: false;
+    readonly isLocal: false;
+    readonly defaultApiBase: "";
+}, {
+    readonly name: "deepseek";
+    readonly keywords: readonly ["deepseek"];
+    readonly isOauth: false;
+    readonly isGateway: false;
+    readonly isLocal: false;
+    readonly defaultApiBase: "";
+}, {
+    readonly name: "gemini";
+    readonly keywords: readonly ["gemini"];
+    readonly isOauth: false;
+    readonly isGateway: false;
+    readonly isLocal: false;
+    readonly defaultApiBase: "";
+}, {
+    readonly name: "zhipu";
+    readonly keywords: readonly ["zhipu", "glm", "zai"];
+    readonly isOauth: false;
+    readonly isGateway: false;
+    readonly isLocal: false;
+    readonly defaultApiBase: "";
+}, {
+    readonly name: "dashscope";
+    readonly keywords: readonly ["qwen", "dashscope"];
+    readonly isOauth: false;
+    readonly isGateway: false;
+    readonly isLocal: false;
+    readonly defaultApiBase: "";
+}, {
+    readonly name: "moonshot";
+    readonly keywords: readonly ["moonshot", "kimi"];
+    readonly isOauth: false;
+    readonly isGateway: false;
+    readonly isLocal: false;
+    readonly defaultApiBase: "https://api.moonshot.ai/v1";
+}, {
+    readonly name: "minimax";
+    readonly keywords: readonly ["minimax"];
+    readonly isOauth: false;
+    readonly isGateway: false;
+    readonly isLocal: false;
+    readonly defaultApiBase: "https://api.minimax.io/v1";
+}, {
+    readonly name: "vllm";
+    readonly keywords: readonly ["vllm"];
+    readonly isOauth: false;
+    readonly isGateway: false;
+    readonly isLocal: true;
+    readonly defaultApiBase: "";
+}, {
+    readonly name: "groq";
+    readonly keywords: readonly ["groq"];
+    readonly isOauth: false;
+    readonly isGateway: false;
+    readonly isLocal: false;
+    readonly defaultApiBase: "";
+}];
+export declare const DEFAULT_CONFIG: Config;
+export declare function getProviderName(config: Config, model?: string): string | null;
+export declare function getProvider(config: Config, model?: string): ProviderConfig | null;
+export declare function getApiBase(config: Config, model?: string): string | null;

package/dist/config/schema.js

@@ -0,0 +1,94 @@
+import path from "node:path";
+export const PROVIDERS = [
+    { name: "custom", keywords: [], isOauth: false, isGateway: false, isLocal: false, defaultApiBase: "" },
+    { name: "openrouter", keywords: ["openrouter"], isOauth: false, isGateway: true, isLocal: false, defaultApiBase: "https://openrouter.ai/api/v1", detectByKeyPrefix: "sk-or-", detectByBaseKeyword: "openrouter" },
+    { name: "aihubmix", keywords: ["aihubmix"], isOauth: false, isGateway: true, isLocal: false, defaultApiBase: "https://aihubmix.com/v1", detectByBaseKeyword: "aihubmix" },
+    { name: "siliconflow", keywords: ["siliconflow"], isOauth: false, isGateway: true, isLocal: false, defaultApiBase: "https://api.siliconflow.cn/v1", detectByBaseKeyword: "siliconflow" },
+    { name: "volcengine", keywords: ["volcengine", "volces", "ark"], isOauth: false, isGateway: true, isLocal: false, defaultApiBase: "https://ark.cn-beijing.volces.com/api/v3", detectByBaseKeyword: "volces" },
+    { name: "anthropic", keywords: ["anthropic", "claude"], isOauth: false, isGateway: false, isLocal: false, defaultApiBase: "" },
+    { name: "openai", keywords: ["openai", "gpt"], isOauth: false, isGateway: false, isLocal: false, defaultApiBase: "" },
+    { name: "openai_codex", keywords: ["openai-codex", "codex"], isOauth: true, isGateway: false, isLocal: false, defaultApiBase: "https://chatgpt.com/backend-api" },
+    { name: "github_copilot", keywords: ["github_copilot", "copilot"], isOauth: true, isGateway: false, isLocal: false, defaultApiBase: "" },
+    { name: "deepseek", keywords: ["deepseek"], isOauth: false, isGateway: false, isLocal: false, defaultApiBase: "" },
+    { name: "gemini", keywords: ["gemini"], isOauth: false, isGateway: false, isLocal: false, defaultApiBase: "" },
+    { name: "zhipu", keywords: ["zhipu", "glm", "zai"], isOauth: false, isGateway: false, isLocal: false, defaultApiBase: "" },
+    { name: "dashscope", keywords: ["qwen", "dashscope"], isOauth: false, isGateway: false, isLocal: false, defaultApiBase: "" },
+    { name: "moonshot", keywords: ["moonshot", "kimi"], isOauth: false, isGateway: false, isLocal: false, defaultApiBase: "https://api.moonshot.ai/v1" },
+    { name: "minimax", keywords: ["minimax"], isOauth: false, isGateway: false, isLocal: false, defaultApiBase: "https://api.minimax.io/v1" },
+    { name: "vllm", keywords: ["vllm"], isOauth: false, isGateway: false, isLocal: true, defaultApiBase: "" },
+    { name: "groq", keywords: ["groq"], isOauth: false, isGateway: false, isLocal: false, defaultApiBase: "" },
+];
+const providerDefaults = Object.fromEntries(PROVIDERS.map((p) => [p.name, { apiKey: "", apiBase: null, extraHeaders: null }]));
+export const DEFAULT_CONFIG = {
+    agents: {
+        defaults: {
+            workspace: path.join("~", ".pretticlaw", "workspace"),
+            model: "anthropic/claude-sonnet-4",
+            provider: "auto",
+            maxTokens: 8192,
+            temperature: 0.1,
+            maxToolIterations: 40,
+            memoryWindow: 100,
+        },
+    },
+    channels: {
+        sendProgress: true,
+        sendToolHints: false,
+        whatsapp: { enabled: false, bridgeUrl: "ws://localhost:3001", bridgeToken: "", allowFrom: [] },
+        telegram: { enabled: false, token: "", allowFrom: [], proxy: null, replyToMessage: false },
+        discord: { enabled: false, token: "", allowFrom: [], gatewayUrl: "wss://gateway.discord.gg/?v=10&encoding=json", intents: 37377 },
+        feishu: { enabled: false, appId: "", appSecret: "", allowFrom: [] },
+        mochat: { enabled: false, baseUrl: "https://mochat.io", allowFrom: [] },
+        dingtalk: { enabled: false, clientId: "", clientSecret: "", allowFrom: [] },
+        email: { enabled: false, consentGranted: false, imapHost: "", allowFrom: [] },
+        slack: { enabled: false, botToken: "", appToken: "", groupPolicy: "mention", groupAllowFrom: [] },
+        qq: { enabled: false, appId: "", secret: "", allowFrom: [] },
+        matrix: { enabled: false, homeserver: "https://matrix.org", accessToken: "", userId: "", deviceId: "", allowFrom: [] },
+    },
+    providers: providerDefaults,
+    gateway: { host: "0.0.0.0", port: 18790, heartbeat: { enabled: true, intervalS: 1800 } },
+    tools: { web: { search: { apiKey: "", maxResults: 5 } }, exec: { timeout: 60, pathAppend: "" }, restrictToWorkspace: false, mcpServers: {} },
+};
+function normalize(name) {
+    return name.toLowerCase().replace(/-/g, "_");
+}
+export function getProviderName(config, model) {
+    const forced = config.agents.defaults.provider;
+    if (forced !== "auto")
+        return config.providers[forced] ? forced : null;
+    const m = (model ?? config.agents.defaults.model).toLowerCase();
+    const mNorm = normalize(m);
+    const prefix = m.includes("/") ? m.split("/", 1)[0] : "";
+    for (const spec of PROVIDERS) {
+        const p = config.providers[spec.name];
+        if (prefix && normalize(prefix) === spec.name && (spec.isOauth || p?.apiKey))
+            return spec.name;
+    }
+    for (const spec of PROVIDERS) {
+        const p = config.providers[spec.name];
+        if (spec.keywords.some((kw) => m.includes(kw) || mNorm.includes(normalize(kw))) && (spec.isOauth || p?.apiKey))
+            return spec.name;
+    }
+    for (const spec of PROVIDERS) {
+        if (spec.isOauth)
+            continue;
+        const p = config.providers[spec.name];
+        if (p?.apiKey)
+            return spec.name;
+    }
+    return null;
+}
+export function getProvider(config, model) {
+    const name = getProviderName(config, model);
+    return name ? config.providers[name] ?? null : null;
+}
+export function getApiBase(config, model) {
+    const name = getProviderName(config, model);
+    if (!name)
+        return null;
+    const p = config.providers[name];
+    if (p?.apiBase)
+        return p.apiBase;
+    const spec = PROVIDERS.find((s) => s.name === name);
+    return spec?.isGateway ? spec.defaultApiBase : null;
+}

package/dist/cron/service.d.ts

@@ -0,0 +1,33 @@
+import type { CronJob, CronSchedule } from "./types.js";
+declare function validateScheduleForAdd(schedule: CronSchedule): void;
+export declare class CronService {
+    private readonly storePath;
+    onJob?: ((job: CronJob) => Promise<string | null>) | undefined;
+    private store;
+    private timer;
+    private running;
+    constructor(storePath: string, onJob?: ((job: CronJob) => Promise<string | null>) | undefined);
+    private loadStore;
+    private saveStore;
+    private getNextWakeMs;
+    private armTimer;
+    private onTimer;
+    private executeJob;
+    start(): Promise<void>;
+    stop(): void;
+    listJobs(includeDisabled?: boolean): CronJob[];
+    addJob(input: {
+        name: string;
+        schedule: CronSchedule;
+        message: string;
+        deliver?: boolean;
+        channel?: string;
+        to?: string;
+        deleteAfterRun?: boolean;
+    }): CronJob;
+    removeJob(jobId: string): boolean;
+    enableJob(jobId: string, enabled?: boolean): CronJob | null;
+    runJob(jobId: string, force?: boolean): Promise<boolean>;
+    status(): Record<string, unknown>;
+}
+export { validateScheduleForAdd };

package/dist/cron/service.js

@@ -0,0 +1,195 @@
+import fs from "node:fs";
+import path from "node:path";
+import { randomUUID } from "node:crypto";
+import parser from "cron-parser";
+function nowMs() { return Date.now(); }
+function computeNextRun(schedule, now) {
+    if (schedule.kind === "at")
+        return schedule.atMs > now ? schedule.atMs : null;
+    if (schedule.kind === "every")
+        return schedule.everyMs > 0 ? now + schedule.everyMs : null;
+    if (schedule.kind === "cron") {
+        try {
+            const it = parser.parseExpression(schedule.expr, { currentDate: new Date(now), tz: schedule.tz });
+            return it.next().toDate().getTime();
+        }
+        catch {
+            return null;
+        }
+    }
+    return null;
+}
+function validateScheduleForAdd(schedule) {
+    if ("tz" in schedule && schedule.tz && schedule.kind !== "cron")
+        throw new Error("tz can only be used with cron schedules");
+    if (schedule.kind === "cron" && schedule.tz) {
+        try {
+            new Intl.DateTimeFormat("en-US", { timeZone: schedule.tz });
+        }
+        catch {
+            throw new Error(`unknown timezone '${schedule.tz}'`);
+        }
+    }
+}
+export class CronService {
+    storePath;
+    onJob;
+    store = null;
+    timer = null;
+    running = false;
+    constructor(storePath, onJob) {
+        this.storePath = storePath;
+        this.onJob = onJob;
+    }
+    loadStore() {
+        if (this.store)
+            return this.store;
+        if (!fs.existsSync(this.storePath)) {
+            this.store = { version: 1, jobs: [] };
+            return this.store;
+        }
+        try {
+            const parsed = JSON.parse(fs.readFileSync(this.storePath, "utf8"));
+            this.store = parsed;
+        }
+        catch {
+            this.store = { version: 1, jobs: [] };
+        }
+        return this.store;
+    }
+    saveStore() {
+        if (!this.store)
+            return;
+        fs.mkdirSync(path.dirname(this.storePath), { recursive: true });
+        fs.writeFileSync(this.storePath, JSON.stringify(this.store, null, 2), "utf8");
+    }
+    getNextWakeMs() {
+        const s = this.loadStore();
+        const times = s.jobs.filter((j) => j.enabled && j.state.nextRunAtMs).map((j) => j.state.nextRunAtMs);
+        return times.length ? Math.min(...times) : null;
+    }
+    armTimer() {
+        if (this.timer)
+            clearTimeout(this.timer);
+        const next = this.getNextWakeMs();
+        if (!this.running || !next)
+            return;
+        this.timer = setTimeout(() => void this.onTimer(), Math.max(0, next - nowMs()));
+    }
+    async onTimer() {
+        const s = this.loadStore();
+        const now = nowMs();
+        const due = s.jobs.filter((j) => j.enabled && j.state.nextRunAtMs && now >= j.state.nextRunAtMs);
+        for (const job of due)
+            await this.executeJob(job);
+        this.saveStore();
+        this.armTimer();
+    }
+    async executeJob(job) {
+        const start = nowMs();
+        try {
+            if (this.onJob)
+                await this.onJob(job);
+            job.state.lastStatus = "ok";
+            job.state.lastError = null;
+        }
+        catch (err) {
+            job.state.lastStatus = "error";
+            job.state.lastError = String(err);
+        }
+        job.state.lastRunAtMs = start;
+        job.updatedAtMs = nowMs();
+        if (job.schedule.kind === "at") {
+            if (job.deleteAfterRun) {
+                this.store.jobs = this.store.jobs.filter((j) => j.id !== job.id);
+            }
+            else {
+                job.enabled = false;
+                job.state.nextRunAtMs = null;
+            }
+        }
+        else {
+            job.state.nextRunAtMs = computeNextRun(job.schedule, nowMs());
+        }
+    }
+    async start() {
+        this.running = true;
+        const s = this.loadStore();
+        for (const job of s.jobs)
+            if (job.enabled)
+                job.state.nextRunAtMs = computeNextRun(job.schedule, nowMs());
+        this.saveStore();
+        this.armTimer();
+    }
+    stop() {
+        this.running = false;
+        if (this.timer)
+            clearTimeout(this.timer);
+        this.timer = null;
+    }
+    listJobs(includeDisabled = false) {
+        const s = this.loadStore();
+        const jobs = includeDisabled ? s.jobs : s.jobs.filter((j) => j.enabled);
+        return [...jobs].sort((a, b) => (a.state.nextRunAtMs ?? Number.MAX_SAFE_INTEGER) - (b.state.nextRunAtMs ?? Number.MAX_SAFE_INTEGER));
+    }
+    addJob(input) {
+        const s = this.loadStore();
+        validateScheduleForAdd(input.schedule);
+        const now = nowMs();
+        const job = {
+            id: randomUUID().slice(0, 8),
+            name: input.name,
+            enabled: true,
+            schedule: input.schedule,
+            payload: { kind: "agent_turn", message: input.message, deliver: !!input.deliver, channel: input.channel, to: input.to },
+            state: { nextRunAtMs: computeNextRun(input.schedule, now), lastRunAtMs: null, lastStatus: null, lastError: null },
+            createdAtMs: now,
+            updatedAtMs: now,
+            deleteAfterRun: !!input.deleteAfterRun,
+        };
+        s.jobs.push(job);
+        this.saveStore();
+        this.armTimer();
+        return job;
+    }
+    removeJob(jobId) {
+        const s = this.loadStore();
+        const before = s.jobs.length;
+        s.jobs = s.jobs.filter((j) => j.id !== jobId);
+        const removed = s.jobs.length < before;
+        if (removed) {
+            this.saveStore();
+            this.armTimer();
+        }
+        return removed;
+    }
+    enableJob(jobId, enabled = true) {
+        const s = this.loadStore();
+        const job = s.jobs.find((j) => j.id === jobId);
+        if (!job)
+            return null;
+        job.enabled = enabled;
+        job.updatedAtMs = nowMs();
+        job.state.nextRunAtMs = enabled ? computeNextRun(job.schedule, nowMs()) : null;
+        this.saveStore();
+        this.armTimer();
+        return job;
+    }
+    async runJob(jobId, force = false) {
+        const s = this.loadStore();
+        const job = s.jobs.find((j) => j.id === jobId);
+        if (!job)
+            return false;
+        if (!force && !job.enabled)
+            return false;
+        await this.executeJob(job);
+        this.saveStore();
+        this.armTimer();
+        return true;
+    }
+    status() {
+        const s = this.loadStore();
+        return { enabled: this.running, jobs: s.jobs.length, nextWakeAtMs: this.getNextWakeMs() };
+    }
+}
+export { validateScheduleForAdd };

package/dist/cron/types.d.ts

@@ -0,0 +1,47 @@
+export type CronSchedule = {
+    kind: "at";
+    atMs: number;
+    everyMs?: never;
+    expr?: never;
+    tz?: string;
+} | {
+    kind: "every";
+    everyMs: number;
+    atMs?: never;
+    expr?: never;
+    tz?: string;
+} | {
+    kind: "cron";
+    expr: string;
+    tz?: string;
+    atMs?: never;
+    everyMs?: never;
+};
+export interface CronPayload {
+    kind: "system_event" | "agent_turn";
+    message: string;
+    deliver: boolean;
+    channel?: string;
+    to?: string;
+}
+export interface CronJobState {
+    nextRunAtMs: number | null;
+    lastRunAtMs: number | null;
+    lastStatus: "ok" | "error" | "skipped" | null;
+    lastError: string | null;
+}
+export interface CronJob {
+    id: string;
+    name: string;
+    enabled: boolean;
+    schedule: CronSchedule;
+    payload: CronPayload;
+    state: CronJobState;
+    createdAtMs: number;
+    updatedAtMs: number;
+    deleteAfterRun: boolean;
+}
+export interface CronStore {
+    version: number;
+    jobs: CronJob[];
+}

package/dist/cron/types.js

@@ -0,0 +1 @@
+export {};