crnd 0.0.1

package/src/cli/commands/createScheduleCommand.ts

@@ -0,0 +1,184 @@
+import { defineCommand } from "citty";
+import isOverlapPolicy from "../../shared/jobs/isOverlapPolicy";
+import createRpcClient from "../../shared/rpc/createRpcClient";
+import getCommandArgs from "./getCommandArgs";
+import parseEnvArgs from "./parseEnvArgs";
+
+export default function createScheduleCommand() {
+  return defineCommand({
+    meta: {
+      name: "schedule",
+      description: "Create or update a job",
+    },
+    args: {
+      name: {
+        type: "string",
+        alias: "n",
+        required: true,
+      },
+      description: {
+        type: "string",
+        alias: "d",
+      },
+      schedule: {
+        type: "string",
+        alias: "s",
+      },
+      at: {
+        type: "string",
+        alias: "a",
+      },
+      timezone: {
+        type: "string",
+        alias: "z",
+      },
+      timeout: {
+        type: "string",
+        alias: "t",
+      },
+      paused: {
+        type: "boolean",
+        alias: "p",
+      },
+      overlap: {
+        type: "string",
+        alias: "o",
+      },
+      cwd: {
+        type: "string",
+        alias: "c",
+      },
+      env: {
+        type: "string",
+        alias: "e",
+      },
+      json: {
+        type: "boolean",
+        alias: "j",
+      },
+    },
+    async run({ args }) {
+      const command = getCommandArgs(process.argv);
+      if (command.length === 0) {
+        const payload = { status: "missing_command" };
+        if (!process.stdout.isTTY || args.json) {
+          console.log(JSON.stringify(payload));
+        } else {
+          console.log("schedule: missing command after --");
+        }
+        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;
+      }
+
+      let env: Record<string, string> | undefined;
+      try {
+        env = parseEnvArgs(args.env);
+      } catch {
+        const payload = { status: "invalid_env" };
+        if (!process.stdout.isTTY || args.json) {
+          console.log(JSON.stringify(payload));
+        } else {
+          console.log("schedule: invalid env");
+        }
+        process.exitCode = 2;
+        return;
+      }
+      const timeoutMs = args.timeout ? Number(args.timeout) : undefined;
+      if (args.timeout && Number.isNaN(timeoutMs)) {
+        const payload = { status: "invalid_timeout" };
+        if (!process.stdout.isTTY || args.json) {
+          console.log(JSON.stringify(payload));
+        } else {
+          console.log("schedule: invalid timeout");
+        }
+        process.exitCode = 2;
+        return;
+      }
+
+      const hasSchedule = Boolean(args.schedule);
+      const hasRunAt = Boolean(args.at);
+      if (hasSchedule === hasRunAt) {
+        const payload = { status: "invalid_schedule" };
+        if (!process.stdout.isTTY || args.json) {
+          console.log(JSON.stringify(payload));
+        } else {
+          console.log("schedule: provide schedule or at");
+        }
+        process.exitCode = 2;
+        return;
+      }
+
+      if (args.overlap && !isOverlapPolicy(args.overlap)) {
+        const payload = { status: "invalid_overlap" };
+        if (!process.stdout.isTTY || args.json) {
+          console.log(JSON.stringify(payload));
+        } else {
+          console.log("schedule: invalid overlap policy");
+        }
+        process.exitCode = 2;
+        return;
+      }
+
+      const overlapPolicy =
+        args.overlap && isOverlapPolicy(args.overlap)
+          ? args.overlap
+          : undefined;
+
+      const payload = {
+        name: args.name,
+        description: args.description,
+        command,
+        schedule: args.schedule,
+        runAt: args.at,
+        timezone: args.timezone,
+        timeoutMs,
+        paused: args.paused,
+        overlapPolicy,
+        cwd: args.cwd,
+        env,
+      };
+
+      try {
+        const res = await client.jobs.$post({ json: payload });
+        if (!res.ok) {
+          const errorPayload = { status: "error", code: res.status };
+          if (!process.stdout.isTTY || args.json) {
+            console.log(JSON.stringify(errorPayload));
+          } else {
+            console.log(`schedule: 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(`job: ${data.name} (${data.id})`);
+      } 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/createShowCommand.ts

@@ -0,0 +1,92 @@
+import { defineCommand } from "citty";
+import createRpcClient from "../../shared/rpc/createRpcClient";
+
+export default function createShowCommand() {
+  return defineCommand({
+    meta: {
+      name: "show",
+      description: "Show a 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"].$get({
+          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("show: 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(`show: 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(`name: ${data.name}`);
+        console.log(`id: ${data.id}`);
+        if (data.description) {
+          console.log(`description: ${data.description}`);
+        }
+        console.log(`command: ${data.command.join(" ")}`);
+        if (data.scheduleType === "cron") {
+          console.log(`schedule: ${data.cron ?? ""}`);
+        } else {
+          console.log(`runAt: ${data.runAt ?? ""}`);
+        }
+        if (data.timezone) {
+          console.log(`timezone: ${data.timezone}`);
+        }
+        console.log(`paused: ${data.paused}`);
+      } 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/createStatusCommand.ts

@@ -0,0 +1,145 @@
+import { defineCommand } from "citty";
+import createRpcClient from "../../shared/rpc/createRpcClient";
+
+export default function createStatusCommand() {
+  return defineCommand({
+    meta: {
+      name: "status",
+      description: "Show daemon status",
+    },
+    args: {
+      name: {
+        type: "string",
+        alias: "n",
+      },
+      json: {
+        type: "boolean",
+        alias: "j",
+      },
+    },
+    async run({ args }) {
+      if (args.name) {
+        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 jobRes = await client.jobs[":name"].$get({
+            param: { name: args.name },
+          });
+          if (jobRes.status === 404) {
+            const payload = { status: "not_found" };
+            if (!process.stdout.isTTY || args.json) {
+              console.log(JSON.stringify(payload));
+            } else {
+              console.log("status: job not found");
+            }
+            process.exitCode = 1;
+            return;
+          }
+
+          if (!jobRes.ok) {
+            const payload = { status: "error", code: jobRes.status };
+            if (!process.stdout.isTTY || args.json) {
+              console.log(JSON.stringify(payload));
+            } else {
+              console.log(`status: error (${jobRes.status})`);
+            }
+            process.exitCode = 1;
+            return;
+          }
+
+          const job = await jobRes.json();
+          const runsRes = await client.jobs[":name"].runs.$get({
+            param: { name: args.name },
+            query: { limit: "1" },
+          });
+
+          const latestRun = runsRes.ok ? (await runsRes.json())[0] : null;
+          const payload = {
+            job,
+            latestRun,
+          };
+
+          if (!process.stdout.isTTY || args.json) {
+            console.log(JSON.stringify(payload));
+            return;
+          }
+
+          console.log(`job: ${job.name} (${job.id})`);
+          console.log(`paused: ${job.paused}`);
+          if (job.nextRunAt) {
+            console.log(`nextRunAt: ${job.nextRunAt}`);
+          }
+          if (latestRun) {
+            console.log(
+              `lastRun: ${latestRun.status} ${latestRun.startedAt ?? ""}`.trim(),
+            );
+          }
+          return;
+        } catch {
+          const payload = { status: "unreachable" };
+          if (!process.stdout.isTTY || args.json) {
+            console.log(JSON.stringify(payload));
+          } else {
+            console.log("daemon: unreachable");
+          }
+          process.exitCode = 3;
+          return;
+        }
+      }
+
+      const client = createRpcClient();
+      if (!client) {
+        const payload = { status: "stopped" };
+        if (!process.stdout.isTTY || args.json) {
+          console.log(JSON.stringify(payload));
+        } else {
+          console.log("daemon: stopped");
+        }
+        process.exitCode = 3;
+        return;
+      }
+
+      try {
+        const res = await client.health.$get();
+        if (!res.ok) {
+          const payload = { status: "unreachable", code: res.status };
+          if (!process.stdout.isTTY || args.json) {
+            console.log(JSON.stringify(payload));
+          } else {
+            console.log(`daemon: unreachable (${res.status})`);
+          }
+          process.exitCode = 3;
+          return;
+        }
+
+        const data = await res.json();
+        if (!process.stdout.isTTY || args.json) {
+          console.log(JSON.stringify(data));
+          return;
+        }
+
+        console.log(`daemon: running (pid ${data.pid})`);
+        console.log(`started: ${data.startedAt}`);
+        console.log(`version: ${data.version}`);
+      } 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/createStopCommand.ts

@@ -0,0 +1,89 @@
+import { defineCommand } from "citty";
+import createRpcClient from "../../shared/rpc/createRpcClient";
+
+export default function createStopCommand() {
+  return defineCommand({
+    meta: {
+      name: "stop",
+      description: "Stop 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"].stop.$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("stop: 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("stop: 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(`stop: 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(`stop: 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;
+      }
+    },
+  });
+}

package/src/cli/commands/createUpdateCommand.ts

@@ -0,0 +1,13 @@
+import createScheduleCommand from "./createScheduleCommand";
+
+export default function createUpdateCommand() {
+  const base = createScheduleCommand();
+  return {
+    ...base,
+    meta: {
+      ...base.meta,
+      name: "update",
+      description: "Update a job",
+    },
+  };
+}

package/src/cli/commands/daemon/createDaemonCommand.ts

@@ -0,0 +1,24 @@
+import { defineCommand } from "citty";
+import createDaemonInstallCommand from "./createDaemonInstallCommand";
+import createDaemonServeCommand from "./createDaemonServeCommand";
+import createDaemonStartCommand from "./createDaemonStartCommand";
+import createDaemonStatusCommand from "./createDaemonStatusCommand";
+import createDaemonStopCommand from "./createDaemonStopCommand";
+import createDaemonUninstallCommand from "./createDaemonUninstallCommand";
+
+export default function createDaemonCommand() {
+  return defineCommand({
+    meta: {
+      name: "daemon",
+      description: "Manage the crnd daemon",
+    },
+    subCommands: {
+      start: createDaemonStartCommand(),
+      stop: createDaemonStopCommand(),
+      status: createDaemonStatusCommand(),
+      serve: createDaemonServeCommand(),
+      install: createDaemonInstallCommand(),
+      uninstall: createDaemonUninstallCommand(),
+    },
+  });
+}

package/src/cli/commands/daemon/createDaemonInstallCommand.ts

@@ -0,0 +1,144 @@
+import { mkdirSync, writeFileSync } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { defineCommand } from "citty";
+import getStateDir from "../../../shared/paths/getStateDir";
+import createLaunchdPlist from "./createLaunchdPlist";
+import createSystemdService from "./createSystemdService";
+import getDaemonServiceArgs from "./getDaemonServiceArgs";
+import quoteWindowsArg from "./quoteWindowsArg";
+
+export default function createDaemonInstallCommand() {
+  return defineCommand({
+    meta: {
+      name: "install",
+      description: "Install auto-start service",
+    },
+    args: {
+      json: {
+        type: "boolean",
+        alias: "j",
+      },
+    },
+    run({ args }) {
+      if (process.env.CRND_AUTOSTART_DRY_RUN === "1") {
+        const payload = { ok: true, dryRun: true };
+        if (!process.stdout.isTTY || args.json) {
+          console.log(JSON.stringify(payload));
+        } else {
+          console.log("daemon: install dry run");
+        }
+        return;
+      }
+
+      const stdoutPath = path.join(getStateDir(), "daemon.out");
+      const stderrPath = path.join(getStateDir(), "daemon.err");
+      const daemonArgs = getDaemonServiceArgs();
+      const platform = process.platform;
+
+      if (platform === "darwin") {
+        const plistPath = path.join(
+          os.homedir(),
+          "Library",
+          "LaunchAgents",
+          "com.crnd.daemon.plist",
+        );
+        mkdirSync(path.dirname(plistPath), { recursive: true });
+        writeFileSync(
+          plistPath,
+          createLaunchdPlist(daemonArgs, stdoutPath, stderrPath),
+          "utf-8",
+        );
+        Bun.spawnSync(["launchctl", "unload", plistPath]);
+        const result = Bun.spawnSync(["launchctl", "load", plistPath]);
+
+        const ok = result.success;
+        if (!process.stdout.isTTY || args.json) {
+          console.log(JSON.stringify({ ok, path: plistPath }));
+        } else {
+          console.log(
+            ok ? `daemon: installed (${plistPath})` : "daemon: install failed",
+          );
+        }
+        if (!ok) {
+          process.exitCode = 1;
+        }
+        return;
+      }
+
+      if (platform === "linux") {
+        const servicePath = path.join(
+          os.homedir(),
+          ".config",
+          "systemd",
+          "user",
+          "crnd.service",
+        );
+        mkdirSync(path.dirname(servicePath), { recursive: true });
+        writeFileSync(
+          servicePath,
+          createSystemdService(daemonArgs, stdoutPath, stderrPath),
+          "utf-8",
+        );
+        Bun.spawnSync(["systemctl", "--user", "daemon-reload"]);
+        const result = Bun.spawnSync([
+          "systemctl",
+          "--user",
+          "enable",
+          "--now",
+          "crnd.service",
+        ]);
+        const ok = result.success;
+        if (!process.stdout.isTTY || args.json) {
+          console.log(JSON.stringify({ ok, path: servicePath }));
+        } else {
+          console.log(
+            ok
+              ? `daemon: installed (${servicePath})`
+              : "daemon: install failed",
+          );
+        }
+        if (!ok) {
+          process.exitCode = 1;
+        }
+        return;
+      }
+
+      if (platform === "win32") {
+        const taskName = "crnd";
+        const taskCommand = daemonArgs.map(quoteWindowsArg).join(" ");
+        const result = Bun.spawnSync([
+          "schtasks",
+          "/Create",
+          "/F",
+          "/SC",
+          "ONLOGON",
+          "/TN",
+          taskName,
+          "/TR",
+          taskCommand,
+        ]);
+        const ok = result.success;
+        if (!process.stdout.isTTY || args.json) {
+          console.log(JSON.stringify({ ok, task: taskName }));
+        } else {
+          console.log(
+            ok ? `daemon: installed (${taskName})` : "daemon: install failed",
+          );
+        }
+        if (!ok) {
+          process.exitCode = 1;
+        }
+        return;
+      }
+
+      const payload = { ok: false, error: "unsupported_platform" };
+      if (!process.stdout.isTTY || args.json) {
+        console.log(JSON.stringify(payload));
+      } else {
+        console.log("daemon: unsupported platform");
+      }
+      process.exitCode = 1;
+    },
+  });
+}

package/src/cli/commands/daemon/createDaemonServeCommand.ts

@@ -0,0 +1,14 @@
+import { defineCommand } from "citty";
+import startDaemon from "../../../daemon/main";
+
+export default function createDaemonServeCommand() {
+  return defineCommand({
+    meta: {
+      name: "serve",
+      description: "Run the daemon in the foreground",
+    },
+    run() {
+      startDaemon();
+    },
+  });
+}