@robodev-ai/runtime 0.1.0 → 0.3.0

package/src/local-google.ts

@@ -0,0 +1,232 @@
+import { createRemoteJWKSet, jwtVerify, SignJWT, type JWTVerifyGetKey } from "jose";
+
+const LOOPBACK_HOSTS = new Set(["localhost", "127.0.0.1", "[::1]", "::1"]);
+const LOCAL_STATE_TYP = "local_google_oauth_state";
+export const LOCAL_DEV_IDENTITY_TYP = "robodev_local_dev_identity";
+export const LOCAL_DEV_IDENTITY_AUD = "robodev-local-dev";
+const JTI_TTL_MS = 3 * 60 * 1000;
+
+const usedJti = new Map<string, number>();
+
+function invalidRedirect(message: string): Error {
+  return Object.assign(new Error(message), {
+    statusCode: 400,
+    code: "invalid_redirect_uri",
+  });
+}
+
+function invalidAssertion(message = "invalid_assertion"): Error {
+  return Object.assign(new Error(message), {
+    statusCode: 400,
+    code: "invalid_assertion",
+  });
+}
+
+function parseLoopbackUrl(raw: string): URL {
+  let url: URL;
+  try {
+    url = new URL(raw);
+  } catch {
+    throw invalidRedirect("redirect_uri is not a valid URL");
+  }
+  if (url.username || url.password) {
+    throw invalidRedirect("redirect_uri must not include credentials");
+  }
+  if (!LOOPBACK_HOSTS.has(url.hostname)) {
+    throw invalidRedirect("redirect_uri must be a loopback host");
+  }
+  url.hash = "";
+  return url;
+}
+
+/** http-only loopback URL. Starbase bounce target. */
+export function assertLocalBrokerRedirectUri(raw: string): string {
+  const url = parseLoopbackUrl(raw);
+  if (url.protocol !== "http:") {
+    throw invalidRedirect("callback_uri must be http on a loopback host");
+  }
+  return url.toString();
+}
+
+/** Loopback http or https. Local app `redirect_uri` (Vite may be https). */
+export function assertLocalAppRedirectUri(raw: string): string {
+  const url = parseLoopbackUrl(raw);
+  if (url.protocol !== "http:" && url.protocol !== "https:") {
+    throw invalidRedirect("redirect_uri must be http or https on a loopback host");
+  }
+  return url.toString();
+}
+
+export function localGoogleCallbackUri(listenOrigin: string): string {
+  return `${listenOrigin.replace(/\/$/, "")}/api/user/auth/google/callback`;
+}
+
+export function projectGoogleOverrideMode(
+  clientId?: string,
+  clientSecret?: string,
+): "both" | "one" | "none" {
+  const id = clientId?.trim() ?? "";
+  const secret = clientSecret?.trim() ?? "";
+  if (id && secret) return "both";
+  if (id || secret) return "one";
+  return "none";
+}
+
+export function brokerDevStartUrl(
+  brokerBaseUrl: string,
+  input: { callbackUri: string; redirectUri: string },
+): string {
+  const url = new URL(`${brokerBaseUrl.replace(/\/$/, "")}/internal/auth/google/dev`);
+  url.searchParams.set("callback_uri", input.callbackUri);
+  url.searchParams.set("redirect_uri", input.redirectUri);
+  return url.toString();
+}
+
+export function redirectWithQuery(redirectUri: string, params: Record<string, string>): string {
+  const url = new URL(redirectUri);
+  for (const [key, value] of Object.entries(params)) {
+    url.searchParams.set(key, value);
+  }
+  return url.toString();
+}
+
+/** Google authorize URL with a caller-supplied redirect (local override). */
+export function localGoogleAuthorizeUrl(
+  state: string,
+  creds: { clientId: string; redirectUri: string },
+): string {
+  const url = new URL("https://accounts.google.com/o/oauth2/v2/auth");
+  url.searchParams.set("client_id", creds.clientId);
+  url.searchParams.set("redirect_uri", creds.redirectUri);
+  url.searchParams.set("response_type", "code");
+  url.searchParams.set("scope", "openid email profile");
+  url.searchParams.set("state", state);
+  url.searchParams.set("prompt", "select_account");
+  return url.toString();
+}
+
+export async function exchangeLocalGoogleCode(
+  code: string,
+  creds: { clientId: string; clientSecret: string; redirectUri: string },
+): Promise<{ email: string; name: string | null; subject: string }> {
+  const body = new URLSearchParams({
+    code,
+    client_id: creds.clientId,
+    client_secret: creds.clientSecret,
+    redirect_uri: creds.redirectUri,
+    grant_type: "authorization_code",
+  });
+  const tokenRes = await fetch("https://oauth2.googleapis.com/token", {
+    method: "POST",
+    headers: { "Content-Type": "application/x-www-form-urlencoded" },
+    body,
+  });
+  if (!tokenRes.ok) {
+    throw new Error("google token exchange failed");
+  }
+  const tokens = (await tokenRes.json()) as { access_token?: string };
+  if (!tokens.access_token) {
+    throw new Error("google token exchange failed");
+  }
+  const profileRes = await fetch("https://www.googleapis.com/oauth2/v2/userinfo", {
+    headers: { Authorization: `Bearer ${tokens.access_token}` },
+  });
+  if (!profileRes.ok) {
+    throw new Error("google profile failed");
+  }
+  const profile = (await profileRes.json()) as {
+    id?: string;
+    email?: string;
+    name?: string;
+  };
+  if (!profile.email || !profile.id) {
+    throw new Error("google profile missing email");
+  }
+  return {
+    email: profile.email,
+    name: profile.name?.trim() || null,
+    subject: profile.id,
+  };
+}
+
+export async function signLocalGoogleState(
+  jwtSecret: string,
+  redirectUri: string,
+): Promise<string> {
+  return new SignJWT({ typ: LOCAL_STATE_TYP, redirectUri })
+    .setProtectedHeader({ alg: "HS256" })
+    .setIssuedAt()
+    .setExpirationTime("10m")
+    .sign(new TextEncoder().encode(jwtSecret));
+}
+
+export async function verifyLocalGoogleState(
+  jwtSecret: string,
+  token: string,
+): Promise<{ redirectUri: string }> {
+  const { payload } = await jwtVerify(token, new TextEncoder().encode(jwtSecret));
+  if (payload.typ !== LOCAL_STATE_TYP || typeof payload.redirectUri !== "string") {
+    throw new Error("invalid local google oauth state");
+  }
+  return { redirectUri: payload.redirectUri };
+}
+
+function pruneUsedJti(now: number): void {
+  for (const [jti, expires] of usedJti) {
+    if (expires <= now) usedJti.delete(jti);
+  }
+}
+
+export function resetLocalDevAssertionReplayForTests(): void {
+  usedJti.clear();
+}
+
+export async function verifyLocalDevIdentityAssertion(
+  assertion: string,
+  options: {
+    brokerBaseUrl: string;
+    callbackUri: string;
+    jwks?: JWTVerifyGetKey;
+  },
+): Promise<{
+  email: string;
+  name: string | null;
+  googleSubject: string;
+  redirectUri: string;
+}> {
+  const issuer = options.brokerBaseUrl.replace(/\/$/, "");
+  const jwks = options.jwks ?? createRemoteJWKSet(new URL(`${issuer}/internal/auth/jwks.json`));
+  const { payload } = await jwtVerify(assertion, jwks, {
+    issuer,
+    audience: LOCAL_DEV_IDENTITY_AUD,
+  });
+  if (payload.typ !== LOCAL_DEV_IDENTITY_TYP) {
+    throw invalidAssertion();
+  }
+  if (payload.callback_uri !== options.callbackUri) {
+    throw invalidAssertion();
+  }
+  if (typeof payload.email !== "string" || typeof payload.google_subject !== "string") {
+    throw invalidAssertion();
+  }
+  if (typeof payload.redirect_uri !== "string") {
+    throw invalidAssertion();
+  }
+  const redirectUri = assertLocalAppRedirectUri(payload.redirect_uri);
+  const jti = payload.jti;
+  if (typeof jti !== "string" || !jti) {
+    throw invalidAssertion();
+  }
+  const now = Date.now();
+  pruneUsedJti(now);
+  if (usedJti.has(jti)) {
+    throw invalidAssertion();
+  }
+  usedJti.set(jti, now + JTI_TTL_MS);
+  return {
+    email: payload.email.toLowerCase(),
+    name: typeof payload.name === "string" ? payload.name : null,
+    googleSubject: payload.google_subject,
+    redirectUri,
+  };
+}

package/src/local-jobs.test.ts

@@ -0,0 +1,448 @@
+import assert from "node:assert/strict";
+import { test } from "node:test";
+import type { JobDefinition, JobHandlerContext, RobodevDb } from "@robodev-ai/sdk";
+import { JOB_KIND } from "@robodev-ai/sdk";
+import { nextRunAfter } from "./cron.js";
+import type { RouteClients } from "./invoke.js";
+import { JOB_MAX_ATTEMPTS, JOB_PAYLOAD_MAX_BYTES } from "./job-queue.js";
+import {
+  createLocalJobsEngine,
+  ensureJobsSchema,
+  type JobsQueryable,
+  type LocalCronRow,
+  type LocalJobRow,
+  type LocalJobsGeneration,
+} from "./local-jobs.js";
+
+function jobDef(
+  handler: (ctx: JobHandlerContext) => Promise<unknown> | unknown,
+  extras: { timeoutMs?: number; cron?: string } = {},
+): JobDefinition {
+  return { _kind: JOB_KIND, handler, ...extras };
+}
+
+function unavailable(feature: string): never {
+  throw new Error(`ctx.${feature} needs hosted Starbase. Run robodev deploy to use it.`);
+}
+
+function mockClients(): RouteClients {
+  return {
+    email: {
+      async send() {
+        return { id: "local_mail", status: "sent" };
+      },
+    },
+    llm: { complete: () => unavailable("llm"), stream: () => unavailable("llm") },
+    agent: {
+      createSession: () => unavailable("agent"),
+      start: () => unavailable("agent"),
+      events: () => unavailable("agent"),
+      subscribe: () => unavailable("agent"),
+      destroy: () => unavailable("agent"),
+    },
+    storage: {
+      upload: () => unavailable("storage"),
+      get: () => unavailable("storage"),
+      getUrl: () => unavailable("storage"),
+      delete: () => unavailable("storage"),
+      list: () => unavailable("storage"),
+    },
+    push: { send: () => unavailable("push") },
+    jobs: { enqueue: async () => ({ id: "nested" }) },
+    sockets: {
+      send: () => unavailable("sockets"),
+      broadcast: () => unavailable("sockets"),
+    },
+    env: {},
+  };
+}
+
+function memoryJobs() {
+  const jobs: LocalJobRow[] = [];
+  const crons: LocalCronRow[] = [];
+  const now = () => new Date();
+
+  const query: JobsQueryable["query"] = async (text, values = []) => {
+    const sql = text.replace(/\s+/g, " ").trim();
+    if (/^(CREATE SCHEMA|CREATE TABLE|CREATE INDEX)/.test(sql)) return { rows: [] };
+
+    if (sql.includes("INSERT INTO robodev_jobs.jobs")) {
+      const created = now();
+      jobs.push({
+        id: String(values[0]),
+        name: String(values[1]),
+        payload_json: String(values[2]),
+        status: "queued",
+        attempts: 0,
+        max_attempts: Number(values[3]),
+        run_at: values[4] as Date,
+        last_error: null,
+        created_at: created,
+        updated_at: created,
+      });
+      return { rows: [] };
+    }
+
+    if (sql.includes("FOR UPDATE SKIP LOCKED")) {
+      const due = jobs
+        .filter((row) => row.status === "queued" && row.run_at.getTime() <= Date.now())
+        .sort((a, b) => a.run_at.getTime() - b.run_at.getTime())[0];
+      if (!due) return { rows: [] };
+      due.status = "running";
+      due.updated_at = now();
+      return { rows: [{ ...due }] };
+    }
+
+    if (sql.includes("SET status = 'succeeded'")) {
+      const row = jobs.find((entry) => entry.id === values[0]);
+      if (row) {
+        row.status = "succeeded";
+        row.last_error = null;
+        row.updated_at = now();
+      }
+      return { rows: [] };
+    }
+
+    if (sql.includes("run_at = COALESCE")) {
+      const row = jobs.find((entry) => entry.id === values[0]);
+      if (row) {
+        row.status = values[1] as LocalJobRow["status"];
+        row.attempts = Number(values[2]);
+        row.last_error = (values[3] as string | null) ?? null;
+        if (values[4]) row.run_at = values[4] as Date;
+        row.updated_at = now();
+      }
+      return { rows: [] };
+    }
+
+    if (sql.includes("WHERE status = 'running'") && sql.includes("SET status = 'queued'")) {
+      for (const row of jobs) {
+        if (row.status === "running") {
+          row.status = "queued";
+          row.updated_at = now();
+        }
+      }
+      return { rows: [] };
+    }
+
+    if (sql.includes("INSERT INTO robodev_jobs.crons")) {
+      crons.push({
+        job_name: String(values[0]),
+        cron: String(values[1]),
+        next_run_at: values[2] as Date,
+      });
+      return { rows: [] };
+    }
+
+    if (sql.includes("FROM robodev_jobs.crons") && sql.includes("WHERE next_run_at <=")) {
+      const at = values[0] as Date;
+      return {
+        rows: crons
+          .filter((row) => row.next_run_at.getTime() <= at.getTime())
+          .sort((a, b) => a.next_run_at.getTime() - b.next_run_at.getTime())
+          .slice(0, 50),
+      };
+    }
+
+    if (sql.includes("FROM robodev_jobs.crons") && sql.includes("SELECT job_name")) {
+      return { rows: [...crons] };
+    }
+
+    if (sql.includes("UPDATE robodev_jobs.crons") && sql.includes("SET cron")) {
+      const row = crons.find((entry) => entry.job_name === values[0]);
+      if (row) {
+        row.cron = String(values[1]);
+        row.next_run_at = values[2] as Date;
+      }
+      return { rows: [] };
+    }
+
+    if (sql.includes("UPDATE robodev_jobs.crons") && sql.includes("SET next_run_at")) {
+      const row = crons.find((entry) => entry.job_name === values[0]);
+      if (row) row.next_run_at = values[1] as Date;
+      return { rows: [] };
+    }
+
+    if (sql.includes("DELETE FROM robodev_jobs.crons")) {
+      const keep = new Set(values[0] as string[]);
+      for (let i = crons.length - 1; i >= 0; i--) {
+        if (!keep.has(crons[i]!.job_name)) crons.splice(i, 1);
+      }
+      return { rows: [] };
+    }
+
+    throw new Error(`unexpected query: ${sql}`);
+  };
+
+  return { jobs, crons, query };
+}
+
+async function waitUntil(pred: () => boolean, ms = 1000): Promise<void> {
+  const start = Date.now();
+  while (!pred()) {
+    if (Date.now() - start > ms) throw new Error("timed out waiting");
+    await new Promise((resolve) => setImmediate(resolve));
+  }
+}
+
+function engineFor(
+  store: ReturnType<typeof memoryJobs>,
+  jobs: LocalJobsGeneration["jobs"],
+  logs: string[] = [],
+) {
+  const generation: LocalJobsGeneration = { db: {} as RobodevDb, jobs };
+  return createLocalJobsEngine({
+    query: store.query,
+    getGeneration: () => generation,
+    log: (line) => logs.push(line),
+    clients: mockClients,
+  });
+}
+
+test("ensureJobsSchema is idempotent SQL", async () => {
+  const store = memoryJobs();
+  await ensureJobsSchema({ query: store.query });
+  await ensureJobsSchema({ query: store.query });
+});
+
+test("enqueue known job; unknown and oversize throw without insert", async () => {
+  const store = memoryJobs();
+  const engine = engineFor(store, [{ name: "digest", def: jobDef(() => undefined) }]);
+  const queued = await engine.enqueue({ name: "digest", payload: { ok: true } });
+  assert.match(queued.id, /^job_/);
+  assert.equal(store.jobs.length, 1);
+  assert.equal(JSON.parse(store.jobs[0]!.payload_json).ok, true);
+
+  await assert.rejects(() => engine.enqueue({ name: "missing" }), /Unknown job name: missing/);
+  await assert.rejects(
+    () => engine.enqueue({ name: "digest", payload: "x".repeat(JOB_PAYLOAD_MAX_BYTES) }),
+    /job payload must be at most 256KB/,
+  );
+  assert.equal(store.jobs.length, 1);
+});
+
+test("successful handler marks succeeded and logs", async () => {
+  const store = memoryJobs();
+  const logs: string[] = [];
+  const seen: unknown[] = [];
+  const engine = engineFor(
+    store,
+    [{ name: "digest", def: jobDef((ctx) => seen.push(ctx.payload)) }],
+    logs,
+  );
+  await engine.enqueue({ name: "digest", payload: { n: 1 } });
+  await engine.tickJobs();
+  await waitUntil(() => store.jobs[0]?.status === "succeeded" && logs.length > 0);
+  assert.deepEqual(seen, [{ n: 1 }]);
+  assert.equal(logs[0], "  digest succeeded");
+});
+
+test("throw backs off then dead at 5", async () => {
+  const store = memoryJobs();
+  const logs: string[] = [];
+  const engine = engineFor(
+    store,
+    [
+      {
+        name: "digest",
+        def: jobDef(() => {
+          throw new Error("boom");
+        }),
+      },
+    ],
+    logs,
+  );
+  await engine.enqueue({ name: "digest" });
+  for (let attempt = 1; attempt <= JOB_MAX_ATTEMPTS; attempt++) {
+    store.jobs[0]!.run_at = new Date(0);
+    store.jobs[0]!.status = "queued";
+    await engine.tickJobs();
+    await waitUntil(() => store.jobs[0]!.status !== "running");
+  }
+  assert.equal(store.jobs[0]?.status, "dead");
+  assert.equal(store.jobs[0]?.attempts, 5);
+  assert.equal(store.jobs[0]?.last_error, "boom");
+  assert.match(logs[0] ?? "", /failed attempt 1\/5: boom/);
+  assert.match(logs.at(-1) ?? "", /digest dead: boom/);
+});
+
+test("timeout is handler_timeout and retries", async () => {
+  const store = memoryJobs();
+  const logs: string[] = [];
+  const engine = engineFor(
+    store,
+    [
+      {
+        name: "slow",
+        def: jobDef(() => new Promise((resolve) => setTimeout(resolve, 50)), { timeoutMs: 10 }),
+      },
+    ],
+    logs,
+  );
+  await engine.enqueue({ name: "slow" });
+  await engine.tickJobs();
+  await waitUntil(() => store.jobs[0]?.last_error === "handler_timeout");
+  assert.equal(store.jobs[0]?.status, "queued");
+  assert.equal(store.jobs[0]?.last_error, "handler_timeout");
+  assert.match(logs[0] ?? "", /failed attempt 1\/5: handler_timeout/);
+});
+
+test("reconcile keeps unchanged next_run, reschedules, and deletes", async () => {
+  const now = new Date("2026-01-01T00:00:00.000Z");
+  const keptNext = new Date("2026-01-01T01:00:00.000Z");
+  const store = memoryJobs();
+  store.crons.push(
+    { job_name: "hourly", cron: "0 * * * *", next_run_at: keptNext },
+    { job_name: "stale", cron: "0 0 * * *", next_run_at: new Date("2026-01-02T00:00:00.000Z") },
+    { job_name: "daily", cron: "0 0 * * *", next_run_at: new Date("2026-01-02T00:00:00.000Z") },
+  );
+  const engine = engineFor(store, []);
+  await engine.reconcile(
+    [
+      { name: "hourly", def: { cron: "0 * * * *" } },
+      { name: "daily", def: { cron: "0 12 * * *" } },
+      { name: "fresh", def: { cron: "*/5 * * * *" } },
+    ],
+    now,
+  );
+  const byName = Object.fromEntries(store.crons.map((row) => [row.job_name, row]));
+  assert.equal(store.crons.length, 3);
+  assert.equal(byName.hourly?.next_run_at, keptNext);
+  assert.equal(byName.daily?.cron, "0 12 * * *");
+  assert.deepEqual(byName.daily?.next_run_at, nextRunAfter("0 12 * * *", now));
+  assert.deepEqual(byName.fresh?.next_run_at, nextRunAfter("*/5 * * * *", now));
+  assert.equal(byName.stale, undefined);
+});
+
+test("removing cron deletes the row", async () => {
+  const store = memoryJobs();
+  store.crons.push({
+    job_name: "hourly",
+    cron: "0 * * * *",
+    next_run_at: new Date("2026-01-01T01:00:00.000Z"),
+  });
+  const engine = engineFor(store, []);
+  await engine.reconcile([{ name: "hourly", def: {} }]);
+  assert.equal(store.crons.length, 0);
+});
+
+test("tick enqueues null payload, advances first, and does not roll back", async () => {
+  const now = new Date("2026-01-01T00:00:00.000Z");
+  const store = memoryJobs();
+  store.crons.push({ job_name: "hourly", cron: "0 * * * *", next_run_at: now });
+  const events: string[] = [];
+  const engine = createLocalJobsEngine({
+    query: async (text, values) => {
+      if (text.includes("UPDATE robodev_jobs.crons") && text.includes("SET next_run_at")) {
+        events.push("advance");
+      }
+      if (text.includes("INSERT INTO robodev_jobs.jobs")) events.push("enqueue");
+      return store.query(text, values);
+    },
+    getGeneration: () => ({
+      db: {} as RobodevDb,
+      jobs: [{ name: "hourly", def: jobDef(() => undefined) }],
+    }),
+    clients: mockClients,
+  });
+  await engine.tickDue(now);
+  assert.deepEqual(events, ["advance", "enqueue"]);
+  assert.equal(JSON.parse(store.jobs[0]!.payload_json), null);
+  assert.deepEqual(store.crons[0]?.next_run_at, nextRunAfter("0 * * * *", now));
+
+  const failStore = memoryJobs();
+  failStore.crons.push({ job_name: "hourly", cron: "0 * * * *", next_run_at: now });
+  const failing = createLocalJobsEngine({
+    query: failStore.query,
+    getGeneration: () => ({ db: {} as RobodevDb, jobs: [] }),
+    clients: mockClients,
+  });
+  await failing.tickDue(now);
+  assert.equal(failStore.jobs.length, 0);
+  assert.deepEqual(failStore.crons[0]?.next_run_at, nextRunAfter("0 * * * *", now));
+});
+
+test("overlap piles up queued rows", async () => {
+  const now = new Date("2026-01-01T00:00:00.000Z");
+  const store = memoryJobs();
+  store.crons.push({ job_name: "hourly", cron: "0 * * * *", next_run_at: now });
+  const engine = engineFor(store, [{ name: "hourly", def: jobDef(() => undefined) }]);
+  await engine.tickDue(now);
+  store.crons[0]!.next_run_at = now;
+  await engine.tickDue(now);
+  assert.equal(store.jobs.length, 2);
+  assert.equal(
+    store.jobs.every((row) => row.status === "queued"),
+    true,
+  );
+});
+
+test("missing handler is route_not_found", async () => {
+  const store = memoryJobs();
+  const logs: string[] = [];
+  const engine = engineFor(store, [], logs);
+  store.jobs.push({
+    id: "job_ghost",
+    name: "gone",
+    payload_json: "null",
+    status: "queued",
+    attempts: 0,
+    max_attempts: 5,
+    run_at: new Date(0),
+    last_error: null,
+    created_at: new Date(),
+    updated_at: new Date(),
+  });
+  await engine.tickJobs();
+  await waitUntil(() => store.jobs[0]?.last_error === "route_not_found");
+});
+
+test("hosted-only clients still throw in job handlers; email is real", async () => {
+  const store = memoryJobs();
+  const seen: string[] = [];
+  const engine = engineFor(store, [
+    {
+      name: "probe",
+      def: jobDef(async (ctx) => {
+        await ctx.email.send({ to: "a@b.c", subject: "hi" });
+        seen.push("email");
+        try {
+          await ctx.llm.complete({ messages: [{ role: "user", content: "x" }] });
+        } catch (error) {
+          seen.push((error as Error).message);
+        }
+      }),
+    },
+  ]);
+  await engine.enqueue({ name: "probe" });
+  await engine.tickJobs();
+  await waitUntil(() => store.jobs[0]?.status === "succeeded");
+  assert.equal(seen[0], "email");
+  assert.match(seen[1] ?? "", /ctx\.llm needs hosted Starbase/);
+});
+
+test("start resets running rows; stop clears timers", async () => {
+  const store = memoryJobs();
+  store.jobs.push({
+    id: "job_stuck",
+    name: "digest",
+    payload_json: "null",
+    status: "running",
+    attempts: 1,
+    max_attempts: 5,
+    run_at: new Date(),
+    last_error: null,
+    created_at: new Date(),
+    updated_at: new Date(),
+  });
+  const engine = engineFor(store, [{ name: "digest", def: jobDef(() => undefined) }]);
+  assert.equal(engine.running, false);
+  await engine.start();
+  assert.equal(store.jobs[0]?.status, "queued");
+  assert.equal(engine.running, true);
+  await engine.start();
+  assert.equal(engine.running, true);
+  await engine.stop();
+  assert.equal(engine.running, false);
+  await engine.stop();
+});