@cfio/cohort-sync 0.2.4 → 0.3.0

package/dist/index.js

@@ -11503,6 +11503,7 @@ var _systemSchema = defineSchema({
 });
 
 // src/subscription.ts
+import { execFileSync } from "node:child_process";
 function deriveConvexUrl(apiUrl) {
   return apiUrl.replace(/\.convex\.site\/?$/, ".convex.cloud");
 }
@@ -11584,6 +11585,7 @@ var markDeliveredByPlugin = makeFunctionReference("notifications:markDeliveredBy
 var upsertTelemetryFromPlugin = makeFunctionReference("telemetryPlugin:upsertTelemetryFromPlugin");
 var upsertSessionsFromPlugin = makeFunctionReference("telemetryPlugin:upsertSessionsFromPlugin");
 var pushActivityFromPluginRef = makeFunctionReference("activityFeed:pushActivityFromPlugin");
+var upsertCronSnapshotFromPluginRef = makeFunctionReference("telemetryPlugin:upsertCronSnapshotFromPlugin");
 var getPendingCommandsForPlugin = makeFunctionReference("gatewayCommands:getPendingForPlugin");
 var acknowledgeCommandRef = makeFunctionReference("gatewayCommands:acknowledgeCommand");
 var addCommentFromPluginRef = makeFunctionReference("comments:addCommentFromPlugin");
@@ -11740,23 +11742,38 @@ function initCommandSubscription(cfg, logger) {
       if (processing) return;
       if (commands.length === 0) return;
       processing = true;
-      const cmd = commands[commands.length - 1];
-      logger.info(`cohort-sync: received gateway command: ${cmd.type} (${cmd._id})`);
-      if (cmd.type === "restart") {
-        try {
-          await c.mutation(acknowledgeCommandRef, {
-            commandId: cmd._id,
-            apiKey: cfg.apiKey
-          });
-          logger.info("cohort-sync: restart command acknowledged, terminating in 500ms");
-          await new Promise((r) => setTimeout(r, 500));
-          process.kill(process.pid, "SIGTERM");
-        } catch (err) {
-          logger.error(`cohort-sync: failed to process restart command: ${String(err)}`);
-          processing = false;
+      try {
+        for (const cmd of commands) {
+          logger.info(`cohort-sync: processing command: ${cmd.type} (${cmd._id})`);
+          try {
+            await c.mutation(acknowledgeCommandRef, {
+              commandId: cmd._id,
+              apiKey: cfg.apiKey
+            });
+            if (cmd.type === "restart") {
+              logger.info("cohort-sync: restart acknowledged, terminating in 500ms");
+              await new Promise((r) => setTimeout(r, 500));
+              process.kill(process.pid, "SIGTERM");
+              return;
+            }
+            if (cmd.type.startsWith("cron") && cmd.payload?.jobId) {
+              handleCronCommand(cmd.type, cmd.payload.jobId, logger);
+              try {
+                const freshJobs = fetchCronJobs(logger);
+                await pushCronSnapshot(cfg.apiKey, freshJobs);
+              } catch (snapErr) {
+                logger.warn(`cohort-sync: post-command snapshot push failed: ${String(snapErr)}`);
+              }
+            } else if (cmd.type.startsWith("cron")) {
+              logger.warn(`cohort-sync: cron command missing jobId: ${cmd.type}`);
+            } else {
+              logger.warn(`cohort-sync: unknown command type: ${cmd.type}`);
+            }
+          } catch (err) {
+            logger.error(`cohort-sync: failed to process command ${cmd._id}: ${String(err)}`);
+          }
         }
-      } else {
-        logger.warn(`cohort-sync: unknown command type: ${cmd.type}`);
+      } finally {
         processing = false;
       }
     },
@@ -11768,6 +11785,31 @@ function initCommandSubscription(cfg, logger) {
   getHotState().unsubscribers = [...unsubscribers];
   logger.info("cohort-sync: command subscription active");
 }
+function handleCronCommand(type, jobId, logger) {
+  const subcommandMap = {
+    cronEnable: ["cron", "enable", jobId],
+    cronDisable: ["cron", "disable", jobId],
+    cronRunNow: ["cron", "run", jobId],
+    cronDelete: ["cron", "delete", jobId, "--force"]
+  };
+  const args = subcommandMap[type];
+  if (!args) {
+    logger.warn(`cohort-sync: unknown cron command type: ${type}`);
+    return;
+  }
+  const timeout = type === "cronRunNow" ? 3e4 : 15e3;
+  try {
+    execFileSync("openclaw", args, {
+      encoding: "utf8",
+      timeout,
+      stdio: ["ignore", "pipe", "ignore"]
+    });
+    logger.info(`cohort-sync: cron command ${type} executed for job ${jobId}`);
+  } catch (err) {
+    logger.error(`cohort-sync: cron command ${type} failed for job ${jobId}: ${String(err)}`);
+    throw err;
+  }
+}
 async function callAddCommentFromPlugin(apiKey, args) {
   const c = getOrCreateClient();
   if (!c) {
@@ -11828,6 +11870,15 @@ async function pushActivity(apiKey, entries) {
     getLogger().error(`cohort-sync: pushActivity failed: ${err}`);
   }
 }
+async function pushCronSnapshot(apiKey, jobs) {
+  const c = getOrCreateClient();
+  if (!c) return;
+  try {
+    await c.mutation(upsertCronSnapshotFromPluginRef, { apiKey, jobs });
+  } catch (err) {
+    getLogger().error(`cohort-sync: pushCronSnapshot failed: ${err}`);
+  }
+}
 function saveIntervalsToHot(heartbeat, activityFlush) {
   const state = getHotState();
   state.intervals = { heartbeat, activityFlush };
@@ -11891,6 +11942,44 @@ function fetchSkills(logger) {
     return [];
   }
 }
+function fetchCronJobs(logger) {
+  try {
+    const raw = execSync("openclaw cron list --all --json", {
+      encoding: "utf8",
+      timeout: 1e4,
+      stdio: ["ignore", "pipe", "ignore"],
+      env: { ...process.env, NO_COLOR: "1" }
+    });
+    const parsed = JSON.parse(extractJson(raw));
+    const list = Array.isArray(parsed) ? parsed : parsed?.jobs ?? [];
+    return list.map((j) => ({
+      id: String(j.jobId ?? j.id ?? "unknown"),
+      text: String(j.name ?? j.text ?? ""),
+      schedule: formatSchedule(j.schedule),
+      ...j.nextRunAt != null ? { nextRun: Number(j.nextRunAt) } : {},
+      ...j.lastRunAt != null ? { lastRun: Number(j.lastRunAt) } : {},
+      ...j.lastStatus ? { lastStatus: String(j.lastStatus) } : {},
+      enabled: j.enabled !== false,
+      ...j.agentId != null ? { agentId: String(j.agentId) } : {}
+    }));
+  } catch (err) {
+    logger.warn(`cohort-sync: failed to fetch cron jobs: ${String(err)}`);
+    return [];
+  }
+}
+function formatSchedule(schedule) {
+  if (typeof schedule === "string") return schedule;
+  if (schedule && typeof schedule === "object") {
+    const s = schedule;
+    if (s.kind === "cron" && typeof s.expr === "string") return s.expr;
+    if (s.kind === "interval" && typeof s.everyMs === "number") {
+      const mins = Math.floor(Number(s.everyMs) / 6e4);
+      if (mins > 0) return `*/${mins} * * * *`;
+      return `every ${s.everyMs}ms`;
+    }
+  }
+  return String(schedule);
+}
 var VALID_STATUSES = /* @__PURE__ */ new Set(["idle", "working", "waiting"]);
 function normalizeStatus(status) {
   return VALID_STATUSES.has(status) ? status : "idle";
@@ -12933,6 +13022,16 @@ Do not attempt to make more comments until ${resetAt}.`
       }
     }
     saveSessionsToDisk(tracker);
+    try {
+      const cronJobs2 = fetchCronJobs(logger);
+      const resolvedJobs = cronJobs2.map((job) => ({
+        ...job,
+        agentId: job.agentId ? resolveAgentName(job.agentId) : job.agentId
+      }));
+      await pushCronSnapshot(cfg.apiKey, resolvedJobs);
+    } catch (err) {
+      logger.warn(`cohort-sync: heartbeat cron push failed: ${String(err)}`);
+    }
     logger.info(`cohort-sync: heartbeat pushed for ${allAgentIds.length} agents`);
   }
   async function flushActivityBuffer() {

package/dist/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cfio/cohort-sync",
-  "version": "0.2.4",
+  "version": "0.3.0",
   "description": "Syncs agent status and skills to Cohort dashboard",
   "type": "module",
   "main": "index.js",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cfio/cohort-sync",
-  "version": "0.2.4",
+  "version": "0.3.0",
   "description": "Syncs agent status and skills to Cohort dashboard",
   "license": "MIT",
   "homepage": "https://docs.cohort.bot/gateway",