crond-js 1.0.0

package/README.md

@@ -0,0 +1,134 @@
+# crond-js
+
+Project-local cron daemon that reads a standard crontab file. Works on macOS and Linux, ships as an npm package with optional MCP integration for AI agent lifecycle management.
+
+## Why
+
+- **System cron** is global — one daemon per machine, can't scope to a project
+- **npm cron packages** (`cron`, `node-cron`, `croner`) are libraries, not daemons
+- **supercronic** does exactly the right thing but only ships Linux binaries
+
+crond-js fills the gap: point it at a crontab file in your project directory and it runs.
+
+## Install
+
+```sh
+npm install crond-js
+```
+
+Or run directly:
+
+```sh
+npx crond-js .cron/crontab
+```
+
+## Crontab format
+
+Standard 5-field cron syntax. Put it in `.cron/crontab` (or wherever you like):
+
+```crontab
+# Check API health every 5 minutes
+*/5 * * * *   ./scripts/check-health.sh
+
+# Daily report at 9am weekdays
+0 9 * * 1-5   ./scripts/daily-report.sh
+
+# Clean tmp directory every hour
+0 * * * *     rm -rf tmp/*
+```
+
+## CLI usage
+
+```sh
+# Foreground (logs to stdout + file)
+crond-js .cron/crontab
+
+# Background daemon
+crond-js .cron/crontab -d
+crond-js .cron/crontab --daemon
+
+# Check status
+crond-js .cron/crontab -s
+crond-js .cron/crontab --status
+
+# Stop daemon
+crond-js .cron/crontab -k
+crond-js .cron/crontab --stop
+
+# Custom PID file location
+crond-js .cron/crontab -d -p /tmp/my.pid
+```
+
+| Flag | Description |
+|------|-------------|
+| `-d`, `--daemon` | Run as background daemon |
+| `-s`, `--status` | Check if daemon is running |
+| `-k`, `--stop` | Stop the daemon |
+| `-p`, `--pidfile` | Override PID file path (default: same dir as crontab) |
+
+## MCP integration
+
+Add to your `.mcp.json`:
+
+```json
+{
+  "mcpServers": {
+    "cron": {
+      "command": "npx",
+      "args": ["-y", "crond-mcp", ".cron/crontab"]
+    }
+  }
+}
+```
+
+The MCP server auto-starts the daemon if it's not running, and exposes a single `cron_status` tool:
+
+```json
+{
+  "daemon_pid": 12345,
+  "daemon_running": true,
+  "jobs": [
+    {
+      "schedule": "*/5 * * * *",
+      "command": "./scripts/check-health.sh",
+      "last_run": "2026-03-15 14:05:01",
+      "last_exit_code": "0",
+      "next_run": "2026-03-15T18:10:00.000Z"
+    }
+  ]
+}
+```
+
+Agents manage jobs by editing the crontab file directly — no custom MCP tools needed.
+
+## How it works
+
+- Re-reads the crontab file every 60 seconds (same as traditional crond)
+- Commands run with `sh -c` in the crontab's directory
+- Jobs still running when the next tick fires are skipped (no overlapping)
+- Logs written to `.cron/log/YYYY-MM-DD.log` in crond format
+- PID stored in `.cron/cron.pid`
+- The daemon survives MCP session restarts — second sessions detect the existing daemon
+
+### Log format
+
+```
+2026-03-15 01:05:01 crond-js[12345]: STARTUP (crond-js 1.0.0)
+2026-03-15 01:05:01 crond-js[12345]: CMD (./scripts/check-health.sh)
+2026-03-15 01:05:03 crond-js[12345]: CMDOUT (OK: 200)
+2026-03-15 01:05:03 crond-js[12345]: CMDEND (./scripts/check-health.sh exit=0)
+2026-03-15 01:10:01 crond-js[12345]: RELOAD (.cron/crontab)
+```
+
+### Project file layout
+
+```
+.cron/
+  crontab       # the schedule (check into git)
+  cron.pid      # daemon PID (gitignore)
+  log/          # execution logs (gitignore)
+```
+
+## License
+
+MIT

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli.js

@@ -0,0 +1,72 @@
+#!/usr/bin/env node
+import { spawn } from 'node:child_process';
+import { resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { checkDaemon, readPid, isProcessAlive, stopDaemon } from './pid.js';
+import { startDaemon } from './daemon.js';
+import { dirname, join } from 'node:path';
+const args = process.argv.slice(2);
+const flags = new Set();
+let crontabPath = null;
+let pidFile = null;
+for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === '-p' || arg === '--pidfile') {
+        pidFile = args[++i];
+    }
+    else if (arg.startsWith('-')) {
+        flags.add(arg);
+    }
+    else {
+        crontabPath = arg;
+    }
+}
+if (!crontabPath) {
+    console.error('Usage: crond-js <crontab-path> [-d|--daemon] [-s|--status] [-k|--stop] [-p|--pidfile <path>]');
+    process.exit(1);
+}
+const resolvedCrontab = resolve(crontabPath);
+const cronDir = dirname(resolvedCrontab);
+const resolvedPidFile = pidFile ? resolve(pidFile) : join(cronDir, 'cron.pid');
+// --status
+if (flags.has('-s') || flags.has('--status')) {
+    const { running, pid } = checkDaemon(resolvedPidFile);
+    if (running) {
+        console.log(`crond-js is running (PID ${pid})`);
+    }
+    else {
+        console.log('crond-js is not running');
+    }
+    process.exit(0);
+}
+// --stop
+if (flags.has('-k') || flags.has('--stop')) {
+    const pid = readPid(resolvedPidFile);
+    if (pid === null || !isProcessAlive(pid)) {
+        console.log('crond-js is not running');
+        process.exit(0);
+    }
+    try {
+        await stopDaemon(pid, resolvedPidFile);
+    }
+    catch (err) {
+        console.error(`Failed to stop crond-js: ${err.message}`);
+        process.exit(1);
+    }
+    console.log(`crond-js stopped (PID ${pid})`);
+    process.exit(0);
+}
+// --daemon (fork and exit)
+if (flags.has('-d') || flags.has('--daemon')) {
+    // Re-invoke with the same argv[0..1] so tsx/node/bun all work
+    const execArgs = [...process.execArgv, fileURLToPath(import.meta.url), resolvedCrontab, '-p', resolvedPidFile];
+    const child = spawn(process.execPath, execArgs, {
+        detached: true,
+        stdio: 'ignore',
+    });
+    child.unref();
+    console.log(`crond-js started in background (PID ${child.pid})`);
+    process.exit(0);
+}
+// Foreground mode (default)
+startDaemon(resolvedCrontab, { foreground: true, pidFile: resolvedPidFile });

package/dist/crontab.d.ts

@@ -0,0 +1,11 @@
+import { Cron } from 'croner';
+export interface CronJob {
+    id: number;
+    schedule: string;
+    command: string;
+    cron: Cron;
+}
+/** Check if a date (floored to the minute) matches a cron schedule. */
+export declare function cronMatchDate(cron: Cron, date: Date): boolean;
+export declare function parseCrontab(content: string): CronJob[];
+export declare function readCrontab(path: string): Promise<CronJob[]>;

package/dist/crontab.js

@@ -0,0 +1,38 @@
+import { Cron } from 'croner';
+import { readFile } from 'node:fs/promises';
+/** Check if a date (floored to the minute) matches a cron schedule. */
+export function cronMatchDate(cron, date) {
+    const prev = new Date(date.getTime() - 60_000);
+    const next = cron.nextRun(prev);
+    if (!next)
+        return false;
+    return Math.floor(next.getTime() / 60_000) === Math.floor(date.getTime() / 60_000);
+}
+export function parseCrontab(content) {
+    const jobs = [];
+    for (const raw of content.split('\n')) {
+        const line = raw.trim();
+        if (!line || line.startsWith('#'))
+            continue;
+        // Split into 5 cron fields + command (everything after field 5)
+        const parts = line.split(/\s+/);
+        if (parts.length < 6) {
+            console.warn(`crond-js: skipping malformed line: ${line}`);
+            continue;
+        }
+        const schedule = parts.slice(0, 5).join(' ');
+        const command = parts.slice(5).join(' ');
+        try {
+            const cron = new Cron(schedule, { paused: true });
+            jobs.push({ id: jobs.length, schedule, command, cron });
+        }
+        catch {
+            console.warn(`crond-js: skipping invalid schedule "${schedule}": ${line}`);
+        }
+    }
+    return jobs;
+}
+export async function readCrontab(path) {
+    const content = await readFile(path, 'utf-8');
+    return parseCrontab(content);
+}

package/dist/daemon.d.ts

@@ -0,0 +1,15 @@
+import { type Logger } from './logger.js';
+import { type CronJob } from './crontab.js';
+export interface DaemonOptions {
+    foreground?: boolean;
+    pidFile?: string;
+}
+export declare function msToNextMinute(now?: Date): number;
+export declare function matchJobs(jobs: CronJob[], now: Date): CronJob[];
+export declare function executeJob(job: CronJob): void;
+export declare function getRunningJobCount(): number;
+/** @internal — test-only: inject a logger without full startDaemon side-effects */
+export declare function _setLogger(l: Logger): void;
+/** Stop the daemon and reset module state. Useful for tests. */
+export declare function stopDaemonProcess(): void;
+export declare function startDaemon(crontabFile: string, options?: DaemonOptions): void;

package/dist/daemon.js

@@ -0,0 +1,163 @@
+import { spawn } from 'node:child_process';
+import { readFileSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+import { createLogger } from './logger.js';
+import { writePid, checkDaemon, removePid } from './pid.js';
+import { parseCrontab, cronMatchDate } from './crontab.js';
+const runningJobs = new Map();
+let lastCrontabContent = '';
+let currentJobs = [];
+let logger;
+let pidPath;
+let crontabPath;
+let cwd;
+let timer = null;
+let isRunning = false;
+function floorToMinute(date) {
+    const d = new Date(date);
+    d.setSeconds(0, 0);
+    return d;
+}
+export function msToNextMinute(now) {
+    const date = now ?? new Date();
+    return 60_000 - (date.getTime() % 60_000);
+}
+export function matchJobs(jobs, now) {
+    const floored = floorToMinute(now);
+    return jobs.filter(job => cronMatchDate(job.cron, floored));
+}
+function loadCrontab() {
+    let content;
+    try {
+        content = readFileSync(crontabPath, 'utf-8');
+    }
+    catch {
+        return; // File missing or unreadable — keep current jobs
+    }
+    if (content === lastCrontabContent)
+        return;
+    if (lastCrontabContent !== '') {
+        logger.log('RELOAD', crontabPath);
+    }
+    lastCrontabContent = content;
+    currentJobs = parseCrontab(content);
+}
+export function executeJob(job) {
+    if (runningJobs.has(job.id))
+        return; // Skip overlapping
+    logger.log('CMD', job.command);
+    const child = spawn('sh', ['-c', job.command], {
+        cwd,
+        stdio: ['ignore', 'pipe', 'pipe'],
+    });
+    runningJobs.set(job.id, child);
+    let stdoutBuf = '';
+    child.stdout?.on('data', (data) => {
+        stdoutBuf += data.toString();
+        const lines = stdoutBuf.split('\n');
+        stdoutBuf = lines.pop(); // keep incomplete fragment
+        for (const line of lines) {
+            if (line)
+                logger.log('CMDOUT', line);
+        }
+    });
+    let stderrBuf = '';
+    child.stderr?.on('data', (data) => {
+        stderrBuf += data.toString();
+        const lines = stderrBuf.split('\n');
+        stderrBuf = lines.pop(); // keep incomplete fragment
+        for (const line of lines) {
+            if (line)
+                logger.log('CMDOUT', line);
+        }
+    });
+    child.on('error', (err) => {
+        logger.log('CMDERR', `${job.command} error=${err.message}`);
+        runningJobs.delete(job.id);
+    });
+    child.on('close', (code) => {
+        if (stdoutBuf)
+            logger.log('CMDOUT', stdoutBuf);
+        if (stderrBuf)
+            logger.log('CMDOUT', stderrBuf);
+        logger.log('CMDEND', `${job.command} exit=${code ?? 'unknown'}`);
+        runningJobs.delete(job.id);
+    });
+}
+export function getRunningJobCount() {
+    return runningJobs.size;
+}
+/** @internal — test-only: inject a logger without full startDaemon side-effects */
+export function _setLogger(l) {
+    logger = l;
+}
+function tick() {
+    loadCrontab();
+    const now = new Date();
+    const matched = matchJobs(currentJobs, now);
+    for (const job of matched) {
+        executeJob(job);
+    }
+}
+function scheduleTick() {
+    timer = setTimeout(() => { tick(); scheduleTick(); }, msToNextMinute());
+}
+function cleanup() {
+    if (timer) {
+        clearTimeout(timer);
+        timer = null;
+    }
+    // Kill all running child processes before removing PID file
+    for (const [id, child] of runningJobs) {
+        try {
+            child.kill('SIGTERM');
+        }
+        catch {
+            // Process may have already exited
+        }
+    }
+    runningJobs.clear();
+    isRunning = false;
+    removePid(pidPath);
+    logger.log('SHUTDOWN', 'crond-js');
+}
+/** Stop the daemon and reset module state. Useful for tests. */
+export function stopDaemonProcess() {
+    cleanup();
+}
+export function startDaemon(crontabFile, options = {}) {
+    if (isRunning) {
+        throw new Error('crond-js: daemon already running in this process');
+    }
+    crontabPath = resolve(crontabFile);
+    cwd = process.cwd();
+    const cronDir = dirname(crontabPath);
+    const logDir = join(cronDir, 'log');
+    pidPath = options.pidFile ?? join(cronDir, 'cron.pid');
+    const foreground = options.foreground ?? true;
+    // Check for existing daemon
+    const { running, pid } = checkDaemon(pidPath);
+    if (running) {
+        console.error(`crond-js: daemon already running (PID ${pid})`);
+        process.exit(1);
+    }
+    logger = createLogger(logDir, foreground);
+    writePid(pidPath);
+    isRunning = true;
+    logger.log('STARTUP', 'crond-js 1.0.0');
+    // Clean shutdown on signals — re-entrancy guard prevents double cleanup
+    let cleaningUp = false;
+    const onSignal = () => {
+        if (cleaningUp)
+            return;
+        cleaningUp = true;
+        cleanup();
+        setTimeout(() => process.exit(0), 3000);
+    };
+    process.on('SIGINT', onSignal);
+    process.on('SIGTERM', onSignal);
+    // First tick immediately
+    tick();
+    // Schedule next tick aligned to wall clock
+    scheduleTick();
+}

package/dist/logger.d.ts

@@ -0,0 +1,4 @@
+export interface Logger {
+    log(tag: string, detail: string): void;
+}
+export declare function createLogger(logDir: string, foreground: boolean): Logger;

package/dist/logger.js

@@ -0,0 +1,27 @@
+import { appendFileSync, mkdirSync } from 'node:fs';
+import { join } from 'node:path';
+function pad(n) {
+    return String(n).padStart(2, '0');
+}
+function timestamp() {
+    const d = new Date();
+    return `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())} ${pad(d.getHours())}:${pad(d.getMinutes())}:${pad(d.getSeconds())}`;
+}
+function dateSlug() {
+    const d = new Date();
+    return `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())}`;
+}
+export function createLogger(logDir, foreground) {
+    const pid = process.pid;
+    return {
+        log(tag, detail) {
+            const line = `${timestamp()} crond-js[${pid}]: ${tag} (${detail})\n`;
+            if (foreground) {
+                process.stdout.write(line);
+            }
+            mkdirSync(logDir, { recursive: true });
+            const logFile = join(logDir, `${dateSlug()}.log`);
+            appendFileSync(logFile, line);
+        },
+    };
+}

package/dist/mcp.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/mcp.js

@@ -0,0 +1,129 @@
+#!/usr/bin/env node
+import { spawn } from 'node:child_process';
+import { readFileSync } from 'node:fs';
+import { resolve, dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { checkDaemon, readPid, isProcessAlive } from './pid.js';
+import { parseCrontab } from './crontab.js';
+// Parse args
+const args = process.argv.slice(2);
+let crontabPath = null;
+let pidFile = null;
+for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === '-p' || arg === '--pidfile') {
+        pidFile = args[++i];
+    }
+    else if (!arg.startsWith('-')) {
+        crontabPath = arg;
+    }
+}
+if (!crontabPath) {
+    console.error('Usage: crond-mcp <crontab-path> [-p|--pidfile <path>]');
+    process.exit(1);
+}
+const resolvedCrontab = resolve(crontabPath);
+const cronDir = dirname(resolvedCrontab);
+const resolvedPidFile = pidFile ? resolve(pidFile) : join(cronDir, 'cron.pid');
+const logDir = join(cronDir, 'log');
+// Ensure daemon is running
+const { running } = checkDaemon(resolvedPidFile);
+if (!running) {
+    // Fork daemon using CLI entry point — preserve tsx/loader args
+    // Use the same extension as the current file (.ts in dev, .js when compiled)
+    const thisFile = fileURLToPath(import.meta.url);
+    const ext = thisFile.endsWith('.ts') ? '.ts' : '.js';
+    const cliPath = fileURLToPath(new URL(`./cli${ext}`, import.meta.url));
+    const child = spawn(process.execPath, [...process.execArgv, cliPath, resolvedCrontab, '-p', resolvedPidFile], {
+        detached: true,
+        stdio: 'ignore',
+    });
+    child.on('error', (err) => console.error('crond-js: failed to start daemon:', err.message));
+    child.unref();
+    // Poll for daemon to be ready (PID file written + process alive), up to 5s
+    const POLL_INTERVAL = 200;
+    const POLL_TIMEOUT = 5000;
+    let waited = 0;
+    while (waited < POLL_TIMEOUT) {
+        await new Promise(r => setTimeout(r, POLL_INTERVAL));
+        waited += POLL_INTERVAL;
+        const status = checkDaemon(resolvedPidFile);
+        if (status.running)
+            break;
+    }
+    if (waited >= POLL_TIMEOUT) {
+        console.warn('crond-js: daemon did not start within 5s — continuing anyway');
+    }
+}
+// Parse today's log for last run info
+function parseLogForJobs() {
+    const results = new Map();
+    const now = new Date();
+    const dateSlug = `${now.getFullYear()}-${String(now.getMonth() + 1).padStart(2, '0')}-${String(now.getDate()).padStart(2, '0')}`;
+    const logFile = join(logDir, `${dateSlug}.log`);
+    let content;
+    try {
+        content = readFileSync(logFile, 'utf-8');
+    }
+    catch {
+        return results;
+    }
+    for (const line of content.split('\n')) {
+        const cmdMatch = line.match(/^(\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}) crond-js\[\d+\]: CMD \((.+)\)$/);
+        if (cmdMatch) {
+            results.set(cmdMatch[2], { lastRun: cmdMatch[1], lastExitCode: 'running' });
+            continue;
+        }
+        const endMatch = line.match(/^(\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}) crond-js\[\d+\]: CMDEND \((.+) exit=(.+)\)$/);
+        if (endMatch) {
+            const cmd = endMatch[2];
+            const existing = results.get(cmd);
+            if (existing) {
+                existing.lastExitCode = endMatch[3];
+            }
+        }
+    }
+    return results;
+}
+// MCP Server
+const server = new McpServer({
+    name: 'crond-mcp',
+    version: '1.0.0',
+});
+server.tool('cron_status', 'Check daemon status, scheduled jobs, last/next run times', {}, async () => {
+    const pid = readPid(resolvedPidFile);
+    const alive = pid !== null && isProcessAlive(pid);
+    const logInfo = parseLogForJobs();
+    let jobs = [];
+    try {
+        const parsed = parseCrontab(readFileSync(resolvedCrontab, 'utf-8'));
+        jobs = parsed.map(job => {
+            const info = logInfo.get(job.command);
+            const nextRun = job.cron.nextRun();
+            return {
+                schedule: job.schedule,
+                command: job.command,
+                last_run: info?.lastRun ?? null,
+                last_exit_code: info?.lastExitCode ?? null,
+                next_run: nextRun ? nextRun.toISOString() : null,
+            };
+        });
+    }
+    catch {
+        // Crontab unreadable
+    }
+    return {
+        content: [{
+                type: 'text',
+                text: JSON.stringify({
+                    daemon_pid: alive ? pid : null,
+                    daemon_running: alive,
+                    jobs,
+                }, null, 2),
+            }],
+    };
+});
+const transport = new StdioServerTransport();
+await server.connect(transport);

package/dist/pid.d.ts

@@ -0,0 +1,18 @@
+export declare function writePid(pidPath: string): void;
+export declare function readPid(pidPath: string): number | null;
+export declare function isProcessAlive(pid: number): boolean;
+export declare function checkDaemon(pidPath: string): {
+    running: boolean;
+    pid: number | null;
+};
+export declare function removePid(pidPath: string): void;
+/**
+ * Send SIGTERM to a daemon and wait for it to exit.
+ * Polls isProcessAlive every `intervalMs` up to `timeoutMs`.
+ * Only removes the PID file if the daemon's own cleanup didn't.
+ * Throws if the process doesn't exit within the timeout.
+ */
+export declare function stopDaemon(pid: number, pidPath: string, { timeoutMs, intervalMs }?: {
+    timeoutMs?: number | undefined;
+    intervalMs?: number | undefined;
+}): Promise<void>;

package/dist/pid.js

@@ -0,0 +1,61 @@
+import { readFileSync, writeFileSync, unlinkSync } from 'node:fs';
+export function writePid(pidPath) {
+    writeFileSync(pidPath, String(process.pid), 'utf-8');
+}
+export function readPid(pidPath) {
+    try {
+        const content = readFileSync(pidPath, 'utf-8').trim();
+        const pid = parseInt(content, 10);
+        return isNaN(pid) ? null : pid;
+    }
+    catch {
+        return null;
+    }
+}
+export function isProcessAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function checkDaemon(pidPath) {
+    const pid = readPid(pidPath);
+    if (pid === null)
+        return { running: false, pid: null };
+    if (isProcessAlive(pid))
+        return { running: true, pid };
+    // Stale PID file — clean it up
+    removePid(pidPath);
+    return { running: false, pid: null };
+}
+export function removePid(pidPath) {
+    try {
+        unlinkSync(pidPath);
+    }
+    catch {
+        // Already gone
+    }
+}
+/**
+ * Send SIGTERM to a daemon and wait for it to exit.
+ * Polls isProcessAlive every `intervalMs` up to `timeoutMs`.
+ * Only removes the PID file if the daemon's own cleanup didn't.
+ * Throws if the process doesn't exit within the timeout.
+ */
+export async function stopDaemon(pid, pidPath, { timeoutMs = 5000, intervalMs = 100 } = {}) {
+    process.kill(pid, 'SIGTERM');
+    const deadline = Date.now() + timeoutMs;
+    while (isProcessAlive(pid)) {
+        if (Date.now() >= deadline) {
+            throw new Error(`Process ${pid} did not exit within ${timeoutMs}ms after SIGTERM`);
+        }
+        await new Promise((r) => setTimeout(r, intervalMs));
+    }
+    // Clean up PID file only if the daemon didn't remove it itself
+    if (readPid(pidPath) !== null) {
+        removePid(pidPath);
+    }
+}

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "crond-js",
+  "version": "1.0.0",
+  "description": "Project-local cron daemon that reads a standard crontab file",
+  "type": "module",
+  "bin": {
+    "crond-js": "dist/cli.js",
+    "crond-mcp": "dist/mcp.js"
+  },
+  "files": [
+    "dist/"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "test:unit": "vitest run test/unit/",
+    "test:e2e": "vitest run test/e2e/ --testTimeout=120000",
+    "test": "vitest run",
+    "test:integration": "vitest run test/integration/ --testTimeout=180000",
+    "prepublishOnly": "tsc"
+  },
+  "keywords": [
+    "cron",
+    "daemon",
+    "mcp",
+    "crontab"
+  ],
+  "license": "MIT",
+  "engines": {
+    "node": ">=18"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.27.1",
+    "croner": "^9.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "tsx": "^4.21.0",
+    "typescript": "^5.7.0",
+    "vitest": "^3.0.0"
+  }
+}