doc2vec 2.10.5 → 2.11.0

package/dist/controller/index.js

@@ -0,0 +1,139 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startController = startController;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const logger_1 = require("../logger");
+const config_registry_1 = require("./config-registry");
+const events_1 = require("./events");
+const job_runner_1 = require("./job-runner");
+const notifier_1 = require("./notifier");
+const scheduler_1 = require("./scheduler");
+const server_1 = require("./server");
+const store_1 = require("./store");
+const LOG_PRUNE_INTERVAL_MS = 24 * 60 * 60 * 1000;
+async function startController(opts) {
+    const logger = new logger_1.Logger('Controller', {
+        level: logger_1.LogLevel.INFO,
+        useTimestamp: true,
+        useColor: true,
+        prettyPrint: true,
+    });
+    if (!opts.databaseUrl) {
+        throw new Error('controller mode requires Postgres: pass --database-url or set DATABASE_URL');
+    }
+    if (opts.readWrite && !opts.configDir) {
+        throw new Error('--read-write requires --config-dir (where new configs are written)');
+    }
+    if (opts.configArgs.length === 0 && !(opts.readWrite && opts.configDir)) {
+        throw new Error('provide at least one config file or directory');
+    }
+    if (opts.configDir) {
+        fs.mkdirSync(path.resolve(opts.configDir), { recursive: true });
+    }
+    logger.section('DOC2VEC CONTROLLER');
+    logger.info(`Mode: ${opts.readWrite ? 'read-write' : 'read-only'}, max parallel jobs: ${opts.maxParallel}`);
+    const store = new store_1.ControllerStore(opts.databaseUrl, logger.child('store'));
+    await store.init();
+    const events = new events_1.ControllerEvents();
+    const runner = new job_runner_1.JobRunner(store, events, { maxParallel: Math.max(opts.maxParallel, 1) }, logger.child('runner'));
+    const registry = new config_registry_1.ConfigRegistry({
+        configArgs: opts.configArgs,
+        configDir: opts.configDir,
+        readWrite: opts.readWrite,
+        reloadIntervalSec: opts.reloadIntervalSec,
+    }, store, events, logger.child('registry'));
+    const scheduler = new scheduler_1.Scheduler(configId => {
+        const config = registry.get(configId);
+        if (!config)
+            return;
+        runner.enqueue(config, 'scheduled').catch(err => logger.error(`Failed to enqueue scheduled run for '${config.name}':`, err));
+    }, logger.child('scheduler'));
+    events.on('config:update', () => scheduler.sync(registry.list()));
+    if (opts.slackWebhookUrl) {
+        new notifier_1.SlackNotifier({
+            webhookUrl: opts.slackWebhookUrl,
+            notify: opts.slackNotify ?? 'all',
+            publicUrl: opts.publicUrl,
+        }, store, logger.child('slack')).attach(events);
+    }
+    await registry.start();
+    scheduler.sync(registry.list());
+    const app = (0, server_1.createServer)({
+        store,
+        registry,
+        scheduler,
+        runner,
+        events,
+        readWrite: opts.readWrite,
+        logger: logger.child('api'),
+    });
+    const server = app.listen(opts.port, () => {
+        logger.info(`API and UI listening on http://localhost:${opts.port}`);
+    });
+    const pruneLogs = () => {
+        store.pruneOldLogs(opts.logRetentionDays)
+            .then(count => { if (count > 0)
+            logger.info(`Pruned ${count} log row(s) older than ${opts.logRetentionDays} days`); })
+            .catch(err => logger.error('Log retention pruning failed:', err));
+    };
+    pruneLogs();
+    const pruneTimer = setInterval(pruneLogs, LOG_PRUNE_INTERVAL_MS);
+    pruneTimer.unref();
+    let shuttingDown = false;
+    const shutdown = (signal) => {
+        if (shuttingDown)
+            return;
+        shuttingDown = true;
+        logger.info(`Received ${signal}, shutting down...`);
+        clearInterval(pruneTimer);
+        scheduler.stop();
+        registry.stop();
+        server.close();
+        runner.shutdown()
+            .then(() => store.close())
+            .then(() => {
+            logger.info('Shutdown complete');
+            process.exit(0);
+        })
+            .catch(err => {
+            logger.error('Error during shutdown:', err);
+            process.exit(1);
+        });
+    };
+    process.on('SIGTERM', () => shutdown('SIGTERM'));
+    process.on('SIGINT', () => shutdown('SIGINT'));
+}

package/dist/controller/job-runner.js

@@ -0,0 +1,314 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JobRunner = void 0;
+const child_process_1 = require("child_process");
+const path = __importStar(require("path"));
+const readline = __importStar(require("readline"));
+const types_1 = require("./types");
+const MAX_LOG_MESSAGE_BYTES = 8192;
+const LOG_FLUSH_LINES = 100;
+const LOG_FLUSH_MS = 500;
+const CANCEL_KILL_GRACE_MS = 10000;
+const SHUTDOWN_GRACE_MS = 25000;
+/**
+ * Runs sync jobs as child processes with a global concurrency cap and a
+ * per-config lock (a config never has two simultaneous runs). Captures the
+ * child's structured log stream into Postgres and fans it out over SSE.
+ */
+class JobRunner {
+    constructor(store, events, opts, logger) {
+        this.store = store;
+        this.events = events;
+        this.opts = opts;
+        this.logger = logger;
+        this.queue = [];
+        this.active = new Map(); // by runId
+        this.queuedConfigs = new Set();
+        this.activeConfigs = new Set();
+        this.shuttingDown = false;
+    }
+    isBusy(configId) {
+        return this.queuedConfigs.has(configId) || this.activeConfigs.has(configId);
+    }
+    runningCount() {
+        return this.active.size;
+    }
+    async enqueue(config, trigger) {
+        if (this.shuttingDown) {
+            throw new types_1.ConflictError('controller is shutting down');
+        }
+        if (this.isBusy(config.id)) {
+            if (trigger === 'scheduled') {
+                // Overlapping scheduled run: record it as skipped so the history shows why nothing happened
+                const run = await this.store.createRun(config.id, config.content_hash, trigger, 'skipped', 'previous run still queued or running');
+                this.events.emitRunUpdate(run);
+                this.logger.warn(`Skipped scheduled run for '${config.name}': previous run still in progress`);
+                return run;
+            }
+            throw new types_1.ConflictError('a run for this config is already queued or running');
+        }
+        if (config.parse_error) {
+            throw new types_1.ConflictError(`config is invalid: ${config.parse_error}`);
+        }
+        const run = await this.store.createRun(config.id, config.content_hash, trigger, 'queued');
+        this.queuedConfigs.add(config.id);
+        this.queue.push({ runId: run.id, configId: config.id, configPath: config.path });
+        this.events.emitRunUpdate(run);
+        this.pump();
+        return run;
+    }
+    pump() {
+        while (!this.shuttingDown && this.active.size < this.opts.maxParallel && this.queue.length > 0) {
+            const job = this.queue.shift();
+            this.queuedConfigs.delete(job.configId);
+            this.activeConfigs.add(job.configId);
+            this.start(job).catch(async (err) => {
+                this.logger.error(`Failed to start run ${job.runId}:`, err);
+                this.activeConfigs.delete(job.configId);
+                this.active.delete(job.runId);
+                const run = await this.store.finishRun(job.runId, {
+                    status: 'failed',
+                    error: `failed to spawn job: ${err instanceof Error ? err.message : String(err)}`,
+                });
+                this.events.emitRunUpdate(run);
+                this.pump();
+            });
+        }
+    }
+    commandFor(configPath) {
+        if (this.opts.commandFor)
+            return this.opts.commandFor(configPath);
+        // dist/controller/job-runner.js → dist/doc2vec.js
+        const scriptPath = path.resolve(__dirname, '..', 'doc2vec.js');
+        return { cmd: process.execPath, args: [scriptPath, 'run', configPath] };
+    }
+    async start(job) {
+        const { cmd, args } = this.commandFor(job.configPath);
+        this.logger.info(`Starting run ${job.runId}: ${cmd} ${args.join(' ')}`);
+        const child = (0, child_process_1.spawn)(cmd, args, {
+            env: { ...process.env, DOC2VEC_STRUCTURED_LOGS: '1' },
+            stdio: ['ignore', 'pipe', 'pipe'],
+        });
+        const activeJob = {
+            runId: job.runId,
+            configId: job.configId,
+            child,
+            seq: 0,
+            buffer: [],
+            flushTimer: null,
+            warnCount: 0,
+            errorCount: 0,
+            sources: null,
+            cancelReason: null,
+            killTimer: null,
+        };
+        this.active.set(job.runId, activeJob);
+        const run = await this.store.markRunStarted(job.runId, child.pid);
+        this.events.emitRunUpdate(run);
+        readline.createInterface({ input: child.stdout }).on('line', line => this.handleLine(activeJob, line, false));
+        readline.createInterface({ input: child.stderr }).on('line', line => this.handleLine(activeJob, line, true));
+        child.on('error', err => {
+            this.appendLog(activeJob, 'error', null, `spawn error: ${err.message}`);
+        });
+        child.on('close', (code, signal) => {
+            this.finish(activeJob, code, signal).catch(err => this.logger.error(`Failed to finalize run ${job.runId}:`, err));
+        });
+    }
+    handleLine(aj, raw, fromStderr) {
+        if (!raw.trim())
+            return;
+        let level = fromStderr ? 'warn' : 'info';
+        let module = null;
+        let message = raw;
+        let ts = new Date().toISOString();
+        try {
+            const obj = JSON.parse(raw);
+            if (obj && typeof obj === 'object') {
+                ts = obj.ts || ts;
+                module = obj.module ?? null;
+                if (obj.event === 'run-summary') {
+                    aj.sources = Array.isArray(obj.sources) ? obj.sources : null;
+                    return;
+                }
+                else if (obj.event === 'progress') {
+                    message = `${obj.title}: ${obj.current}/${obj.total}${obj.message ? ` — ${obj.message}` : ''}`;
+                    level = 'info';
+                }
+                else if (obj.event === 'section') {
+                    message = `═══ ${obj.title} ═══`;
+                    level = 'info';
+                }
+                else if (obj.msg !== undefined) {
+                    message = String(obj.msg);
+                    level = String(obj.level || level);
+                }
+            }
+        }
+        catch {
+            // Not JSON (e.g. Chromium noise on stderr) — keep the raw line
+        }
+        if (level === 'warn')
+            aj.warnCount++;
+        if (level === 'error')
+            aj.errorCount++;
+        this.appendLog(aj, level, module, message, ts);
+    }
+    appendLog(aj, level, module, message, ts = new Date().toISOString()) {
+        aj.buffer.push({
+            seq: ++aj.seq,
+            ts,
+            level,
+            module,
+            message: Buffer.byteLength(message) > MAX_LOG_MESSAGE_BYTES
+                ? message.slice(0, MAX_LOG_MESSAGE_BYTES) + '… [truncated]'
+                : message,
+        });
+        if (aj.buffer.length >= LOG_FLUSH_LINES) {
+            void this.flush(aj);
+        }
+        else if (!aj.flushTimer) {
+            aj.flushTimer = setTimeout(() => void this.flush(aj), LOG_FLUSH_MS);
+        }
+    }
+    async flush(aj) {
+        if (aj.flushTimer) {
+            clearTimeout(aj.flushTimer);
+            aj.flushTimer = null;
+        }
+        if (aj.buffer.length === 0)
+            return;
+        const rows = aj.buffer.splice(0, aj.buffer.length);
+        this.events.emitRunLogs(aj.runId, rows);
+        try {
+            await this.store.insertLogs(aj.runId, rows);
+        }
+        catch (err) {
+            this.logger.error(`Failed to persist ${rows.length} log line(s) for run ${aj.runId}:`, err);
+        }
+    }
+    async finish(aj, code, signal) {
+        if (aj.killTimer)
+            clearTimeout(aj.killTimer);
+        await this.flush(aj);
+        let status;
+        let error = null;
+        if (aj.cancelReason === 'user') {
+            status = 'canceled';
+        }
+        else if (aj.cancelReason === 'shutdown') {
+            status = 'failed';
+            error = 'controller shutdown';
+        }
+        else if (code === 0) {
+            status = 'succeeded';
+        }
+        else {
+            status = 'failed';
+            error = signal ? `terminated by signal ${signal}` : `exited with code ${code}`;
+            const failedSources = aj.sources?.filter(s => !s.ok) ?? [];
+            if (failedSources.length > 0) {
+                error = `${failedSources.length} source(s) failed: ${failedSources.map(s => s.product_name).join(', ')}`;
+            }
+        }
+        const run = await this.store.finishRun(aj.runId, {
+            status,
+            exitCode: code,
+            error,
+            stats: {
+                ...(aj.sources && { sources: aj.sources }),
+                warn_count: aj.warnCount,
+                error_count: aj.errorCount,
+            },
+        });
+        this.active.delete(aj.runId);
+        this.activeConfigs.delete(aj.configId);
+        this.logger.info(`Run ${aj.runId} finished: ${status}${error ? ` (${error})` : ''}`);
+        this.events.emitRunUpdate(run);
+        this.pump();
+    }
+    async cancel(runId) {
+        const queuedIndex = this.queue.findIndex(job => job.runId === runId);
+        if (queuedIndex >= 0) {
+            const [job] = this.queue.splice(queuedIndex, 1);
+            this.queuedConfigs.delete(job.configId);
+            const run = await this.store.finishRun(runId, { status: 'canceled', error: 'canceled while queued' });
+            this.events.emitRunUpdate(run);
+            return run;
+        }
+        const aj = this.active.get(runId);
+        if (!aj) {
+            throw new types_1.ConflictError('run is not queued or running');
+        }
+        aj.cancelReason = 'user';
+        aj.child.kill('SIGTERM');
+        aj.killTimer = setTimeout(() => {
+            if (this.active.has(runId))
+                aj.child.kill('SIGKILL');
+        }, CANCEL_KILL_GRACE_MS);
+        aj.killTimer.unref();
+        const run = await this.store.getRun(runId);
+        return run;
+    }
+    async shutdown() {
+        this.shuttingDown = true;
+        const queued = this.queue.splice(0, this.queue.length);
+        this.queuedConfigs.clear();
+        for (const job of queued) {
+            const run = await this.store.finishRun(job.runId, { status: 'canceled', error: 'controller shutdown' });
+            this.events.emitRunUpdate(run);
+        }
+        if (this.active.size === 0)
+            return;
+        this.logger.info(`Waiting for ${this.active.size} running job(s) to terminate...`);
+        for (const aj of this.active.values()) {
+            aj.cancelReason = aj.cancelReason ?? 'shutdown';
+            aj.child.kill('SIGTERM');
+        }
+        const deadline = Date.now() + SHUTDOWN_GRACE_MS;
+        while (this.active.size > 0 && Date.now() < deadline) {
+            await new Promise(resolve => setTimeout(resolve, 250));
+        }
+        for (const aj of this.active.values()) {
+            this.logger.warn(`Run ${aj.runId} did not exit in time, sending SIGKILL`);
+            aj.child.kill('SIGKILL');
+        }
+        const killDeadline = Date.now() + 3000;
+        while (this.active.size > 0 && Date.now() < killDeadline) {
+            await new Promise(resolve => setTimeout(resolve, 100));
+        }
+    }
+}
+exports.JobRunner = JobRunner;

package/dist/controller/migrations.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MIGRATIONS = void 0;
+/**
+ * Ordered schema migrations for the controller's Postgres database.
+ * Applied versions are tracked in d2v_schema_migrations; never edit an entry
+ * after it has shipped — append a new one instead.
+ */
+exports.MIGRATIONS = [
+    // 1: initial schema
+    `
+    CREATE TABLE IF NOT EXISTS d2v_configs (
+        id             SERIAL PRIMARY KEY,
+        path           TEXT NOT NULL UNIQUE,
+        name           TEXT NOT NULL,
+        content        TEXT NOT NULL,
+        content_hash   TEXT NOT NULL,
+        schedule       TEXT,
+        source_summary JSONB NOT NULL DEFAULT '[]',
+        parse_error    TEXT,
+        enabled        BOOLEAN NOT NULL DEFAULT TRUE,
+        deleted_at     TIMESTAMPTZ,
+        created_at     TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+        updated_at     TIMESTAMPTZ NOT NULL DEFAULT NOW()
+    );
+
+    CREATE TABLE IF NOT EXISTS d2v_runs (
+        id          SERIAL PRIMARY KEY,
+        config_id   INT NOT NULL REFERENCES d2v_configs(id),
+        config_hash TEXT NOT NULL,
+        trigger     TEXT NOT NULL CHECK (trigger IN ('scheduled','manual')),
+        status      TEXT NOT NULL CHECK (status IN ('queued','running','succeeded','failed','skipped','canceled')),
+        pid         INT,
+        exit_code   INT,
+        error       TEXT,
+        stats       JSONB NOT NULL DEFAULT '{}',
+        queued_at   TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+        started_at  TIMESTAMPTZ,
+        finished_at TIMESTAMPTZ
+    );
+
+    CREATE INDEX IF NOT EXISTS d2v_runs_config_queued_idx ON d2v_runs (config_id, queued_at DESC);
+    CREATE INDEX IF NOT EXISTS d2v_runs_status_idx ON d2v_runs (status);
+
+    CREATE TABLE IF NOT EXISTS d2v_run_logs (
+        run_id  INT NOT NULL REFERENCES d2v_runs(id) ON DELETE CASCADE,
+        seq     BIGINT NOT NULL,
+        ts      TIMESTAMPTZ NOT NULL,
+        level   TEXT NOT NULL,
+        module  TEXT,
+        message TEXT NOT NULL,
+        PRIMARY KEY (run_id, seq)
+    );
+    `,
+];

package/dist/controller/notifier.js

@@ -0,0 +1,106 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SlackNotifier = void 0;
+exports.buildRunMessage = buildRunMessage;
+// Terminal statuses worth a notification. 'skipped' (overlapping schedule)
+// is deliberately excluded — it would be pure noise on busy schedules.
+const NOTIFIED_STATUSES = ['succeeded', 'failed', 'canceled'];
+const STATUS_DECOR = {
+    succeeded: { emoji: '✅', verb: 'succeeded' },
+    failed: { emoji: '❌', verb: 'failed' },
+    canceled: { emoji: '⚠️', verb: 'was canceled' },
+};
+function formatDuration(run) {
+    if (!run.started_at || !run.finished_at)
+        return null;
+    const seconds = (new Date(run.finished_at).getTime() - new Date(run.started_at).getTime()) / 1000;
+    if (seconds < 60)
+        return `${Math.round(seconds)}s`;
+    const minutes = Math.floor(seconds / 60);
+    if (minutes < 60)
+        return `${minutes}m ${Math.round(seconds % 60)}s`;
+    return `${Math.floor(minutes / 60)}h ${minutes % 60}m`;
+}
+/** Builds the Slack webhook payload (Block Kit) for a finished run. */
+function buildRunMessage(run, configName, publicUrl) {
+    const decor = STATUS_DECOR[run.status] ?? { emoji: 'ℹ️', verb: run.status };
+    const sources = run.stats?.sources ?? [];
+    const failedSources = sources.filter(s => !s.ok);
+    let headline = `${decor.emoji} doc2vec sync *${configName}* ${decor.verb}`;
+    if (publicUrl) {
+        headline += ` — <${publicUrl.replace(/\/$/, '')}/runs/${run.id}|view run #${run.id}>`;
+    }
+    else {
+        headline += ` (run #${run.id})`;
+    }
+    const lines = [];
+    if (sources.length > 0) {
+        lines.push(`${sources.length - failedSources.length}/${sources.length} sources ok`);
+    }
+    if (failedSources.length > 0) {
+        const shown = failedSources.slice(0, 5)
+            .map(s => `• *${s.product_name}*: ${s.error ?? 'failed'}`);
+        if (failedSources.length > 5)
+            shown.push(`• …and ${failedSources.length - 5} more`);
+        lines.push(shown.join('\n'));
+    }
+    if (run.error && failedSources.length === 0) {
+        lines.push(run.error);
+    }
+    const meta = [`trigger: ${run.trigger}`];
+    const duration = formatDuration(run);
+    if (duration)
+        meta.push(`duration: ${duration}`);
+    if (run.stats?.warn_count)
+        meta.push(`warnings: ${run.stats.warn_count}`);
+    if (run.stats?.error_count)
+        meta.push(`errors: ${run.stats.error_count}`);
+    return {
+        text: `doc2vec sync ${configName} ${decor.verb}`, // fallback for notifications
+        blocks: [
+            {
+                type: 'section',
+                text: { type: 'mrkdwn', text: [headline, ...lines].join('\n') },
+            },
+            {
+                type: 'context',
+                elements: [{ type: 'mrkdwn', text: meta.join(' · ') }],
+            },
+        ],
+    };
+}
+/**
+ * Posts a Slack message (incoming webhook) whenever a run reaches a terminal
+ * status. Subscribes to the same event bus that feeds the UI, so every path
+ * that finishes a run — success, failure, cancel — is covered.
+ */
+class SlackNotifier {
+    constructor(opts, store, logger) {
+        this.opts = opts;
+        this.store = store;
+        this.logger = logger;
+    }
+    attach(events) {
+        events.on('run:update', (run) => {
+            this.maybeNotify(run).catch(err => this.logger.error(`Failed to send Slack notification for run ${run.id}:`, err));
+        });
+        this.logger.info(`Slack notifications enabled (${this.opts.notify})`);
+    }
+    async maybeNotify(run) {
+        if (!NOTIFIED_STATUSES.includes(run.status))
+            return;
+        if (this.opts.notify === 'failures' && run.status === 'succeeded')
+            return;
+        const config = await this.store.getConfig(run.config_id);
+        const payload = buildRunMessage(run, config?.name ?? `config ${run.config_id}`, this.opts.publicUrl);
+        const response = await fetch(this.opts.webhookUrl, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify(payload),
+        });
+        if (!response.ok) {
+            this.logger.warn(`Slack webhook returned ${response.status}: ${await response.text().catch(() => '')}`);
+        }
+    }
+}
+exports.SlackNotifier = SlackNotifier;

package/dist/controller/scheduler.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Scheduler = void 0;
+const croner_1 = require("croner");
+/**
+ * One croner Cron per config that has a valid schedule. Reconciled against the
+ * registry's current config list whenever configs change on disk.
+ */
+class Scheduler {
+    constructor(onTrigger, logger) {
+        this.onTrigger = onTrigger;
+        this.logger = logger;
+        this.crons = new Map();
+    }
+    sync(configs) {
+        const seen = new Set();
+        for (const config of configs) {
+            if (!config.schedule || config.parse_error || !config.enabled || config.deleted_at)
+                continue;
+            seen.add(config.id);
+            const existing = this.crons.get(config.id);
+            if (existing && existing.getPattern() === config.schedule)
+                continue;
+            existing?.stop();
+            try {
+                const cron = new croner_1.Cron(config.schedule, { name: `config-${config.id}` }, () => {
+                    this.onTrigger(config.id);
+                });
+                this.crons.set(config.id, cron);
+                this.logger.info(`Scheduled '${config.name}' (${config.schedule}), next run ${cron.nextRun()?.toISOString() ?? 'never'}`);
+            }
+            catch (err) {
+                this.crons.delete(config.id);
+                this.logger.warn(`Failed to schedule '${config.name}' with '${config.schedule}':`, err);
+            }
+        }
+        for (const [id, cron] of this.crons) {
+            if (!seen.has(id)) {
+                cron.stop();
+                this.crons.delete(id);
+                this.logger.info(`Unscheduled config ${id}`);
+            }
+        }
+    }
+    nextRun(configId) {
+        return this.crons.get(configId)?.nextRun()?.toISOString() ?? null;
+    }
+    stop() {
+        for (const cron of this.crons.values())
+            cron.stop();
+        this.crons.clear();
+    }
+}
+exports.Scheduler = Scheduler;