crnd 0.0.1 → 0.0.4

package/src/daemon/jobs/upsertJob.ts

@@ -1,85 +0,0 @@
-import { eq } from "drizzle-orm";
-import { ulid } from "ulid";
-import type { z } from "zod";
-import type openDatabase from "../../db/openDatabase";
-import { jobs } from "../../db/schema";
-import appendEvent from "../../shared/events/appendEvent";
-import createJobInputSchema from "../../shared/jobs/createJobInputSchema";
-import formatJobRow from "../../shared/jobs/formatJobRow";
-import serializeCommand from "../../shared/jobs/serializeCommand";
-import serializeEnv from "../../shared/jobs/serializeEnv";
-import ensureAutostart from "../autostart/ensureAutostart";
-
-type Db = ReturnType<typeof openDatabase>["orm"];
-type JobInput = z.infer<ReturnType<typeof createJobInputSchema>>;
-
-export default function upsertJob(db: Db, payload: unknown, id?: string) {
-  const input: JobInput = createJobInputSchema().parse(payload);
-  const existing = db
-    .select()
-    .from(jobs)
-    .where(eq(jobs.name, input.name))
-    .get();
-  const now = new Date().toISOString();
-  const scheduleType = input.schedule ? "cron" : "once";
-  const jobId = existing?.id ?? id ?? ulid();
-
-  const insertValues = {
-    id: jobId,
-    name: input.name,
-    description: input.description ?? null,
-    command: serializeCommand(input.command),
-    cwd: input.cwd ?? null,
-    env: input.env ? serializeEnv(input.env) : null,
-    scheduleType,
-    cron: input.schedule ?? null,
-    runAt: input.runAt ?? null,
-    timezone: input.timezone ?? null,
-    overlapPolicy: input.overlapPolicy ?? "skip",
-    timeoutMs: input.timeoutMs ?? null,
-    paused: input.paused ?? false,
-    createdAt: now,
-    updatedAt: now,
-    lastRunAt: existing?.lastRunAt ?? null,
-    nextRunAt: existing?.nextRunAt ?? null,
-  };
-
-  const updateValues = {
-    description: insertValues.description,
-    command: insertValues.command,
-    cwd: insertValues.cwd,
-    env: insertValues.env,
-    scheduleType: insertValues.scheduleType,
-    cron: insertValues.cron,
-    runAt: insertValues.runAt,
-    timezone: insertValues.timezone,
-    overlapPolicy: insertValues.overlapPolicy,
-    timeoutMs: insertValues.timeoutMs,
-    paused: insertValues.paused,
-    updatedAt: now,
-  };
-
-  db.insert(jobs)
-    .values(insertValues)
-    .onConflictDoUpdate({
-      target: jobs.name,
-      set: updateValues,
-    })
-    .run();
-
-  const saved = db.select().from(jobs).where(eq(jobs.name, input.name)).get();
-  if (!saved) {
-    throw new Error("job_not_saved");
-  }
-
-  const job = formatJobRow(saved);
-  const created = !existing;
-  appendEvent(created ? "job_created" : "job_updated", {
-    jobId: job.id,
-    name: job.name,
-  });
-  if (created) {
-    ensureAutostart();
-  }
-  return { job, created };
-}

package/src/daemon/main.ts

@@ -1,64 +0,0 @@
-import migrateDatabase from "../db/migrateDatabase";
-import openDatabase from "../db/openDatabase";
-import createToken from "../shared/auth/createToken";
-import appendEvent from "../shared/events/appendEvent";
-import writeDaemonState from "../shared/state/writeDaemonState";
-import getVersion from "../shared/version";
-import createLogger from "./createLogger";
-import createShutdownHandler from "./createShutdownHandler";
-import createJobsFileSync from "./jobs/createJobsFileSync";
-import recoverRunningRuns from "./runner/recoverRunningRuns";
-import createScheduler from "./scheduler/createScheduler";
-import createApp from "./server/createApp";
-import startServer from "./server/startServer";
-
-export default function startDaemon() {
-  const logger = createLogger();
-  const startedAt = new Date().toISOString();
-  const token = createToken();
-  const pid = process.pid;
-  const { orm } = openDatabase();
-  const migrationResult = migrateDatabase(orm);
-  if (!migrationResult.migrated) {
-    logger.warn({
-      event: "migrations_skipped",
-      reason: migrationResult.reason,
-    });
-  }
-  recoverRunningRuns(orm);
-  const scheduler = createScheduler(orm);
-  const jobsFileSync = createJobsFileSync(orm, scheduler, logger);
-  jobsFileSync.init();
-  scheduler.start();
-  let shutdown = () => {};
-  const app = createApp(
-    { token, startedAt, pid },
-    orm,
-    scheduler,
-    jobsFileSync,
-    () => shutdown(),
-  );
-  const server = startServer(app);
-  const port = server.port;
-  if (typeof port !== "number") {
-    throw new Error("daemon_port_unavailable");
-  }
-
-  writeDaemonState({
-    port,
-    token,
-    pid,
-    startedAt,
-    version: getVersion(),
-  });
-
-  appendEvent("daemon_started", { pid });
-
-  logger.info("daemon_started");
-
-  shutdown = createShutdownHandler(server, logger, scheduler, jobsFileSync);
-  process.on("SIGINT", shutdown);
-  process.on("SIGTERM", shutdown);
-
-  return { server, shutdown: () => shutdown() };
-}

package/src/daemon/runner/createRunOutputFds.ts

@@ -1,18 +0,0 @@
-import { closeSync, openSync } from "node:fs";
-
-export default function createRunOutputFds(
-  stdoutPath: string,
-  stderrPath: string,
-) {
-  const stdoutFd = openSync(stdoutPath, "a");
-  const stderrFd = openSync(stderrPath, "a");
-
-  return {
-    stdoutFd,
-    stderrFd,
-    close() {
-      closeSync(stdoutFd);
-      closeSync(stderrFd);
-    },
-  };
-}

package/src/daemon/runner/getRunStatus.ts

@@ -1,14 +0,0 @@
-export default function getRunStatus(
-  exitCode: number | null,
-  signal: string | null,
-) {
-  if (signal) {
-    return "killed";
-  }
-
-  if (exitCode === 0) {
-    return "success";
-  }
-
-  return "failed";
-}

package/src/daemon/runner/recordSkippedRun.ts

@@ -1,27 +0,0 @@
-import { ulid } from "ulid";
-import type openDatabase from "../../db/openDatabase";
-import { runs } from "../../db/schema";
-import appendEvent from "../../shared/events/appendEvent";
-import type formatJobRow from "../../shared/jobs/formatJobRow";
-
-type Db = ReturnType<typeof openDatabase>["orm"];
-type Job = ReturnType<typeof formatJobRow>;
-
-export default function recordSkippedRun(db: Db, job: Job) {
-  const now = new Date().toISOString();
-  const runId = ulid();
-
-  db.insert(runs)
-    .values({
-      id: runId,
-      jobId: job.id,
-      status: "skipped",
-      startedAt: now,
-      endedAt: now,
-    })
-    .run();
-
-  appendEvent("run_skipped", { jobId: job.id, runId });
-
-  return runId;
-}

package/src/daemon/runner/recoverRunningRuns.ts

@@ -1,36 +0,0 @@
-import { eq } from "drizzle-orm";
-import type openDatabase from "../../db/openDatabase";
-import { runs } from "../../db/schema";
-import appendEvent from "../../shared/events/appendEvent";
-
-type Db = ReturnType<typeof openDatabase>["orm"];
-
-export default function recoverRunningRuns(db: Db) {
-  const running = db
-    .select()
-    .from(runs)
-    .where(eq(runs.status, "running"))
-    .all();
-  const now = new Date().toISOString();
-
-  for (const run of running) {
-    if (!run.pid) {
-      db.update(runs)
-        .set({ status: "lost", endedAt: now })
-        .where(eq(runs.id, run.id))
-        .run();
-      appendEvent("run_lost", { runId: run.id, jobId: run.jobId });
-      continue;
-    }
-
-    try {
-      process.kill(run.pid, 0);
-    } catch {
-      db.update(runs)
-        .set({ status: "lost", endedAt: now })
-        .where(eq(runs.id, run.id))
-        .run();
-      appendEvent("run_lost", { runId: run.id, jobId: run.jobId });
-    }
-  }
-}

package/src/daemon/runner/runJob.ts

@@ -1,94 +0,0 @@
-import { eq } from "drizzle-orm";
-import { ulid } from "ulid";
-import type openDatabase from "../../db/openDatabase";
-import { jobs, runs } from "../../db/schema";
-import appendEvent from "../../shared/events/appendEvent";
-import type formatJobRow from "../../shared/jobs/formatJobRow";
-import getRunOutputPaths from "../../shared/paths/getRunOutputPaths";
-import createRunOutputFds from "./createRunOutputFds";
-import getRunStatus from "./getRunStatus";
-
-type Db = ReturnType<typeof openDatabase>["orm"];
-type Job = ReturnType<typeof formatJobRow>;
-
-export default function runJob(db: Db, job: Job) {
-  const runId = ulid();
-  const startedAt = new Date().toISOString();
-  const { stdoutPath, stderrPath } = getRunOutputPaths(job.id, runId);
-  const outputs = createRunOutputFds(stdoutPath, stderrPath);
-
-  db.insert(runs)
-    .values({
-      id: runId,
-      jobId: job.id,
-      status: "running",
-      startedAt,
-      stdoutPath,
-      stderrPath,
-    })
-    .run();
-
-  appendEvent("run_started", { jobId: job.id, runId });
-
-  db.update(jobs)
-    .set({ lastRunAt: startedAt, updatedAt: startedAt })
-    .where(eq(jobs.id, job.id))
-    .run();
-
-  const env = job.env ? { ...process.env, ...job.env } : process.env;
-
-  try {
-    const proc = Bun.spawn(job.command, {
-      cwd: job.cwd ?? undefined,
-      env,
-      stdout: outputs.stdoutFd,
-      stderr: outputs.stderrFd,
-      timeout: job.timeoutMs ?? undefined,
-      killSignal: "SIGKILL",
-      onExit: (_proc, exitCode, signalCode, error) => {
-        outputs.close();
-
-        const signal = signalCode ? String(signalCode) : null;
-        const status = getRunStatus(exitCode ?? null, signal);
-
-        const endedAt = new Date().toISOString();
-
-        db.update(runs)
-          .set({
-            status,
-            exitCode: exitCode ?? null,
-            signal,
-            endedAt,
-            errorMessage: error ? error.message : null,
-          })
-          .where(eq(runs.id, runId))
-          .run();
-
-        const eventType =
-          status === "killed"
-            ? "run_killed"
-            : status === "failed"
-              ? "run_failed"
-              : "run_finished";
-        appendEvent(eventType, { jobId: job.id, runId, status });
-      },
-    });
-
-    db.update(runs).set({ pid: proc.pid }).where(eq(runs.id, runId)).run();
-
-    return { runId, exited: proc.exited };
-  } catch (error) {
-    outputs.close();
-
-    const endedAt = new Date().toISOString();
-    const message = error instanceof Error ? error.message : "spawn_failed";
-    db.update(runs)
-      .set({ status: "failed", endedAt, errorMessage: message })
-      .where(eq(runs.id, runId))
-      .run();
-
-    appendEvent("run_failed", { jobId: job.id, runId, status: "failed" });
-
-    return { runId, exited: Promise.resolve(1) };
-  }
-}

package/src/daemon/scheduler/createScheduler.ts

@@ -1,45 +0,0 @@
-import type openDatabase from "../../db/openDatabase";
-import type formatJobRow from "../../shared/jobs/formatJobRow";
-import createSchedulerState from "./createSchedulerState";
-import loadJobs from "./loadJobs";
-import runJobWithTracking from "./runJobWithTracking";
-import scheduleJob from "./scheduleJob";
-import unscheduleJob from "./unscheduleJob";
-
-type Db = ReturnType<typeof openDatabase>["orm"];
-type Job = ReturnType<typeof formatJobRow>;
-
-export default function createScheduler(db: Db) {
-  const state = createSchedulerState();
-  const stop = () => {
-    for (const jobId of state.scheduled.keys()) {
-      unscheduleJob(state, jobId);
-    }
-    state.running.clear();
-  };
-
-  return {
-    start() {
-      stop();
-      const jobs = loadJobs(db);
-      for (const job of jobs) {
-        scheduleJob(state, db, job, (current) => {
-          runJobWithTracking(state, db, current);
-        });
-      }
-    },
-    stop,
-    upsert(job: Job) {
-      unscheduleJob(state, job.id);
-      scheduleJob(state, db, job, (current) => {
-        runJobWithTracking(state, db, current);
-      });
-    },
-    remove(jobId: string) {
-      unscheduleJob(state, jobId);
-    },
-    runNow(job: Job) {
-      return runJobWithTracking(state, db, job);
-    },
-  };
-}

package/src/daemon/scheduler/createSchedulerState.ts

@@ -1,8 +0,0 @@
-import type { Cron } from "croner";
-
-export default function createSchedulerState() {
-  return {
-    scheduled: new Map<string, Cron>(),
-    running: new Set<string>(),
-  };
-}

package/src/daemon/scheduler/loadJobs.ts

@@ -1,10 +0,0 @@
-import type openDatabase from "../../db/openDatabase";
-import { jobs } from "../../db/schema";
-import formatJobRow from "../../shared/jobs/formatJobRow";
-
-type Db = ReturnType<typeof openDatabase>["orm"];
-
-export default function loadJobs(db: Db) {
-  const rows = db.select().from(jobs).all();
-  return rows.map(formatJobRow);
-}

package/src/daemon/scheduler/runJobWithTracking.ts

@@ -1,48 +0,0 @@
-import type openDatabase from "../../db/openDatabase";
-import type formatJobRow from "../../shared/jobs/formatJobRow";
-import recordSkippedRun from "../runner/recordSkippedRun";
-import runJob from "../runner/runJob";
-import type createSchedulerState from "./createSchedulerState";
-import updateNextRunAt from "./updateNextRunAt";
-
-type Db = ReturnType<typeof openDatabase>["orm"];
-type Job = ReturnType<typeof formatJobRow>;
-type SchedulerState = ReturnType<typeof createSchedulerState>;
-
-export default function runJobWithTracking(
-  state: SchedulerState,
-  db: Db,
-  job: Job,
-) {
-  if (state.running.has(job.id) && job.overlapPolicy === "skip") {
-    const runId = recordSkippedRun(db, job);
-    const cron = state.scheduled.get(job.id);
-    if (cron) {
-      updateNextRunAt(db, job.id, cron.nextRun());
-    }
-    return runId;
-  }
-
-  state.running.add(job.id);
-  const result = runJob(db, job);
-
-  result.exited
-    .then(() => {
-      state.running.delete(job.id);
-
-      const cron = state.scheduled.get(job.id);
-      if (cron) {
-        const nextRun = cron.nextRun();
-        updateNextRunAt(db, job.id, nextRun);
-        if (!nextRun) {
-          cron.stop();
-          state.scheduled.delete(job.id);
-        }
-      }
-    })
-    .catch(() => {
-      state.running.delete(job.id);
-    });
-
-  return result.runId;
-}

package/src/daemon/scheduler/scheduleJob.ts

@@ -1,32 +0,0 @@
-import { Cron } from "croner";
-import type openDatabase from "../../db/openDatabase";
-import type formatJobRow from "../../shared/jobs/formatJobRow";
-import type createSchedulerState from "./createSchedulerState";
-import updateNextRunAt from "./updateNextRunAt";
-
-type Db = ReturnType<typeof openDatabase>["orm"];
-type Job = ReturnType<typeof formatJobRow>;
-type SchedulerState = ReturnType<typeof createSchedulerState>;
-
-export default function scheduleJob(
-  state: SchedulerState,
-  db: Db,
-  job: Job,
-  runScheduled: (job: Job) => void,
-) {
-  if (job.paused) {
-    return;
-  }
-
-  const pattern = job.scheduleType === "cron" ? job.cron : job.runAt;
-  if (!pattern) {
-    return;
-  }
-
-  const cron = new Cron(pattern, { timezone: job.timezone ?? undefined }, () =>
-    runScheduled(job),
-  );
-
-  state.scheduled.set(job.id, cron);
-  updateNextRunAt(db, job.id, cron.nextRun());
-}

package/src/daemon/scheduler/unscheduleJob.ts

@@ -1,11 +0,0 @@
-import type createSchedulerState from "./createSchedulerState";
-
-type SchedulerState = ReturnType<typeof createSchedulerState>;
-
-export default function unscheduleJob(state: SchedulerState, jobId: string) {
-  const cron = state.scheduled.get(jobId);
-  if (cron) {
-    cron.stop();
-  }
-  state.scheduled.delete(jobId);
-}

package/src/daemon/scheduler/updateNextRunAt.ts

@@ -1,14 +0,0 @@
-import { eq } from "drizzle-orm";
-import type openDatabase from "../../db/openDatabase";
-import { jobs } from "../../db/schema";
-
-type Db = ReturnType<typeof openDatabase>["orm"];
-
-export default function updateNextRunAt(
-  db: Db,
-  jobId: string,
-  nextRun: Date | null,
-) {
-  const nextRunAt = nextRun ? nextRun.toISOString() : null;
-  db.update(jobs).set({ nextRunAt }).where(eq(jobs.id, jobId)).run();
-}

package/src/daemon/server/createApp.ts

@@ -1,76 +0,0 @@
-import { Hono } from "hono";
-import { z } from "zod";
-import type openDatabase from "../../db/openDatabase";
-import getVersion from "../../shared/version";
-import type createJobsFileSync from "../jobs/createJobsFileSync";
-import type createScheduler from "../scheduler/createScheduler";
-import createAuthMiddleware from "./createAuthMiddleware";
-import registerExportRoute from "./routes/registerExportRoute";
-import registerHealthRoute from "./routes/registerHealthRoute";
-import registerImportRoute from "./routes/registerImportRoute";
-import registerJobRunsRoute from "./routes/registerJobRunsRoute";
-import registerJobsDeleteRoute from "./routes/registerJobsDeleteRoute";
-import registerJobsGetRoute from "./routes/registerJobsGetRoute";
-import registerJobsKillRoute from "./routes/registerJobsKillRoute";
-import registerJobsListRoute from "./routes/registerJobsListRoute";
-import registerJobsPauseRoute from "./routes/registerJobsPauseRoute";
-import registerJobsResetRoute from "./routes/registerJobsResetRoute";
-import registerJobsResumeRoute from "./routes/registerJobsResumeRoute";
-import registerJobsRunRoute from "./routes/registerJobsRunRoute";
-import registerJobsStopRoute from "./routes/registerJobsStopRoute";
-import registerJobsUpsertRoute from "./routes/registerJobsUpsertRoute";
-import registerRunGetRoute from "./routes/registerRunGetRoute";
-import registerRunLogsRoute from "./routes/registerRunLogsRoute";
-import registerShutdownRoute from "./routes/registerShutdownRoute";
-
-const createAppOptionsSchema = z.object({
-  token: z.string().min(1),
-  startedAt: z.string().datetime(),
-  pid: z.number().int().positive(),
-});
-
-type CreateAppOptions = z.infer<typeof createAppOptionsSchema>;
-type Db = ReturnType<typeof openDatabase>["orm"];
-type Scheduler = ReturnType<typeof createScheduler>;
-type JobsFileSync = ReturnType<typeof createJobsFileSync>;
-
-export default function createApp(
-  options: CreateAppOptions,
-  db: Db,
-  scheduler: Scheduler,
-  jobsFileSync: JobsFileSync,
-  shutdown: () => void,
-) {
-  const parsed = createAppOptionsSchema.parse(options);
-  const app = new Hono()
-    .use("*", createAuthMiddleware(parsed.token))
-    .route(
-      "/",
-      registerHealthRoute({
-        status: "ok",
-        startedAt: parsed.startedAt,
-        pid: parsed.pid,
-        version: getVersion(),
-      }),
-    )
-    .route("/", registerShutdownRoute(shutdown))
-    .route("/", registerJobsGetRoute(db))
-    .route("/", registerJobsListRoute(db))
-    .route("/", registerJobRunsRoute(db))
-    .route("/", registerJobsUpsertRoute(db, scheduler, jobsFileSync))
-    .route("/", registerJobsRunRoute(db, scheduler))
-    .route("/", registerJobsPauseRoute(db, scheduler, jobsFileSync))
-    .route("/", registerJobsResumeRoute(db, scheduler, jobsFileSync))
-    .route("/", registerJobsResetRoute(db, scheduler, jobsFileSync))
-    .route("/", registerJobsStopRoute(db))
-    .route("/", registerJobsKillRoute(db))
-    .route("/", registerJobsDeleteRoute(db, scheduler, jobsFileSync))
-    .route("/", registerExportRoute(db, jobsFileSync))
-    .route("/", registerImportRoute(jobsFileSync))
-    .route("/", registerRunGetRoute(db))
-    .route("/", registerRunLogsRoute(db));
-
-  return app;
-}
-
-export type AppType = ReturnType<typeof createApp>;

package/src/daemon/server/createAuthMiddleware.ts

@@ -1,16 +0,0 @@
-import type { MiddlewareHandler } from "hono";
-
-export default function createAuthMiddleware(token: string): MiddlewareHandler {
-  return async (c, next) => {
-    const header = c.req.header("authorization");
-    const value = header?.startsWith("Bearer ")
-      ? header.slice("Bearer ".length)
-      : null;
-
-    if (!value || value !== token) {
-      return c.json({ error: "unauthorized" }, 401);
-    }
-
-    await next();
-  };
-}

package/src/daemon/server/routes/registerExportRoute.ts

@@ -1,21 +0,0 @@
-import { Hono } from "hono";
-import type openDatabase from "../../../db/openDatabase";
-import { jobs } from "../../../db/schema";
-import formatJobRow from "../../../shared/jobs/formatJobRow";
-import serializeJobsToml from "../../../shared/jobs/serializeJobsToml";
-import type createJobsFileSync from "../../jobs/createJobsFileSync";
-
-type Db = ReturnType<typeof openDatabase>["orm"];
-type JobsFileSync = ReturnType<typeof createJobsFileSync>;
-
-export default function registerExportRoute(
-  db: Db,
-  jobsFileSync: JobsFileSync,
-) {
-  return new Hono().post("/export", (c) => {
-    const rows = db.select().from(jobs).all().map(formatJobRow);
-    jobsFileSync.writeFromDb();
-    const toml = serializeJobsToml(rows);
-    return c.json({ toml });
-  });
-}

package/src/daemon/server/routes/registerHealthRoute.ts

@@ -1,16 +0,0 @@
-import { Hono } from "hono";
-import { z } from "zod";
-
-const healthPayloadSchema = z.object({
-  status: z.literal("ok"),
-  startedAt: z.string(),
-  pid: z.number().int(),
-  version: z.string(),
-});
-
-type HealthPayload = z.infer<typeof healthPayloadSchema>;
-
-export default function registerHealthRoute(payload: HealthPayload) {
-  const parsed = healthPayloadSchema.parse(payload);
-  return new Hono().get("/health", (c) => c.json(parsed));
-}

package/src/daemon/server/routes/registerImportRoute.ts

@@ -1,22 +0,0 @@
-import { zValidator } from "@hono/zod-validator";
-import { Hono } from "hono";
-import { z } from "zod";
-import type createJobsFileSync from "../../jobs/createJobsFileSync";
-
-type JobsFileSync = ReturnType<typeof createJobsFileSync>;
-
-const payloadSchema = z.object({
-  toml: z.string().min(1),
-});
-
-export default function registerImportRoute(jobsFileSync: JobsFileSync) {
-  return new Hono().post("/import", zValidator("json", payloadSchema), (c) => {
-    const payload = c.req.valid("json");
-    const result = jobsFileSync.applyFromText(payload.toml);
-    if (!result.ok) {
-      return c.json({ error: "import_failed", message: result.error }, 400);
-    }
-
-    return c.json({ ok: true });
-  });
-}