kempo 4.6.2 → 4.8.0

package/server/utils/menus/markup.js

@@ -0,0 +1,55 @@
+const escapeHtml = value => String(value)
+  .replace(/&/g, '&')
+  .replace(/</g, '&lt;')
+  .replace(/>/g, '&gt;')
+  .replace(/"/g, '&quot;');
+
+const unescapeHtml = value => String(value)
+  .replace(/&quot;/g, '"')
+  .replace(/&lt;/g, '<')
+  .replace(/&gt;/g, '>')
+  .replace(/&amp;/g, '&');
+
+const UNSAFE_HREF = /^\s*(javascript|data|vbscript):/i;
+const ICON_NAME = /^[\w-]+$/;
+
+/*
+  A menu item is stored as nothing more than one link, so the entry stays plain global content that
+  any template renders without knowing about menus. This reads that link back into its fields, and
+  returns null for markup that is anything more than a link with an optional icon.
+*/
+export const parseLink = markup => {
+  const match = /^<a\s((?:[^>"']|"[^"]*"|'[^']*')*)>([\s\S]*)<\/a>$/.exec(String(markup || '').trim());
+  if(!match || /<a[\s>]/.test(match[2])) return null;
+
+  const attrs = {};
+  const attrRegex = /(\w[\w-]*)=(?:"([^"]*)"|'([^']*)')/g;
+  let a;
+  while((a = attrRegex.exec(match[1])) !== null) attrs[a[1]] = a[2] ?? a[3];
+  if(attrs.href === undefined) return null;
+
+  const icon = /^\s*<k-icon\s+name="([\w-]+)"\s*><\/k-icon>/.exec(match[2]);
+  const rest = icon ? match[2].slice(icon[0].length) : match[2];
+  if(/</.test(rest)) return null;
+
+  return {
+    label: unescapeHtml(rest.trim()),
+    href: unescapeHtml(attrs.href),
+    icon: icon ? icon[1] : '',
+    newTab: attrs.target === '_blank'
+  };
+};
+
+/*
+  Returns [error, markup], with the same error shape as the rest of the server utils.
+*/
+export const buildLink = ({ label, href, icon, newTab }) => {
+  if(!String(label || '').trim()) return [{ code: 400, msg: 'Label is required' }, null];
+  if(!String(href || '').trim()) return [{ code: 400, msg: 'Link is required' }, null];
+  if(UNSAFE_HREF.test(href)) return [{ code: 400, msg: 'That link is not allowed' }, null];
+  if(icon && !ICON_NAME.test(icon)) return [{ code: 400, msg: 'Icon names use letters, numbers, dashes and underscores' }, null];
+
+  const target = newTab ? ' target="_blank" rel="noopener"' : '';
+  const iconMarkup = icon ? `<k-icon name="${icon}"></k-icon> ` : '';
+  return [null, `<a href="${escapeHtml(href.trim())}"${target}>${iconMarkup}${escapeHtml(label.trim())}</a>`];
+};

package/server/utils/menus/reorderMenuItems.js

@@ -0,0 +1,36 @@
+import { readStores, writeStores, isMenuItem } from './store.js';
+import triggerHook from '../hooks/triggerHook.js';
+
+/*
+  `ids` are a menu's items in the order they should now render. They take over the priorities those
+  same items already held, so the priorities stay in the range they were in. Priorities that were
+  equal are separated by one each, because equal ones have no order to keep.
+*/
+export default async ({ rootDir, menuId, ids, extensionDirs }) => {
+  if(!rootDir){
+    return [{ code: 400, msg: 'Root directory is required' }, null];
+  }
+  if(!menuId || !Array.isArray(ids) || !ids.length){
+    return [{ code: 400, msg: 'A menu and the item order are required' }, null];
+  }
+
+  const stores = await readStores(rootDir);
+  const items = ids.map(id => [...stores.active, ...stores.disabled].find(e => e.id === id && isMenuItem(e) && e.menu === menuId));
+  if(items.includes(undefined) || new Set(ids).size !== ids.length){
+    return [{ code: 404, msg: 'Menu item not found' }, null];
+  }
+
+  const slots = items.map(e => e.priority).sort((a, b) => b - a);
+  for(let i = 1; i < slots.length; i++) slots[i] = Math.min(slots[i], slots[i - 1] - 1);
+
+  const now = new Date().toISOString();
+  items.forEach((entry, i) => {
+    if(entry.priority === slots[i]) return;
+    entry.priority = slots[i];
+    entry.updatedAt = now;
+  });
+  await writeStores(rootDir, stores, extensionDirs);
+  await triggerHook('globalContent:updated', { id: ids[0], updatedAt: now });
+
+  return [null, { ids }];
+};

package/server/utils/menus/saveMenu.js

@@ -0,0 +1,54 @@
+import crypto from 'crypto';
+import { readStores, writeStores, menuHome, isMenuDefinition } from './store.js';
+import triggerHook from '../hooks/triggerHook.js';
+
+/*
+  Creates a menu, or renames one when `id` is given. A new menu is not shown anywhere until it is
+  assigned to a location.
+*/
+export default async ({ rootDir, id, name, author, extensionDirs }) => {
+  if(!rootDir){
+    return [{ code: 400, msg: 'Root directory is required' }, null];
+  }
+  if(!String(name || '').trim()){
+    return [{ code: 400, msg: 'Name is required' }, null];
+  }
+
+  const stores = await readStores(rootDir);
+  const now = new Date().toISOString();
+
+  if(id){
+    const definition = stores.active.find(e => e.id === id && isMenuDefinition(e));
+    if(!definition){
+      return [{ code: 404, msg: 'Menu not found' }, null];
+    }
+    definition.name = name.trim();
+    definition.updatedAt = now;
+    await writeStores(rootDir, stores, extensionDirs);
+    await triggerHook('globalContent:updated', { id, updatedAt: now });
+    return [null, { id }];
+  }
+
+  const menuId = crypto.randomUUID();
+  stores.active.push({
+    id: menuId,
+    name: name.trim(),
+    owner: 'custom',
+    author: author || '',
+    locked: false,
+    menu: menuId,
+    menuLocations: [],
+    menuCopyOf: '',
+    navItem: '',
+    extra: {},
+    location: menuHome(menuId),
+    priority: 0,
+    createdAt: now,
+    updatedAt: now,
+    markup: ''
+  });
+  await writeStores(rootDir, stores, extensionDirs);
+  await triggerHook('globalContent:created', { id: menuId, name: name.trim(), location: menuHome(menuId) });
+
+  return [null, { id: menuId }];
+};

package/server/utils/menus/saveMenuItem.js

@@ -0,0 +1,122 @@
+import crypto from 'crypto';
+import { buildLink } from './markup.js';
+import { readStores, writeStores, menuHome, isMenuItem, isMenuDefinition } from './store.js';
+import findMenuLocations from './findMenuLocations.js';
+import findNavItems from './findNavItems.js';
+import triggerHook from '../hooks/triggerHook.js';
+
+/*
+  Adds an item to a menu, or changes one when `id` is given. A new item goes to the end of the menu: its
+  priority is one below the lowest in that menu (items render highest first).
+
+  An item is a link (`label`, `href`, ...) or one an extension supplies, named by `navItem`
+  (`<extension>:<id>`, from findNavItems), which takes its label and markup from the extension.
+
+  A new item can name the `menuId` to join, or just the `location` it should show in. For a location,
+  it joins the menu shown there; when there is none, one is made, named after the location, and shown
+  there. That is what lets an item be added to "Main menu" without making a menu first.
+*/
+export default async ({ rootDir, id, menuId, location, navItem, label, href, icon, newTab, author, extensionDirs }) => {
+  if(!rootDir){
+    return [{ code: 400, msg: 'Root directory is required' }, null];
+  }
+
+  let name;
+  let markup;
+  if(navItem){
+    const supplied = (await findNavItems({ extensionDirs }))[1].find(item => item.key === navItem);
+    if(!supplied){
+      return [{ code: 404, msg: 'That item is not available. Its extension may be disabled or removed.' }, null];
+    }
+    name = supplied.label;
+    markup = supplied.markup;
+  } else {
+    const [linkError, linkMarkup] = buildLink({ label, href, icon, newTab });
+    if(linkError){
+      return [linkError, null];
+    }
+    name = label.trim();
+    markup = linkMarkup;
+  }
+
+  const stores = await readStores(rootDir);
+  const now = new Date().toISOString();
+
+  if(id){
+    const entry = [...stores.active, ...stores.disabled].find(e => e.id === id && isMenuItem(e));
+    if(!entry){
+      return [{ code: 404, msg: 'Menu item not found' }, null];
+    }
+    if(entry.navItem){
+      return [{ code: 400, msg: 'An item from an extension cannot be edited. Delete it and add it again to change it.' }, null];
+    }
+    if(entry.locked){
+      return [{ code: 403, msg: 'This item is locked and cannot be edited' }, null];
+    }
+    entry.name = name;
+    entry.markup = markup;
+    entry.updatedAt = now;
+    await writeStores(rootDir, stores, extensionDirs);
+    await triggerHook('globalContent:updated', { id, updatedAt: now });
+    return [null, { id, updatedAt: now }];
+  }
+
+  let target = menuId
+    ? stores.active.find(e => e.id === menuId && isMenuDefinition(e))
+    : stores.active.find(e => isMenuDefinition(e) && e.menuLocations.includes(location));
+
+  if(!target && !menuId && location){
+    const [, declared] = await findMenuLocations({ rootDir });
+    const place = declared.find(l => l.location === location);
+    if(!place){
+      return [{ code: 400, msg: 'That place is not a menu in the theme' }, null];
+    }
+    const newId = crypto.randomUUID();
+    target = {
+      id: newId,
+      name: place.label,
+      owner: 'custom',
+      author: author || '',
+      locked: false,
+      menu: newId,
+      menuLocations: [location],
+      menuCopyOf: '',
+      navItem: '',
+      extra: {},
+      location: menuHome(newId),
+      priority: 0,
+      createdAt: now,
+      updatedAt: now,
+      markup: ''
+    };
+    stores.active.push(target);
+  }
+
+  if(!target){
+    return [{ code: 404, msg: 'Menu not found' }, null];
+  }
+
+  const siblings = [...stores.active, ...stores.disabled].filter(e => isMenuItem(e) && e.menu === target.id);
+  const entry = {
+    id: crypto.randomUUID(),
+    name,
+    owner: 'custom',
+    author: author || '',
+    locked: false,
+    menu: target.id,
+    menuLocations: null,
+    menuCopyOf: '',
+    navItem: navItem || '',
+    extra: {},
+    location: menuHome(target.id),
+    priority: siblings.length ? Math.min(...siblings.map(e => e.priority)) - 1 : 100,
+    createdAt: now,
+    updatedAt: now,
+    markup
+  };
+  stores.active.push(entry);
+  await writeStores(rootDir, stores, extensionDirs);
+  await triggerHook('globalContent:created', { id: entry.id, name: entry.name, location: entry.location });
+
+  return [null, { id: entry.id, menuId: target.id, priority: entry.priority }];
+};

package/server/utils/menus/setMenuItemEnabled.js

@@ -0,0 +1,31 @@
+import { readStores, writeStores, isMenuItem } from './store.js';
+import triggerHook from '../hooks/triggerHook.js';
+
+/*
+  Hides an item from its menu without deleting it, or shows it again.
+*/
+export default async ({ rootDir, id, enabled, extensionDirs }) => {
+  if(!rootDir){
+    return [{ code: 400, msg: 'Root directory is required' }, null];
+  }
+  if(!id || typeof enabled !== 'boolean'){
+    return [{ code: 400, msg: 'An item and whether it is enabled are required' }, null];
+  }
+
+  const stores = await readStores(rootDir);
+  const [from, to] = enabled ? [stores.disabled, stores.active] : [stores.active, stores.disabled];
+  const index = from.findIndex(e => e.id === id && isMenuItem(e));
+  if(index === -1){
+    const already = to.some(e => e.id === id && isMenuItem(e));
+    return already ? [null, { id, enabled }] : [{ code: 404, msg: 'Menu item not found' }, null];
+  }
+  if(from[index].locked){
+    return [{ code: 403, msg: 'A locked item cannot be hidden' }, null];
+  }
+
+  to.push(...from.splice(index, 1));
+  await writeStores(rootDir, stores, extensionDirs);
+  await triggerHook('globalContent:updated', { id, updatedAt: new Date().toISOString() });
+
+  return [null, { id, enabled }];
+};

package/server/utils/menus/store.js

@@ -0,0 +1,90 @@
+import { readFile, writeFile } from 'fs/promises';
+import { join } from 'path';
+import { existsSync } from 'fs';
+import { GLOBAL_FILE, GLOBAL_DISABLED_FILE, parseEntries, serializeEntries } from '../global-content/helpers.js';
+import findNavItems from './findNavItems.js';
+
+const read = async path => existsSync(path) ? parseEntries(await readFile(path, 'utf-8')) : [];
+
+const write = async (path, entries) => {
+  if(!entries.length && !existsSync(path)) return;
+  await writeFile(path, entries.length ? serializeEntries(entries) + '\n' : '', 'utf-8');
+};
+
+/*
+  Where a menu's own entries are filed. It is not a place any template has, so nothing is rendered
+  from them directly: what shows up on the site is the copies below.
+*/
+export const menuHome = menuId => `menu:${menuId}`;
+
+export const isMenuDefinition = entry => entry.menuLocations !== null;
+
+export const isMenuItem = entry => Boolean(entry.menu) && entry.menuLocations === null && !entry.menuCopyOf;
+
+/*
+  The page shows a menu in as many places as it is assigned, but a piece of global content fills one
+  location. So each enabled item gets a copy in every location its menu is assigned to, and the copies
+  are what a template renders. They are rebuilt from the items on every write, never edited, which is
+  what keeps a menu's places in step with its items.
+
+  An item an extension supplies keeps the extension's markup as it was when last written, so it renders
+  even though kempo-server cannot look it up at render time. `navItems` (name to item) is how it is kept
+  current: the markup is refreshed from the extension, and the item gets no copies, so it disappears from
+  the site, while the extension is not available. The item itself stays in its menu, so it returns with
+  the extension.
+*/
+const rebuildCopies = (active, navItems) => {
+  const entries = active.filter(e => !e.menuCopyOf);
+  const copies = [];
+
+  for(const entry of entries.filter(e => e.navItem && navItems?.has(e.navItem))){
+    const current = navItems.get(entry.navItem);
+    entry.name = current.label;
+    entry.markup = current.markup;
+  }
+
+  for(const definition of entries.filter(isMenuDefinition)){
+    const items = entries.filter(e => isMenuItem(e) && e.menu === definition.id && !(e.navItem && navItems && !navItems.has(e.navItem)));
+    for(const location of definition.menuLocations){
+      for(const item of items){
+        copies.push({
+          ...item,
+          id: `${item.id}@${location}`,
+          locked: false,
+          location,
+          menuCopyOf: item.id,
+          navItem: '',
+          extra: {}
+        });
+      }
+    }
+  }
+  return [...entries, ...copies];
+};
+
+/*
+  Both files a site's global content lives in: what is showing, and what has been switched off.
+  An item can be in either, so menu operations always look at both. The copies are left out of
+  `active`, as they only exist to be rendered.
+*/
+export const readStores = async rootDir => ({
+  active: (await read(join(rootDir, GLOBAL_FILE))).filter(e => !e.menuCopyOf),
+  disabled: await read(join(rootDir, GLOBAL_DISABLED_FILE))
+});
+
+export const writeStores = async (rootDir, { active, disabled }, extensionDirs) => {
+  const hasNavItems = [...active, ...disabled].some(e => e.navItem);
+  const navItems = hasNavItems ? new Map((await findNavItems({ extensionDirs }))[1].map(item => [item.key, item])) : null;
+  await write(join(rootDir, GLOBAL_FILE), rebuildCopies(active, navItems));
+  await write(join(rootDir, GLOBAL_DISABLED_FILE), disabled);
+};
+
+/*
+  Brings every menu up to date with the extensions that are installed now. Run when extensions are
+  installed, enabled, disabled or removed, so what an extension supplied leaves the site with it.
+*/
+export const resyncMenus = async (rootDir, extensionDirs) => {
+  const stores = await readStores(rootDir);
+  if(![...stores.active, ...stores.disabled].some(e => e.navItem)) return;
+  await writeStores(rootDir, stores, extensionDirs);
+};

package/server/utils/scheduler/helpers.js

@@ -0,0 +1,36 @@
+import parseDuration from '../realtime/duration.js';
+
+export const MIN_INTERVAL_MS = 1000;
+
+/* How long a process may hold a job before another may take it over, in case the first one died mid-run. */
+export const LEASE_MS = 5 * 60 * 1000;
+
+export const jobId = (owner, name) => `${owner}:${name}`;
+
+/*
+  Checks the `jobs` an extension declares: [{ name, every, callback }]. `every` is a number of
+  milliseconds or a string such as "30s", "1m" or "6h". Returns [error, jobs] where each job has
+  `everyMs` filled in.
+*/
+export const normalizeJobs = jobs => {
+  if(jobs === undefined || jobs === null) return [null, []];
+  if(!Array.isArray(jobs)) return [{ code: 400, msg: 'jobs must be a list' }, null];
+
+  const seen = new Set();
+  const result = [];
+  for(const job of jobs){
+    const name = String(job?.name ?? '');
+    if(!/^[a-z0-9][a-z0-9-]*$/.test(name)) return [{ code: 400, msg: `Job name "${name}" must be lowercase letters, numbers and dashes` }, null];
+    if(seen.has(name)) return [{ code: 400, msg: `Job "${name}" is declared twice` }, null];
+    seen.add(name);
+
+    const everyMs = parseDuration(job.every);
+    if(everyMs === null || everyMs < MIN_INTERVAL_MS) return [{ code: 400, msg: `Job "${name}" needs an "every" of at least one second, such as "1m"` }, null];
+
+    const callback = String(job.callback ?? '');
+    if(!callback.startsWith('./')) return [{ code: 400, msg: `Job "${name}" needs a "callback" path starting with ./` }, null];
+
+    result.push({ name, every: job.every, everyMs, callback });
+  }
+  return [null, result];
+};

package/server/utils/scheduler/listJobs.js

@@ -0,0 +1,11 @@
+import db from '../../db/index.js';
+import { scheduledJob } from '../../db/schema.js';
+import { asc } from 'drizzle-orm';
+
+export default async () => {
+  try {
+    return [null, await db.select().from(scheduledJob).orderBy(asc(scheduledJob.owner), asc(scheduledJob.name))];
+  } catch(error) {
+    return [{ code: 500, msg: 'Failed to list jobs' }, null];
+  }
+};

package/server/utils/scheduler/registerJobs.js

@@ -0,0 +1,37 @@
+import db from '../../db/index.js';
+import { scheduledJob } from '../../db/schema.js';
+import { and, eq, notInArray } from 'drizzle-orm';
+import { normalizeJobs, jobId } from './helpers.js';
+
+/*
+  Makes an extension's schedule match what it declares: adds new jobs, refreshes the interval and
+  callback of existing ones (keeping when they are next due), and removes the ones no longer declared.
+  Safe to call from install and again from update.
+*/
+export default async ({ owner, jobs }) => {
+  if(!owner){
+    return [{ code: 400, msg: 'Owner is required' }, null];
+  }
+
+  const [invalid, declared] = normalizeJobs(jobs);
+  if(invalid){
+    return [invalid, null];
+  }
+
+  try {
+    const now = new Date();
+    for(const job of declared){
+      const row = { owner, name: job.name, everyMs: job.everyMs, callback: job.callback };
+      await db.insert(scheduledJob)
+        .values({ id: jobId(owner, job.name), ...row, nextRunAt: now, createdAt: now })
+        .onConflictDoUpdate({ target: scheduledJob.id, set: row });
+    }
+    const names = declared.map(job => job.name);
+    await db.delete(scheduledJob).where(names.length
+      ? and(eq(scheduledJob.owner, owner), notInArray(scheduledJob.name, names))
+      : eq(scheduledJob.owner, owner));
+    return [null, { registered: declared.length }];
+  } catch(error) {
+    return [{ code: 500, msg: 'Failed to register jobs' }, null];
+  }
+};

package/server/utils/scheduler/runJobs.js

@@ -0,0 +1,90 @@
+import db from '../../db/index.js';
+import { scheduledJob } from '../../db/schema.js';
+import { and, eq, lte, or, isNull, asc } from 'drizzle-orm';
+import { join } from 'path';
+import { pathToFileURL } from 'url';
+import { getDisabledExtensionNames } from '../extensions/scopeCache.js';
+import { LEASE_MS, jobId } from './helpers.js';
+
+const resolveHandler = (owner, callback) => join(process.cwd(), 'node_modules', owner, callback);
+
+/*
+  Takes a job for this process: one conditional UPDATE, so of any number of processes asking at once
+  exactly one gets the row. It then moves `nextRunAt` on by an interval. `force` skips the "is it due"
+  test (for running a job by hand) but never the lease.
+*/
+const claim = async (id, { force = false } = {}) => {
+  const now = new Date();
+  const conditions = [eq(scheduledJob.id, id), or(isNull(scheduledJob.lockedUntil), lte(scheduledJob.lockedUntil, now))];
+  if(!force) conditions.push(lte(scheduledJob.nextRunAt, now));
+
+  const [row] = await db.update(scheduledJob)
+    .set({ lockedUntil: new Date(now.getTime() + LEASE_MS) })
+    .where(and(...conditions))
+    .returning();
+  if(!row) return null;
+
+  if(!force){
+    await db.update(scheduledJob).set({ nextRunAt: new Date(now.getTime() + row.everyMs) }).where(eq(scheduledJob.id, id));
+  }
+  return row;
+};
+
+/* Runs a claimed job's handler, then releases the lease and records how it went. A throwing job never stops anything else. */
+const execute = async row => {
+  let status = 'ok';
+  let message = null;
+  try {
+    const mod = await import(pathToFileURL(resolveHandler(row.owner, row.callback)).href);
+    await (mod.default || mod)({ owner: row.owner, name: row.name });
+  } catch(error) {
+    status = 'error';
+    message = String(error?.message ?? error).slice(0, 500);
+    console.error(`[kempo] Job "${row.name}" (${row.owner}) failed: ${message}`);
+  }
+  await db.update(scheduledJob)
+    .set({ lockedUntil: null, lastRunAt: new Date(), lastStatus: status, lastError: message })
+    .where(eq(scheduledJob.id, row.id))
+    .catch(() => {});
+  return { status, error: message };
+};
+
+/*
+  Runs every job that is due and not held by another process. A disabled extension's jobs stay
+  registered but never run, the same as its hooks. Returns the ones this process ran.
+*/
+export const runDueJobs = async () => {
+  try {
+    const disabled = await getDisabledExtensionNames();
+    const candidates = await db.select().from(scheduledJob).where(lte(scheduledJob.nextRunAt, new Date())).orderBy(asc(scheduledJob.nextRunAt));
+    const ran = [];
+    for(const candidate of candidates){
+      if(disabled.has(candidate.owner)) continue;
+      const row = await claim(candidate.id);
+      if(!row) continue;
+      ran.push({ owner: row.owner, name: row.name, ...(await execute(row)) });
+    }
+    return [null, ran];
+  } catch(error) {
+    return [{ code: 500, msg: 'Failed to run jobs' }, null];
+  }
+};
+
+/* Runs one job now, whatever the schedule says. Refused with 409 while another process is running it. */
+export const runJob = async ({ owner, name } = {}) => {
+  if(!owner || !name){
+    return [{ code: 400, msg: 'Owner and name are required' }, null];
+  }
+
+  try {
+    const id = jobId(owner, name);
+    const [exists] = await db.select({ id: scheduledJob.id }).from(scheduledJob).where(eq(scheduledJob.id, id));
+    if(!exists) return [{ code: 404, msg: 'Job not found' }, null];
+    if((await getDisabledExtensionNames()).has(owner)) return [{ code: 409, msg: 'The extension is disabled' }, null];
+    const row = await claim(id, { force: true });
+    if(!row) return [{ code: 409, msg: 'The job is already running' }, null];
+    return [null, await execute(row)];
+  } catch(error) {
+    return [{ code: 500, msg: 'Failed to run the job' }, null];
+  }
+};

package/server/utils/scheduler/scheduler.js

@@ -0,0 +1,37 @@
+import { runDueJobs } from './runJobs.js';
+
+/*
+  One ticker per process, held on a Symbol.for global so that the middleware and an extension reach the
+  same one even if kempo was resolved twice. Each tick only asks the database what is due; the lease on
+  each job row is what stops several processes running the same job. Set KEMPO_SCHEDULER=off to keep a
+  process from running jobs.
+*/
+const SCHEDULER = Symbol.for('kempo.scheduler');
+
+export const TICK_MS = 15000;
+
+export const startScheduler = ({ tickMs = TICK_MS } = {}) => {
+  if(globalThis[SCHEDULER] || process.env.KEMPO_SCHEDULER === 'off') return false;
+
+  let running = false;
+  const timer = setInterval(async () => {
+    if(running) return;
+    running = true;
+    try {
+      const [error] = await runDueJobs();
+      if(error) console.error(`[kempo] Scheduler: ${error.msg}`);
+    } finally {
+      running = false;
+    }
+  }, tickMs);
+  timer.unref?.();
+  globalThis[SCHEDULER] = timer;
+  return true;
+};
+
+export const stopScheduler = () => {
+  if(!globalThis[SCHEDULER]) return false;
+  clearInterval(globalThis[SCHEDULER]);
+  globalThis[SCHEDULER] = null;
+  return true;
+};

package/server/utils/scheduler/unregisterJobs.js

@@ -0,0 +1,16 @@
+import db from '../../db/index.js';
+import { scheduledJob } from '../../db/schema.js';
+import { eq } from 'drizzle-orm';
+
+export default async ({ owner }) => {
+  if(!owner){
+    return [{ code: 400, msg: 'Owner is required' }, null];
+  }
+
+  try {
+    await db.delete(scheduledJob).where(eq(scheduledJob.owner, owner));
+    return [null, { success: true }];
+  } catch(error) {
+    return [{ code: 500, msg: 'Failed to remove jobs' }, null];
+  }
+};