@agentage/extension 0.1.2 → 0.2.1

package/dist/worker/scheduler.js

@@ -0,0 +1,106 @@
+import {} from '../health/health.js';
+import {} from '../log/log.js';
+import { nextRun, parseCron } from './cron.js';
+import { JobNameSchema, JobOptionsSchema, toMs } from './job-options.js';
+import { withRunBuffer } from './run-log.js';
+import {} from './runs.js';
+// A timer overdue by this much means the process stalled: the job is late.
+export const LATE_MS = 60_000;
+const MAX_DELAY = 2 ** 31 - 1;
+const arm = (s, entry) => {
+    const delay = Math.min(MAX_DELAY, Math.max(0, entry.nextAt.getTime() - s.now().getTime()));
+    entry.timer = setTimeout(() => void fire(s, entry), delay);
+};
+const fire = async (s, entry) => {
+    if (!s.started)
+        return undefined;
+    if (entry.nextAt.getTime() > s.now().getTime())
+        return arm(s, entry);
+    entry.nextAt = nextRun(entry.cron, s.now());
+    arm(s, entry);
+    if (!entry.running)
+        return execute(s, entry);
+    entry.overran = true;
+    s.deps.log.warn('job skipped: its previous run is still running', { job: entry.name });
+    return undefined;
+};
+const newEntry = (name, cron, job, options, at) => {
+    JobNameSchema.parse(name);
+    const parsed = parseCron(cron);
+    const timeout = JobOptionsSchema.parse(options)?.timeout;
+    const nextAt = nextRun(parsed, at);
+    const entry = { name, cron: parsed, job, nextAt, running: false, overran: false };
+    if (timeout !== undefined)
+        entry.timeoutMs = toMs(timeout);
+    return entry;
+};
+const runJob = async (entry, log, buffer) => {
+    try {
+        await withRunBuffer(buffer, async () => entry.job());
+        return 'ok';
+    }
+    catch (err) {
+        await withRunBuffer(buffer, async () => log.error(err, { job: entry.name }));
+        return 'failed';
+    }
+};
+// Never twice at once; every run saved with its log, a failed save is logged and the job goes on.
+const execute = async (s, entry) => {
+    const startedAt = s.now();
+    Object.assign(entry, { running: true, runningSince: startedAt, overran: false });
+    const buffer = { text: '', truncated: false };
+    const status = await runJob(entry, s.deps.log, buffer);
+    entry.running = false;
+    entry.last = status;
+    const run = { job: entry.name, startedAt, endedAt: s.now(), status, log: buffer.text };
+    if (entry.timeoutMs !== undefined)
+        run.timeoutMs = entry.timeoutMs;
+    await s.deps.runs.save(run).catch((err) => s.deps.log.error(err, { job: entry.name }));
+    return run;
+};
+// A run still going past its declared timeout, or one that made the job skip a tick.
+const overrunning = (s, entry) => {
+    if (!entry.running)
+        return false;
+    const ranMs = s.now().getTime() - (entry.runningSince?.getTime() ?? 0);
+    return entry.overran || (entry.timeoutMs !== undefined && ranMs > entry.timeoutMs);
+};
+// ok: the last run ok, the timer on time, no run overrunning; else degraded, never a restart.
+const check = (s, entry) => async () => {
+    const late = s.now().getTime() - entry.nextAt.getTime() > LATE_MS;
+    return entry.last === 'failed' || late || overrunning(s, entry) ? 'degraded' : 'ok';
+};
+const scheduleOn = (s) => (name, cron, job, options) => {
+    const entry = newEntry(name, cron, job, options, s.now());
+    if (s.entries.has(entry.name))
+        throw new Error(`job ${name} is scheduled twice`);
+    s.entries.set(entry.name, entry);
+    if (s.started)
+        arm(s, entry);
+};
+const setStarted = (s, started) => {
+    s.started = started;
+    for (const entry of s.entries.values()) {
+        clearTimeout(entry.timer);
+        if (started)
+            arm(s, entry);
+    }
+};
+export const createScheduler = (deps) => {
+    const s = {
+        deps,
+        now: deps.now ?? (() => new Date()),
+        entries: new Map(),
+        started: false,
+    };
+    return {
+        schedule: scheduleOn(s),
+        start: () => setStarted(s, true),
+        stop: () => setStarted(s, false),
+        run: async (name) => {
+            const entry = s.entries.get(name);
+            return entry && !entry.running ? execute(s, entry) : undefined;
+        },
+        checks: () => Object.fromEntries([...s.entries.values()].map((e) => [`job:${e.name}`, check(s, e)])),
+    };
+};

package/dist/worker/worker.types.d.ts

@@ -0,0 +1,5 @@
+import { type PartContext } from '../context/context.js';
+import { type Schedule } from './scheduler.js';
+export interface WorkerContext extends PartContext {
+    readonly schedule: Schedule;
+}

package/dist/worker/worker.types.js

@@ -0,0 +1,2 @@
+import {} from '../context/context.js';
+import {} from './scheduler.js';

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@agentage/extension",
-  "version": "0.1.2",
-  "description": "The agentage extension kit: create(ctx) per part, the server, /health, discovery, the envelope, and the build tool",
+  "version": "0.2.1",
+  "description": "The agentage extension kit: create(ctx) per part (pages, ui, api, mcp, worker, cli), the store, /health, discovery, the envelope, and the build tool with up and token",
   "type": "module",
   "license": "MIT",
   "repository": {
@@ -28,6 +28,9 @@
       "types": "./dist/tool/index.d.ts",
       "default": "./dist/tool/index.js"
     },
+    "./migrate": {
+      "default": "./dist/store/migrate.js"
+    },
     "./schemas/*": "./schemas/*",
     "./package.json": "./package.json"
   },
@@ -44,14 +47,20 @@
     "prepublishOnly": "npm run verify"
   },
   "dependencies": {
+    "@modelcontextprotocol/server": "^2.4.0",
     "cors": "^2.8.5",
     "helmet": "^8.1.0",
+    "pg": "^8.23.1",
     "zod": "^4.2.0"
   },
   "peerDependencies": {
+    "@electric-sql/pglite": "^0.5.0",
     "express": "^5.1.0"
   },
   "peerDependenciesMeta": {
+    "@electric-sql/pglite": {
+      "optional": true
+    },
     "express": {
       "optional": true
     }

package/schemas/extension-discovery.schema.json

@@ -105,6 +105,11 @@
                 "git",
                 "signoz"
               ]
+            },
+            "migrations": {
+              "type": "integer",
+              "minimum": 0,
+              "maximum": 9007199254740991
             }
           },
           "required": [

package/schemas/extension-package.schema.json

@@ -213,6 +213,9 @@
                         "boolean"
                       ]
                     },
+                    "optional": {
+                      "type": "boolean"
+                    },
                     "required": {
                       "type": "boolean"
                     },

package/schemas/extension-record.schema.json

@@ -105,6 +105,11 @@
                 "git",
                 "signoz"
               ]
+            },
+            "migrations": {
+              "type": "integer",
+              "minimum": 0,
+              "maximum": 9007199254740991
             }
           },
           "required": [

package/schemas/health.schema.json

@@ -65,7 +65,7 @@
           "type": "object",
           "propertyNames": {
             "type": "string",
-            "pattern": "^[a-z][a-z0-9-]*$"
+            "pattern": "^[a-z][a-z0-9-]*(:[a-z][a-z0-9-]*)?$"
           },
           "additionalProperties": {
             "type": "string",