@cfio/cohort-sync 0.2.3 → 0.3.0

package/dist/index.js

@@ -11503,44 +11503,63 @@ var _systemSchema = defineSchema({
 });
 
 // src/subscription.ts
+import { execFileSync } from "node:child_process";
 function deriveConvexUrl(apiUrl) {
   return apiUrl.replace(/\.convex\.site\/?$/, ".convex.cloud");
 }
+var DEFAULT_BEHAVIORAL_PROMPT = `BEFORE RESPONDING:
+- Does your planned response address the task's stated scope? If not, do not comment.
+- Do not post acknowledgment-only responses ("got it", "sounds good", "confirmed"). If you have no new information to add, do not comment.
+- If the work is complete, transition the task to "waiting" and set noReply=true on your final comment, then stop working on this task.`;
 function buildNotificationMessage(n) {
   let header;
   let cta;
   switch (n.type) {
     case "comment":
       if (n.isMentioned) {
-        header = `\u{1F4AC} You were @mentioned on task #${n.taskNumber} "${n.taskTitle}"
+        header = `You were @mentioned on task #${n.taskNumber} "${n.taskTitle}"
 By: ${n.actorName}`;
         cta = "You were directly mentioned. Read the comment and respond using the cohort_comment tool.";
       } else {
-        header = `\u{1F4AC} New comment on task #${n.taskNumber} "${n.taskTitle}"
+        header = `New comment on task #${n.taskNumber} "${n.taskTitle}"
 From: ${n.actorName}`;
         cta = "Read the comment thread and respond using the cohort_comment tool if appropriate.";
       }
       break;
     case "assignment":
-      header = `\u{1F4CC} You were assigned to task #${n.taskNumber} "${n.taskTitle}"
+      header = `You were assigned to task #${n.taskNumber} "${n.taskTitle}"
 By: ${n.actorName}`;
       cta = "Review the task description and begin working on it.";
       break;
     case "status_change":
-      header = `\u{1F504} Status changed on task #${n.taskNumber} "${n.taskTitle}"
+      header = `Status changed on task #${n.taskNumber} "${n.taskTitle}"
 By: ${n.actorName}`;
       cta = "Review the status change and take any follow-up action needed.";
       break;
     default:
-      header = `\u{1F4CB} Notification on task #${n.taskNumber} "${n.taskTitle}"
+      header = `Notification on task #${n.taskNumber} "${n.taskTitle}"
 From: ${n.actorName}`;
       cta = "Check the task and respond if needed.";
   }
   const body = n.preview ? `
 Comment: "${n.preview}"` : "";
-  return `${header}${body}
+  let scope = "";
+  if (n.taskDescription && n.type === "comment") {
+    const truncated = n.taskDescription.length > 500 ? n.taskDescription.slice(0, 500) + "..." : n.taskDescription;
+    scope = `
 
-${cta}`;
+Scope: ${truncated}`;
+  }
+  const prompt = n.behavioralPrompt ? `${n.behavioralPrompt}
+
+${DEFAULT_BEHAVIORAL_PROMPT}` : DEFAULT_BEHAVIORAL_PROMPT;
+  const promptBlock = n.type === "comment" ? `
+
+---
+${prompt}` : "";
+  return `${header}${scope}${body}
+
+${cta}${promptBlock}`;
 }
 async function injectNotification(port, hooksToken, n, agentId = "main") {
   const response = await fetch(`http://localhost:${port}/hooks/agent`, {
@@ -11566,6 +11585,10 @@ 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");
 var HOT_KEY = "__cohort_sync__";
 function getHotState() {
   let state = globalThis[HOT_KEY];
@@ -11705,6 +11728,101 @@ async function initSubscription(port, cfg, hooksToken, logger) {
   }
   state.unsubscribers = [...unsubscribers];
 }
+function initCommandSubscription(cfg, logger) {
+  const c = getOrCreateClient();
+  if (!c) {
+    logger.warn("cohort-sync: no ConvexClient \u2014 command subscription skipped");
+    return;
+  }
+  let processing = false;
+  const unsubscribe = c.onUpdate(
+    getPendingCommandsForPlugin,
+    { apiKey: cfg.apiKey },
+    async (commands) => {
+      if (processing) return;
+      if (commands.length === 0) return;
+      processing = true;
+      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)}`);
+          }
+        }
+      } finally {
+        processing = false;
+      }
+    },
+    (err) => {
+      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;
+  }
+}
+async function callAddCommentFromPlugin(apiKey, args) {
+  const c = getOrCreateClient();
+  if (!c) {
+    throw new Error("Convex client not initialized \u2014 subscription may not be active");
+  }
+  return await c.mutation(addCommentFromPluginRef, {
+    apiKey,
+    taskNumber: args.taskNumber,
+    agentName: args.agentName,
+    content: args.content,
+    noReply: args.noReply
+  });
+}
 function closeSubscription() {
   for (const unsub of unsubscribers) {
     try {
@@ -11752,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 };
@@ -11815,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";
@@ -12731,31 +12896,75 @@ function registerHooks(api, cfg) {
       description: "Post a comment on a Cohort task. Use this to respond to @mentions or collaborate on tasks.",
       parameters: Type.Object({
         task_number: Type.Number({ description: "Task number (e.g. 312)" }),
-        comment: Type.String({ description: "Comment text to post" })
+        comment: Type.String({ description: "Comment text to post" }),
+        no_reply: Type.Optional(Type.Boolean({
+          description: "If true, no notifications will be sent for this comment. Use for final/closing comments."
+        }))
       }),
       async execute(_toolCallId, params) {
-        const apiUrl = cfg.apiUrl.replace(/\/+$/, "");
-        const res = await fetch(
-          `${apiUrl}/api/v1/tasks/${params.task_number}/comments`,
-          {
-            method: "POST",
-            headers: {
-              Authorization: `Bearer ${cfg.apiKey}`,
-              "Content-Type": "application/json"
-            },
-            body: JSON.stringify({ body: params.comment }),
-            signal: AbortSignal.timeout(1e4)
+        try {
+          const result = await callAddCommentFromPlugin(cfg.apiKey, {
+            taskNumber: params.task_number,
+            agentName,
+            content: params.comment,
+            noReply: params.no_reply ?? false
+          });
+          const lines = [`Comment posted on task #${params.task_number}.`];
+          if (result.stats) {
+            lines.push("");
+            lines.push(`This task has ${result.stats.totalComments} comments. ${result.stats.myRecentCount}/${result.stats.threshold} hourly limit used on this task.`);
           }
-        );
-        if (!res.ok) {
-          const text = await res.text().catch(() => "");
-          throw new Error(`POST /api/v1/tasks/${params.task_number}/comments \u2192 ${res.status}: ${text}`);
+          if (result.budget) {
+            lines.push(`Daily budget: ${result.budget.used}/${result.budget.limit}`);
+          }
+          return {
+            content: [{ type: "text", text: lines.join("\n") }],
+            details: result
+          };
+        } catch (err) {
+          const msg = err instanceof Error ? err.message : String(err);
+          if (msg.includes("AGENT_COMMENTS_LOCKED")) {
+            return {
+              content: [{
+                type: "text",
+                text: `Cannot comment on task #${params.task_number}.
+Reason: Agent comments are locked on this task.
+Do not re-attempt to comment on this task.`
+              }],
+              details: { error: "AGENT_COMMENTS_LOCKED", taskNumber: params.task_number }
+            };
+          }
+          if (msg.includes("TASK_HOUR_LIMIT_REACHED")) {
+            const parts = msg.split("|");
+            const count = parts[1] ?? "?";
+            const limit = parts[2] ?? "?";
+            return {
+              content: [{
+                type: "text",
+                text: `Cannot comment on task #${params.task_number}.
+Reason: You have posted ${count} comments on this task in the last hour (limit: ${limit}).
+Step back from this task. Do not comment again until the next hour.`
+              }],
+              details: { error: "TASK_HOUR_LIMIT_REACHED", count, limit, taskNumber: params.task_number }
+            };
+          }
+          if (msg.includes("DAILY_LIMIT_REACHED")) {
+            const parts = msg.split("|");
+            const used = parts[1] ?? "?";
+            const max = parts[2] ?? "?";
+            const resetAt = parts[3] ?? "tomorrow";
+            return {
+              content: [{
+                type: "text",
+                text: `Cannot comment on task #${params.task_number}.
+Reason: Daily comment limit reached (${used}/${max}).
+Do not attempt to make more comments until ${resetAt}.`
+              }],
+              details: { error: "DAILY_LIMIT_REACHED", used, max, resetAt, taskNumber: params.task_number }
+            };
+          }
+          throw err;
         }
-        const result = await res.json();
-        return {
-          content: [{ type: "text", text: `Comment posted on task #${params.task_number}` }],
-          details: result
-        };
       }
     };
   });
@@ -12813,6 +13022,16 @@ function registerHooks(api, cfg) {
       }
     }
     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() {
@@ -12858,6 +13077,7 @@ function registerHooks(api, cfg) {
     ).catch((err) => {
       logger.error(`cohort-sync: subscription init failed: ${String(err)}`);
     });
+    initCommandSubscription(cfg, logger);
     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.2.3",
+  "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.3",
+  "version": "0.3.0",
   "description": "Syncs agent status and skills to Cohort dashboard",
   "license": "MIT",
   "homepage": "https://docs.cohort.bot/gateway",