openclaw-remote 0.3.1 → 0.4.1

package/dist/index.js

@@ -2795,7 +2795,67 @@ async function getTeam(account) {
 
 // src/realtime-listener.ts
 import { createClient } from "@supabase/supabase-js";
-function connectRealtime(account, onEvent, onError, log) {
+var leaderTimers = /* @__PURE__ */ new Map();
+var LEADER_DEBOUNCE_MS = 6e4;
+var leaderRolesCache = [];
+var leaderRolesCacheTime = 0;
+var LEADER_CACHE_TTL = 5 * 6e4;
+async function resolveAgentIdentity(account, log) {
+  try {
+    const res = await fetch(`${account.baseUrl}/api/v1/roles`, {
+      headers: { Authorization: `Bearer ${account.apiKey}`, Accept: "application/json" },
+      signal: AbortSignal.timeout(1e4)
+    });
+    if (!res.ok) {
+      log?.warn?.(`Failed to resolve agent identity: HTTP ${res.status}`);
+      return null;
+    }
+    const data = await res.json();
+    const roles = data.roles || [];
+    const myRoles = roles.filter((r) => r.is_mine);
+    const myRoleIds = myRoles.map((r) => r.id);
+    const isLeader = myRoles.some((r) => r.is_leader);
+    const hbRes = await fetch(`${account.baseUrl}/api/v1/heartbeat`, {
+      headers: { Authorization: `Bearer ${account.apiKey}`, Accept: "application/json" },
+      signal: AbortSignal.timeout(1e4)
+    });
+    let agentName = "";
+    if (hbRes.ok) {
+      const hb = await hbRes.json();
+      agentName = hb.agent_name || "";
+    }
+    log?.info?.(`Agent identity resolved: "${agentName}", roles: [${myRoleIds.join(", ")}], leader: ${isLeader}`);
+    return { agentName, myRoleIds, isLeader };
+  } catch (err) {
+    log?.warn?.(`Failed to resolve agent identity: ${err}`);
+    return null;
+  }
+}
+async function fetchLeaderRoles(supabase, log) {
+  const now = Date.now();
+  if (now - leaderRolesCacheTime < LEADER_CACHE_TTL && leaderRolesCache.length > 0) {
+    return leaderRolesCache;
+  }
+  const { data: roles } = await supabase.from("project_roles").select("id").eq("is_leader", true);
+  if (!roles || roles.length === 0) {
+    leaderRolesCache = [];
+    leaderRolesCacheTime = now;
+    return [];
+  }
+  const roleIds = roles.map((r) => r.id);
+  const { data: assignments } = await supabase.from("agent_role_assignments").select("project_role_id, agent_id").in("project_role_id", roleIds);
+  const map = /* @__PURE__ */ new Map();
+  for (const a of assignments ?? []) {
+    const list = map.get(a.project_role_id) || [];
+    list.push(a.agent_id);
+    map.set(a.project_role_id, list);
+  }
+  leaderRolesCache = roleIds.map((id) => ({ roleId: id, agentIds: map.get(id) || [] }));
+  leaderRolesCacheTime = now;
+  log?.info?.(`Leader roles cache refreshed: ${leaderRolesCache.length} leader role(s)`);
+  return leaderRolesCache;
+}
+function connectRealtime(account, identity, onEvent, onError, log) {
   const { supabaseUrl, supabaseKey } = account;
   if (!supabaseUrl || !supabaseKey) {
     throw new Error("Supabase URL and key are required for Realtime listener. Set supabaseUrl and supabaseKey in channels.remote config.");
@@ -2819,14 +2879,31 @@ function connectRealtime(account, onEvent, onError, log) {
         const row = payload.new;
         if (row.agent_author_id && !row.author_id) {
           log?.info?.(`Skipping agent-authored comment on task ${row.task_id} (echo suppression)`);
+          scheduleLeaderNotification(row.task_id, row.agent_author_id, supabase, log);
           return;
         }
+        const body = row.body || row.content || "";
+        if (!row.author_id && !row.agent_author_id && identity) {
+          if (body.startsWith("\u{1F4CC} Assigned to ")) {
+            const targetName = body.replace("\u{1F4CC} Assigned to ", "").trim();
+            if (targetName.toLowerCase() !== identity.agentName.toLowerCase()) {
+              log?.info?.(`Skipping assignment notification for ${targetName} (I am ${identity.agentName})`);
+              return;
+            }
+          }
+          if (body.startsWith("\u{1F440} ")) {
+            if (!identity.isLeader) {
+              log?.info?.(`Skipping leader notification (I am not a leader)`);
+              return;
+            }
+          }
+        }
         const event = {
           type: "task.commented",
           task_id: row.task_id,
           comment: {
             id: row.id,
-            content: row.body || row.content || "",
+            content: body,
             author_name: row.author_name || "System",
             author_id: row.author_id || "",
             created_at: row.created_at
@@ -2854,11 +2931,49 @@ function connectRealtime(account, onEvent, onError, log) {
   return {
     unsubscribe: async () => {
       log?.info?.("Unsubscribing from Supabase Realtime...");
+      for (const timer of leaderTimers.values()) clearTimeout(timer);
+      leaderTimers.clear();
       await supabase.removeChannel(channel);
       log?.info?.("Realtime listener shut down cleanly.");
     }
   };
 }
+async function scheduleLeaderNotification(taskId, commentingAgentId, supabase, log) {
+  const existing = leaderTimers.get(taskId);
+  if (existing) clearTimeout(existing);
+  const timer = setTimeout(async () => {
+    leaderTimers.delete(taskId);
+    try {
+      const leaders = await fetchLeaderRoles(supabase, log);
+      if (leaders.length === 0) return;
+      const { data: task } = await supabase.from("tasks").select("id, title, assigned_role_id").eq("id", taskId).single();
+      if (!task) return;
+      for (const leader of leaders) {
+        if (task.assigned_role_id === leader.roleId) {
+          log?.info?.(`Skipping leader notification for task ${taskId} \u2014 assigned to leader role ${leader.roleId}`);
+          continue;
+        }
+        if (leader.agentIds.includes(commentingAgentId)) continue;
+        if (leader.agentIds.length === 0) continue;
+        const { error } = await supabase.from("task_comments").insert({
+          task_id: taskId,
+          author_id: null,
+          agent_author_id: null,
+          body: `\u{1F440} Activity on this task \u2014 leader review needed`
+        });
+        if (error) {
+          log?.warn?.(`Failed to insert leader notification for task ${taskId}: ${error.message}`);
+        } else {
+          log?.info?.(`Leader notification sent for task ${taskId}`);
+        }
+      }
+    } catch (err) {
+      log?.warn?.(`Leader notification error for task ${taskId}: ${err}`);
+    }
+  }, LEADER_DEBOUNCE_MS);
+  leaderTimers.set(taskId, timer);
+  log?.info?.(`Leader debounce timer set for task ${taskId} (60s)`);
+}
 
 // src/event-formatter.ts
 function formatEvent(event) {
@@ -3163,8 +3278,10 @@ function createRemotePlugin() {
         let realtimeHandle = null;
         if (account.supabaseUrl && account.supabaseKey) {
           try {
+            const identity = await resolveAgentIdentity(account, log);
             realtimeHandle = connectRealtime(
               account,
+              identity,
               async (event) => {
                 const formatted = formatEvent(event);
                 if (!formatted) return;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openclaw-remote",
-  "version": "0.3.1",
+  "version": "0.4.1",
   "description": "Remote project board channel plugin for OpenClaw",
   "type": "module",
   "main": "dist/index.js",