opc-agent 1.4.0 → 2.0.1

package/dist/core/runtime.js

@@ -1,15 +1,56 @@
 "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.AgentRuntime = void 0;
 exports.truncateOutput = truncateOutput;
+const plugins_1 = require("../plugins");
+const logger_1 = require("../plugins/logger");
+const rate_limiter_1 = require("../plugins/rate-limiter");
+const content_filter_1 = require("../plugins/content-filter");
 const agent_1 = require("./agent");
 const config_1 = require("./config");
-const logger_1 = require("./logger");
+const logger_2 = require("./logger");
 const web_1 = require("../channels/web");
 const telegram_1 = require("../channels/telegram");
 const websocket_1 = require("../channels/websocket");
+const wechat_1 = require("../channels/wechat");
+const feishu_1 = require("../channels/feishu");
+const email_1 = require("../channels/email");
 const deepbrain_1 = require("../memory/deepbrain");
 const analytics_1 = require("../analytics");
+const scheduler_1 = require("./scheduler");
 const MAX_TOOL_OUTPUT = 5000;
 const DEFAULT_HISTORY_LIMIT = 50;
 function truncateOutput(output, maxChars = MAX_TOOL_OUTPUT) {
@@ -21,11 +62,16 @@ function truncateOutput(output, maxChars = MAX_TOOL_OUTPUT) {
 class AgentRuntime {
     agent = null;
     config = null;
-    logger = new logger_1.Logger('runtime');
+    logger = new logger_2.Logger('runtime');
     historyLimit = DEFAULT_HISTORY_LIMIT;
     shutdownHandlers = [];
     isShuttingDown = false;
     analytics = new analytics_1.Analytics();
+    scheduler = null;
+    pluginManager = new plugins_1.PluginManager();
+    brain = null;
+    agentBrain = null;
+    evolveScheduler = null;
     async loadConfig(filePath) {
         this.config = (0, config_1.loadOAD)(filePath);
         this.logger.info('Config loaded', { name: this.config.metadata.name });
@@ -103,8 +149,88 @@ class AgentRuntime {
                 this.agent.bindChannel(new websocket_1.WebSocketChannel(ch.port ?? 3002));
                 this.logger.info('Bound websocket channel', { port: ch.port ?? 3002 });
             }
+            else if (ch.type === 'wechat') {
+                this.agent.bindChannel(new wechat_1.WeChatChannel({
+                    appId: ch.config?.appId ?? process.env.WECHAT_APP_ID ?? '',
+                    appSecret: ch.config?.appSecret ?? process.env.WECHAT_APP_SECRET ?? '',
+                    token: ch.config?.token ?? process.env.WECHAT_TOKEN ?? '',
+                    encodingAESKey: ch.config?.encodingAESKey,
+                    port: ch.port,
+                }));
+                this.logger.info('Bound wechat channel', { port: ch.port ?? 8080 });
+            }
+            else if (ch.type === 'feishu') {
+                this.agent.bindChannel(new feishu_1.FeishuChannel({
+                    appId: ch.config?.appId ?? process.env.FEISHU_APP_ID,
+                    appSecret: ch.config?.appSecret ?? process.env.FEISHU_APP_SECRET,
+                    verificationToken: ch.config?.verificationToken ?? process.env.FEISHU_VERIFICATION_TOKEN,
+                    encryptKey: ch.config?.encryptKey,
+                    port: ch.port,
+                }));
+                this.logger.info('Bound feishu channel', { port: ch.port ?? 8081 });
+            }
+            else if (ch.type === 'email') {
+                this.agent.bindChannel(new email_1.EmailChannel({
+                    mode: ch.config?.mode ?? 'webhook',
+                    smtp: ch.config?.smtp,
+                    imap: ch.config?.imap,
+                    webhookPort: ch.port,
+                    filters: ch.config?.filters,
+                }));
+                this.logger.info('Bound email channel', { mode: ch.config?.mode ?? 'webhook', port: ch.port ?? 8082 });
+            }
         }
         await this.agent.init();
+        // === Auto-wire DeepBrain long-term memory (Brain/AgentBrain) ===
+        const longTermCfg = memCfg && typeof memCfg.longTerm === 'object' ? memCfg.longTerm : null;
+        if (longTermCfg?.provider === 'deepbrain') {
+            try {
+                const deepbrainModule = await Promise.resolve().then(() => __importStar(require(/* webpackIgnore: true */ 'deepbrain')));
+                const BrainClass = deepbrainModule.Brain ?? deepbrainModule.default?.Brain;
+                const AgentBrainClass = deepbrainModule.AgentBrain ?? deepbrainModule.default?.AgentBrain;
+                if (BrainClass && AgentBrainClass) {
+                    const dbConfig = longTermCfg.config ?? {};
+                    const dbPath = dbConfig.database || './data/brain.db';
+                    const embeddingProvider = dbConfig.embeddingProvider || 'ollama';
+                    this.brain = new BrainClass({
+                        database: dbPath,
+                        embedding_provider: embeddingProvider,
+                    });
+                    await this.brain.connect();
+                    this.agentBrain = new AgentBrainClass(this.brain, cfg.metadata.name);
+                    this.agent.setLongTermMemory(this.agentBrain, {
+                        autoLearn: dbConfig.autoLearn !== false,
+                        autoRecall: dbConfig.autoRecall !== false,
+                    });
+                    this.logger.info('DeepBrain Brain/AgentBrain connected', { database: dbPath });
+                    // Brain seed loading
+                    const { existsSync, readFileSync, renameSync } = await Promise.resolve().then(() => __importStar(require('fs')));
+                    const seedPath = './data/brain-seed.md';
+                    if (existsSync(seedPath)) {
+                        const seed = readFileSync(seedPath, 'utf-8');
+                        await this.brain.put('brain-seed', seed, { type: 'seed', tags: ['seed', 'initial'] });
+                        renameSync(seedPath, './data/brain-seed.loaded.md');
+                        this.logger.info('Brain seed loaded');
+                    }
+                    // Auto-evolve scheduling
+                    const evolveInterval = dbConfig.evolveInterval;
+                    if (evolveInterval && evolveInterval > 0) {
+                        const AutoEvolveSchedulerClass = deepbrainModule.AutoEvolveScheduler ?? deepbrainModule.default?.AutoEvolveScheduler;
+                        if (AutoEvolveSchedulerClass) {
+                            this.evolveScheduler = new AutoEvolveSchedulerClass();
+                            this.evolveScheduler.start(this.agentBrain, evolveInterval);
+                            this.logger.info('DeepBrain auto-evolve scheduled', { interval: evolveInterval });
+                        }
+                    }
+                }
+                else {
+                    this.logger.warn('DeepBrain module found but Brain/AgentBrain classes not available');
+                }
+            }
+            catch (e) {
+                this.logger.warn('DeepBrain not available (install with: npm install deepbrain)', { error: e.message });
+            }
+        }
         // Wire analytics to agent events
         this.agent.on('message:out', () => {
             // responseTime is approximated; real timing is done via skill/llm events
@@ -116,6 +242,57 @@ class AgentRuntime {
             this.analytics.recordError();
         });
         this.logger.info('Agent initialized', { name: cfg.metadata.name });
+        // Load enhanced plugins from OAD config
+        const pluginsCfg = cfg.spec.plugins;
+        if (pluginsCfg && Array.isArray(pluginsCfg)) {
+            const builtinPlugins = {
+                'logger': () => logger_1.loggerPlugin,
+                'rate-limiter': (c) => (0, rate_limiter_1.createRateLimiterPlugin)(c?.maxPerMinute ?? 60),
+                'content-filter': (c) => (0, content_filter_1.createContentFilterPlugin)(c?.blocklist ?? []),
+            };
+            for (const entry of pluginsCfg) {
+                const factory = builtinPlugins[entry.name];
+                if (factory) {
+                    this.pluginManager.registerEnhanced(factory(entry.config));
+                    this.logger.info('Enhanced plugin loaded from config', { name: entry.name });
+                }
+            }
+        }
+        await this.pluginManager.initAll(this);
+        // Initialize scheduler if jobs are configured
+        const schedulerCfg = cfg.spec.scheduler;
+        if (schedulerCfg?.jobs && Array.isArray(schedulerCfg.jobs) && schedulerCfg.jobs.length > 0) {
+            this.scheduler = new scheduler_1.Scheduler(async (job) => {
+                this.logger.info('Scheduler firing job', { name: job.name, task: job.task });
+                if (this.agent) {
+                    const msg = {
+                        id: `cron-${job.id}-${Date.now()}`,
+                        role: 'user',
+                        content: job.task,
+                        timestamp: Date.now(),
+                        metadata: { source: 'scheduler', jobId: job.id, jobName: job.name },
+                    };
+                    try {
+                        await this.agent.handleMessage(msg);
+                    }
+                    catch (err) {
+                        this.logger.error('Scheduler job failed', { name: job.name, error: err instanceof Error ? err.message : String(err) });
+                    }
+                }
+            });
+            for (let i = 0; i < schedulerCfg.jobs.length; i++) {
+                const j = schedulerCfg.jobs[i];
+                const id = j.id || j.name?.toLowerCase().replace(/\s+/g, '-') || `job-${i}`;
+                this.scheduler.addJob({
+                    id,
+                    name: j.name || id,
+                    schedule: j.schedule,
+                    task: j.task || '',
+                    enabled: j.enabled !== false,
+                });
+            }
+            this.logger.info('Scheduler configured', { jobs: schedulerCfg.jobs.length });
+        }
         return this.agent;
     }
     async start() {
@@ -123,12 +300,35 @@ class AgentRuntime {
             throw new Error('Agent not initialized.');
         this.setupGracefulShutdown();
         await this.agent.start();
+        if (this.scheduler) {
+            this.scheduler.start();
+            this.logger.info('Scheduler started');
+        }
         this.logger.info('Agent started');
     }
     async stop() {
         if (!this.agent)
             return;
         this.logger.info('Stopping agent...');
+        if (this.evolveScheduler) {
+            try {
+                this.evolveScheduler.stop();
+            }
+            catch { /* ignore */ }
+            this.logger.info('DeepBrain auto-evolve stopped');
+        }
+        if (this.brain) {
+            try {
+                await this.brain.disconnect();
+                this.logger.info('DeepBrain disconnected');
+            }
+            catch { /* ignore */ }
+        }
+        if (this.scheduler) {
+            this.scheduler.stop();
+            this.logger.info('Scheduler stopped');
+        }
+        await this.pluginManager.shutdownAll();
         await this.agent.stop();
         for (const handler of this.shutdownHandlers) {
             await handler();
@@ -169,6 +369,9 @@ class AgentRuntime {
     getConfig() {
         return this.config;
     }
+    getPluginManager() {
+        return this.pluginManager;
+    }
 }
 exports.AgentRuntime = AgentRuntime;
 //# sourceMappingURL=runtime.js.map

package/dist/core/sandbox.d.ts

@@ -4,6 +4,22 @@ export interface SandboxConfig {
     agentDir: string;
     networkAllowlist?: string[];
     shellAllowed?: boolean;
+    allowedCommands?: string[];
+    blockedCommands?: string[];
+    maxFileSize?: number;
+    maxFiles?: number;
+    networkAccess?: boolean;
+    readOnlyPaths?: string[];
+    timeout?: number;
+}
+export interface ValidationResult {
+    allowed: boolean;
+    reason?: string;
+}
+export interface SandboxStatus {
+    files: number;
+    totalSize: number;
+    violations: number;
 }
 export interface SandboxRestrictions {
     fileSystem: {
@@ -18,11 +34,21 @@ export interface SandboxRestrictions {
 export declare class Sandbox {
     private config;
     private restrictions;
+    private violations;
+    private maxFileSize;
+    private maxFiles;
     constructor(config: SandboxConfig);
     get trustLevel(): TrustLevelType;
     getRestrictions(): SandboxRestrictions;
     checkFileAccess(filePath: string, mode: 'read' | 'write'): boolean;
     checkNetworkAccess(url: string): boolean;
     checkShellAccess(): boolean;
+    validateFileOp(action: 'read' | 'write' | 'delete', filePath: string): ValidationResult;
+    validateCommand(command: string): ValidationResult;
+    validateNetwork(url: string): ValidationResult;
+    getStatus(): SandboxStatus;
+    getViolations(): number;
+    getMaxFileSize(): number;
+    getMaxFiles(): number;
 }
 //# sourceMappingURL=sandbox.d.ts.map

package/dist/core/sandbox.js

@@ -35,6 +35,7 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Sandbox = void 0;
 const path = __importStar(require("path"));
+const fs = __importStar(require("fs"));
 const TRUST_RESTRICTIONS = {
     sandbox: {
         fileSystem: { read: ['.'], write: ['.'] },
@@ -60,6 +61,9 @@ const TRUST_RESTRICTIONS = {
 class Sandbox {
     config;
     restrictions;
+    violations = 0;
+    maxFileSize;
+    maxFiles;
     constructor(config) {
         this.config = config;
         this.restrictions = {
@@ -71,6 +75,11 @@ class Sandbox {
         if (config.shellAllowed !== undefined) {
             this.restrictions.shell = config.shellAllowed;
         }
+        if (config.networkAccess === false) {
+            this.restrictions.network.allowed = [];
+        }
+        this.maxFileSize = config.maxFileSize ?? 10 * 1024 * 1024; // 10MB
+        this.maxFiles = config.maxFiles ?? 1000;
     }
     get trustLevel() {
         return this.config.trustLevel;
@@ -113,6 +122,114 @@ class Sandbox {
     checkShellAccess() {
         return this.restrictions.shell;
     }
+    validateFileOp(action, filePath) {
+        const resolved = path.resolve(filePath);
+        if (action === 'write' || action === 'delete') {
+            // Check read-only paths
+            if (this.config.readOnlyPaths) {
+                for (const ro of this.config.readOnlyPaths) {
+                    const roResolved = path.resolve(ro);
+                    if (resolved.startsWith(roResolved) || resolved === roResolved) {
+                        this.violations++;
+                        return { allowed: false, reason: `Path is read-only: ${ro}` };
+                    }
+                }
+            }
+            // Check file size for writes
+            if (action === 'write') {
+                try {
+                    if (fs.existsSync(resolved)) {
+                        const stat = fs.statSync(resolved);
+                        if (stat.size > this.maxFileSize) {
+                            this.violations++;
+                            return { allowed: false, reason: `File exceeds max size: ${this.maxFileSize} bytes` };
+                        }
+                    }
+                }
+                catch {
+                    // File doesn't exist yet — that's fine
+                }
+            }
+        }
+        const mode = action === 'read' ? 'read' : 'write';
+        if (!this.checkFileAccess(filePath, mode)) {
+            this.violations++;
+            return { allowed: false, reason: `File access denied for ${action}: ${filePath}` };
+        }
+        return { allowed: true };
+    }
+    validateCommand(command) {
+        if (!this.restrictions.shell) {
+            this.violations++;
+            return { allowed: false, reason: 'Shell access is disabled' };
+        }
+        // Check blocklist
+        if (this.config.blockedCommands) {
+            for (const blocked of this.config.blockedCommands) {
+                if (command.includes(blocked)) {
+                    this.violations++;
+                    return { allowed: false, reason: `Command is blocked: ${blocked}` };
+                }
+            }
+        }
+        // Check allowlist (if set, only allowed commands pass)
+        if (this.config.allowedCommands && this.config.allowedCommands.length > 0) {
+            const allowed = this.config.allowedCommands.some(a => command.startsWith(a) || command.includes(a));
+            if (!allowed) {
+                this.violations++;
+                return { allowed: false, reason: 'Command not in allowlist' };
+            }
+        }
+        return { allowed: true };
+    }
+    validateNetwork(url) {
+        if (this.config.networkAccess === false) {
+            this.violations++;
+            return { allowed: false, reason: 'Network access is disabled' };
+        }
+        if (!this.checkNetworkAccess(url)) {
+            this.violations++;
+            return { allowed: false, reason: `Network access denied for: ${url}` };
+        }
+        return { allowed: true };
+    }
+    getStatus() {
+        let files = 0;
+        let totalSize = 0;
+        try {
+            const agentDir = path.resolve(this.config.agentDir);
+            if (fs.existsSync(agentDir)) {
+                const countFiles = (dir) => {
+                    const entries = fs.readdirSync(dir, { withFileTypes: true });
+                    for (const entry of entries) {
+                        const full = path.join(dir, entry.name);
+                        if (entry.isDirectory() && entry.name !== 'node_modules') {
+                            countFiles(full);
+                        }
+                        else if (entry.isFile()) {
+                            files++;
+                            try {
+                                totalSize += fs.statSync(full).size;
+                            }
+                            catch { }
+                        }
+                    }
+                };
+                countFiles(agentDir);
+            }
+        }
+        catch { }
+        return { files, totalSize, violations: this.violations };
+    }
+    getViolations() {
+        return this.violations;
+    }
+    getMaxFileSize() {
+        return this.maxFileSize;
+    }
+    getMaxFiles() {
+        return this.maxFiles;
+    }
 }
 exports.Sandbox = Sandbox;
 //# sourceMappingURL=sandbox.js.map

package/dist/core/scheduler.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Simple cron scheduler — no external dependencies.
+ * Supports cron expressions: star, star-slash-N, M-N, M,N for minute/hour/day/month/weekday.
+ */
+export interface CronJob {
+    id: string;
+    name: string;
+    schedule: string;
+    task: string;
+    enabled: boolean;
+    lastRun?: Date;
+    nextRun?: Date;
+}
+type CronField = {
+    type: 'any';
+} | {
+    type: 'every';
+    step: number;
+} | {
+    type: 'list';
+    values: number[];
+};
+interface ParsedCron {
+    minute: CronField;
+    hour: CronField;
+    dayOfMonth: CronField;
+    month: CronField;
+    dayOfWeek: CronField;
+}
+export declare function parseCron(expr: string): ParsedCron;
+export declare function cronMatches(parsed: ParsedCron, date: Date): boolean;
+export type JobHandler = (job: CronJob) => void | Promise<void>;
+export declare class Scheduler {
+    private jobs;
+    private parsed;
+    private timer;
+    private handler;
+    constructor(handler: JobHandler);
+    addJob(job: CronJob): void;
+    removeJob(id: string): void;
+    enableJob(id: string): void;
+    disableJob(id: string): void;
+    getJobs(): CronJob[];
+    getJob(id: string): CronJob | undefined;
+    /** Run a specific job immediately */
+    runJob(id: string): Promise<boolean>;
+    start(): void;
+    stop(): void;
+    private tick;
+}
+export {};
+//# sourceMappingURL=scheduler.d.ts.map

package/dist/core/scheduler.js

@@ -0,0 +1,168 @@
+"use strict";
+/**
+ * Simple cron scheduler — no external dependencies.
+ * Supports cron expressions: star, star-slash-N, M-N, M,N for minute/hour/day/month/weekday.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Scheduler = void 0;
+exports.parseCron = parseCron;
+exports.cronMatches = cronMatches;
+function parseField(field, min, max) {
+    if (field === '*')
+        return { type: 'any' };
+    if (field.startsWith('*/')) {
+        const step = parseInt(field.slice(2), 10);
+        if (isNaN(step) || step <= 0)
+            throw new Error(`Invalid cron step: ${field}`);
+        return { type: 'every', step };
+    }
+    // Could be comma-separated, each part could be a range
+    const values = [];
+    for (const part of field.split(',')) {
+        if (part.includes('-')) {
+            const [a, b] = part.split('-').map(Number);
+            if (isNaN(a) || isNaN(b))
+                throw new Error(`Invalid cron range: ${part}`);
+            for (let i = a; i <= b; i++)
+                values.push(i);
+        }
+        else {
+            const n = parseInt(part, 10);
+            if (isNaN(n))
+                throw new Error(`Invalid cron value: ${part}`);
+            values.push(n);
+        }
+    }
+    return { type: 'list', values };
+}
+function parseCron(expr) {
+    const parts = expr.trim().split(/\s+/);
+    if (parts.length !== 5)
+        throw new Error(`Invalid cron expression (need 5 fields): ${expr}`);
+    return {
+        minute: parseField(parts[0], 0, 59),
+        hour: parseField(parts[1], 0, 23),
+        dayOfMonth: parseField(parts[2], 1, 31),
+        month: parseField(parts[3], 1, 12),
+        dayOfWeek: parseField(parts[4], 0, 6),
+    };
+}
+function fieldMatches(field, value) {
+    switch (field.type) {
+        case 'any': return true;
+        case 'every': return value % field.step === 0;
+        case 'list': return field.values.includes(value);
+    }
+}
+function cronMatches(parsed, date) {
+    return (fieldMatches(parsed.minute, date.getMinutes()) &&
+        fieldMatches(parsed.hour, date.getHours()) &&
+        fieldMatches(parsed.dayOfMonth, date.getDate()) &&
+        fieldMatches(parsed.month, date.getMonth() + 1) &&
+        fieldMatches(parsed.dayOfWeek, date.getDay()));
+}
+/** Compute approximate next run (scans forward up to 48h). */
+function computeNextRun(parsed, from) {
+    const d = new Date(from);
+    d.setSeconds(0, 0);
+    d.setMinutes(d.getMinutes() + 1);
+    const limit = 48 * 60; // 48 hours in minutes
+    for (let i = 0; i < limit; i++) {
+        if (cronMatches(parsed, d))
+            return new Date(d);
+        d.setMinutes(d.getMinutes() + 1);
+    }
+    return undefined;
+}
+class Scheduler {
+    jobs = new Map();
+    parsed = new Map();
+    timer = null;
+    handler;
+    constructor(handler) {
+        this.handler = handler;
+    }
+    addJob(job) {
+        const p = parseCron(job.schedule);
+        this.parsed.set(job.id, p);
+        job.nextRun = computeNextRun(p, new Date()) ?? undefined;
+        this.jobs.set(job.id, job);
+    }
+    removeJob(id) {
+        this.jobs.delete(id);
+        this.parsed.delete(id);
+    }
+    enableJob(id) {
+        const job = this.jobs.get(id);
+        if (job)
+            job.enabled = true;
+    }
+    disableJob(id) {
+        const job = this.jobs.get(id);
+        if (job)
+            job.enabled = false;
+    }
+    getJobs() {
+        return Array.from(this.jobs.values());
+    }
+    getJob(id) {
+        return this.jobs.get(id);
+    }
+    /** Run a specific job immediately */
+    async runJob(id) {
+        const job = this.jobs.get(id);
+        if (!job)
+            return false;
+        job.lastRun = new Date();
+        await this.handler(job);
+        const parsed = this.parsed.get(id);
+        if (parsed)
+            job.nextRun = computeNextRun(parsed, new Date());
+        return true;
+    }
+    start() {
+        if (this.timer)
+            return;
+        // Check every 60 seconds
+        this.timer = setInterval(() => this.tick(), 60_000);
+        // Also tick immediately
+        this.tick();
+    }
+    stop() {
+        if (this.timer) {
+            clearInterval(this.timer);
+            this.timer = null;
+        }
+    }
+    tick() {
+        const now = new Date();
+        for (const [id, job] of this.jobs) {
+            if (!job.enabled)
+                continue;
+            const parsed = this.parsed.get(id);
+            if (!parsed)
+                continue;
+            if (cronMatches(parsed, now)) {
+                // Avoid double-fire: check lastRun isn't same minute
+                if (job.lastRun) {
+                    const last = job.lastRun;
+                    if (last.getFullYear() === now.getFullYear() &&
+                        last.getMonth() === now.getMonth() &&
+                        last.getDate() === now.getDate() &&
+                        last.getHours() === now.getHours() &&
+                        last.getMinutes() === now.getMinutes()) {
+                        continue;
+                    }
+                }
+                job.lastRun = new Date(now);
+                job.nextRun = computeNextRun(parsed, now);
+                // Fire and forget (log errors)
+                Promise.resolve(this.handler(job)).catch((err) => {
+                    console.error(`[scheduler] Job "${job.name}" failed:`, err);
+                });
+            }
+        }
+    }
+}
+exports.Scheduler = Scheduler;
+//# sourceMappingURL=scheduler.js.map