@cfio/cohort-sync 0.29.0 → 0.31.0

package/dist/index.js

@@ -11655,8 +11655,8 @@ function humanizeMs(ms) {
   if (ms >= 6e4) return `${Math.round(ms / 6e4)}m`;
   return `${Math.round(ms / 1e3)}s`;
 }
-function mapCronJob(job, resolveAgentName) {
-  return {
+function mapCronJob(job, resolveAgentName, tracker) {
+  const base = {
     id: job.id,
     text: job.name,
     schedule: formatSchedule(job.schedule),
@@ -11665,9 +11665,58 @@ function mapCronJob(job, resolveAgentName) {
     nextRun: job.state?.nextRunAtMs,
     lastRun: job.state?.lastRunAtMs,
     lastStatus: job.state?.lastRunStatus,
-    lastError: job.state?.lastError ?? null
+    lastError: job.state?.lastError ?? null,
+    message: job.payload?.message
   };
+  if (tracker) {
+    const stamps = tracker.observe(job.id, base);
+    base.createdAt = stamps.createdAt;
+    base.updatedAt = stamps.updatedAt;
+  }
+  return base;
 }
+function fingerprintJob(job) {
+  return [
+    job.text,
+    job.schedule,
+    job.agentId,
+    job.enabled ? "1" : "0",
+    job.message ?? ""
+  ].join("
");
+}
+var CronTimestampTracker = class {
+  records = /* @__PURE__ */ new Map();
+  /**
+   * Observe a job. Returns the current `{ createdAt, updatedAt }` for the job.
+   * Mutates internal state. Idempotent for unchanged jobs (returns the prior
+   * `updatedAt` when the fingerprint hasn't changed).
+   *
+   * `now` is injectable for tests.
+   */
+  observe(jobId, job, now = Date.now()) {
+    const fingerprint = fingerprintJob(job);
+    const existing = this.records.get(jobId);
+    if (!existing) {
+      const record = { createdAt: now, updatedAt: now, fingerprint };
+      this.records.set(jobId, record);
+      return { createdAt: record.createdAt, updatedAt: record.updatedAt };
+    }
+    if (existing.fingerprint !== fingerprint) {
+      existing.fingerprint = fingerprint;
+      existing.updatedAt = now;
+    }
+    return { createdAt: existing.createdAt, updatedAt: existing.updatedAt };
+  }
+  /** Drop a jobId (e.g. after cronDelete). Safe to call for unknown ids. */
+  forget(jobId) {
+    this.records.delete(jobId);
+  }
+  /** Test helper — read internal state without mutating it. */
+  peek(jobId) {
+    const r = this.records.get(jobId);
+    return r ? { createdAt: r.createdAt, updatedAt: r.updatedAt } : void 0;
+  }
+};
 function reverseResolveAgentName(cohortName, forwardMap) {
   const lower = cohortName.toLowerCase();
   for (const [openclawId, name] of Object.entries(forwardMap)) {
@@ -11692,7 +11741,7 @@ function checkRateLimit() {
   return true;
 }
 var MAX_CRON_MESSAGE_LENGTH = 1e3;
-async function executeCommand(cmd, gwClient, cfg, resolveAgentName, logger) {
+async function executeCommand(cmd, gwClient, cfg, resolveAgentName, logger, cronTimestampTracker) {
   logger.info(`cohort-sync: executing command type=${cmd.type} id=${cmd._id}`);
   if (!checkRateLimit()) {
     logger.warn(`cohort-sync: rate limit exceeded (>${RATE_LIMIT_MAX} commands/min), rejecting command ${cmd._id}`);
@@ -11773,11 +11822,14 @@ async function executeCommand(cmd, gwClient, cfg, resolveAgentName, logger) {
       default:
         logger.warn(`cohort-sync: unknown cron command type: ${cmd.type}`);
     }
+    if (cmd.type === "cronDelete" && cmd.payload?.jobId && cronTimestampTracker) {
+      cronTimestampTracker.forget(cmd.payload.jobId);
+    }
     if (gwClient.isAlive()) {
       try {
         const snapResult = await gwClient.request("cron.list", { includeDisabled: true });
         const freshJobs = Array.isArray(snapResult) ? snapResult : snapResult?.jobs ?? [];
-        const mapped = freshJobs.map((j) => mapCronJob(j, resolveAgentName));
+        const mapped = freshJobs.map((j) => mapCronJob(j, resolveAgentName, cronTimestampTracker));
         await pushCronSnapshot(cfg.apiKey, mapped);
       } catch (snapErr) {
         logger.warn(`cohort-sync: post-command snapshot push failed: ${String(snapErr)}`);
@@ -11881,6 +11933,7 @@ var upsertTelemetryFromPlugin = makeFunctionReference("telemetryPlugin:upsertTel
 var upsertSessionsFromPlugin = makeFunctionReference("telemetryPlugin:upsertSessionsFromPlugin");
 var pushActivityFromPluginRef = makeFunctionReference("activityFeed:pushActivityFromPlugin");
 var upsertCronSnapshotFromPluginRef = makeFunctionReference("telemetryPlugin:upsertCronSnapshotFromPlugin");
+var recordCronRunFromPluginRef = makeFunctionReference("cronRunHistory:recordFromPlugin");
 var getUndeliveredForPlugin = makeFunctionReference("notifications:getUndeliveredForPlugin");
 var markDeliveredByPlugin = makeFunctionReference("notifications:markDeliveredByPlugin");
 var getPendingCommandsForPlugin = makeFunctionReference("gatewayCommands:getPendingForPlugin");
@@ -11946,6 +11999,25 @@ async function pushCronSnapshot(apiKey2, jobs) {
     return false;
   }
 }
+async function recordCronRun(apiKey2, run) {
+  if (authCircuitOpen) return false;
+  const c = getClient();
+  if (!c) return false;
+  try {
+    await c.mutation(recordCronRunFromPluginRef, {
+      apiKeyHash: hashApiKey(apiKey2),
+      ...run
+    });
+    return true;
+  } catch (err) {
+    if (isUnauthorizedError(err)) {
+      tripAuthCircuit();
+      return false;
+    }
+    getLogger().error(`cohort-sync: recordCronRun failed: ${err}`);
+    return false;
+  }
+}
 async function callAddCommentFromPlugin(apiKey2, args) {
   if (authCircuitOpen) {
     throw new Error(
@@ -12169,7 +12241,7 @@ async function startNotificationSubscription(port, cfg, hooksToken, logger, gwCl
     unsubscribers.push(unsubscribe);
   }
 }
-function startCommandSubscription(cfg, logger, resolveAgentName, gwClient) {
+function startCommandSubscription(cfg, logger, resolveAgentName, gwClient, cronTimestampTracker) {
   const c = getClient();
   if (!c) {
     logger.warn("cohort-sync: no ConvexClient \u2014 command subscription skipped");
@@ -12192,7 +12264,7 @@ function startCommandSubscription(cfg, logger, resolveAgentName, gwClient) {
               commandId: cmd._id,
               apiKeyHash
             });
-            await executeCommand(cmd, gwClient, cfg, resolveAgentName, logger);
+            await executeCommand(cmd, gwClient, cfg, resolveAgentName, logger, cronTimestampTracker);
             if (cmd.type === "restart") return;
           } catch (err) {
             if (isUnauthorizedError(err)) {
@@ -13487,12 +13559,12 @@ function dumpCtx(ctx) {
 function dumpEvent(event) {
   return dumpCtx(event);
 }
-var PLUGIN_VERSION = true ? "0.29.0" : "unknown";
+var PLUGIN_VERSION = true ? "0.31.0" : "unknown";
 function resolveGatewayToken(api) {
   const token = api.config?.gateway?.auth?.token;
   return typeof token === "string" ? token : null;
 }
-function registerCronEventHandlers(client2, cfg, resolveAgentName, logger) {
+function registerCronEventHandlers(client2, cfg, resolveAgentName, cronTimestampTracker, logger) {
   if (client2.availableEvents.has("cron")) {
     let debounceTimer = null;
     client2.on("cron", () => {
@@ -13501,7 +13573,7 @@ function registerCronEventHandlers(client2, cfg, resolveAgentName, logger) {
         try {
           const cronResult = await client2.request("cron.list", { includeDisabled: true });
           const jobs = Array.isArray(cronResult) ? cronResult : cronResult?.jobs ?? [];
-          const mapped = jobs.map((j) => mapCronJob(j, resolveAgentName));
+          const mapped = jobs.map((j) => mapCronJob(j, resolveAgentName, cronTimestampTracker));
           await pushCronSnapshot(cfg.apiKey, mapped);
           logger.debug("cohort-sync: cron event pushed", { count: mapped.length });
         } catch (err) {
@@ -13588,12 +13660,12 @@ function loadSessionsFromDisk(tracker, stateFilePath, logger) {
   } catch {
   }
 }
-function initGatewayClient(port, token, cfg, resolveAgentName, logger) {
+function initGatewayClient(port, token, cfg, resolveAgentName, cronTimestampTracker, logger) {
   const client2 = new GatewayClient(port, token, logger, PLUGIN_VERSION);
   const onConnected = async () => {
     logger.debug(`cohort-sync: gateway client connected (methods=${client2.availableMethods.size}, events=${client2.availableEvents.size})`);
     logger.info(`cohort-sync: gateway client connected (methods=${client2.availableMethods.size}, events=${client2.availableEvents.size})`);
-    registerCronEventHandlers(client2, cfg, resolveAgentName, logger);
+    registerCronEventHandlers(client2, cfg, resolveAgentName, cronTimestampTracker, logger);
     if (client2.availableEvents.has("shutdown")) {
       client2.on("shutdown", () => {
         logger.info("cohort-sync: gateway shutdown event received");
@@ -13602,7 +13674,7 @@ function initGatewayClient(port, token, cfg, resolveAgentName, logger) {
     try {
       const cronResult = await client2.request("cron.list", { includeDisabled: true });
       const jobs = Array.isArray(cronResult) ? cronResult : cronResult?.jobs ?? [];
-      const mapped = jobs.map((j) => mapCronJob(j, resolveAgentName));
+      const mapped = jobs.map((j) => mapCronJob(j, resolveAgentName, cronTimestampTracker));
       await pushCronSnapshot(cfg.apiKey, mapped);
       logger.debug("cohort-sync: cron snapshot pushed", { count: mapped.length });
     } catch (err) {
@@ -13641,6 +13713,19 @@ async function handleGatewayStart(event, state) {
     }
   } catch {
   }
+  const UPDATE_CHECK_INTERVAL_MS = 24 * 60 * 60 * 1e3;
+  if (state.updateCheckInterval) clearInterval(state.updateCheckInterval);
+  state.updateCheckInterval = setInterval(async () => {
+    try {
+      const latest = await checkForUpdate(PLUGIN_VERSION, logger);
+      if (latest) state.latestPluginVersion = latest;
+    } catch {
+    }
+  }, UPDATE_CHECK_INTERVAL_MS);
+  if (typeof state.updateCheckInterval.unref === "function") {
+    state.updateCheckInterval.unref();
+  }
+  logger.debug("cohort-sync: update check interval scheduled (24h)");
   try {
     const agentList = (config?.agents?.list ?? []).map((a) => ({
       id: a.id,
@@ -13666,14 +13751,14 @@ async function handleGatewayStart(event, state) {
     state.gatewayToken = token;
     logger.debug("cohort-sync: gateway client connecting", { port: event.port, hasToken: true });
     try {
-      const client2 = initGatewayClient(event.port, token, cfg, state.resolveAgentName, logger);
+      const client2 = initGatewayClient(event.port, token, cfg, state.resolveAgentName, state.cronTimestampTracker, logger);
       state.persistentGwClient = client2;
       state.gwClientInitialized = true;
       if (state.commandUnsubscriber) {
         state.commandUnsubscriber();
         state.commandUnsubscriber = null;
       }
-      const unsub = startCommandSubscription(cfg, logger, state.resolveAgentName, state.persistentGwClient);
+      const unsub = startCommandSubscription(cfg, logger, state.resolveAgentName, state.persistentGwClient, state.cronTimestampTracker);
       state.commandUnsubscriber = unsub;
     } catch (err) {
       logger.debug("cohort-sync: gateway client connect failed", { error: String(err) });
@@ -13837,16 +13922,40 @@ function registerHookHandlers(api, logger, getState) {
       }
       const sessionKey = ctx.sessionKey;
       if (sessionKey && sessionKey.includes(":cron:")) {
+        const parsed = parseSessionKey(sessionKey);
+        const routineId = parsed.kind === "cron" ? parsed.identifier : void 0;
         try {
           const raw = fs2["read"+"FileSync"](state.cronStorePath, "utf8");
           const store = JSON.parse(raw);
           const jobs = store.jobs ?? [];
-          const mapped = jobs.map((j) => mapCronJob(j, state.resolveAgentName));
+          const mapped = jobs.map((j) => mapCronJob(j, state.resolveAgentName, state.cronTimestampTracker));
           await pushCronSnapshot(cfg.apiKey, mapped);
           log.debug("cohort-sync: cron agent end push", { count: mapped.length, sessionKey });
         } catch (err) {
           log.debug("cohort-sync: cron agent end push failed", { error: String(err) });
         }
+        if (routineId) {
+          const finishedAt = Date.now();
+          const startedAtFromTracker = state.cronRunStarts.get(sessionKey);
+          state.cronRunStarts.delete(sessionKey);
+          const durationMs = typeof event?.durationMs === "number" && event.durationMs >= 0 ? event.durationMs : startedAtFromTracker != null ? Math.max(0, finishedAt - startedAtFromTracker) : void 0;
+          const startedAt = startedAtFromTracker ?? (typeof durationMs === "number" ? finishedAt - durationMs : finishedAt);
+          const status = event?.success === false ? "error" : "ok";
+          const errorMessage = status === "error" && typeof event?.error === "string" ? event.error : void 0;
+          try {
+            await recordCronRun(cfg.apiKey, {
+              routineId,
+              startedAt,
+              finishedAt,
+              status,
+              durationMs,
+              ...errorMessage ? { errorMessage } : {}
+            });
+            log.debug("cohort-sync: cron run recorded", { routineId, status, durationMs });
+          } catch (err) {
+            log.debug("cohort-sync: cron run record failed", { error: String(err) });
+          }
+        }
       }
       if (event.success === false) {
         const entry = buildActivityEntry(agentName, "agent_end", {
@@ -13973,14 +14082,14 @@ function registerHookHandlers(api, logger, getState) {
     try {
       if (!state.gwClientInitialized && state.gatewayPort && state.gatewayToken) {
         try {
-          const client2 = initGatewayClient(state.gatewayPort, state.gatewayToken, cfg, state.resolveAgentName, log);
+          const client2 = initGatewayClient(state.gatewayPort, state.gatewayToken, cfg, state.resolveAgentName, state.cronTimestampTracker, log);
           state.persistentGwClient = client2;
           state.gwClientInitialized = true;
           if (state.commandUnsubscriber) {
             state.commandUnsubscriber();
             state.commandUnsubscriber = null;
           }
-          const unsub = startCommandSubscription(cfg, log, state.resolveAgentName, state.persistentGwClient);
+          const unsub = startCommandSubscription(cfg, log, state.resolveAgentName, state.persistentGwClient, state.cronTimestampTracker);
           state.commandUnsubscriber = unsub;
         } catch (err) {
           log.debug("cohort-sync: gateway client lazy init failed", { error: String(err) });
@@ -14007,6 +14116,9 @@ function registerHookHandlers(api, logger, getState) {
       } else if (sessionKey) {
         tracker.setSessionAgent(sessionKey, agentName);
       }
+      if (sessionKey && sessionKey.includes(":cron:")) {
+        state.cronRunStarts.set(sessionKey, Date.now());
+      }
       const ctxChannelId = ctx.channelId;
       if (ctxChannelId) {
         setChannelAgent(ctxChannelId, agentName);
@@ -14191,6 +14303,10 @@ function registerHookHandlers(api, logger, getState) {
       clearInterval(state.keepaliveInterval);
       state.keepaliveInterval = null;
     }
+    if (state.updateCheckInterval) {
+      clearInterval(state.updateCheckInterval);
+      state.updateCheckInterval = null;
+    }
     if (state.channelsUnsubscriber) {
       try {
         state.channelsUnsubscriber();
@@ -14289,14 +14405,16 @@ function initializeHookState(api, cfg) {
   });
   const gatewayPort = api.config?.gateway?.port ?? null;
   const gatewayToken = resolveGatewayToken(api);
+  const cronTimestampTracker = new CronTimestampTracker();
+  const cronRunStarts = /* @__PURE__ */ new Map();
   let persistentGwClient = null;
   let gwClientInitialized = false;
   if (gatewayPort && gatewayToken) {
-    const client2 = initGatewayClient(gatewayPort, gatewayToken, cfg, resolveAgentName, logger);
+    const client2 = initGatewayClient(gatewayPort, gatewayToken, cfg, resolveAgentName, cronTimestampTracker, logger);
     persistentGwClient = client2;
     gwClientInitialized = true;
   }
-  const commandUnsub = startCommandSubscription(cfg, logger, resolveAgentName, persistentGwClient);
+  const commandUnsub = startCommandSubscription(cfg, logger, resolveAgentName, persistentGwClient, cronTimestampTracker);
   setToolRuntime({
     apiKey: cfg.apiKey,
     apiUrl: cfg.apiUrl,
@@ -14331,6 +14449,8 @@ function initializeHookState(api, cfg) {
   return {
     cfg,
     tracker,
+    cronTimestampTracker,
+    cronRunStarts,
     logger,
     config,
     resolveAgentName,
@@ -14347,7 +14467,8 @@ function initializeHookState(api, cfg) {
     commandUnsubscriber: commandUnsub,
     channelsUnsubscriber: null,
     api,
-    latestPluginVersion: null
+    latestPluginVersion: null,
+    updateCheckInterval: null
   };
 }
 

package/dist/openclaw.plugin.json

@@ -72,5 +72,5 @@
       }
     }
   },
-  "version": "0.29.0"
+  "version": "0.31.0"
 }

package/dist/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cfio/cohort-sync",
-  "version": "0.29.0",
+  "version": "0.31.0",
   "description": "OpenClaw plugin — syncs agent telemetry, sessions, and activity to the Cohort dashboard",
   "type": "module",
   "main": "index.js",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cfio/cohort-sync",
-  "version": "0.29.0",
+  "version": "0.31.0",
   "description": "OpenClaw plugin — syncs agent telemetry, sessions, and activity to the Cohort dashboard",
   "license": "MIT",
   "homepage": "https://docs.cohort.bot/gateway",