crnd 0.0.1

package/README.md

@@ -0,0 +1,108 @@
+# crnd
+
+Cron daemon built for agents. JSON output, no prompts, real OS processes.
+
+## Install
+
+```sh
+# npm/bun
+bunx crnd
+
+# or homebrew
+brew install ysm-dev/crnd/crnd
+```
+
+## 30 seconds to your first job
+
+```sh
+# start daemon (happens automatically, but let's be explicit)
+crnd daemon start
+
+# schedule a backup at 2am UTC daily
+crnd schedule -n backup -s "0 2 * * *" -- rsync -a ~/docs ~/backup
+
+# run it now
+crnd run-once -n backup
+
+# check status
+crnd status -n backup
+```
+
+That's it. Job definitions live in `~/.config/crnd/jobs.toml` - edit it directly and the daemon picks up changes.
+
+## Why crnd
+
+Most cron tools are built for humans clicking around. crnd is built for scripts and agents that need to:
+
+- Schedule jobs without interactive prompts
+- Parse structured output (`crnd list --json`)
+- Stream logs from running processes
+- Kill/stop jobs by name
+- Trust that jobs run as real OS processes (not some container abstraction)
+
+Everything runs locally. No cloud, no Docker, no account, no network calls.
+
+## Commands
+
+```sh
+crnd schedule -n NAME -s "CRON" -- command args   # create/update job
+crnd schedule -n NAME -a "ISO_TIMESTAMP" -- cmd   # one-time job
+crnd list                                         # all jobs
+crnd status -n NAME                               # job details
+crnd runs -n NAME                                 # run history
+crnd logs -n NAME -s                              # stream stdout/stderr
+crnd run-once -n NAME                             # trigger now
+crnd pause -n NAME                                # pause scheduling
+crnd resume -n NAME                               # resume
+crnd stop -n NAME                                 # graceful stop (SIGTERM)
+crnd kill -n NAME                                 # hard kill (SIGKILL)
+crnd delete -n NAME -f                            # remove job
+crnd export                                       # dump jobs.toml
+crnd import -f jobs.toml                          # load jobs
+crnd daemon install                               # autostart on login
+crnd doctor                                       # check setup
+```
+
+All commands support `--json` for machine-readable output.
+
+## jobs.toml
+
+```toml
+[jobs.backup]
+command = ["rsync", "-a", "/src", "/dst"]
+schedule = "0 2 * * *"
+timezone = "UTC"
+timeout_ms = 600000
+
+[jobs.deploy]
+command = ["./deploy.sh"]
+run_at = "2026-02-01T10:00:00Z"
+```
+
+Edit this file directly. The daemon watches it and syncs automatically.
+
+**Paths:**
+- macOS: `~/Library/Application Support/crnd/`
+- Linux: `~/.config/crnd/`
+- Windows: `%APPDATA%\crnd\`
+
+## How it works
+
+- Each job spawns a real OS process via `Bun.spawn`
+- State lives in SQLite, job definitions in TOML
+- Daemon runs per-user, binds to `127.0.0.1`
+- Autostart via launchd (macOS), systemd user (Linux), or Task Scheduler (Windows)
+- Stdout/stderr saved per-run in `state/runs/<jobId>/<runId>.out|.err`
+
+## Development
+
+```sh
+bun install
+bun run dev          # start daemon in dev mode
+bun run build        # compile single binary
+bun test
+```
+
+## License
+
+MIT

package/drizzle/0000_init.sql

@@ -0,0 +1,35 @@
+CREATE TABLE IF NOT EXISTS "jobs" (
+  "id" text PRIMARY KEY NOT NULL,
+  "name" text NOT NULL UNIQUE,
+  "description" text,
+  "command" text NOT NULL,
+  "cwd" text,
+  "env" text,
+  "schedule_type" text NOT NULL,
+  "cron" text,
+  "run_at" text,
+  "timezone" text,
+  "overlap_policy" text NOT NULL DEFAULT 'skip',
+  "timeout_ms" integer,
+  "paused" integer NOT NULL DEFAULT 0,
+  "created_at" text NOT NULL DEFAULT CURRENT_TIMESTAMP,
+  "updated_at" text NOT NULL DEFAULT CURRENT_TIMESTAMP,
+  "last_run_at" text,
+  "next_run_at" text
+);
+
+--> statement-breakpoint
+
+CREATE TABLE IF NOT EXISTS "runs" (
+  "id" text PRIMARY KEY NOT NULL,
+  "job_id" text NOT NULL REFERENCES "jobs"("id"),
+  "status" text NOT NULL,
+  "pid" integer,
+  "exit_code" integer,
+  "signal" text,
+  "started_at" text,
+  "ended_at" text,
+  "stdout_path" text,
+  "stderr_path" text,
+  "error_message" text
+);

package/drizzle/0001_add_runs.sql

@@ -0,0 +1,13 @@
+CREATE TABLE IF NOT EXISTS "runs" (
+  "id" text PRIMARY KEY NOT NULL,
+  "job_id" text NOT NULL REFERENCES "jobs"("id"),
+  "status" text NOT NULL,
+  "pid" integer,
+  "exit_code" integer,
+  "signal" text,
+  "started_at" text,
+  "ended_at" text,
+  "stdout_path" text,
+  "stderr_path" text,
+  "error_message" text
+);

package/drizzle/meta/_journal.json

@@ -0,0 +1,20 @@
+{
+  "version": "5",
+  "dialect": "sqlite",
+  "entries": [
+    {
+      "idx": 0,
+      "version": "0000",
+      "when": 1700000000000,
+      "tag": "0000_init",
+      "breakpoints": true
+    },
+    {
+      "idx": 1,
+      "version": "0001",
+      "when": 1700000001000,
+      "tag": "0001_add_runs",
+      "breakpoints": true
+    }
+  ]
+}

package/package.json

@@ -0,0 +1,59 @@
+{
+  "name": "crnd",
+  "version": "0.0.1",
+  "description": "Agent-first CLI for cron scheduling and process management",
+  "type": "module",
+  "bin": {
+    "crnd": "src/cli/main.ts"
+  },
+  "files": [
+    "src",
+    "drizzle"
+  ],
+  "scripts": {
+    "dev": "bun run src/cli/main.ts",
+    "build": "bun build ./src/cli/main.ts --compile --outfile dist/crnd",
+    "lint": "biome lint .",
+    "format": "biome format . --write",
+    "check": "biome check .",
+    "typecheck": "tsgo --noEmit",
+    "test": "bun test"
+  },
+  "keywords": [
+    "cron",
+    "scheduler",
+    "daemon",
+    "jobs",
+    "cli",
+    "process-manager"
+  ],
+  "author": "ysm-dev",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ysm-dev/crnd.git"
+  },
+  "bugs": {
+    "url": "https://github.com/ysm-dev/crnd/issues"
+  },
+  "homepage": "https://github.com/ysm-dev/crnd#readme",
+  "dependencies": {
+    "@hono/zod-validator": "^0.7.6",
+    "@iarna/toml": "^2.2.5",
+    "citty": "^0.2.0",
+    "consola": "^3.4.2",
+    "croner": "^9.1.0",
+    "drizzle-orm": "^0.45.1",
+    "drizzle-zod": "^0.8.3",
+    "env-paths": "^4.0.0",
+    "hono": "^4.11.7",
+    "ulid": "^3.0.2",
+    "zod": "^4.3.6"
+  },
+  "devDependencies": {
+    "@biomejs/biome": "^2.3.13",
+    "@typescript/native-preview": "7.0.0-dev.20260131.1",
+    "bun-types": "^1.3.8",
+    "drizzle-kit": "^0.31.8"
+  }
+}

package/src/cli/commands/createDeleteCommand.ts

@@ -0,0 +1,93 @@
+import { defineCommand } from "citty";
+import createRpcClient from "../../shared/rpc/createRpcClient";
+
+export default function createDeleteCommand() {
+  return defineCommand({
+    meta: {
+      name: "delete",
+      description: "Delete a job",
+    },
+    args: {
+      name: {
+        type: "string",
+        alias: "n",
+        required: true,
+      },
+      force: {
+        type: "boolean",
+        alias: "f",
+      },
+      json: {
+        type: "boolean",
+        alias: "j",
+      },
+    },
+    async run({ args }) {
+      if (!args.force) {
+        const payload = { status: "missing_force" };
+        if (!process.stdout.isTTY || args.json) {
+          console.log(JSON.stringify(payload));
+        } else {
+          console.log("delete: requires --force");
+        }
+        process.exitCode = 2;
+        return;
+      }
+
+      const client = createRpcClient();
+      if (!client) {
+        const payload = { status: "unreachable" };
+        if (!process.stdout.isTTY || args.json) {
+          console.log(JSON.stringify(payload));
+        } else {
+          console.log("daemon: unreachable");
+        }
+        process.exitCode = 3;
+        return;
+      }
+
+      try {
+        const res = await client.jobs[":name"].$delete({
+          param: { name: args.name },
+        });
+        if (res.status === 404) {
+          const payload = { status: "not_found" };
+          if (!process.stdout.isTTY || args.json) {
+            console.log(JSON.stringify(payload));
+          } else {
+            console.log("delete: job not found");
+          }
+          process.exitCode = 1;
+          return;
+        }
+
+        if (!res.ok) {
+          const payload = { status: "error", code: res.status };
+          if (!process.stdout.isTTY || args.json) {
+            console.log(JSON.stringify(payload));
+          } else {
+            console.log(`delete: error (${res.status})`);
+          }
+          process.exitCode = 1;
+          return;
+        }
+
+        const data = await res.json();
+        if (!process.stdout.isTTY || args.json) {
+          console.log(JSON.stringify(data));
+          return;
+        }
+
+        console.log(`delete: removed (${data.jobId})`);
+      } catch {
+        const payload = { status: "unreachable" };
+        if (!process.stdout.isTTY || args.json) {
+          console.log(JSON.stringify(payload));
+        } else {
+          console.log("daemon: unreachable");
+        }
+        process.exitCode = 3;
+      }
+    },
+  });
+}

package/src/cli/commands/createDoctorCommand.ts

@@ -0,0 +1,93 @@
+import { accessSync, constants, existsSync } from "node:fs";
+import { defineCommand } from "citty";
+import getAutostartPath from "../../daemon/autostart/getAutostartPath";
+import getJobsTomlPath from "../../shared/paths/getJobsTomlPath";
+import createRpcClient from "../../shared/rpc/createRpcClient";
+
+export default function createDoctorCommand() {
+  return defineCommand({
+    meta: {
+      name: "doctor",
+      description: "Check crnd health",
+    },
+    args: {
+      json: {
+        type: "boolean",
+        alias: "j",
+      },
+    },
+    async run({ args }) {
+      const results: Array<{ check: string; ok: boolean; detail?: string }> =
+        [];
+      const client = createRpcClient();
+
+      if (!client) {
+        results.push({ check: "daemon", ok: false, detail: "unreachable" });
+      } else {
+        try {
+          const res = await client.health.$get();
+          results.push({
+            check: "daemon",
+            ok: res.ok,
+            detail: res.ok ? "running" : `status ${res.status}`,
+          });
+        } catch {
+          results.push({ check: "daemon", ok: false, detail: "unreachable" });
+        }
+      }
+
+      const jobsToml = getJobsTomlPath();
+      if (!existsSync(jobsToml)) {
+        results.push({ check: "jobs.toml", ok: false, detail: "missing" });
+      } else {
+        try {
+          accessSync(jobsToml, constants.R_OK | constants.W_OK);
+          results.push({ check: "jobs.toml", ok: true });
+        } catch {
+          results.push({
+            check: "jobs.toml",
+            ok: false,
+            detail: "not_readable",
+          });
+        }
+      }
+
+      const autostartPath = getAutostartPath();
+      if (!autostartPath) {
+        results.push({ check: "autostart", ok: false, detail: "unsupported" });
+      } else if (process.platform === "win32") {
+        const result = Bun.spawnSync([
+          "schtasks",
+          "/Query",
+          "/TN",
+          autostartPath,
+        ]);
+        results.push({
+          check: "autostart",
+          ok: result.success,
+          detail: "task",
+        });
+      } else {
+        results.push({
+          check: "autostart",
+          ok: existsSync(autostartPath),
+          detail: autostartPath,
+        });
+      }
+
+      const ok = results.every((item) => item.ok);
+      if (!process.stdout.isTTY || args.json) {
+        console.log(JSON.stringify({ ok, results }));
+      } else {
+        for (const item of results) {
+          const detail = item.detail ? ` (${item.detail})` : "";
+          console.log(`${item.check}: ${item.ok ? "ok" : "fail"}${detail}`);
+        }
+      }
+
+      if (!ok) {
+        process.exitCode = 1;
+      }
+    },
+  });
+}

package/src/cli/commands/createExportCommand.ts

@@ -0,0 +1,75 @@
+import { writeFileSync } from "node:fs";
+import { defineCommand } from "citty";
+import createRpcClient from "../../shared/rpc/createRpcClient";
+
+export default function createExportCommand() {
+  return defineCommand({
+    meta: {
+      name: "export",
+      description: "Export jobs to TOML",
+    },
+    args: {
+      output: {
+        type: "string",
+        alias: "o",
+      },
+      json: {
+        type: "boolean",
+        alias: "j",
+      },
+    },
+    async run({ args }) {
+      const client = createRpcClient();
+      if (!client) {
+        const payload = { status: "unreachable" };
+        if (!process.stdout.isTTY || args.json) {
+          console.log(JSON.stringify(payload));
+        } else {
+          console.log("daemon: unreachable");
+        }
+        process.exitCode = 3;
+        return;
+      }
+
+      try {
+        const res = await client.export.$post();
+        if (!res.ok) {
+          const payload = { status: "error", code: res.status };
+          if (!process.stdout.isTTY || args.json) {
+            console.log(JSON.stringify(payload));
+          } else {
+            console.log(`export: error (${res.status})`);
+          }
+          process.exitCode = 1;
+          return;
+        }
+
+        const data = await res.json();
+        if (args.output) {
+          writeFileSync(args.output, data.toml, "utf-8");
+          if (!process.stdout.isTTY || args.json) {
+            console.log(JSON.stringify({ ok: true, output: args.output }));
+          } else {
+            console.log(`export: wrote ${args.output}`);
+          }
+          return;
+        }
+
+        if (!process.stdout.isTTY || args.json) {
+          console.log(JSON.stringify(data));
+          return;
+        }
+
+        console.log(data.toml);
+      } catch {
+        const payload = { status: "unreachable" };
+        if (!process.stdout.isTTY || args.json) {
+          console.log(JSON.stringify(payload));
+        } else {
+          console.log("daemon: unreachable");
+        }
+        process.exitCode = 3;
+      }
+    },
+  });
+}

package/src/cli/commands/createImportCommand.ts

@@ -0,0 +1,80 @@
+import { readFileSync } from "node:fs";
+import { defineCommand } from "citty";
+import createRpcClient from "../../shared/rpc/createRpcClient";
+
+export default function createImportCommand() {
+  return defineCommand({
+    meta: {
+      name: "import",
+      description: "Import jobs from TOML",
+    },
+    args: {
+      file: {
+        type: "string",
+        alias: "f",
+        required: true,
+      },
+      json: {
+        type: "boolean",
+        alias: "j",
+      },
+    },
+    async run({ args }) {
+      const client = createRpcClient();
+      if (!client) {
+        const payload = { status: "unreachable" };
+        if (!process.stdout.isTTY || args.json) {
+          console.log(JSON.stringify(payload));
+        } else {
+          console.log("daemon: unreachable");
+        }
+        process.exitCode = 3;
+        return;
+      }
+
+      let toml: string;
+      try {
+        toml = readFileSync(args.file, "utf-8");
+      } catch {
+        const payload = { status: "missing_file" };
+        if (!process.stdout.isTTY || args.json) {
+          console.log(JSON.stringify(payload));
+        } else {
+          console.log("import: failed to read file");
+        }
+        process.exitCode = 2;
+        return;
+      }
+
+      try {
+        const res = await client.import.$post({ json: { toml } });
+        if (!res.ok) {
+          const payload = { status: "error", code: res.status };
+          if (!process.stdout.isTTY || args.json) {
+            console.log(JSON.stringify(payload));
+          } else {
+            console.log(`import: error (${res.status})`);
+          }
+          process.exitCode = 1;
+          return;
+        }
+
+        const data = await res.json();
+        if (!process.stdout.isTTY || args.json) {
+          console.log(JSON.stringify(data));
+          return;
+        }
+
+        console.log("import: ok");
+      } catch {
+        const payload = { status: "unreachable" };
+        if (!process.stdout.isTTY || args.json) {
+          console.log(JSON.stringify(payload));
+        } else {
+          console.log("daemon: unreachable");
+        }
+        process.exitCode = 3;
+      }
+    },
+  });
+}

package/src/cli/commands/createKillCommand.ts

@@ -0,0 +1,89 @@
+import { defineCommand } from "citty";
+import createRpcClient from "../../shared/rpc/createRpcClient";
+
+export default function createKillCommand() {
+  return defineCommand({
+    meta: {
+      name: "kill",
+      description: "Kill a running job",
+    },
+    args: {
+      name: {
+        type: "string",
+        alias: "n",
+        required: true,
+      },
+      json: {
+        type: "boolean",
+        alias: "j",
+      },
+    },
+    async run({ args }) {
+      const client = createRpcClient();
+      if (!client) {
+        const payload = { status: "unreachable" };
+        if (!process.stdout.isTTY || args.json) {
+          console.log(JSON.stringify(payload));
+        } else {
+          console.log("daemon: unreachable");
+        }
+        process.exitCode = 3;
+        return;
+      }
+
+      try {
+        const res = await client.jobs[":name"].kill.$post({
+          param: { name: args.name },
+        });
+        if (res.status === 404) {
+          const payload = { status: "not_found" };
+          if (!process.stdout.isTTY || args.json) {
+            console.log(JSON.stringify(payload));
+          } else {
+            console.log("kill: job not found");
+          }
+          process.exitCode = 1;
+          return;
+        }
+
+        if (res.status === 409) {
+          const payload = { status: "not_running" };
+          if (!process.stdout.isTTY || args.json) {
+            console.log(JSON.stringify(payload));
+          } else {
+            console.log("kill: no running job");
+          }
+          process.exitCode = 1;
+          return;
+        }
+
+        if (!res.ok) {
+          const payload = { status: "error", code: res.status };
+          if (!process.stdout.isTTY || args.json) {
+            console.log(JSON.stringify(payload));
+          } else {
+            console.log(`kill: error (${res.status})`);
+          }
+          process.exitCode = 1;
+          return;
+        }
+
+        const data = await res.json();
+        if (!process.stdout.isTTY || args.json) {
+          console.log(JSON.stringify(data));
+          return;
+        }
+
+        console.log(`kill: requested (${data.runId})`);
+      } catch {
+        const payload = { status: "unreachable" };
+        if (!process.stdout.isTTY || args.json) {
+          console.log(JSON.stringify(payload));
+        } else {
+          console.log("daemon: unreachable");
+        }
+        process.exitCode = 3;
+      }
+    },
+  });
+}