aiden-runtime 4.1.5 → 4.5.0

package/dist/cli/v4/commands/cron.js

@@ -61,12 +61,18 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.cron = void 0;
 exports.tokenize = tokenize;
 exports.resolveJob = resolveJob;
+exports.runCronSubcommand = runCronSubcommand;
 const node_fs_1 = require("node:fs");
 const fs = __importStar(require("node:fs"));
 const path = __importStar(require("node:path"));
 const os = __importStar(require("node:os"));
 const table_1 = require("../table");
 const cronManager_1 = require("../../../core/cronManager");
+// v4.5 Phase 6 — daemon-mode scheduled_workflows read-through.
+const daemon_1 = require("../../../core/v4/daemon");
+const cronBridge_1 = require("../../../core/v4/daemon/cron/cronBridge");
+const misfirePolicy_1 = require("../../../core/v4/daemon/cron/misfirePolicy");
+const paths_1 = require("../../../core/v4/paths");
 const NAME_RE = /^[A-Za-z0-9_-]+$/;
 const LOGS_DIR = path.join(os.homedir(), '.aiden', 'cron-logs');
 const TAIL_LINES = 100;
@@ -333,6 +339,264 @@ async function cmdRemove(ctx, args) {
         ctx.display.printError('Remove failed.');
     }
 }
+const cronNoopOut = (s) => { process.stdout.write(s); };
+const cronNoopErr = (s) => { process.stderr.write(s); };
+/** Read the scheduled_workflows rows for the daemon-mode view. */
+function readScheduledWorkflows() {
+    const out = new Map();
+    try {
+        const root = (0, paths_1.resolveAidenRoot)();
+        const db = (0, daemon_1.openDaemonDb)((0, daemon_1.daemonDbPath)(root));
+        const rows = db.prepare(`SELECT id, misfire_policy, last_fired_at, next_fire_at FROM scheduled_workflows`).all();
+        for (const r of rows)
+            out.set(r.id, r);
+    }
+    catch { /* daemon DB absent — return empty map */ }
+    return out;
+}
+/** Write/refresh a scheduled_workflows row from a CronJobV2. Idempotent. */
+function upsertScheduledWorkflow(job, misfirePolicy, promptTemplate, deliverOnly) {
+    try {
+        const root = (0, paths_1.resolveAidenRoot)();
+        const db = (0, daemon_1.openDaemonDb)((0, daemon_1.daemonDbPath)(root));
+        const row = (0, cronBridge_1.jobToRow)(job);
+        const policy = misfirePolicy && (0, misfirePolicy_1.isMisfirePolicy)(misfirePolicy) ? misfirePolicy : row.misfire_policy;
+        db.prepare(`INSERT INTO scheduled_workflows
+         (id, name, schedule_expression, timezone, enabled, payload_json,
+          prompt_template, deliver_only, misfire_policy, fire_rate_limit,
+          catch_up_limit, grace_ms, last_fired_at, next_fire_at,
+          created_at, updated_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+       ON CONFLICT(id) DO UPDATE SET
+         name = excluded.name,
+         schedule_expression = excluded.schedule_expression,
+         enabled = excluded.enabled,
+         payload_json = excluded.payload_json,
+         prompt_template = excluded.prompt_template,
+         deliver_only = excluded.deliver_only,
+         misfire_policy = excluded.misfire_policy,
+         updated_at = excluded.updated_at`).run(row.id, row.name, row.schedule_expression, row.timezone, row.enabled, row.payload_json, promptTemplate ?? row.prompt_template, deliverOnly === true ? 1 : 0, policy, row.fire_rate_limit, row.catch_up_limit, row.grace_ms, row.last_fired_at, row.next_fire_at, row.created_at, row.updated_at);
+    }
+    catch { /* daemon DB absent — JSON path still wrote the job */ }
+}
+/** Delete a scheduled_workflows row. Best-effort. */
+function deleteScheduledWorkflow(id) {
+    try {
+        const root = (0, paths_1.resolveAidenRoot)();
+        const db = (0, daemon_1.openDaemonDb)((0, daemon_1.daemonDbPath)(root));
+        db.prepare(`DELETE FROM scheduled_workflows WHERE id = ?`).run(id);
+    }
+    catch { /* noop */ }
+}
+/** Set enabled = 0/1 on scheduled_workflows. Best-effort. */
+function setWorkflowEnabled(id, enabled) {
+    try {
+        const root = (0, paths_1.resolveAidenRoot)();
+        const db = (0, daemon_1.openDaemonDb)((0, daemon_1.daemonDbPath)(root));
+        db.prepare(`UPDATE scheduled_workflows SET enabled = ?, updated_at = ? WHERE id = ?`).run(enabled, Date.now(), id);
+    }
+    catch { /* noop */ }
+}
+/**
+ * Top-level `aiden cron` dispatcher. Mirrors runTriggerSubcommand shape.
+ */
+async function runCronSubcommand(action, args, argv, opts = {}) {
+    const out = opts.writeOut ?? cronNoopOut;
+    const err = opts.writeErr ?? cronNoopErr;
+    switch (action) {
+        case 'add': return cmdCliAdd(argv, out, err);
+        case 'list': return cmdCliList(out);
+        case 'show': return cmdCliShow(args[0], out, err);
+        case 'remove':
+        case 'rm': return cmdCliRemove(args[0], out, err);
+        case 'enable': return cmdCliEnable(args[0], out, err);
+        case 'disable': return cmdCliDisable(args[0], out, err);
+        case 'run': return cmdCliRun(args[0], out, err);
+        case 'logs': return cmdCliLogs(args[0], out, err);
+        default:
+            err(`Unknown cron action: ${action}\n`);
+            err('Actions: add, list, show <id>, remove <id>, enable <id>, disable <id>, run <id>, logs <id>\n');
+            return 2;
+    }
+}
+async function cmdCliAdd(a, out, err) {
+    const name = a.name ?? a.label;
+    if (!name || !NAME_RE.test(name)) {
+        err('cron add: --label is required (alphanumeric, dash, underscore only)\n');
+        return 2;
+    }
+    if (!a.schedule || a.schedule.length === 0) {
+        err('cron add: --schedule is required (cron expr, "every Nm/h/d", or ISO timestamp)\n');
+        return 2;
+    }
+    if (!a.command || a.command.length === 0) {
+        err('cron add: --command is required\n');
+        return 2;
+    }
+    if (a.misfirePolicy && !(0, misfirePolicy_1.isMisfirePolicy)(a.misfirePolicy)) {
+        err(`cron add: invalid --misfire-policy "${a.misfirePolicy}" (skip_stale|run_once_if_late|catch_up_with_limit|manual_review)\n`);
+        return 2;
+    }
+    if (resolveJob(name)) {
+        err(`cron add: a job named "${name}" already exists\n`);
+        return 2;
+    }
+    let job;
+    try {
+        job = await (0, cronManager_1.createJobAsync)(name, a.schedule, a.command);
+    }
+    catch (e) {
+        err(`cron add: ${e instanceof Error ? e.message : String(e)}\n`);
+        return 2;
+    }
+    // Mirror to SQLite for daemon-mode visibility.
+    upsertScheduledWorkflow(job, a.misfirePolicy, a.promptTemplate, a.deliverOnly === true);
+    await (0, cronManager_1.awaitPendingSaves)();
+    out(`cron added: ${job.id} (${job.description})\n`);
+    out(`  schedule:       ${job.schedule}\n`);
+    out(`  command:        ${job.action}\n`);
+    if (a.misfirePolicy)
+        out(`  misfire policy: ${a.misfirePolicy}\n`);
+    if (a.deliverOnly)
+        out(`  deliver_only:   true (daemon will skip the agent loop)\n`);
+    if (job.nextRun)
+        out(`  next run:       ${fmtTime(job.nextRun)}\n`);
+    return 0;
+}
+function cmdCliList(out) {
+    const jobs = (0, cronManager_1.listJobs)();
+    if (jobs.length === 0) {
+        out('No cron jobs.\n');
+        return 0;
+    }
+    const sqlView = readScheduledWorkflows();
+    out(`${'id'.padEnd(10)}  ${'enabled'.padEnd(8)}  ${'schedule'.padEnd(20)}  ${'misfire'.padEnd(20)}  ${'lastRun'.padEnd(20)}  name\n`);
+    for (const j of jobs) {
+        const sql = sqlView.get(j.id);
+        const id = j.id.slice(0, 10).padEnd(10);
+        const enabled = (j.enabled ? 'on' : 'off').padEnd(8);
+        const sched = (j.schedule || '').slice(0, 20).padEnd(20);
+        const policy = (sql?.misfire_policy ?? '-').padEnd(20);
+        const lastRun = (j.lastRun ? fmtTime(j.lastRun) : '-').padEnd(20);
+        out(`${id}  ${enabled}  ${sched}  ${policy}  ${lastRun}  ${j.description}\n`);
+    }
+    out(`\n${jobs.length} job${jobs.length === 1 ? '' : 's'}\n`);
+    return 0;
+}
+function cmdCliShow(ref, out, err) {
+    if (!ref) {
+        err('cron show: id or name required\n');
+        return 2;
+    }
+    const job = resolveJob(ref);
+    if (!job) {
+        err(`cron show: not found: ${ref}\n`);
+        return 1;
+    }
+    const sqlView = readScheduledWorkflows().get(job.id);
+    out(JSON.stringify({
+        jsonView: job,
+        sqlView: sqlView ?? null,
+    }, null, 2) + '\n');
+    return 0;
+}
+async function cmdCliRemove(ref, out, err) {
+    if (!ref) {
+        err('cron remove: id or name required\n');
+        return 2;
+    }
+    const job = resolveJob(ref);
+    if (!job) {
+        err(`cron remove: not found: ${ref}\n`);
+        return 1;
+    }
+    if (!(0, cronManager_1.deleteJob)(job.id)) {
+        err('cron remove: delete failed\n');
+        return 1;
+    }
+    deleteScheduledWorkflow(job.id);
+    await (0, cronManager_1.awaitPendingSaves)();
+    out(`cron removed: ${job.id} (${job.description})\n`);
+    return 0;
+}
+function cmdCliEnable(ref, out, err) {
+    if (!ref) {
+        err('cron enable: id or name required\n');
+        return 2;
+    }
+    const job = resolveJob(ref);
+    if (!job) {
+        err(`cron enable: not found: ${ref}\n`);
+        return 1;
+    }
+    if (!(0, cronManager_1.resumeJob)(job.id)) {
+        err('cron enable: enable failed\n');
+        return 1;
+    }
+    setWorkflowEnabled(job.id, 1);
+    out(`cron enabled: ${job.id}\n`);
+    return 0;
+}
+function cmdCliDisable(ref, out, err) {
+    if (!ref) {
+        err('cron disable: id or name required\n');
+        return 2;
+    }
+    const job = resolveJob(ref);
+    if (!job) {
+        err(`cron disable: not found: ${ref}\n`);
+        return 1;
+    }
+    if (!(0, cronManager_1.pauseJob)(job.id)) {
+        err('cron disable: disable failed\n');
+        return 1;
+    }
+    setWorkflowEnabled(job.id, 0);
+    out(`cron disabled: ${job.id}\n`);
+    return 0;
+}
+async function cmdCliRun(ref, out, err) {
+    if (!ref) {
+        err('cron run: id or name required\n');
+        return 2;
+    }
+    const job = resolveJob(ref);
+    if (!job) {
+        err(`cron run: not found: ${ref}\n`);
+        return 1;
+    }
+    out(`cron run: triggering ${job.id} (${job.description})...\n`);
+    const ok = await (0, cronManager_1.triggerJob)(job.id);
+    if (!ok) {
+        err('cron run: trigger failed\n');
+        return 1;
+    }
+    const fresh = (0, cronManager_1.getJob)(job.id);
+    out(`cron run: done — lastResult=${fresh?.lastResult ?? 'unknown'}\n`);
+    return 0;
+}
+async function cmdCliLogs(ref, out, err) {
+    if (!ref) {
+        err('cron logs: id or name required\n');
+        return 2;
+    }
+    const job = resolveJob(ref);
+    if (!job) {
+        err(`cron logs: not found: ${ref}\n`);
+        return 1;
+    }
+    const logPath = path.join(LOGS_DIR, `${job.id}.log`);
+    if (!fs.existsSync(logPath)) {
+        out(`No log yet for ${job.id} (${job.description}).\n`);
+        return 0;
+    }
+    const text = await node_fs_1.promises.readFile(logPath, 'utf-8');
+    const lines = text.split(/\r?\n/);
+    const tail = lines.slice(Math.max(0, lines.length - TAIL_LINES - 1));
+    out(`--- ${logPath} (last ${tail.length} lines) ---\n`);
+    out(tail.join('\n') + '\n');
+    return 0;
+}
 // ── SlashCommand definition ────────────────────────────────────────────────
 exports.cron = {
     name: 'cron',