agent-office 0.0.1 → 0.0.2

package/dist/server/cron.js

@@ -0,0 +1,121 @@
+import { Cron } from "croner";
+const CRON_INJECTION_BLURB = [
+    ``,
+    `---`,
+    `You have a scheduled cron job trigger. Please review the injected message above`,
+    `and take appropriate action.`,
+].join("\n");
+export class CronScheduler {
+    options;
+    activeJobs = new Map();
+    sql = null;
+    opencode = null;
+    started = false;
+    constructor(options = {}) {
+        this.options = options;
+    }
+    async start(sql, opencode) {
+        if (this.started)
+            return;
+        this.sql = sql;
+        this.opencode = opencode;
+        const rows = await sql `
+      SELECT id, name, schedule, timezone, message, session_name
+      FROM cron_jobs
+      WHERE enabled = TRUE
+    `;
+        for (const job of rows) {
+            this.addJob(job);
+        }
+        this.started = true;
+        console.log(`Cron scheduler started: tracking ${rows.length} active jobs`);
+    }
+    stop() {
+        for (const cronInst of this.activeJobs.values()) {
+            cronInst.cron.stop();
+        }
+        this.activeJobs.clear();
+        this.started = false;
+        console.log("Cron scheduler stopped");
+    }
+    addJob(job) {
+        if (!this.opencode || !this.sql)
+            return;
+        const options = {
+            protect: true,
+            name: job.name,
+        };
+        if (job.timezone) {
+            options.timezone = job.timezone;
+        }
+        const cron = new Cron(job.schedule, options, async () => {
+            await this.executeJob(job);
+        });
+        this.activeJobs.set(job.id, { cron, job });
+    }
+    async executeJob(job) {
+        if (!this.sql || !this.opencode)
+            return;
+        const executedAt = new Date();
+        try {
+            const [session] = await this.sql `
+        SELECT session_id FROM sessions WHERE name = ${job.session_name}
+      `;
+            if (!session) {
+                throw new Error(`Session "${job.session_name}" not found`);
+            }
+            const providers = await this.opencode.app.providers();
+            const defaultEntry = Object.entries(providers.default)[0];
+            if (!defaultEntry) {
+                throw new Error("No default model configured");
+            }
+            const injectText = `[Cron Job "${job.name}" — ${executedAt.toISOString()}]\n${job.message}${CRON_INJECTION_BLURB}`;
+            await this.opencode.session.chat(session.session_id, {
+                modelID: defaultEntry[0],
+                providerID: defaultEntry[1],
+                parts: [{ type: "text", text: injectText }],
+            });
+            await this.sql `
+        UPDATE cron_jobs SET last_run = ${executedAt} WHERE id = ${job.id}
+      `;
+            await this.sql `
+        INSERT INTO cron_history (cron_job_id, executed_at, success)
+        VALUES (${job.id}, ${executedAt}, TRUE)
+      `;
+            this.options.onJobExecuted?.(job.id, true);
+            console.log(`Cron job "${job.name}" executed successfully`);
+        }
+        catch (err) {
+            const errorMessage = err instanceof Error ? err.message : String(err);
+            await this.sql `
+        INSERT INTO cron_history (cron_job_id, executed_at, success, error_message)
+        VALUES (${job.id}, ${executedAt}, FALSE, ${errorMessage})
+      `;
+            this.options.onJobExecuted?.(job.id, false, errorMessage);
+            console.error(`Cron job "${job.name}" failed:`, errorMessage);
+        }
+    }
+    addCronJob(job) {
+        if (job.enabled) {
+            this.addJob(job);
+        }
+    }
+    removeCronJob(jobId) {
+        const cronInst = this.activeJobs.get(jobId);
+        if (cronInst) {
+            cronInst.cron.stop();
+            this.activeJobs.delete(jobId);
+        }
+    }
+    enableCronJob(job) {
+        if (!this.activeJobs.has(job.id) && job.enabled) {
+            this.addJob(job);
+        }
+    }
+    disableCronJob(jobId) {
+        this.removeCronJob(jobId);
+    }
+    isTracking(jobId) {
+        return this.activeJobs.has(jobId);
+    }
+}

package/dist/server/index.d.ts

@@ -1,3 +1,4 @@
 import type { Sql } from "../db/index.js";
 import type { OpencodeClient } from "../lib/opencode.js";
-export declare function createApp(sql: Sql, opencode: OpencodeClient, password: string, serverUrl: string): import("express-serve-static-core").Express;
+import { CronScheduler } from "./cron.js";
+export declare function createApp(sql: Sql, opencode: OpencodeClient, password: string, serverUrl: string, cronScheduler: CronScheduler): import("express-serve-static-core").Express;

package/dist/server/index.js

@@ -10,13 +10,13 @@ function authMiddleware(password) {
         next();
     };
 }
-export function createApp(sql, opencode, password, serverUrl) {
+export function createApp(sql, opencode, password, serverUrl, cronScheduler) {
     const app = express();
     app.use(express.json());
     // Worker routes are unauthenticated — mounted before auth middleware
     app.use("/", createWorkerRouter(sql, opencode, serverUrl));
     // Everything else requires Bearer auth
     app.use(authMiddleware(password));
-    app.use("/", createRouter(sql, opencode, serverUrl));
+    app.use("/", createRouter(sql, opencode, serverUrl, cronScheduler));
     return app;
 }

package/dist/server/routes.d.ts

@@ -1,5 +1,6 @@
 import { Router } from "express";
 import type { Sql } from "../db/index.js";
 import type { OpencodeClient } from "../lib/opencode.js";
-export declare function createRouter(sql: Sql, opencode: OpencodeClient, serverUrl: string): Router;
+import { CronScheduler } from "./cron.js";
+export declare function createRouter(sql: Sql, opencode: OpencodeClient, serverUrl: string, scheduler: CronScheduler): Router;
 export declare function createWorkerRouter(sql: Sql, opencode: OpencodeClient, serverUrl: string): Router;