openclaw-remote 0.4.4 → 0.5.0

package/dist/index.js

@@ -8,7 +8,7 @@ var __export = (target, all) => {
 import {
   DEFAULT_ACCOUNT_ID,
   setAccountEnabledInConfigSection,
-  waitUntilAbort,
+  registerPluginHttpRoute,
   optionalStringEnum
 } from "openclaw/plugin-sdk/compat";
 
@@ -2655,13 +2655,11 @@ function resolveAccount(cfg, accountId) {
     baseUrl: (accountOverride.baseUrl ?? channelCfg.baseUrl ?? envBaseUrl).replace(/\/+$/, ""),
     apiKey: accountOverride.apiKey ?? channelCfg.apiKey ?? envApiKey,
     projectId: accountOverride.projectId ?? channelCfg.projectId,
-    supabaseUrl: accountOverride.supabaseUrl ?? channelCfg.supabaseUrl ?? process.env.REMOTE_SUPABASE_URL,
-    supabaseKey: accountOverride.supabaseKey ?? channelCfg.supabaseKey ?? process.env.REMOTE_SUPABASE_KEY,
     dmPolicy: accountOverride.dmPolicy ?? channelCfg.dmPolicy ?? "open",
     allowedUserIds: parseAllowedUserIds(
       accountOverride.allowedUserIds ?? channelCfg.allowedUserIds ?? envAllowedUserIds
     ),
-    webhookPath: accountOverride.webhookPath ?? channelCfg.webhookPath
+    webhookPath: accountOverride.webhookPath ?? channelCfg.webhookPath ?? `/webhooks/remote/${id}`
   };
 }
 
@@ -2793,347 +2791,73 @@ async function getTeam(account) {
   );
 }
 
-// src/realtime-listener.ts
-import { createClient } from "@supabase/supabase-js";
-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);
-    let agentName = "";
-    for (const r of myRoles) {
-      if (r.assigned_to?.type === "agent" && r.assigned_to?.name) {
-        agentName = r.assigned_to.name;
-        break;
-      }
-    }
-    if (!agentName) {
-      const hbRes = await fetch(`${account.baseUrl}/api/v1/heartbeat`, {
-        headers: { Authorization: `Bearer ${account.apiKey}`, Accept: "application/json" },
-        signal: AbortSignal.timeout(1e4)
-      });
-      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.");
-  }
-  log?.info?.(`Connecting to Supabase Realtime: ${supabaseUrl}`);
-  const supabase = createClient(supabaseUrl, supabaseKey, {
-    realtime: {
-      params: { eventsPerSecond: 10 }
-    }
-  });
-  const channelName = `remote-${account.accountId}-${Date.now()}`;
-  const channel = supabase.channel(channelName).on(
-    "postgres_changes",
-    {
-      event: "INSERT",
-      schema: "public",
-      table: "task_comments"
-    },
-    (payload) => {
-      try {
-        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: body,
-            author_name: row.author_name || "System",
-            author_id: row.author_id || "",
-            created_at: row.created_at
-          }
-        };
-        log?.info?.(`Realtime: new comment on task ${row.task_id}`);
-        onEvent(event);
-      } catch (err) {
-        log?.warn?.(`Failed to process comment event: ${err}`);
-      }
+// src/runtime.ts
+import { createPluginRuntimeStore } from "openclaw/plugin-sdk/compat";
+var { setRuntime: setRemoteRuntime, getRuntime: getRemoteRuntime } = createPluginRuntimeStore(
+  "Remote runtime not initialized - plugin not registered"
+);
+
+// src/channel.ts
+var CHANNEL_ID = "remote";
+var activeRouteUnregisters = /* @__PURE__ */ new Map();
+function waitUntilAbort(signal, onAbort) {
+  return new Promise((resolve) => {
+    const complete = () => {
+      onAbort?.();
+      resolve();
+    };
+    if (!signal) {
+      return;
     }
-  );
-  channel.subscribe((status, err) => {
-    if (status === "SUBSCRIBED") {
-      log?.info?.("Supabase Realtime connected and subscribed.");
-    } else if (status === "CHANNEL_ERROR") {
-      log?.error?.(`Realtime channel error: ${err?.message || "unknown"}`);
-      onError(new Error(`Realtime channel error: ${err?.message || "unknown"}`));
-    } else if (status === "TIMED_OUT") {
-      log?.warn?.("Realtime subscription timed out, will auto-retry...");
-    } else if (status === "CLOSED") {
-      log?.info?.("Realtime channel closed.");
+    if (signal.aborted) {
+      complete();
+      return;
     }
+    signal.addEventListener("abort", complete, { once: true });
   });
-  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) {
-  switch (event.type) {
+function formatWebhookEvent(payload) {
+  const { event, task_id, task_title, comment_body, author_name, wake_reason } = payload;
+  switch (event) {
+    case "task.assigned":
     case "task.created":
-      return formatTaskCreated(event);
-    case "task.updated":
-      return formatTaskUpdated(event);
+      return [
+        `You've been assigned a new task:`,
+        ``,
+        `**${task_title}** (ID: ${task_id})`,
+        ``,
+        wake_reason ? `Reason: ${wake_reason}` : "",
+        ``,
+        `Use this task ID for API calls (e.g. to move it to in_progress).`,
+        `Review the task and share your initial thoughts or plan.`
+      ].filter(Boolean).join("\n");
     case "task.commented":
-      return formatTaskCommented(event);
-    case "task.assigned":
-      return formatTaskAssigned(event);
+      return [
+        `${author_name || "Someone"} commented on "${task_title}" (ID: ${task_id}):`,
+        ``,
+        `> ${comment_body || ""}`,
+        ``,
+        `Respond to their comment.`
+      ].join("\n");
+    case "task.mentioned":
+      return [
+        `You were mentioned in a comment on "${task_title}" (ID: ${task_id}):`,
+        ``,
+        `> ${comment_body || ""}`,
+        ``,
+        `Respond to the mention.`
+      ].join("\n");
+    case "task.status_changed":
+      return [
+        `Task "${task_title}" (ID: ${task_id}) status changed.`,
+        wake_reason ? `Details: ${wake_reason}` : "",
+        ``,
+        `Acknowledge the status change if relevant to your work.`
+      ].filter(Boolean).join("\n");
     default:
-      return formatGenericEvent(event);
-  }
-}
-function formatTaskCreated(event) {
-  const task = event.task;
-  if (!task) return null;
-  const meta = [task.type, task.priority].filter(Boolean).join(", ");
-  let body = `\u{1F4CB} New task created: **${task.title}**`;
-  if (meta) body += ` [${meta}]`;
-  if (task.description) body += `
-${task.description}`;
-  body += `
-
-[task:${task.id}]`;
-  return {
-    body,
-    taskId: task.id,
-    taskTitle: task.title,
-    isDirect: false
-  };
-}
-function formatTaskUpdated(event) {
-  const task = event.task;
-  if (!task) return null;
-  const changes = event.changes;
-  if (changes?.field === "assigned_role_id" || changes?.field === "assigned_to_agent" || changes?.field === "assigned_profile_id") {
-    if (changes.to && changes.to !== "null" && changes.to !== "") {
-      let body2 = `\u{1F464} You've been assigned: **${task.title}**`;
-      if (task.description) body2 += `
-
-${task.description}`;
-      body2 += `
-
-Priority: ${task.priority || "medium"} | Type: ${task.type || "task"}`;
-      body2 += `
-
-Acknowledge this task, move it to in_progress using remote_update_task, and share your plan.`;
-      body2 += `
-
-[task:${task.id}]`;
-      return {
-        body: body2,
-        taskId: task.id,
-        taskTitle: task.title,
-        isDirect: true
-      };
-    }
-    return null;
-  }
-  if (changes?.field === "status") {
-    let body2 = `\u{1F504} Task **${task.title}** moved to **${changes.to}**`;
-    body2 += `
-
-[task:${task.id}]`;
-    return {
-      body: body2,
-      taskId: task.id,
-      taskTitle: task.title,
-      isDirect: false
-    };
-  }
-  let body = `\u{1F504} Task updated: **${task.title}**`;
-  if (changes) {
-    body += ` \u2014 ${changes.field} changed from "${changes.from}" to "${changes.to}"`;
+      return `Task update on "${task_title}" (ID: ${task_id}): ${event}${wake_reason ? ` \u2014 ${wake_reason}` : ""}`;
   }
-  body += `
-
-[task:${task.id}]`;
-  return {
-    body,
-    taskId: task.id,
-    taskTitle: task.title,
-    isDirect: false
-  };
-}
-function formatTaskCommented(event) {
-  const comment = event.comment;
-  const taskId = event.task_id ?? event.task?.id;
-  if (!comment || !taskId) return null;
-  const taskTitle = event.task?.title ?? `Task ${taskId}`;
-  let body = `\u{1F4AC} ${comment.author_name} commented on **${taskTitle}**:
-${comment.content}`;
-  body += `
-
-[task:${taskId}]`;
-  return {
-    body,
-    taskId,
-    senderName: comment.author_name,
-    senderId: comment.author_id,
-    taskTitle,
-    isDirect: false
-  };
-}
-function formatTaskAssigned(event) {
-  const task = event.task;
-  const assignee = event.assigned_to;
-  if (!task) return null;
-  let body = `\u{1F464} Task **${task.title}** assigned`;
-  if (assignee) {
-    body += ` to ${assignee.name} (${assignee.role})`;
-  }
-  body += `
-
-[task:${task.id}]`;
-  return {
-    body,
-    taskId: task.id,
-    senderName: assignee?.name,
-    taskTitle: task.title,
-    // Assigned events are direct — the agent is likely the assignee
-    isDirect: true
-  };
-}
-function formatGenericEvent(event) {
-  const task = event.task;
-  const taskId = event.task_id ?? task?.id;
-  if (!taskId) return null;
-  const taskTitle = task?.title ?? `Task ${taskId}`;
-  let body = `\u{1F514} Remote event (${event.type}): **${taskTitle}**`;
-  body += `
-
-[task:${taskId}]`;
-  return {
-    body,
-    taskId,
-    taskTitle,
-    isDirect: false
-  };
 }
-
-// src/runtime.ts
-import { createPluginRuntimeStore } from "openclaw/plugin-sdk/compat";
-var { setRuntime: setRemoteRuntime, getRuntime: getRemoteRuntime } = createPluginRuntimeStore(
-  "Remote runtime not initialized - plugin not registered"
-);
-
-// src/channel.ts
-var CHANNEL_ID = "remote";
 function createRemotePlugin() {
   return {
     id: CHANNEL_ID,
@@ -3212,11 +2936,6 @@ function createRemotePlugin() {
             "- Remote: apiKey is not configured. The plugin cannot authenticate with the Remote API."
           );
         }
-        if (account.dmPolicy === "open") {
-          warnings.push(
-            '- Remote: dmPolicy="open" allows any board event to trigger agent actions. Consider "allowlist" for production use.'
-          );
-        }
         return warnings;
       }
     },
@@ -3262,96 +2981,100 @@ function createRemotePlugin() {
     },
     gateway: {
       startAccount: async (ctx) => {
-        const { cfg, accountId, log, abortSignal, channelRuntime } = ctx;
+        const { cfg, accountId, log } = ctx;
         const account = resolveAccount(cfg, accountId);
         if (!account.enabled) {
           log?.info?.(`Remote account ${accountId} is disabled, skipping`);
-          return waitUntilAbort(abortSignal);
+          return waitUntilAbort(ctx.abortSignal);
         }
         if (!account.baseUrl || !account.apiKey) {
           log?.warn?.(
             `Remote account ${accountId} not fully configured (missing baseUrl or apiKey)`
           );
-          return waitUntilAbort(abortSignal);
-        }
-        if (!account.supabaseUrl || !account.supabaseKey) {
-          log?.warn?.(
-            `Remote account ${accountId} missing supabaseUrl or supabaseKey \u2014 Realtime events disabled. Agent tools still work.`
-          );
+          return waitUntilAbort(ctx.abortSignal);
         }
         log?.info?.(
-          `Starting Remote channel (account: ${accountId}, url: ${account.baseUrl})`
+          `Starting Remote channel (account: ${accountId}, webhookPath: ${account.webhookPath})`
         );
-        const runtime = channelRuntime ?? getRemoteRuntime().channel;
-        let realtimeHandle = null;
-        if (account.supabaseUrl && account.supabaseKey) {
+        const handler = async (req) => {
+          if (req.method !== "POST") {
+            return { status: 405, body: { error: "Method not allowed" } };
+          }
+          const payload = req.body;
+          if (!payload || !payload.event || !payload.task_id) {
+            return { status: 400, body: { error: "Invalid payload: missing event or task_id" } };
+          }
+          log?.info?.(`Webhook received: ${payload.event} for task ${payload.task_id} (agent: ${payload.agent_name})`);
+          const body = formatWebhookEvent(payload);
+          const sessionKey = `remote:${account.accountId}:${payload.task_id}`;
           try {
-            const identity = await resolveAgentIdentity(account, log);
-            realtimeHandle = connectRealtime(
-              account,
-              identity,
-              async (event) => {
-                const formatted = formatEvent(event);
-                if (!formatted) return;
-                try {
-                  const rt = getRemoteRuntime();
-                  const currentCfg = await rt.config.loadConfig();
-                  const sessionKey = `remote:${account.accountId}:${formatted.taskId}`;
-                  const msgCtx = runtime.reply.finalizeInboundContext({
-                    Body: formatted.body,
-                    RawBody: formatted.body,
-                    CommandBody: formatted.body,
-                    From: `remote:${formatted.senderId ?? "board"}`,
-                    To: `remote:${account.accountId}`,
-                    SessionKey: sessionKey,
-                    AccountId: account.accountId,
-                    OriginatingChannel: CHANNEL_ID,
-                    OriginatingTo: `remote:${formatted.taskId}`,
-                    ChatType: formatted.isDirect ? "direct" : "group",
-                    SenderName: formatted.senderName ?? "Remote Board",
-                    SenderId: formatted.senderId ?? "board",
-                    Provider: CHANNEL_ID,
-                    Surface: CHANNEL_ID,
-                    ConversationLabel: formatted.taskTitle ?? `Task ${formatted.taskId}`,
-                    Timestamp: Date.now()
-                  });
-                  await runtime.reply.dispatchReplyWithBufferedBlockDispatcher({
-                    ctx: msgCtx,
-                    cfg: currentCfg,
-                    dispatcherOptions: {
-                      deliver: async (payload, _info) => {
-                        if (payload.isReasoning) return;
-                        const text = payload?.text;
-                        if (text) {
-                          await postComment(account, formatted.taskId, text);
-                        }
-                      },
-                      onReplyStart: () => {
-                        log?.info?.(`Agent reply started for task ${formatted.taskId}`);
-                      }
-                    }
-                  });
-                } catch (err) {
-                  log?.error?.(
-                    `Error dispatching Remote event: ${err instanceof Error ? err.message : String(err)}`
-                  );
+            const rt = getRemoteRuntime();
+            const currentCfg = await rt.config.loadConfig();
+            const msgCtx = rt.channel.reply.finalizeInboundContext({
+              Body: body,
+              RawBody: body,
+              CommandBody: body,
+              From: `remote:${payload.task_id}`,
+              To: `remote:${account.accountId}`,
+              SessionKey: sessionKey,
+              AccountId: account.accountId,
+              OriginatingChannel: CHANNEL_ID,
+              OriginatingTo: `remote:${payload.task_id}`,
+              ChatType: "direct",
+              SenderName: payload.author_name || "Remote Board",
+              SenderId: payload.task_id,
+              Provider: CHANNEL_ID,
+              Surface: CHANNEL_ID,
+              ConversationLabel: payload.task_title || `Task ${payload.task_id}`,
+              Timestamp: Date.now()
+            });
+            await rt.channel.reply.dispatchReplyWithBufferedBlockDispatcher({
+              ctx: msgCtx,
+              cfg: currentCfg,
+              dispatcherOptions: {
+                deliver: async (deliverPayload) => {
+                  if (deliverPayload.isReasoning) return;
+                  const text = deliverPayload?.text ?? deliverPayload?.body;
+                  if (text) {
+                    await postComment(account, payload.task_id, text);
+                  }
+                },
+                onReplyStart: () => {
+                  log?.info?.(`Agent reply started for task ${payload.task_id}`);
                 }
-              },
-              (err) => {
-                log?.warn?.(`Realtime error: ${err.message}`);
-              },
-              log
-            );
+              }
+            });
           } catch (err) {
-            log?.error?.(`Failed to connect Realtime: ${err instanceof Error ? err.message : String(err)}`);
+            log?.error?.(
+              `Error dispatching webhook event: ${err instanceof Error ? err.message : String(err)}`
+            );
+            return { status: 500, body: { error: "Internal error" } };
           }
+          return { status: 200, body: { ok: true } };
+        };
+        const routeKey = `${accountId}:${account.webhookPath}`;
+        const prevUnregister = activeRouteUnregisters.get(routeKey);
+        if (prevUnregister) {
+          log?.info?.(`Deregistering stale route before re-registering: ${account.webhookPath}`);
+          prevUnregister();
+          activeRouteUnregisters.delete(routeKey);
         }
-        await waitUntilAbort(abortSignal, async () => {
-          if (realtimeHandle) {
-            await realtimeHandle.unsubscribe();
-          }
+        const unregister = registerPluginHttpRoute({
+          path: account.webhookPath,
+          auth: "plugin",
+          replaceExisting: true,
+          pluginId: CHANNEL_ID,
+          accountId: account.accountId,
+          log: (msg) => log?.info?.(msg),
+          handler
+        });
+        activeRouteUnregisters.set(routeKey, unregister);
+        log?.info?.(`Registered HTTP route: ${account.webhookPath} for Remote`);
+        return waitUntilAbort(ctx.abortSignal, () => {
+          log?.info?.(`Stopping Remote channel (account: ${accountId})`);
+          if (typeof unregister === "function") unregister();
+          activeRouteUnregisters.delete(routeKey);
         });
-        log?.info?.(`Stopped Remote channel (account: ${accountId})`);
       },
       stopAccount: async (ctx) => {
         ctx.log?.info?.(`Remote account ${ctx.accountId} stopped`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openclaw-remote",
-  "version": "0.4.4",
+  "version": "0.5.0",
   "description": "Remote project board channel plugin for OpenClaw",
   "type": "module",
   "main": "dist/index.js",
@@ -16,7 +16,6 @@
     "openclaw": "*"
   },
   "dependencies": {
-    "@sinclair/typebox": "^0.34.48",
-    "@supabase/supabase-js": "^2.99.1"
+    "@sinclair/typebox": "^0.34.48"
   }
 }