@nordbyte/nordrelay-auto-updater 0.1.0

package/src/runtime.js

@@ -0,0 +1,319 @@
+#!/usr/bin/env node
+import { hostname, platform, release } from "node:os";
+import { mkdir } from "node:fs/promises";
+import { collectNpmPackages } from "./npm-packages.js";
+import { collectOsUpdates } from "./os-updates.js";
+import { normalizeCommand } from "./commands.js";
+import { renderDashboardPanel, dashboardPanelScript, dashboardPanelStyles } from "./render-panel.js";
+import {
+  cleanupSnapshots,
+  dueNpmAutoRules,
+  insertSnapshot,
+  openDatabase,
+  readHistory,
+  readLatestSnapshot,
+  readNpmAutoRules,
+  recordNpmAutoRuleResult,
+  storageHealth,
+  upsertNpmAutoRule,
+} from "./storage.js";
+import { runNpmUninstallAction, runNpmUpdateAction, runOsUpdateAction } from "./update-actions.js";
+
+export async function runPlugin() {
+  const request = await readRequest();
+  const settings = normalizeSettings(request.settings);
+  const dataDir = request.dataDir || process.cwd();
+  await mkdir(dataDir, { recursive: true });
+
+  if (request.type === "web-panel") {
+    writeResult({
+      ok: true,
+      html: renderDashboardPanel(request.input, request.context, settings),
+      panel: { script: dashboardPanelScript(), styles: dashboardPanelStyles() },
+    });
+    return;
+  }
+
+  if (request.type === "diagnostics") {
+    const db = await openDatabase(dataDir);
+    try {
+      writeResult({ ok: true, diagnostics: await diagnostics(db, dataDir, settings) });
+    } finally {
+      db.close();
+    }
+    return;
+  }
+
+  requireReadPermissions(request, settings);
+  const db = await openDatabase(dataDir);
+  try {
+    if (request.type === "collector") {
+      const snapshot = await collectAndStoreSnapshot(db, settings, request);
+      writeResult({ ok: true, output: { snapshot } });
+      return;
+    }
+    if (request.type === "command") {
+      await handleCommand(request, db, dataDir, settings);
+      return;
+    }
+  } finally {
+    db.close();
+  }
+
+  writeResult({ ok: false, stderr: `Unsupported request type: ${request.type}` });
+}
+
+async function handleCommand(request, db, dataDir, settings) {
+  const command = normalizeCommand(request);
+  if (command === "refresh") {
+    const snapshot = await collectAndStoreSnapshot(db, settings, request);
+    writeResult({ ok: true, output: { snapshot } });
+    return;
+  }
+  if (command === "latest") {
+    const snapshot = readLatestSnapshot(db) || await collectAndStoreSnapshot(db, settings, request);
+    writeResult({ ok: true, output: { snapshot } });
+    return;
+  }
+  if (command === "panel-data") {
+    const snapshot = request.input?.force === true
+      ? await collectAndStoreSnapshot(db, settings, request)
+      : readLatestSnapshot(db) || await collectAndStoreSnapshot(db, settings, request);
+    writeResult({
+      ok: true,
+      output: {
+        panelData: {
+          snapshot,
+          history: readHistory(db, { range: "24h", limit: request.input?.limit || 240 }),
+          automation: { rules: readNpmAutoRules(db) },
+          storage: await storageHealth(db, dataDir),
+          settings: publicSettings(settings),
+        },
+      },
+    });
+    return;
+  }
+  if (command === "os-updates") {
+    const snapshot = readLatestSnapshot(db) || await collectAndStoreSnapshot(db, settings, request);
+    writeResult({ ok: true, output: { os: snapshot.os } });
+    return;
+  }
+  if (command === "npm-packages") {
+    const snapshot = readLatestSnapshot(db) || await collectAndStoreSnapshot(db, settings, request);
+    writeResult({ ok: true, output: { npm: snapshot.npm } });
+    return;
+  }
+  if (command === "update-os") {
+    requirePermission(request, "system.updates.write");
+    const action = runOsUpdateAction(request.input || {}, settings);
+    const snapshot = await collectAndStoreSnapshot(db, settings, request);
+    writeResult({ ok: action.ok, output: { action, snapshot }, stderr: action.error || action.results.find((item) => !item.ok)?.stderr || "" });
+    return;
+  }
+  if (command === "update-npm") {
+    requirePermission(request, "system.packages.write");
+    const action = runNpmUpdateAction(request.input || {}, settings);
+    const snapshot = await collectAndStoreSnapshot(db, settings, request);
+    writeResult({ ok: action.ok, output: { action, snapshot }, stderr: action.error || action.results.find((item) => !item.ok)?.stderr || "" });
+    return;
+  }
+  if (command === "configure-npm-auto") {
+    requirePermission(request, "system.packages.write");
+    const rule = upsertNpmAutoRule(db, request.input || {});
+    writeResult({ ok: true, output: { rule, automation: { rules: readNpmAutoRules(db) } } });
+    return;
+  }
+  if (command === "uninstall-npm") {
+    requirePermission(request, "system.packages.write");
+    const action = runNpmUninstallAction(request.input || {}, settings);
+    const snapshot = await collectAndStoreSnapshot(db, settings, request);
+    writeResult({ ok: action.ok, output: { action, snapshot }, stderr: action.error || action.results.find((item) => !item.ok)?.stderr || "" });
+    return;
+  }
+  if (command === "history") {
+    writeResult({ ok: true, output: { history: readHistory(db, request.input || {}) } });
+    return;
+  }
+  if (command === "export") {
+    writeResult({ ok: true, output: exportData(db, request.input || {}) });
+    return;
+  }
+  if (command === "storage-health") {
+    writeResult({ ok: true, output: { storage: await storageHealth(db, dataDir) } });
+    return;
+  }
+  if (command === "cleanup") {
+    const deleted = cleanupSnapshots(db, settings.retentionDays);
+    writeResult({ ok: true, output: { deleted, storage: await storageHealth(db, dataDir) } });
+    return;
+  }
+  writeResult({ ok: false, stderr: `Unknown auto-updater command: ${command}` });
+}
+
+export async function collectAndStoreSnapshot(db, settings, request) {
+  const startedAt = Date.now();
+  const os = collectOsUpdates(settings);
+  let npm = collectNpmPackages(settings);
+  const node = runtimeNode(request);
+  const automation = runDueNpmAutomation(db, npm.packages, settings, request);
+  if (automation.actions.length) {
+    npm = collectNpmPackages(settings);
+  }
+  const errors = [
+    ...(os.errors || []).map((item) => ({ area: "os", ...item })),
+    ...(npm.errors || []).map((item) => ({ area: "npm", ...item })),
+    ...automation.errors,
+  ];
+  const snapshot = {
+    ts: startedAt,
+    checkedAt: new Date(startedAt).toISOString(),
+    durationMs: Date.now() - startedAt,
+    node,
+    os,
+    npm,
+    errors,
+    host: {
+      hostname: hostname(),
+      release: release(),
+    },
+  };
+  cleanupSnapshots(db, settings.retentionDays);
+  return insertSnapshot(db, snapshot);
+}
+
+function runDueNpmAutomation(db, packages, settings, request) {
+  const permissions = new Set(request.permissions || []);
+  if (settings.enableNpmPackages === false || !permissions.has("system.packages.write")) {
+    return { actions: [], errors: [] };
+  }
+  const packageMap = new Map((Array.isArray(packages) ? packages : []).map((item) => [String(item.name || ""), item]));
+  const actions = [];
+  const errors = [];
+  for (const rule of dueNpmAutoRules(db, packages)) {
+    const pkg = packageMap.get(rule.name);
+    if (!pkg) continue;
+    if (pkg.status !== "outdated" && !rule.installLatest) {
+      recordNpmAutoRuleResult(db, rule.name, { ran: false, status: "skipped", message: "Package is already latest." });
+      continue;
+    }
+    const action = runNpmUpdateAction({ packages: [rule.name] }, settings);
+    actions.push({ rule, action });
+    const result = action.results?.[0];
+    const message = action.error || result?.stderr || result?.stdout || (action.ok ? "Installed latest package globally." : "npm install failed.");
+    recordNpmAutoRuleResult(db, rule.name, { ran: true, status: action.ok ? "installed" : "failed", message });
+    if (!action.ok) {
+      errors.push({ area: "npm-auto", manager: "npm", package: rule.name, error: message });
+    }
+  }
+  return { actions, errors };
+}
+
+function runtimeNode(request) {
+  const runtime = request.context?.runtime || {};
+  return {
+    id: String(runtime.nodeId || runtime.nodeName || hostname() || "local"),
+    name: String(runtime.nodeName || runtime.nodeId || hostname() || "Local node"),
+    platform: String(runtime.platform || platform()),
+    workspace: runtime.workspace ? String(runtime.workspace) : "",
+  };
+}
+
+async function diagnostics(db, dataDir, settings) {
+  return {
+    plugin: "auto-updater",
+    dataDir,
+    storage: await storageHealth(db, dataDir),
+    latest: readLatestSnapshot(db),
+    settings: publicSettings(settings),
+    supported: {
+      osUpdates: settings.enableOsUpdates !== false && ["linux", "darwin"].includes(process.platform),
+      npmPackages: settings.enableNpmPackages !== false,
+      platform: process.platform,
+    },
+  };
+}
+
+function exportData(db, input) {
+  const format = String(input.format || "json").toLowerCase();
+  const latest = readLatestSnapshot(db);
+  const history = readHistory(db, { range: input.range || "30d", limit: input.limit || 2000 });
+  if (format === "csv") {
+    const rows = ["checkedAt,node,platform,osUpdates,npmPackages,npmOutdated,errors"];
+    for (const item of history) {
+      rows.push([
+        item.checkedAt,
+        csv(item.node?.name),
+        csv(item.node?.platform),
+        item.osUpdateCount,
+        item.npmPackageCount,
+        item.npmOutdatedCount,
+        csv((item.errors || []).map((error) => error.error || error.manager || error.area).join("; ")),
+      ].join(","));
+    }
+    return { format: "csv", content: `${rows.join("\n")}\n` };
+  }
+  return { format: "json", latest, history };
+}
+
+function publicSettings(settings) {
+  return {
+    retentionDays: settings.retentionDays,
+    checkIntervalMs: settings.checkIntervalMs,
+    updateTimeoutMs: settings.updateTimeoutMs,
+    enableOsUpdates: settings.enableOsUpdates,
+    enableNpmPackages: settings.enableNpmPackages,
+    npmRegistry: settings.npmRegistry,
+  };
+}
+
+export function normalizeSettings(settings = {}) {
+  return {
+    checkIntervalMs: numberSetting(settings.checkIntervalMs, 1_800_000),
+    retentionDays: numberSetting(settings.retentionDays, 30),
+    commandTimeoutMs: numberSetting(settings.commandTimeoutMs, 20_000),
+    updateTimeoutMs: numberSetting(settings.updateTimeoutMs, 600_000),
+    enableOsUpdates: settings.enableOsUpdates !== false,
+    enableNpmPackages: settings.enableNpmPackages !== false,
+    npmRegistry: String(settings.npmRegistry || "https://registry.npmjs.org"),
+    disabledManagers: String(settings.disabledManagers || ""),
+    refreshPackageIndexes: settings.refreshPackageIndexes === true,
+  };
+}
+
+function numberSetting(value, fallback) {
+  const parsed = Number(value);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
+}
+
+async function readRequest() {
+  const chunks = [];
+  for await (const chunk of process.stdin) chunks.push(Buffer.from(chunk));
+  const raw = Buffer.concat(chunks).toString("utf8").trim();
+  return raw ? JSON.parse(raw) : {};
+}
+
+function writeResult(result) {
+  process.stdout.write(`${JSON.stringify(result)}\n`);
+}
+
+function requireReadPermissions(request, settings) {
+  const permissions = new Set(request.permissions || []);
+  if (settings.enableOsUpdates !== false && !permissions.has("system.updates.read")) {
+    throw new Error("Plugin permission required: system.updates.read");
+  }
+  if (settings.enableNpmPackages !== false && !permissions.has("system.packages.read")) {
+    throw new Error("Plugin permission required: system.packages.read");
+  }
+}
+
+function requirePermission(request, permission) {
+  const permissions = new Set(request.permissions || []);
+  if (!permissions.has(permission)) {
+    throw new Error(`Plugin permission required: ${permission}`);
+  }
+}
+
+function csv(value) {
+  const text = String(value ?? "");
+  return /[",\n]/.test(text) ? `"${text.replace(/"/g, '""')}"` : text;
+}

package/src/storage.js

@@ -0,0 +1,337 @@
+import path from "node:path";
+import { mkdir, stat } from "node:fs/promises";
+
+const DB_FILE = "updates.sqlite";
+let DatabaseSyncClass;
+
+export async function openDatabase(dataDir) {
+  await mkdir(dataDir, { recursive: true });
+  const DatabaseSync = await loadDatabaseSync();
+  const db = new DatabaseSync(path.join(dataDir, DB_FILE));
+  initializeSchema(db);
+  return db;
+}
+
+export function initializeSchema(db) {
+  db.exec(`
+    PRAGMA foreign_keys = ON;
+    PRAGMA busy_timeout = 3000;
+    PRAGMA journal_mode = WAL;
+    CREATE TABLE IF NOT EXISTS schema_meta (
+      key TEXT PRIMARY KEY,
+      value TEXT NOT NULL
+    );
+    CREATE TABLE IF NOT EXISTS snapshots (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      ts INTEGER NOT NULL,
+      node_id TEXT NOT NULL,
+      node_name TEXT,
+      node_platform TEXT,
+      duration_ms INTEGER,
+      os_supported INTEGER NOT NULL,
+      os_update_count INTEGER NOT NULL,
+      npm_supported INTEGER NOT NULL,
+      npm_package_count INTEGER NOT NULL,
+      npm_outdated_count INTEGER NOT NULL,
+      errors_json TEXT NOT NULL
+    );
+    CREATE TABLE IF NOT EXISTS os_updates (
+      snapshot_id INTEGER NOT NULL REFERENCES snapshots(id) ON DELETE CASCADE,
+      manager TEXT NOT NULL,
+      name TEXT NOT NULL,
+      current TEXT,
+      latest TEXT,
+      source TEXT,
+      arch TEXT
+    );
+    CREATE TABLE IF NOT EXISTS npm_packages (
+      snapshot_id INTEGER NOT NULL REFERENCES snapshots(id) ON DELETE CASCADE,
+      name TEXT NOT NULL,
+      current TEXT,
+      wanted TEXT,
+      latest TEXT,
+      status TEXT,
+      type TEXT,
+      location TEXT,
+      homepage TEXT
+    );
+    CREATE TABLE IF NOT EXISTS npm_auto_rules (
+      name TEXT PRIMARY KEY,
+      enabled INTEGER NOT NULL DEFAULT 0,
+      interval_ms INTEGER NOT NULL DEFAULT 86400000,
+      install_latest INTEGER NOT NULL DEFAULT 0,
+      last_checked_at INTEGER,
+      last_run_at INTEGER,
+      last_status TEXT,
+      last_message TEXT,
+      updated_at INTEGER NOT NULL
+    );
+    CREATE INDEX IF NOT EXISTS idx_snapshots_ts ON snapshots(ts);
+    CREATE INDEX IF NOT EXISTS idx_os_snapshot ON os_updates(snapshot_id);
+    CREATE INDEX IF NOT EXISTS idx_npm_snapshot ON npm_packages(snapshot_id);
+  `);
+  db.prepare("INSERT OR REPLACE INTO schema_meta (key, value) VALUES ('schemaVersion', '2')").run();
+}
+
+export function insertSnapshot(db, snapshot) {
+  const row = db.prepare(`
+    INSERT INTO snapshots (
+      ts, node_id, node_name, node_platform, duration_ms, os_supported, os_update_count,
+      npm_supported, npm_package_count, npm_outdated_count, errors_json
+    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+  `).run(
+    snapshot.ts,
+    snapshot.node.id,
+    snapshot.node.name,
+    snapshot.node.platform,
+    snapshot.durationMs,
+    snapshot.os.supported ? 1 : 0,
+    snapshot.os.updates.length,
+    snapshot.npm.supported ? 1 : 0,
+    snapshot.npm.packages.length,
+    snapshot.npm.packages.filter((item) => item.status === "outdated").length,
+    JSON.stringify(snapshot.errors || []),
+  );
+  const snapshotId = Number(row.lastInsertRowid);
+  const osInsert = db.prepare("INSERT INTO os_updates (snapshot_id, manager, name, current, latest, source, arch) VALUES (?, ?, ?, ?, ?, ?, ?)");
+  for (const item of snapshot.os.updates) {
+    osInsert.run(snapshotId, item.manager || "", item.name || "", item.current || "", item.latest || "", item.source || "", item.arch || "");
+  }
+  const npmInsert = db.prepare("INSERT INTO npm_packages (snapshot_id, name, current, wanted, latest, status, type, location, homepage) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)");
+  for (const item of snapshot.npm.packages) {
+    npmInsert.run(snapshotId, item.name || "", item.current || "", item.wanted || "", item.latest || "", item.status || "", item.type || "", item.location || "", item.homepage || "");
+  }
+  return readSnapshot(db, snapshotId);
+}
+
+export function readLatestSnapshot(db) {
+  const row = db.prepare("SELECT * FROM snapshots ORDER BY ts DESC, id DESC LIMIT 1").get();
+  return row ? inflateSnapshot(db, row) : null;
+}
+
+export function readSnapshot(db, snapshotId) {
+  const row = db.prepare("SELECT * FROM snapshots WHERE id = ?").get(snapshotId);
+  return row ? inflateSnapshot(db, row) : null;
+}
+
+export function readHistory(db, options = {}) {
+  const since = Date.now() - rangeMs(options.range || "7d");
+  const limit = Math.max(1, Math.min(2000, Number(options.limit) || 200));
+  return db.prepare(`
+    SELECT id, ts, node_id, node_name, node_platform, duration_ms, os_update_count,
+      npm_package_count, npm_outdated_count, errors_json
+    FROM snapshots
+    WHERE ts >= ?
+    ORDER BY ts DESC, id DESC
+    LIMIT ?
+  `).all(since, limit).map((row) => ({
+    id: row.id,
+    checkedAt: new Date(Number(row.ts)).toISOString(),
+    node: { id: row.node_id, name: row.node_name, platform: row.node_platform },
+    durationMs: Number(row.duration_ms) || 0,
+    osUpdateCount: Number(row.os_update_count) || 0,
+    npmPackageCount: Number(row.npm_package_count) || 0,
+    npmOutdatedCount: Number(row.npm_outdated_count) || 0,
+    errors: parseJson(row.errors_json, []),
+  }));
+}
+
+export function cleanupSnapshots(db, retentionDays = 30) {
+  const cutoff = Date.now() - Math.max(1, Number(retentionDays) || 30) * 24 * 60 * 60 * 1000;
+  return Number(db.prepare("DELETE FROM snapshots WHERE ts < ?").run(cutoff).changes) || 0;
+}
+
+export async function storageHealth(db, dataDir) {
+  const database = path.join(dataDir, DB_FILE);
+  const wal = `${database}-wal`;
+  const shm = `${database}-shm`;
+  const integrity = safeGet(db, "PRAGMA integrity_check");
+  const snapshots = safeGet(db, "SELECT COUNT(*) AS count FROM snapshots");
+  return {
+    database,
+    sizeBytes: (await fileSize(database)) + (await fileSize(wal)) + (await fileSize(shm)),
+    integrity: String(integrity?.integrity_check || "unknown"),
+    snapshots: Number(snapshots?.count) || 0,
+  };
+}
+
+export function readNpmAutoRules(db) {
+  return db.prepare(`
+    SELECT name, enabled, interval_ms, install_latest, last_checked_at, last_run_at,
+      last_status, last_message, updated_at
+    FROM npm_auto_rules
+    ORDER BY name
+  `).all().map(inflateNpmAutoRule);
+}
+
+export function readNpmAutoRuleMap(db) {
+  const map = new Map();
+  for (const rule of readNpmAutoRules(db)) {
+    map.set(rule.name, rule);
+  }
+  return map;
+}
+
+export function upsertNpmAutoRule(db, input = {}) {
+  const rule = normalizeNpmAutoRule(input);
+  const previous = db.prepare("SELECT * FROM npm_auto_rules WHERE name = ?").get(rule.name);
+  const now = Date.now();
+  db.prepare(`
+    INSERT INTO npm_auto_rules (
+      name, enabled, interval_ms, install_latest, last_checked_at, last_run_at,
+      last_status, last_message, updated_at
+    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+    ON CONFLICT(name) DO UPDATE SET
+      enabled = excluded.enabled,
+      interval_ms = excluded.interval_ms,
+      install_latest = excluded.install_latest,
+      updated_at = excluded.updated_at
+  `).run(
+    rule.name,
+    rule.enabled ? 1 : 0,
+    rule.intervalMs,
+    rule.installLatest ? 1 : 0,
+    previous?.last_checked_at ?? null,
+    previous?.last_run_at ?? null,
+    previous?.last_status ?? null,
+    previous?.last_message ?? null,
+    now,
+  );
+  return inflateNpmAutoRule(db.prepare("SELECT * FROM npm_auto_rules WHERE name = ?").get(rule.name));
+}
+
+export function dueNpmAutoRules(db, packages = [], now = Date.now()) {
+  const installed = new Set((Array.isArray(packages) ? packages : []).map((item) => String(item.name || "")).filter(Boolean));
+  return readNpmAutoRules(db).filter((rule) => {
+    const lastCheckedMs = Date.parse(rule.lastCheckedAt || "");
+    return rule.enabled && installed.has(rule.name) && (!Number.isFinite(lastCheckedMs) || now - lastCheckedMs >= rule.intervalMs);
+  });
+}
+
+export function recordNpmAutoRuleResult(db, name, result = {}) {
+  const now = Date.now();
+  const ran = result.ran !== false;
+  db.prepare(`
+    UPDATE npm_auto_rules
+    SET last_checked_at = ?, last_run_at = CASE WHEN ? THEN ? ELSE last_run_at END,
+      last_status = ?, last_message = ?
+    WHERE name = ?
+  `).run(now, ran ? 1 : 0, now, String(result.status || ""), String(result.message || ""), String(name || ""));
+  const row = db.prepare("SELECT * FROM npm_auto_rules WHERE name = ?").get(String(name || ""));
+  return row ? inflateNpmAutoRule(row) : null;
+}
+
+function inflateSnapshot(db, row) {
+  const snapshotId = Number(row.id);
+  return {
+    id: snapshotId,
+    checkedAt: new Date(Number(row.ts)).toISOString(),
+    durationMs: Number(row.duration_ms) || 0,
+    node: { id: row.node_id, name: row.node_name, platform: row.node_platform },
+    os: {
+      supported: Boolean(row.os_supported),
+      updates: db.prepare("SELECT manager, name, current, latest, source, arch FROM os_updates WHERE snapshot_id = ? ORDER BY manager, name").all(snapshotId),
+      updateCount: Number(row.os_update_count) || 0,
+    },
+    npm: {
+      supported: Boolean(row.npm_supported),
+      packages: db.prepare("SELECT name, current, wanted, latest, status, type, location, homepage FROM npm_packages WHERE snapshot_id = ? ORDER BY status DESC, name").all(snapshotId),
+      packageCount: Number(row.npm_package_count) || 0,
+      outdatedCount: Number(row.npm_outdated_count) || 0,
+    },
+    errors: parseJson(row.errors_json, []),
+  };
+}
+
+function inflateNpmAutoRule(row) {
+  return {
+    name: String(row.name || ""),
+    enabled: Boolean(row.enabled),
+    intervalMs: Number(row.interval_ms) || 24 * 60 * 60 * 1000,
+    intervalValue: intervalValue(Number(row.interval_ms) || 24 * 60 * 60 * 1000),
+    intervalUnit: intervalUnit(Number(row.interval_ms) || 24 * 60 * 60 * 1000),
+    installLatest: Boolean(row.install_latest),
+    lastCheckedAt: row.last_checked_at ? new Date(Number(row.last_checked_at)).toISOString() : "",
+    lastRunAt: row.last_run_at ? new Date(Number(row.last_run_at)).toISOString() : "",
+    lastStatus: String(row.last_status || ""),
+    lastMessage: String(row.last_message || ""),
+    updatedAt: row.updated_at ? new Date(Number(row.updated_at)).toISOString() : "",
+  };
+}
+
+function normalizeNpmAutoRule(input) {
+  const name = String(input.name || input.package || "").trim();
+  if (!/^(?:@[A-Za-z0-9._-]+\/)?[A-Za-z0-9._-]+$/.test(name)) {
+    throw new Error("Invalid npm package name.");
+  }
+  const unit = String(input.intervalUnit || input.unit || "hours").toLowerCase();
+  const value = Math.max(1, Math.min(365, Number(input.intervalValue || input.interval || 24) || 24));
+  const multiplier = unit === "days" || unit === "day" || unit === "d" ? 24 * 60 * 60 * 1000 : 60 * 60 * 1000;
+  return {
+    name,
+    enabled: input.enabled === true || input.enabled === "true" || input.enabled === 1,
+    intervalMs: Math.round(value * multiplier),
+    installLatest: input.installLatest === true || input.installLatest === "true" || input.installLatest === 1,
+  };
+}
+
+function intervalUnit(ms) {
+  return Number(ms) % (24 * 60 * 60 * 1000) === 0 ? "days" : "hours";
+}
+
+function intervalValue(ms) {
+  const value = Number(ms) || 24 * 60 * 60 * 1000;
+  const divisor = intervalUnit(value) === "days" ? 24 * 60 * 60 * 1000 : 60 * 60 * 1000;
+  return Math.max(1, Math.round(value / divisor));
+}
+
+async function loadDatabaseSync() {
+  if (DatabaseSyncClass) return DatabaseSyncClass;
+  const originalEmitWarning = process.emitWarning;
+  process.emitWarning = function emitWarningWithoutSqliteExperimentalNoise(warning, ...args) {
+    const text = typeof warning === "string" ? warning : warning?.message;
+    const type = typeof args[0] === "string" ? args[0] : warning?.name;
+    if (type === "ExperimentalWarning" && /SQLite/i.test(String(text || ""))) return;
+    return originalEmitWarning.call(this, warning, ...args);
+  };
+  try {
+    const sqlite = await import("node:sqlite");
+    DatabaseSyncClass = sqlite.DatabaseSync;
+    return DatabaseSyncClass;
+  } finally {
+    process.emitWarning = originalEmitWarning;
+  }
+}
+
+function parseJson(value, fallback) {
+  try {
+    return JSON.parse(String(value || ""));
+  } catch {
+    return fallback;
+  }
+}
+
+function safeGet(db, sql) {
+  try {
+    return db.prepare(sql).get();
+  } catch {
+    return {};
+  }
+}
+
+async function fileSize(file) {
+  try {
+    return (await stat(file)).size;
+  } catch {
+    return 0;
+  }
+}
+
+function rangeMs(range) {
+  const match = /^(\d+)(m|h|d)$/i.exec(String(range || ""));
+  if (!match) return 7 * 24 * 60 * 60 * 1000;
+  const value = Number(match[1]);
+  if (match[2].toLowerCase() === "m") return value * 60 * 1000;
+  if (match[2].toLowerCase() === "h") return value * 60 * 60 * 1000;
+  return value * 24 * 60 * 60 * 1000;
+}