@theowlops/boombot 0.0.0-stage → 1.1.1

package/dist/node_modules/@boombot/core/workflow/engine.js

@@ -0,0 +1,304 @@
+/**
+ * Workflow Engine.
+ *
+ * Coordinates execution of DAG workflow waves, handles retries, timeouts,
+ * feeds upstream outputs into downstream inputs, and enforces isolation.
+ */
+import { analyzeWorkflowDAG } from './dag.js';
+import { WorkflowError, } from './types.js';
+export class WorkflowEngine {
+    options;
+    constructor(options = {}) {
+        this.options = options;
+    }
+    async execute(nodes, context, signal) {
+        const startTime = Date.now();
+        const { waves } = analyzeWorkflowDAG(nodes);
+        const results = new Map();
+        const outputs = new Map();
+        const errors = new Map();
+        const failFast = this.options.failFast ?? true;
+        for (const wave of waves) {
+            if (signal?.aborted) {
+                break;
+            }
+            // Check if any node in this wave has failed dependencies
+            const executableNodes = [];
+            for (const node of wave) {
+                const hasFailedDep = node.dependencies.some((depId) => results.get(depId)?.status === 'failed');
+                if (hasFailedDep) {
+                    results.set(node.id, {
+                        nodeId: node.id,
+                        status: 'skipped',
+                        durationMs: 0,
+                        attempts: 0,
+                    });
+                }
+                else {
+                    executableNodes.push(node);
+                }
+            }
+            if (executableNodes.length === 0) {
+                continue;
+            }
+            // Execute wave nodes concurrently
+            const wavePromises = executableNodes.map((node) => this.executeNode(node, context, outputs, signal));
+            const waveResults = await Promise.all(wavePromises);
+            let waveHasFailure = false;
+            for (const res of waveResults) {
+                results.set(res.nodeId, res);
+                if (res.status === 'completed' && res.output !== undefined) {
+                    outputs.set(res.nodeId, res.output);
+                }
+                else if (res.status === 'failed') {
+                    waveHasFailure = true;
+                    if (res.error)
+                        errors.set(res.nodeId, res.error);
+                }
+            }
+            if (waveHasFailure && failFast) {
+                break;
+            }
+        }
+        const durationMs = Date.now() - startTime;
+        const isAborted = signal?.aborted === true;
+        const hasFailures = errors.size > 0;
+        // Harvest workflow-level trajectory if recording is enabled
+        let trajectory;
+        if (this.options.recordTrajectories ?? true) {
+            const nodeTrajectories = [];
+            for (const res of results.values()) {
+                if (res.trajectory) {
+                    nodeTrajectories.push(res.trajectory);
+                }
+            }
+            const allGolden = nodeTrajectories.length > 0 &&
+                nodeTrajectories.every((t) => t.golden);
+            trajectory = {
+                workflowId: this.options.workflowId ??
+                    `wf_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`,
+                timestamp: startTime,
+                status: isAborted ? 'aborted' : hasFailures ? 'failed' : 'completed',
+                totalDurationMs: durationMs,
+                nodeTrajectories,
+                golden: allGolden && !hasFailures && !isAborted,
+            };
+        }
+        return {
+            status: isAborted ? 'aborted' : hasFailures ? 'failed' : 'completed',
+            results,
+            outputs,
+            errors,
+            durationMs,
+            trajectory,
+        };
+    }
+    async executeNode(node, context, outputs, workflowSignal) {
+        const nodeStart = Date.now();
+        const maxAttempts = node.retry?.maxAttempts ?? 1;
+        const backoffMs = node.retry?.backoffMs ?? 100;
+        const maxCriticRounds = node.critic ? (node.maxCriticRounds ?? 3) : 1;
+        const minGoldenScore = node.minGoldenScore ?? (this.options.minGoldenScore ?? 0.85);
+        let totalAttempts = 0;
+        let lastError;
+        let lastOutput;
+        let criticFeedback;
+        const trajectorySteps = [];
+        // Filter upstream outputs relevant to this node
+        const upstreamOutputs = new Map();
+        for (const depId of node.dependencies) {
+            if (outputs.has(depId)) {
+                upstreamOutputs.set(depId, outputs.get(depId));
+            }
+        }
+        // Outer Loop: Multi-Agent Self-Supervision (MASS) Critic Feedback Rounds
+        for (let round = 1; round <= maxCriticRounds; round++) {
+            let stepAttempts = 0;
+            let stepOutput;
+            let stepError;
+            const stepStart = Date.now();
+            // Inner Loop: ReAct Execution & standard retry handling
+            while (stepAttempts < maxAttempts) {
+                stepAttempts++;
+                totalAttempts++;
+                if (workflowSignal?.aborted) {
+                    return {
+                        nodeId: node.id,
+                        status: 'failed',
+                        error: new Error('Workflow aborted'),
+                        durationMs: Date.now() - nodeStart,
+                        attempts: totalAttempts,
+                    };
+                }
+                let timeoutId;
+                const controller = new AbortController();
+                const onWorkflowAbort = () => controller.abort();
+                workflowSignal?.addEventListener('abort', onWorkflowAbort);
+                if (node.timeoutMs !== undefined && node.timeoutMs > 0) {
+                    timeoutId = setTimeout(() => {
+                        controller.abort(new Error(`Node '${node.id}' timed out after ${node.timeoutMs}ms`));
+                    }, node.timeoutMs);
+                }
+                try {
+                    stepOutput = await node.execute(context, upstreamOutputs, controller.signal, criticFeedback);
+                    if (timeoutId)
+                        clearTimeout(timeoutId);
+                    workflowSignal?.removeEventListener('abort', onWorkflowAbort);
+                    stepError = undefined;
+                    break;
+                }
+                catch (err) {
+                    if (timeoutId)
+                        clearTimeout(timeoutId);
+                    workflowSignal?.removeEventListener('abort', onWorkflowAbort);
+                    stepError = err instanceof Error ? err : new Error(String(err));
+                    if (stepAttempts < maxAttempts) {
+                        await new Promise((r) => setTimeout(r, backoffMs * stepAttempts));
+                    }
+                }
+            }
+            // If execution completely failed with error across all retry attempts
+            if (stepError || stepOutput === undefined) {
+                lastError = stepError ?? new Error(`Node '${node.id}' produced no output`);
+                trajectorySteps.push({
+                    round,
+                    error: lastError.message,
+                    durationMs: Date.now() - stepStart,
+                });
+                break;
+            }
+            lastOutput = stepOutput;
+            // If Critic is configured, run Self-Supervision Critic Evaluation
+            if (node.critic) {
+                let evaluation;
+                try {
+                    evaluation = await node.critic(stepOutput, context, upstreamOutputs, workflowSignal);
+                }
+                catch (evalErr) {
+                    evaluation = {
+                        pass: false,
+                        score: 0.0,
+                        feedback: `Critic execution threw error: ${evalErr instanceof Error ? evalErr.message : String(evalErr)}`,
+                    };
+                }
+                trajectorySteps.push({
+                    round,
+                    output: stepOutput,
+                    evaluation,
+                    durationMs: Date.now() - stepStart,
+                });
+                if (evaluation.pass) {
+                    // Critic passed the output!
+                    const trajectory = this.buildNodeTrajectory(node, 'completed', trajectorySteps, totalAttempts, minGoldenScore);
+                    return {
+                        nodeId: node.id,
+                        status: 'completed',
+                        output: stepOutput,
+                        durationMs: Date.now() - nodeStart,
+                        attempts: totalAttempts,
+                        trajectory,
+                    };
+                }
+                // Critic rejected: provide feedback for the next round
+                criticFeedback = evaluation;
+                if (round === maxCriticRounds) {
+                    lastError = new WorkflowError(`Node '${node.id}' failed self-supervision critic after ${maxCriticRounds} rounds: ${evaluation.feedback}`);
+                }
+            }
+            else {
+                // No critic configured: pass immediately on successful execution
+                trajectorySteps.push({
+                    round,
+                    output: stepOutput,
+                    durationMs: Date.now() - stepStart,
+                });
+                const trajectory = this.buildNodeTrajectory(node, 'completed', trajectorySteps, totalAttempts, minGoldenScore);
+                return {
+                    nodeId: node.id,
+                    status: 'completed',
+                    output: stepOutput,
+                    durationMs: Date.now() - nodeStart,
+                    attempts: totalAttempts,
+                    trajectory,
+                };
+            }
+        }
+        const failedTrajectory = this.buildNodeTrajectory(node, 'failed', trajectorySteps, totalAttempts, minGoldenScore);
+        return {
+            nodeId: node.id,
+            status: 'failed',
+            error: lastError,
+            output: lastOutput,
+            durationMs: Date.now() - nodeStart,
+            attempts: totalAttempts,
+            trajectory: failedTrajectory,
+        };
+    }
+    buildNodeTrajectory(node, status, steps, totalAttempts, minGoldenScore) {
+        const scores = steps
+            .filter((s) => s.evaluation?.score !== undefined)
+            .map((s) => s.evaluation.score);
+        const averageScore = scores.length > 0
+            ? scores.reduce((a, b) => a + b, 0) / scores.length
+            : undefined;
+        const lastStep = steps[steps.length - 1];
+        const isGolden = status === 'completed' &&
+            (lastStep?.evaluation
+                ? lastStep.evaluation.pass && lastStep.evaluation.score >= minGoldenScore
+                : true);
+        return {
+            nodeId: node.id,
+            nodeName: node.name,
+            finalStatus: status,
+            steps,
+            totalAttempts,
+            averageScore,
+            golden: isGolden,
+        };
+    }
+    /**
+     * Harvest golden trajectories and convert them into SFT fine-tuning records (MASS RSI format).
+     */
+    static exportGoldenDataset(trajectories, minScore = 0.85) {
+        const dataset = [];
+        for (const wf of trajectories) {
+            if (!wf.golden)
+                continue;
+            for (const node of wf.nodeTrajectories) {
+                if (!node.golden)
+                    continue;
+                if (node.averageScore !== undefined &&
+                    node.averageScore < minScore) {
+                    continue;
+                }
+                const lastStep = node.steps[node.steps.length - 1];
+                if (!lastStep?.output)
+                    continue;
+                dataset.push({
+                    instruction: `Execute workflow node: ${node.nodeName || node.nodeId}`,
+                    input: JSON.stringify({
+                        nodeId: node.nodeId,
+                        rounds: node.steps.length,
+                    }),
+                    output: typeof lastStep.output === 'string'
+                        ? lastStep.output
+                        : JSON.stringify(lastStep.output),
+                    score: lastStep.evaluation?.score ?? 1.0,
+                    metadata: {
+                        workflowId: wf.workflowId,
+                        attempts: node.totalAttempts,
+                        critique: lastStep.evaluation?.feedback,
+                    },
+                });
+            }
+        }
+        return dataset;
+    }
+    /**
+     * Export golden dataset directly to JSONL string for Unsloth / HuggingFace fine-tuning.
+     */
+    static exportDatasetAsJSONL(trajectories, minScore = 0.85) {
+        const records = WorkflowEngine.exportGoldenDataset(trajectories, minScore);
+        return records.map((r) => JSON.stringify(r)).join('\n');
+    }
+}

package/dist/node_modules/@boombot/core/workflow/index.d.ts

@@ -0,0 +1,3 @@
+export * from './types.js';
+export * from './dag.js';
+export * from './engine.js';

package/dist/node_modules/@boombot/core/workflow/index.js

@@ -0,0 +1,3 @@
+export * from './types.js';
+export * from './dag.js';
+export * from './engine.js';

package/dist/node_modules/@boombot/core/workflow/types.d.ts

@@ -0,0 +1,98 @@
+/**
+ * Workflow DAG (Directed Acyclic Graph) Types.
+ *
+ * Defines node structures, dependencies, execution state, and output resolution.
+ */
+export type NodeStatus = 'pending' | 'running' | 'completed' | 'failed' | 'skipped';
+export interface WorkflowNode<TContext = unknown, TOutput = unknown> {
+    /** Unique identifier for the node within the workflow. */
+    readonly id: string;
+    /** Human-readable label or description. */
+    readonly name?: string;
+    /** IDs of nodes that must complete successfully before this node executes. */
+    readonly dependencies: readonly string[];
+    /** Execution function for the node. Receives context, upstream outputs, and optional critic feedback. */
+    readonly execute: (context: TContext, upstreamOutputs: ReadonlyMap<string, unknown>, signal?: AbortSignal, criticFeedback?: CriticEvaluation) => Promise<TOutput>;
+    /** Optional timeout in milliseconds. */
+    readonly timeoutMs?: number;
+    /** Optional retry policy. */
+    readonly retry?: {
+        readonly maxAttempts: number;
+        readonly backoffMs?: number;
+    };
+    /**
+     * Optional Multi-Agent Self-Supervision (MASS) Critic function.
+     * If specified, evaluates node output. If evaluation.pass is false,
+     * node is re-executed with the critic feedback up to maxCriticRounds.
+     */
+    readonly critic?: (output: TOutput, context: TContext, upstreamOutputs: ReadonlyMap<string, unknown>, signal?: AbortSignal) => Promise<CriticEvaluation>;
+    /** Maximum rounds of critic feedback loop. Defaults to 3. */
+    readonly maxCriticRounds?: number;
+    /** Minimum score required for golden trajectory classification. Defaults to 0.85. */
+    readonly minGoldenScore?: number;
+}
+export interface CriticEvaluation {
+    readonly pass: boolean;
+    /** Normalized score between 0.0 (total failure) and 1.0 (flawless). */
+    readonly score: number;
+    /** Detailed critique, reasoning, or rubrics. */
+    readonly feedback: string;
+    /** Specific actionable suggestions for improvement. */
+    readonly improvements?: readonly string[];
+}
+export interface TrajectoryStep<TOutput = unknown> {
+    readonly round: number;
+    readonly output?: TOutput;
+    readonly error?: string;
+    readonly evaluation?: CriticEvaluation;
+    readonly durationMs: number;
+}
+export interface NodeTrajectory<TOutput = unknown> {
+    readonly nodeId: string;
+    readonly nodeName?: string;
+    readonly finalStatus: NodeStatus;
+    readonly steps: readonly TrajectoryStep<TOutput>[];
+    readonly totalAttempts: number;
+    readonly averageScore?: number;
+    readonly golden: boolean;
+}
+export interface WorkflowTrajectory {
+    readonly workflowId: string;
+    readonly timestamp: number;
+    readonly status: 'completed' | 'failed' | 'aborted';
+    readonly totalDurationMs: number;
+    readonly nodeTrajectories: readonly NodeTrajectory[];
+    readonly golden: boolean;
+}
+export interface SFTDatasetRecord {
+    readonly instruction: string;
+    readonly input: string;
+    readonly output: string;
+    readonly score: number;
+    readonly metadata?: Record<string, unknown>;
+}
+export interface NodeResult<TOutput = unknown> {
+    readonly nodeId: string;
+    readonly status: NodeStatus;
+    readonly output?: TOutput;
+    readonly error?: Error;
+    readonly durationMs: number;
+    readonly attempts: number;
+    readonly trajectory?: NodeTrajectory<TOutput>;
+}
+export interface WorkflowResult<TOutput = unknown> {
+    readonly status: 'completed' | 'failed' | 'aborted';
+    readonly results: ReadonlyMap<string, NodeResult<TOutput>>;
+    readonly outputs: ReadonlyMap<string, TOutput>;
+    readonly durationMs: number;
+    readonly errors: ReadonlyMap<string, Error>;
+    readonly trajectory?: WorkflowTrajectory;
+}
+export declare class WorkflowError extends Error {
+    readonly details?: unknown | undefined;
+    constructor(message: string, details?: unknown | undefined);
+}
+export declare class CycleDetectedError extends WorkflowError {
+    readonly cyclePath: readonly string[];
+    constructor(cyclePath: readonly string[]);
+}

package/dist/node_modules/@boombot/core/workflow/types.js

@@ -0,0 +1,21 @@
+/**
+ * Workflow DAG (Directed Acyclic Graph) Types.
+ *
+ * Defines node structures, dependencies, execution state, and output resolution.
+ */
+export class WorkflowError extends Error {
+    details;
+    constructor(message, details) {
+        super(message);
+        this.details = details;
+        this.name = 'WorkflowError';
+    }
+}
+export class CycleDetectedError extends WorkflowError {
+    cyclePath;
+    constructor(cyclePath) {
+        super(`Cycle detected in workflow graph: ${cyclePath.join(' -> ')}`);
+        this.cyclePath = cyclePath;
+        this.name = 'CycleDetectedError';
+    }
+}

package/dist/node_modules/@boombot/cronjobs/handlers.d.ts

@@ -0,0 +1,11 @@
+import { type CommandHandler } from "./service.js";
+/** Minimal command-registry surface these handlers need. */
+export interface ScheduleHandlerRegistry {
+    register(type: string, handler: CommandHandler): void;
+}
+/**
+ * Register every `schedule.*` handler on the gateway command registry.
+ * `schedule.run-now` is additive: unknown to older clients/dispatchers,
+ * harmless until the protocol barrel picks it up.
+ */
+export declare function registerScheduleHandlers(registry: ScheduleHandlerRegistry): void;

package/dist/node_modules/@boombot/cronjobs/handlers.js

@@ -0,0 +1,174 @@
+/**
+ * `schedule.*` command handlers for the gateway command registry.
+ *
+ * Implements the protocol schemas in `COMMAND_SCHEMAS` (`schedule.list`,
+ * `schedule.create`, `schedule.update`, `schedule.delete`,
+ * `schedule.toggle`) against the scheduler service's registry, plus the
+ * additive `schedule.run-now` command (see
+ * `packages/gateway-protocol/src/commands-scheduler.ts`, re-exported from
+ * the protocol barrel as `SCHEDULER_EXTRA_COMMAND_DEFS`).
+ *
+ * Notes:
+ * - Cron expressions are validated with the scheduler package's evaluator
+ *   before reaching the registry, so a bad cron fails fast with a clear
+ *   message (the registry would also reject it, but the pre-check names the
+ *   offending field).
+ * - The protocol v1 `schedule.*` payloads carry no timezone; schedules are
+ *   created in UTC. Recorded as a contract difference in the phase-2 report.
+ * - Client-caused failures (bad cron, unknown id, quota, illegal state) are
+ *   mapped to `ProtocolError('INVALID_PAYLOAD')` so the server answers 400,
+ *   not 500. Anything else (storage failure, unexpected) still propagates
+ *   and stays a 500.
+ */
+import { SchedulerError, validateCronExpression, } from "@boombot/core";
+import { COMMAND_SCHEMAS, SCHEDULER_EXTRA_COMMAND_DEFS as EXTRA_COMMAND_DEFS, ProtocolError, } from "@boombot/protocol";
+import { toProtocolSchedule, } from "./service.js";
+/** Default timezone: environment, host system, or Asia/Ho_Chi_Minh. */
+const DEFAULT_TIMEZONE = process.env["BOOMBOT_TIMEZONE"] ||
+    (typeof Intl !== "undefined"
+        ? Intl.DateTimeFormat().resolvedOptions().timeZone || "Asia/Ho_Chi_Minh"
+        : "Asia/Ho_Chi_Minh");
+function internalsOf(ctx) {
+    const service = ctx.schedulerService;
+    if (!service) {
+        throw new Error("scheduler service is not started");
+    }
+    return service.internals;
+}
+/**
+ * Map scheduler-domain failures onto protocol errors the way the `task.*`
+ * handlers map `TaskError`: client-caused `SchedulerError` codes become
+ * `INVALID_PAYLOAD` (400 via the server's ProtocolError mapping); storage
+ * failures, authZ denials and unexpected errors propagate (500).
+ */
+function mapSchedulerError(error) {
+    if (error instanceof ProtocolError)
+        return error;
+    if (error instanceof SchedulerError) {
+        switch (error.code) {
+            case "SCHEDULER_INVALID_SPEC":
+            case "SCHEDULER_NOT_FOUND":
+            case "SCHEDULER_LIMIT_EXCEEDED":
+            case "SCHEDULER_INVALID_STATE":
+                return new ProtocolError("INVALID_PAYLOAD", error.message, {
+                    code: error.code,
+                });
+            default:
+                return error;
+        }
+    }
+    return error instanceof Error ? error : new Error(String(error));
+}
+/**
+ * Parse a command payload, converting schema mismatches into
+ * `INVALID_PAYLOAD` (400) instead of letting a `ZodError` bubble up as a
+ * 500.
+ */
+function parsePayload(command, schema, payload) {
+    const result = schema.safeParse(payload);
+    if (!result.success) {
+        throw new ProtocolError("INVALID_PAYLOAD", `invalid payload for ${command}: ${result.error.message}`);
+    }
+    return result.data;
+}
+function assertValidCron(cron) {
+    const result = validateCronExpression(cron);
+    if (!result.ok) {
+        throw new ProtocolError("INVALID_PAYLOAD", `invalid cron expression: ${result.reason}`);
+    }
+}
+const listSchedules = async (ctx) => {
+    const { registry, authContext } = internalsOf(ctx);
+    const jobs = await registry.list(authContext);
+    return { schedules: jobs.map(toProtocolSchedule) };
+};
+const createSchedule = async (ctx, payload) => {
+    const input = parsePayload("schedule.create", COMMAND_SCHEMAS["schedule.create"].payload, payload);
+    assertValidCron(input.cron);
+    const { registry, authContext } = internalsOf(ctx);
+    try {
+        const job = await registry.create(authContext, {
+            name: input.name,
+            cron: input.cron,
+            timezone: input.timezone ?? DEFAULT_TIMEZONE,
+            promptText: input.prompt,
+            enabled: input.enabled ?? true,
+        });
+        return { schedule: toProtocolSchedule(job) };
+    }
+    catch (error) {
+        throw mapSchedulerError(error);
+    }
+};
+const updateSchedule = async (ctx, payload) => {
+    const input = parsePayload("schedule.update", COMMAND_SCHEMAS["schedule.update"].payload, payload);
+    // Mutable local patch; Partial<ScheduleSpec> fields are readonly.
+    const patch = {};
+    if (input.name !== undefined)
+        patch.name = input.name;
+    if (input.cron !== undefined) {
+        assertValidCron(input.cron);
+        patch.cron = input.cron;
+    }
+    if (input.prompt !== undefined)
+        patch.promptText = input.prompt;
+    if (input.enabled !== undefined)
+        patch.enabled = input.enabled;
+    const { registry, authContext } = internalsOf(ctx);
+    try {
+        const job = await registry.update(authContext, input.id, patch);
+        return { schedule: toProtocolSchedule(job) };
+    }
+    catch (error) {
+        throw mapSchedulerError(error);
+    }
+};
+const deleteSchedule = async (ctx, payload) => {
+    const input = parsePayload("schedule.delete", COMMAND_SCHEMAS["schedule.delete"].payload, payload);
+    const { registry, authContext } = internalsOf(ctx);
+    try {
+        await registry.remove(authContext, input.id);
+        return { ok: true };
+    }
+    catch (error) {
+        throw mapSchedulerError(error);
+    }
+};
+const toggleSchedule = async (ctx, payload) => {
+    const input = parsePayload("schedule.toggle", COMMAND_SCHEMAS["schedule.toggle"].payload, payload);
+    const { registry, authContext } = internalsOf(ctx);
+    try {
+        const job = await registry.setEnabled(authContext, input.id, input.enabled);
+        return { schedule: toProtocolSchedule(job) };
+    }
+    catch (error) {
+        throw mapSchedulerError(error);
+    }
+};
+const runScheduleNow = async (ctx, payload) => {
+    const input = parsePayload("schedule.run-now", EXTRA_COMMAND_DEFS["schedule.run-now"].payload, payload);
+    const service = ctx.schedulerService;
+    if (!service) {
+        throw new Error("scheduler service is not started");
+    }
+    try {
+        const { turnId } = await service.fireNow(input.id);
+        return { ok: true, turnId };
+    }
+    catch (error) {
+        throw mapSchedulerError(error);
+    }
+};
+/**
+ * Register every `schedule.*` handler on the gateway command registry.
+ * `schedule.run-now` is additive: unknown to older clients/dispatchers,
+ * harmless until the protocol barrel picks it up.
+ */
+export function registerScheduleHandlers(registry) {
+    registry.register("schedule.list", listSchedules);
+    registry.register("schedule.create", createSchedule);
+    registry.register("schedule.update", updateSchedule);
+    registry.register("schedule.delete", deleteSchedule);
+    registry.register("schedule.toggle", toggleSchedule);
+    registry.register("schedule.run-now", runScheduleNow);
+}

package/dist/node_modules/@boombot/cronjobs/index.d.ts

@@ -0,0 +1,2 @@
+export * from './handlers.js';
+export * from './service.js';

package/dist/node_modules/@boombot/cronjobs/index.js

@@ -0,0 +1,2 @@
+export * from './handlers.js';
+export * from './service.js';

package/dist/node_modules/@boombot/cronjobs/package.json

@@ -0,0 +1,9 @@
+{
+  "name": "@boombot/cronjobs",
+  "version": "2.0.0",
+  "type": "module",
+  "main": "./index.js",
+  "exports": {
+    ".": "./index.js"
+  }
+}