@cfio/cohort-sync 0.4.8 → 0.5.0

package/dist/index.js

@@ -88,9 +88,8 @@ var init_keychain = __esm({
 });
 
 // src/hooks.ts
-import fs2 from "node:fs";
-import os2 from "node:os";
-import path2 from "node:path";
+import fs from "node:fs";
+import path from "node:path";
 
 // ../../node_modules/.pnpm/@sinclair+typebox@0.34.48/node_modules/@sinclair/typebox/build/esm/type/guard/value.mjs
 var value_exports = {};
@@ -2700,9 +2699,6 @@ var Type = type_exports2;
 
 // src/sync.ts
 import { execSync } from "node:child_process";
-import fs from "node:fs";
-import os from "node:os";
-import path from "node:path";
 
 // ../../node_modules/.pnpm/convex@1.33.0_patch_hash=l43bztwr6e2lbmpd6ao6hmcg24_react@19.2.1/node_modules/convex/dist/esm/index.js
 var version = "1.33.0";
@@ -4558,12 +4554,12 @@ function createApi(pathParts = []) {
             `API path is expected to be of the form \`api.moduleName.functionName\`. Found: \`${found}\``
           );
         }
-        const path3 = pathParts.slice(0, -1).join("/");
+        const path2 = pathParts.slice(0, -1).join("/");
         const exportName = pathParts[pathParts.length - 1];
         if (exportName === "default") {
-          return path3;
+          return path2;
         } else {
-          return path3 + ":" + exportName;
+          return path2 + ":" + exportName;
         }
       } else if (prop === Symbol.toStringTag) {
         return "FunctionReference";
@@ -7632,16 +7628,16 @@ var require_constants = __commonJS({
 });
 var require_node_gyp_build = __commonJS({
   "../common/temp/node_modules/.pnpm/node-gyp-build@4.8.4/node_modules/node-gyp-build/node-gyp-build.js"(exports, module) {
-    var fs3 = __require("fs");
-    var path3 = __require("path");
-    var os3 = __require("os");
+    var fs2 = __require("fs");
+    var path2 = __require("path");
+    var os = __require("os");
     var runtimeRequire = typeof __webpack_require__ === "function" ? __non_webpack_require__ : __require;
     var vars = process.config && process.config.variables || {};
     var prebuildsOnly = !!process.env.PREBUILDS_ONLY;
     var abi = process.versions.modules;
     var runtime = isElectron() ? "electron" : isNwjs() ? "node-webkit" : "node";
-    var arch = process.env.npm_config_arch || os3.arch();
-    var platform = process.env.npm_config_platform || os3.platform();
+    var arch = process.env.npm_config_arch || os.arch();
+    var platform = process.env.npm_config_platform || os.platform();
     var libc = process.env.LIBC || (isAlpine(platform) ? "musl" : "glibc");
     var armv = process.env.ARM_VERSION || (arch === "arm64" ? "8" : vars.arm_version) || "";
     var uv = (process.versions.uv || "").split(".")[0];
@@ -7650,21 +7646,21 @@ var require_node_gyp_build = __commonJS({
       return runtimeRequire(load.resolve(dir));
     }
     load.resolve = load.path = function(dir) {
-      dir = path3.resolve(dir || ".");
+      dir = path2.resolve(dir || ".");
       try {
-        var name = runtimeRequire(path3.join(dir, "package.json")).name.toUpperCase().replace(/-/g, "_");
+        var name = runtimeRequire(path2.join(dir, "package.json")).name.toUpperCase().replace(/-/g, "_");
         if (process.env[name + "_PREBUILD"]) dir = process.env[name + "_PREBUILD"];
       } catch (err) {
       }
       if (!prebuildsOnly) {
-        var release = getFirst(path3.join(dir, "build/Release"), matchBuild);
+        var release = getFirst(path2.join(dir, "build/Release"), matchBuild);
         if (release) return release;
-        var debug = getFirst(path3.join(dir, "build/Debug"), matchBuild);
+        var debug = getFirst(path2.join(dir, "build/Debug"), matchBuild);
         if (debug) return debug;
       }
       var prebuild = resolve(dir);
       if (prebuild) return prebuild;
-      var nearby = resolve(path3.dirname(process.execPath));
+      var nearby = resolve(path2.dirname(process.execPath));
       if (nearby) return nearby;
       var target = [
         "platform=" + platform,
@@ -7681,26 +7677,26 @@ var require_node_gyp_build = __commonJS({
       ].filter(Boolean).join(" ");
       throw new Error("No native build was found for " + target + "\n    loaded from: " + dir + "\n");
       function resolve(dir2) {
-        var tuples = readdirSync(path3.join(dir2, "prebuilds")).map(parseTuple);
+        var tuples = readdirSync(path2.join(dir2, "prebuilds")).map(parseTuple);
         var tuple = tuples.filter(matchTuple(platform, arch)).sort(compareTuples)[0];
         if (!tuple) return;
-        var prebuilds = path3.join(dir2, "prebuilds", tuple.name);
+        var prebuilds = path2.join(dir2, "prebuilds", tuple.name);
         var parsed = readdirSync(prebuilds).map(parseTags);
         var candidates = parsed.filter(matchTags(runtime, abi));
         var winner = candidates.sort(compareTags(runtime))[0];
-        if (winner) return path3.join(prebuilds, winner.file);
+        if (winner) return path2.join(prebuilds, winner.file);
       }
     };
     function readdirSync(dir) {
       try {
-        return fs3.readdirSync(dir);
+        return fs2.readdirSync(dir);
       } catch (err) {
         return [];
       }
     }
     function getFirst(dir, filter) {
       var files = readdirSync(dir).filter(filter);
-      return files[0] && path3.join(dir, files[0]);
+      return files[0] && path2.join(dir, files[0]);
     }
     function matchBuild(name) {
       return /\.node$/.test(name);
@@ -7787,7 +7783,7 @@ var require_node_gyp_build = __commonJS({
       return typeof window !== "undefined" && window.process && window.process.type === "renderer";
     }
     function isAlpine(platform2) {
-      return platform2 === "linux" && fs3.existsSync("/etc/alpine-release");
+      return platform2 === "linux" && fs2.existsSync("/etc/alpine-release");
     }
     load.parseTags = parseTags;
     load.matchTags = matchTags;
@@ -11506,8 +11502,151 @@ var _systemSchema = defineSchema({
   })
 });
 
+// src/gateway-rpc.ts
+import crypto from "node:crypto";
+function buildRequestFrame(id, method, params) {
+  return { id, type: "req", method, params };
+}
+function getPendingRequests() {
+  const g = globalThis;
+  const hot = g.__cohort_sync__ ?? (g.__cohort_sync__ = {});
+  if (!hot.pendingGatewayRequests) hot.pendingGatewayRequests = /* @__PURE__ */ new Map();
+  return hot.pendingGatewayRequests;
+}
+var authReady = null;
+function openGatewayConnection(port, token, logger) {
+  const ws = new WebSocket(`ws://127.0.0.1:${port}`);
+  let resolveAuth;
+  let rejectAuth;
+  let authSettled = false;
+  authReady = new Promise((res, rej) => {
+    resolveAuth = res;
+    rejectAuth = rej;
+  });
+  ws.addEventListener("open", () => {
+    ws.send(JSON.stringify({
+      minProtocol: 1,
+      maxProtocol: 1,
+      client: {
+        id: "gateway-client",
+        version: "1.0.0",
+        platform: process.platform,
+        mode: "backend"
+      },
+      auth: { token }
+    }));
+    logger.info(`cohort-sync: gateway WS connected to port ${port}, awaiting hello-ok`);
+  });
+  ws.addEventListener("message", (event) => {
+    try {
+      const data = JSON.parse(String(event.data));
+      if (data.type === "hello-ok") {
+        authSettled = true;
+        resolveAuth();
+        logger.info("cohort-sync: gateway WS authenticated");
+        return;
+      }
+      if (data.type === "hello-error" || data.type === "error") {
+        authSettled = true;
+        rejectAuth(new Error(`Gateway auth failed: ${data.message ?? data.error ?? "unknown"}`));
+        ws.close();
+        return;
+      }
+      const pending = getPendingRequests();
+      if (data.type === "res" && data.id && pending.has(data.id)) {
+        const entry = pending.get(data.id);
+        pending.delete(data.id);
+        clearTimeout(entry.timer);
+        if (data.ok) {
+          entry.resolve(data.payload);
+        } else {
+          entry.reject(new Error(`Gateway method failed: ${data.error?.message ?? "unknown"}`));
+        }
+      }
+    } catch {
+    }
+  });
+  ws.addEventListener("close", () => {
+    logger.warn("cohort-sync: gateway WS closed");
+    if (!authSettled) {
+      authSettled = true;
+      rejectAuth(new Error("Gateway WS closed during auth"));
+    }
+    const pending = getPendingRequests();
+    for (const [, { reject, timer }] of pending) {
+      clearTimeout(timer);
+      reject(new Error("Gateway WS closed"));
+    }
+    pending.clear();
+  });
+  ws.addEventListener("error", (err) => {
+    logger.error(`cohort-sync: gateway WS error: ${String(err)}`);
+  });
+  return ws;
+}
+async function callGatewayMethod(ws, method, params, timeoutMs = 1e4) {
+  if (!ws || ws.readyState !== WebSocket.OPEN) {
+    throw new Error("Gateway WS not connected");
+  }
+  if (authReady) await authReady;
+  const id = crypto.randomUUID();
+  const frame = buildRequestFrame(id, method, params);
+  const pending = getPendingRequests();
+  return new Promise((resolve, reject) => {
+    const timer = setTimeout(() => {
+      pending.delete(id);
+      reject(new Error(`Gateway method ${method} timed out after ${timeoutMs}ms`));
+    }, timeoutMs);
+    pending.set(id, {
+      resolve,
+      reject,
+      timer
+    });
+    ws.send(JSON.stringify(frame));
+  });
+}
+
+// src/cron-mapping.ts
+function formatSchedule(s) {
+  switch (s.kind) {
+    case "cron":
+      return s.expr ?? "";
+    case "every":
+      return `every ${humanizeMs(s.everyMs ?? 0)}`;
+    case "at":
+      return `once at ${s.at ?? ""}`;
+    default:
+      return s.kind;
+  }
+}
+function humanizeMs(ms) {
+  if (ms >= 864e5) return `${Math.round(ms / 864e5)}d`;
+  if (ms >= 36e5) return `${Math.round(ms / 36e5)}h`;
+  if (ms >= 6e4) return `${Math.round(ms / 6e4)}m`;
+  return `${Math.round(ms / 1e3)}s`;
+}
+function mapCronJob(job, resolveAgentName) {
+  return {
+    id: job.id,
+    text: job.name,
+    schedule: formatSchedule(job.schedule),
+    enabled: job.enabled,
+    agentId: resolveAgentName(job.agentId ?? "main"),
+    nextRun: job.state?.nextRunAtMs,
+    lastRun: job.state?.lastRunAtMs,
+    lastStatus: job.state?.lastRunStatus,
+    lastError: job.state?.lastError ?? null
+  };
+}
+function reverseResolveAgentName(cohortName, forwardMap) {
+  const lower = cohortName.toLowerCase();
+  for (const [openclawId, name] of Object.entries(forwardMap)) {
+    if (name.toLowerCase() === lower) return openclawId;
+  }
+  return cohortName;
+}
+
 // src/subscription.ts
-import { execFileSync } from "node:child_process";
 function deriveConvexUrl(apiUrl) {
   return apiUrl.replace(/\.convex\.site\/?$/, ".convex.cloud");
 }
@@ -11605,7 +11744,11 @@ function getHotState() {
       lastKnownRoster: [],
       intervals: { heartbeat: null, activityFlush: null },
       activityBuffer: [],
-      channelAgentBridge: {}
+      channelAgentBridge: {},
+      gatewayWs: null,
+      gatewayPort: null,
+      gatewayToken: null,
+      commandSubscription: null
     };
     globalThis[HOT_KEY] = state;
   }
@@ -11736,7 +11879,7 @@ function initCommandSubscription(cfg, logger, resolveAgentName) {
   const c = getOrCreateClient();
   if (!c) {
     logger.warn("cohort-sync: no ConvexClient \u2014 command subscription skipped");
-    return;
+    return null;
   }
   let processing = false;
   const unsubscribe = c.onUpdate(
@@ -11760,19 +11903,94 @@ function initCommandSubscription(cfg, logger, resolveAgentName) {
               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);
-                if (freshJobs !== null) {
-                  const resolvedJobs = resolveAgentName ? freshJobs.map((j) => ({ ...j, agentId: j.agentId ? resolveAgentName(j.agentId) : j.agentId })) : freshJobs;
-                  await pushCronSnapshot(cfg.apiKey, resolvedJobs);
+            if (cmd.type.startsWith("cron")) {
+              const ws = getHotState().gatewayWs;
+              if (!ws || ws.readyState !== WebSocket.OPEN) {
+                logger.warn(`cohort-sync: gateway WS not connected, cannot execute ${cmd.type}`);
+                continue;
+              }
+              const nameMap = cfg.agentNameMap ?? {};
+              if (cmd.type === "cronEnable") {
+                await callGatewayMethod(ws, "cohort-sync/cron-update", {
+                  jobId: cmd.payload?.jobId,
+                  patch: { enabled: true }
+                });
+              } else if (cmd.type === "cronDisable") {
+                await callGatewayMethod(ws, "cohort-sync/cron-update", {
+                  jobId: cmd.payload?.jobId,
+                  patch: { enabled: false }
+                });
+              } else if (cmd.type === "cronDelete") {
+                await callGatewayMethod(ws, "cohort-sync/cron-remove", {
+                  jobId: cmd.payload?.jobId
+                });
+              } else if (cmd.type === "cronRunNow") {
+                const runResult = await callGatewayMethod(
+                  ws,
+                  "cohort-sync/cron-run",
+                  { jobId: cmd.payload?.jobId }
+                );
+                if (runResult?.ok && runResult?.ran) {
+                  const jobId = cmd.payload?.jobId;
+                  let polls = 0;
+                  const pollInterval = setInterval(async () => {
+                    polls++;
+                    if (polls >= 15) {
+                      clearInterval(pollInterval);
+                      return;
+                    }
+                    try {
+                      const pollWs = getHotState().gatewayWs;
+                      if (!pollWs || pollWs.readyState !== WebSocket.OPEN) {
+                        clearInterval(pollInterval);
+                        return;
+                      }
+                      const freshJobs = await callGatewayMethod(pollWs, "cohort-sync/cron-list");
+                      const job = freshJobs.find((j) => j.id === jobId);
+                      if (job && !job.state?.runningAtMs) {
+                        clearInterval(pollInterval);
+                        const mapped = freshJobs.map((j) => mapCronJob(j, resolveAgentName));
+                        await pushCronSnapshot(cfg.apiKey, mapped);
+                      }
+                    } catch {
+                    }
+                  }, 2e3);
+                }
+              } else if (cmd.type === "cronCreate") {
+                const agentId = reverseResolveAgentName(cmd.payload?.agentId ?? "main", nameMap);
+                await callGatewayMethod(ws, "cohort-sync/cron-add", {
+                  job: {
+                    agentId,
+                    name: cmd.payload?.name,
+                    enabled: true,
+                    schedule: cmd.payload?.schedule,
+                    payload: { kind: "agentTurn", message: cmd.payload?.message },
+                    sessionTarget: "isolated",
+                    wakeMode: "now"
+                  }
+                });
+              } else if (cmd.type === "cronUpdate") {
+                const patch = {};
+                if (cmd.payload?.name) patch.name = cmd.payload.name;
+                if (cmd.payload?.schedule) patch.schedule = cmd.payload.schedule;
+                if (cmd.payload?.message) patch.payload = { kind: "agentTurn", message: cmd.payload.message };
+                if (cmd.payload?.agentId) patch.agentId = reverseResolveAgentName(cmd.payload.agentId, nameMap);
+                await callGatewayMethod(ws, "cohort-sync/cron-update", {
+                  jobId: cmd.payload?.jobId,
+                  patch
+                });
+              } else {
+                logger.warn(`cohort-sync: unknown cron command type: ${cmd.type}`);
+              }
+              if (ws.readyState === WebSocket.OPEN) {
+                try {
+                  const freshJobs = await callGatewayMethod(ws, "cohort-sync/cron-list");
+                  const mapped = freshJobs.map((j) => mapCronJob(j, resolveAgentName));
+                  await pushCronSnapshot(cfg.apiKey, mapped);
+                } catch (snapErr) {
+                  logger.warn(`cohort-sync: post-command snapshot push failed: ${String(snapErr)}`);
                 }
-              } 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}`);
             }
@@ -11788,34 +12006,8 @@ function initCommandSubscription(cfg, logger, resolveAgentName) {
       logger.error(`cohort-sync: command subscription error: ${String(err)}`);
     }
   );
-  unsubscribers.push(unsubscribe);
-  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;
-  }
+  return unsubscribe;
 }
 async function callAddCommentFromPlugin(apiKey, args) {
   const c = getOrCreateClient();
@@ -11845,6 +12037,13 @@ function closeSubscription() {
     } catch {
     }
   }
+  if (state.commandSubscription) {
+    try {
+      state.commandSubscription();
+    } catch {
+    }
+    state.commandSubscription = null;
+  }
   client?.close();
   client = null;
   clearHotState();
@@ -11918,10 +12117,6 @@ function getChannelAgent(channelId) {
 }
 
 // src/sync.ts
-var cronStorePath = null;
-function setCronStorePath(p) {
-  cronStorePath = p;
-}
 function extractJson(raw) {
   const jsonStart = raw.search(/[\[{]/);
   const jsonEndBracket = raw.lastIndexOf("]");
@@ -11953,73 +12148,35 @@ function fetchSkills(logger) {
     return [];
   }
 }
-function fetchCronJobs(logger) {
-  try {
-    const storePath = cronStorePath ?? path.join(os.homedir(), ".openclaw", "cron", "jobs.json");
-    if (!fs.existsSync(storePath)) {
-      logger.warn(`cohort-sync: cron store not found at ${storePath}`);
-      return null;
-    }
-    const raw = fs.readFileSync(storePath, "utf-8");
-    const parsed = JSON.parse(raw);
-    const jobs = Array.isArray(parsed?.jobs) ? parsed.jobs : [];
-    return jobs.map((j) => ({
-      id: String(j.id ?? "unknown"),
-      text: String(j.name ?? ""),
-      schedule: formatSchedule(j.schedule),
-      ...j.state?.nextRunAtMs != null ? { nextRun: Number(j.state.nextRunAtMs) } : {},
-      ...j.state?.lastRunAtMs != null ? { lastRun: Number(j.state.lastRunAtMs) } : {},
-      ...j.state?.lastStatus ? { lastStatus: String(j.state.lastStatus) } : {},
-      enabled: j.enabled !== false,
-      ...j.agentId != null ? { agentId: String(j.agentId) } : {}
-    }));
-  } catch (err) {
-    logger.warn(`cohort-sync: failed to read cron store: ${String(err)}`);
-    return null;
-  }
-}
-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";
 }
-async function v1Get(apiUrl, apiKey, path3) {
-  const res = await fetch(`${apiUrl.replace(/\/+$/, "")}${path3}`, {
+async function v1Get(apiUrl, apiKey, path2) {
+  const res = await fetch(`${apiUrl.replace(/\/+$/, "")}${path2}`, {
     headers: { Authorization: `Bearer ${apiKey}` },
     signal: AbortSignal.timeout(1e4)
   });
-  if (!res.ok) throw new Error(`GET ${path3} \u2192 ${res.status}`);
+  if (!res.ok) throw new Error(`GET ${path2} \u2192 ${res.status}`);
   return res.json();
 }
-async function v1Patch(apiUrl, apiKey, path3, body) {
-  const res = await fetch(`${apiUrl.replace(/\/+$/, "")}${path3}`, {
+async function v1Patch(apiUrl, apiKey, path2, body) {
+  const res = await fetch(`${apiUrl.replace(/\/+$/, "")}${path2}`, {
     method: "PATCH",
     headers: { Authorization: `Bearer ${apiKey}`, "Content-Type": "application/json" },
     body: JSON.stringify(body),
     signal: AbortSignal.timeout(1e4)
   });
-  if (!res.ok) throw new Error(`PATCH ${path3} \u2192 ${res.status}`);
+  if (!res.ok) throw new Error(`PATCH ${path2} \u2192 ${res.status}`);
 }
-async function v1Post(apiUrl, apiKey, path3, body) {
-  const res = await fetch(`${apiUrl.replace(/\/+$/, "")}${path3}`, {
+async function v1Post(apiUrl, apiKey, path2, body) {
+  const res = await fetch(`${apiUrl.replace(/\/+$/, "")}${path2}`, {
     method: "POST",
     headers: { Authorization: `Bearer ${apiKey}`, "Content-Type": "application/json" },
     body: JSON.stringify(body),
     signal: AbortSignal.timeout(1e4)
   });
-  if (!res.ok) throw new Error(`POST ${path3} \u2192 ${res.status}`);
+  if (!res.ok) throw new Error(`POST ${path2} \u2192 ${res.status}`);
 }
 async function checkForUpdate(currentVersion, logger) {
   try {
@@ -12187,6 +12344,65 @@ async function fullSync(agentName, model, cfg, logger, openClawAgents) {
   logger.info("cohort-sync: full sync complete");
 }
 
+// src/gateway-methods.ts
+function registerCronGatewayMethods(api) {
+  api.registerGatewayMethod("cohort-sync/cron-list", async ({ context, respond }) => {
+    try {
+      const jobs = await context.cron.list({ includeDisabled: true });
+      respond(true, jobs);
+    } catch (err) {
+      respond(false, void 0, {
+        code: "INTERNAL_ERROR",
+        message: (err instanceof Error ? err.message : String(err)).slice(0, 200)
+      });
+    }
+  });
+  api.registerGatewayMethod("cohort-sync/cron-run", async ({ context, params, respond }) => {
+    try {
+      const result = await context.cron.run(params.jobId, "force");
+      respond(true, result);
+    } catch (err) {
+      respond(false, void 0, {
+        code: "CRON_RUN_FAILED",
+        message: (err instanceof Error ? err.message : String(err)).slice(0, 200)
+      });
+    }
+  });
+  api.registerGatewayMethod("cohort-sync/cron-update", async ({ context, params, respond }) => {
+    try {
+      const result = await context.cron.update(params.jobId, params.patch);
+      respond(true, result);
+    } catch (err) {
+      respond(false, void 0, {
+        code: "CRON_UPDATE_FAILED",
+        message: (err instanceof Error ? err.message : String(err)).slice(0, 200)
+      });
+    }
+  });
+  api.registerGatewayMethod("cohort-sync/cron-remove", async ({ context, params, respond }) => {
+    try {
+      const result = await context.cron.remove(params.jobId);
+      respond(true, result);
+    } catch (err) {
+      respond(false, void 0, {
+        code: "CRON_REMOVE_FAILED",
+        message: (err instanceof Error ? err.message : String(err)).slice(0, 200)
+      });
+    }
+  });
+  api.registerGatewayMethod("cohort-sync/cron-add", async ({ context, params, respond }) => {
+    try {
+      const result = await context.cron.add(params.job);
+      respond(true, result);
+    } catch (err) {
+      respond(false, void 0, {
+        code: "CRON_ADD_FAILED",
+        message: (err instanceof Error ? err.message : String(err)).slice(0, 200)
+      });
+    }
+  });
+}
+
 // src/agent-state.ts
 import { basename } from "node:path";
 
@@ -12696,7 +12912,7 @@ function diag(label, data) {
   const line = `[${ts}] ${label}${payload}
 `;
   try {
-    fs2.appendFileSync(DIAG_LOG_PATH, line);
+    fs.appendFileSync(DIAG_LOG_PATH, line);
   } catch {
   }
 }
@@ -12724,16 +12940,16 @@ function dumpEvent(event) {
 }
 var PLUGIN_VERSION = "unknown";
 try {
-  const pkgPath = path2.join(path2.dirname(new URL(import.meta.url).pathname), "package.json");
-  const pkgJson = JSON.parse(fs2.readFileSync(pkgPath, "utf8"));
+  const pkgPath = path.join(path.dirname(new URL(import.meta.url).pathname), "package.json");
+  const pkgJson = JSON.parse(fs.readFileSync(pkgPath, "utf8"));
   PLUGIN_VERSION = pkgJson.version ?? "unknown";
 } catch {
 }
 diag("MODULE_LOADED", { BUILD_ID, PLUGIN_VERSION });
 function parseIdentityFile(workspaceDir) {
   try {
-    const filePath = path2.join(workspaceDir, "IDENTITY.md");
-    const content = fs2.readFileSync(filePath, "utf-8");
+    const filePath = path.join(workspaceDir, "IDENTITY.md");
+    const content = fs.readFileSync(filePath, "utf-8");
     const identity = {};
     for (const line of content.split(/\r?\n/)) {
       const cleaned = line.trim().replace(/^\s*-\s*/, "");
@@ -12771,8 +12987,8 @@ function getOrCreateTracker() {
   state.tracker = fresh;
   return fresh;
 }
-var STATE_FILE_PATH = path2.join(
-  path2.dirname(new URL(import.meta.url).pathname),
+var STATE_FILE_PATH = path.join(
+  path.dirname(new URL(import.meta.url).pathname),
   ".session-state.json"
 );
 function saveSessionsToDisk(tracker) {
@@ -12789,14 +13005,14 @@ function saveSessionsToDisk(tracker) {
         data.sessions.push({ agentName: name, key });
       }
     }
-    fs2.writeFileSync(STATE_FILE_PATH, JSON.stringify(data));
+    fs.writeFileSync(STATE_FILE_PATH, JSON.stringify(data));
   } catch {
   }
 }
 function loadSessionsFromDisk(tracker, logger) {
   try {
-    if (!fs2.existsSync(STATE_FILE_PATH)) return;
-    const data = JSON.parse(fs2.readFileSync(STATE_FILE_PATH, "utf8"));
+    if (!fs.existsSync(STATE_FILE_PATH)) return;
+    const data = JSON.parse(fs.readFileSync(STATE_FILE_PATH, "utf8"));
     if (Date.now() - new Date(data.savedAt).getTime() > 864e5) {
       logger.info("cohort-sync: disk session state too old (>24h), skipping");
       return;
@@ -12843,6 +13059,7 @@ function registerHooks(api, cfg) {
   const tracker = getOrCreateTracker();
   let heartbeatInterval = null;
   let activityFlushInterval = null;
+  registerCronGatewayMethods(api);
   logger.info(`cohort-sync: registerHooks [${BUILD_ID}]`);
   diag("REGISTER_HOOKS", {
     BUILD_ID,
@@ -12854,9 +13071,6 @@ function registerHooks(api, cfg) {
     agentIds: (config?.agents?.list ?? []).map((a) => a.id),
     agentMessageProviders: (config?.agents?.list ?? []).map((a) => ({ id: a.id, mp: a.messageProvider }))
   });
-  const cronPath = path2.join(os2.homedir(), ".openclaw", "cron", "jobs.json");
-  setCronStorePath(cronPath);
-  diag("CRON_STORE_PATH", { cronPath, exists: fs2.existsSync(cronPath) });
   setConvexUrl(cfg);
   setLogger(logger);
   restoreFromHotReload(logger);
@@ -12977,6 +13191,15 @@ function registerHooks(api, cfg) {
   }, 3e3);
   saveIntervalsToHot(heartbeatInterval, activityFlushInterval);
   logger.info("cohort-sync: intervals created (heartbeat=2m, activityFlush=3s)");
+  {
+    const hotState = getHotState();
+    if (hotState.commandSubscription) {
+      hotState.commandSubscription();
+      hotState.commandSubscription = null;
+    }
+    const unsub = initCommandSubscription(cfg, logger, resolveAgentName);
+    hotState.commandSubscription = unsub;
+  }
   api.registerTool((toolCtx) => {
     const agentId = toolCtx.agentId ?? "main";
     const agentName = resolveAgentName(agentId);
@@ -13126,17 +13349,17 @@ Do not attempt to make more comments until ${resetAt}.`
       }
     }
     saveSessionsToDisk(tracker);
-    try {
-      const cronJobs2 = fetchCronJobs(logger);
-      if (cronJobs2 !== null) {
-        const resolvedJobs = cronJobs2.map((job) => ({
-          ...job,
-          agentId: job.agentId ? resolveAgentName(job.agentId) : job.agentId
-        }));
-        await pushCronSnapshot(cfg.apiKey, resolvedJobs);
+    const ws = getHotState().gatewayWs;
+    if (ws && ws.readyState === WebSocket.OPEN) {
+      try {
+        const jobs = await callGatewayMethod(ws, "cohort-sync/cron-list");
+        const mapped = jobs.map((j) => mapCronJob(j, resolveAgentName));
+        await pushCronSnapshot(cfg.apiKey, mapped);
+      } catch (err) {
+        logger.warn(`cohort-sync: cron list failed: ${String(err)}`);
       }
-    } catch (err) {
-      logger.warn(`cohort-sync: heartbeat cron push failed: ${String(err)}`);
+    } else {
+      logger.warn("cohort-sync: gateway WS not connected \u2014 skipping cron snapshot");
     }
     logger.info(`cohort-sync: heartbeat pushed for ${allAgentIds.length} agents`);
   }
@@ -13175,6 +13398,23 @@ Do not attempt to make more comments until ${resetAt}.`
       }
     }
     diag("GATEWAY_START_BRIDGE_AFTER_SEED", { bridge: { ...getHotState().channelAgentBridge } });
+    const hotState = getHotState();
+    hotState.gatewayPort = event.port;
+    const rawToken = api.config?.gateway?.auth?.token;
+    if (typeof rawToken === "string") {
+      hotState.gatewayToken = rawToken;
+    } else if (rawToken && typeof rawToken === "object" && rawToken.source === "env") {
+      hotState.gatewayToken = process.env[rawToken.id] ?? null;
+    } else {
+      hotState.gatewayToken = null;
+    }
+    if (!hotState.gatewayWs || hotState.gatewayWs.readyState !== WebSocket.OPEN) {
+      if (hotState.gatewayToken) {
+        hotState.gatewayWs = openGatewayConnection(event.port, hotState.gatewayToken, logger);
+      } else {
+        logger.warn("cohort-sync: no gateway auth token in config \u2014 cron operations disabled");
+      }
+    }
     await initSubscription(
       event.port,
       cfg,
@@ -13183,7 +13423,6 @@ Do not attempt to make more comments until ${resetAt}.`
     ).catch((err) => {
       logger.error(`cohort-sync: subscription init failed: ${String(err)}`);
     });
-    initCommandSubscription(cfg, logger, resolveAgentName);
     const allAgentIds = ["main", ...(config?.agents?.list ?? []).map((a) => a.id)];
     for (const agentId of allAgentIds) {
       const agentName = resolveAgentName(agentId);

package/dist/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cfio/cohort-sync",
-  "version": "0.4.8",
+  "version": "0.5.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.4.8",
+  "version": "0.5.0",
   "description": "Syncs agent status and skills to Cohort dashboard",
   "license": "MIT",
   "homepage": "https://docs.cohort.bot/gateway",