openclaw-remote 0.1.2 → 0.2.0

package/dist/index.js

@@ -0,0 +1,812 @@
+// src/channel.ts
+import {
+  DEFAULT_ACCOUNT_ID,
+  setAccountEnabledInConfigSection,
+  waitUntilAbort,
+  optionalStringEnum
+} from "openclaw/plugin-sdk/compat";
+import { Type } from "@sinclair/typebox";
+
+// src/accounts.ts
+function getChannelConfig(cfg) {
+  return cfg?.channels?.remote;
+}
+function parseAllowedUserIds(raw) {
+  if (!raw) return [];
+  if (Array.isArray(raw)) return raw.filter(Boolean);
+  return raw.split(",").map((s) => s.trim()).filter(Boolean);
+}
+function listAccountIds(cfg) {
+  const channelCfg = getChannelConfig(cfg);
+  if (!channelCfg) return [];
+  const ids = /* @__PURE__ */ new Set();
+  const hasBaseKey = channelCfg.apiKey || process.env.REMOTE_API_KEY;
+  if (hasBaseKey) {
+    ids.add("default");
+  }
+  if (channelCfg.accounts) {
+    for (const id of Object.keys(channelCfg.accounts)) {
+      ids.add(id);
+    }
+  }
+  return Array.from(ids);
+}
+function resolveAccount(cfg, accountId) {
+  const channelCfg = getChannelConfig(cfg) ?? {};
+  const id = accountId || "default";
+  const accountOverride = channelCfg.accounts?.[id] ?? {};
+  const envBaseUrl = process.env.REMOTE_BASE_URL ?? "";
+  const envApiKey = process.env.REMOTE_API_KEY ?? "";
+  const envAllowedUserIds = process.env.REMOTE_ALLOWED_USER_IDS ?? "";
+  return {
+    accountId: id,
+    enabled: accountOverride.enabled ?? channelCfg.enabled ?? true,
+    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
+  };
+}
+
+// src/client.ts
+function buildHeaders(account) {
+  return {
+    Authorization: `Bearer ${account.apiKey}`,
+    "Content-Type": "application/json",
+    Accept: "application/json"
+  };
+}
+function buildUrl(account, path) {
+  return `${account.baseUrl}${path}`;
+}
+async function apiFetch(url, options) {
+  try {
+    const res = await fetch(url, { ...options, signal: AbortSignal.timeout(3e4) });
+    if (!res.ok) {
+      const body = await res.text().catch(() => "");
+      return {
+        ok: false,
+        error: `HTTP ${res.status}: ${res.statusText}${body ? ` \u2014 ${body.slice(0, 200)}` : ""}`
+      };
+    }
+    const data = await res.json();
+    return { ok: true, data };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return { ok: false, error: message };
+  }
+}
+async function postComment(account, taskId, content) {
+  return apiFetch(
+    buildUrl(account, `/api/v1/tasks/${encodeURIComponent(taskId)}/comments`),
+    {
+      method: "POST",
+      headers: buildHeaders(account),
+      body: JSON.stringify({ content })
+    }
+  );
+}
+async function createTask(account, task) {
+  return apiFetch(
+    buildUrl(account, "/api/v1/tasks"),
+    {
+      method: "POST",
+      headers: buildHeaders(account),
+      body: JSON.stringify(task)
+    }
+  );
+}
+async function updateTask(account, taskId, updates) {
+  return apiFetch(
+    buildUrl(account, `/api/v1/tasks/${encodeURIComponent(taskId)}`),
+    {
+      method: "PATCH",
+      headers: buildHeaders(account),
+      body: JSON.stringify(updates)
+    }
+  );
+}
+async function listTasks(account, filters) {
+  const params = new URLSearchParams();
+  if (filters?.status) params.set("status", filters.status);
+  if (filters?.assigned_to) params.set("assigned_to", filters.assigned_to);
+  const qs = params.toString();
+  const path = `/api/v1/tasks${qs ? `?${qs}` : ""}`;
+  return apiFetch(
+    buildUrl(account, path),
+    {
+      method: "GET",
+      headers: buildHeaders(account)
+    }
+  );
+}
+async function getHeartbeat(account) {
+  return apiFetch(
+    buildUrl(account, "/api/v1/heartbeat"),
+    {
+      method: "GET",
+      headers: buildHeaders(account)
+    }
+  );
+}
+
+// src/realtime-listener.ts
+import { createClient } from "@supabase/supabase-js";
+function connectRealtime(account, 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)`);
+          return;
+        }
+        const event = {
+          type: "task.commented",
+          task_id: row.task_id,
+          comment: {
+            id: row.id,
+            content: row.body || row.content || "",
+            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}`);
+      }
+    }
+  );
+  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.");
+    }
+  });
+  return {
+    unsubscribe: async () => {
+      log?.info?.("Unsubscribing from Supabase Realtime...");
+      await supabase.removeChannel(channel);
+      log?.info?.("Realtime listener shut down cleanly.");
+    }
+  };
+}
+
+// src/event-formatter.ts
+function formatEvent(event) {
+  switch (event.type) {
+    case "task.created":
+      return formatTaskCreated(event);
+    case "task.updated":
+      return formatTaskUpdated(event);
+    case "task.commented":
+      return formatTaskCommented(event);
+    case "task.assigned":
+      return formatTaskAssigned(event);
+    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}"`;
+  }
+  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,
+    meta: {
+      id: CHANNEL_ID,
+      label: "Remote",
+      selectionLabel: "Remote (Project Board)",
+      detailLabel: "Remote (Project Board)",
+      docsPath: "/channels/remote",
+      blurb: "Connect agents to Remote project boards as team members",
+      order: 95
+    },
+    capabilities: {
+      chatTypes: ["direct", "group"],
+      media: false,
+      threads: true,
+      reactions: false,
+      edit: false,
+      unsend: false,
+      reply: false,
+      effects: false,
+      blockStreaming: false
+    },
+    reload: { configPrefixes: [`channels.${CHANNEL_ID}`] },
+    config: {
+      listAccountIds: (cfg) => listAccountIds(cfg),
+      resolveAccount: (cfg, accountId) => resolveAccount(cfg, accountId),
+      defaultAccountId: (_cfg) => DEFAULT_ACCOUNT_ID,
+      setAccountEnabled: ({ cfg, accountId, enabled }) => {
+        const channelConfig = cfg?.channels?.[CHANNEL_ID] ?? {};
+        if (accountId === DEFAULT_ACCOUNT_ID) {
+          return {
+            ...cfg,
+            channels: {
+              ...cfg.channels,
+              [CHANNEL_ID]: { ...channelConfig, enabled }
+            }
+          };
+        }
+        return setAccountEnabledInConfigSection({
+          cfg,
+          sectionKey: `channels.${CHANNEL_ID}`,
+          accountId,
+          enabled
+        });
+      }
+    },
+    security: {
+      resolveDmPolicy: ({
+        cfg,
+        accountId,
+        account
+      }) => {
+        const resolvedAccountId = accountId ?? account.accountId ?? DEFAULT_ACCOUNT_ID;
+        const channelCfg = cfg.channels?.remote;
+        const useAccountPath = Boolean(channelCfg?.accounts?.[resolvedAccountId]);
+        const basePath = useAccountPath ? `channels.remote.accounts.${resolvedAccountId}.` : "channels.remote.";
+        return {
+          policy: account.dmPolicy ?? "open",
+          allowFrom: account.allowedUserIds ?? [],
+          policyPath: `${basePath}dmPolicy`,
+          allowFromPath: basePath,
+          approveHint: "openclaw pairing approve remote <code>",
+          normalizeEntry: (raw) => raw.toLowerCase().trim()
+        };
+      },
+      collectWarnings: ({ account }) => {
+        const warnings = [];
+        if (!account.baseUrl) {
+          warnings.push(
+            "- Remote: baseUrl is not configured. The plugin cannot connect to the Remote API."
+          );
+        }
+        if (!account.apiKey) {
+          warnings.push(
+            "- 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;
+      }
+    },
+    messaging: {
+      normalizeTarget: (target) => {
+        const trimmed = target.trim();
+        if (!trimmed) return void 0;
+        return trimmed.replace(/^remote:/i, "").trim();
+      },
+      targetResolver: {
+        looksLikeId: (id) => {
+          const trimmed = id?.trim();
+          if (!trimmed) return false;
+          return /^remote:/i.test(trimmed) || /^[a-f0-9-]+$/i.test(trimmed);
+        },
+        hint: "<taskId>"
+      }
+    },
+    directory: {
+      self: async () => null,
+      listPeers: async () => [],
+      listGroups: async () => []
+    },
+    outbound: {
+      deliveryMode: "gateway",
+      textChunkLimit: 4e3,
+      sendText: async ({ to, text, accountId, cfg }) => {
+        const account = resolveAccount(cfg ?? {}, accountId);
+        if (!account.baseUrl || !account.apiKey) {
+          throw new Error("Remote baseUrl or apiKey not configured");
+        }
+        const taskId = extractTaskId(to);
+        if (!taskId) {
+          throw new Error(`Invalid Remote target: ${to}. Expected format: remote:{taskId}`);
+        }
+        const result = await postComment(account, taskId, text);
+        if (!result.ok) {
+          throw new Error(`Failed to post comment to Remote: ${result.error}`);
+        }
+        const commentId = result.data.comment?.id ?? `rc-${Date.now()}`;
+        return { channel: CHANNEL_ID, messageId: commentId, chatId: `remote:${taskId}` };
+      }
+    },
+    gateway: {
+      startAccount: async (ctx) => {
+        const { cfg, accountId, log, abortSignal, channelRuntime } = ctx;
+        const account = resolveAccount(cfg, accountId);
+        if (!account.enabled) {
+          log?.info?.(`Remote account ${accountId} is disabled, skipping`);
+          return waitUntilAbort(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.`
+          );
+        }
+        log?.info?.(
+          `Starting Remote channel (account: ${accountId}, url: ${account.baseUrl})`
+        );
+        const runtime = channelRuntime ?? getRemoteRuntime().channel;
+        let realtimeHandle = null;
+        if (account.supabaseUrl && account.supabaseKey) {
+          try {
+            realtimeHandle = connectRealtime(
+              account,
+              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)}`
+                  );
+                }
+              },
+              (err) => {
+                log?.warn?.(`Realtime error: ${err.message}`);
+              },
+              log
+            );
+          } catch (err) {
+            log?.error?.(`Failed to connect Realtime: ${err instanceof Error ? err.message : String(err)}`);
+          }
+        }
+        await waitUntilAbort(abortSignal, async () => {
+          if (realtimeHandle) {
+            await realtimeHandle.unsubscribe();
+          }
+        });
+        log?.info?.(`Stopped Remote channel (account: ${accountId})`);
+      },
+      stopAccount: async (ctx) => {
+        ctx.log?.info?.(`Remote account ${ctx.accountId} stopped`);
+      }
+    },
+    agentTools: ((params) => {
+      const cfg = params.cfg;
+      return [
+        // 1. remote_create_task
+        {
+          name: "remote_create_task",
+          label: "Create a new task on the Remote project board",
+          description: "Create a new task on the Remote project board. Specify title, and optionally description, type (feature/task/bug), priority (low/medium/high/urgent), and assigned_role_id.",
+          parameters: Type.Object({
+            title: Type.String({ description: "Task title" }),
+            description: Type.Optional(Type.String({ description: "Task description" })),
+            type: optionalStringEnum(["feature", "task", "bug"], {
+              description: "Task type: feature, task, or bug"
+            }),
+            priority: optionalStringEnum(["low", "medium", "high", "urgent"], {
+              description: "Task priority: low, medium, high, or urgent"
+            }),
+            assigned_role_id: Type.Optional(
+              Type.String({ description: "Role ID to assign the task to" })
+            )
+          }),
+          execute: async (_toolCallId, args) => {
+            const account = resolveAccount(cfg ?? {});
+            const result = await createTask(account, {
+              title: args.title,
+              description: args.description,
+              type: args.type,
+              priority: args.priority,
+              assigned_role_id: args.assigned_role_id
+            });
+            if (!result.ok) {
+              return {
+                content: [{ type: "text", text: `\u274C Failed to create task: ${result.error}` }],
+                details: { ok: false, error: result.error }
+              };
+            }
+            const task = result.data.task;
+            const text = [
+              `\u2705 Task created successfully!`,
+              `- **ID**: ${task.id}`,
+              `- **Title**: ${task.title}`,
+              `- **Type**: ${task.type}`,
+              `- **Priority**: ${task.priority}`,
+              `- **Status**: ${task.status}`
+            ].join("\n");
+            return {
+              content: [{ type: "text", text }],
+              details: { ok: true, task }
+            };
+          }
+        },
+        // 2. remote_update_task
+        {
+          name: "remote_update_task",
+          label: "Update a task on the Remote project board",
+          description: "Update an existing task on the Remote project board. Specify the task_id and any fields to change: status (todo/in_progress/review/done), priority, assigned_to, title, or description.",
+          parameters: Type.Object({
+            task_id: Type.String({ description: "ID of the task to update" }),
+            status: optionalStringEnum(["todo", "in_progress", "review", "done"], {
+              description: "New status: todo, in_progress, review, or done"
+            }),
+            priority: optionalStringEnum(["low", "medium", "high", "urgent"], {
+              description: "New priority: low, medium, high, or urgent"
+            }),
+            assigned_to: Type.Optional(
+              Type.String({ description: "User or role to assign the task to" })
+            ),
+            title: Type.Optional(Type.String({ description: "New task title" })),
+            description: Type.Optional(Type.String({ description: "New task description" }))
+          }),
+          execute: async (_toolCallId, args) => {
+            const account = resolveAccount(cfg ?? {});
+            const { task_id, ...updates } = args;
+            const result = await updateTask(account, task_id, updates);
+            if (!result.ok) {
+              return {
+                content: [{ type: "text", text: `\u274C Failed to update task: ${result.error}` }],
+                details: { ok: false, error: result.error }
+              };
+            }
+            const task = result.data.task;
+            const text = [
+              `\u2705 Task updated successfully!`,
+              `- **ID**: ${task.id}`,
+              `- **Title**: ${task.title}`,
+              `- **Status**: ${task.status}`,
+              `- **Priority**: ${task.priority}`
+            ].join("\n");
+            return {
+              content: [{ type: "text", text }],
+              details: { ok: true, task }
+            };
+          }
+        },
+        // 3. remote_list_tasks
+        {
+          name: "remote_list_tasks",
+          label: "List tasks on the Remote project board",
+          description: "List tasks on the Remote project board. Optionally filter by status (todo/in_progress/review/done) and assigned_to (use 'me' for tasks assigned to the agent).",
+          parameters: Type.Object({
+            status: optionalStringEnum(["todo", "in_progress", "review", "done"], {
+              description: "Filter by status: todo, in_progress, review, or done"
+            }),
+            assigned_to: Type.Optional(
+              Type.String({ description: "Filter by assignee. Use 'me' for self." })
+            )
+          }),
+          execute: async (_toolCallId, args) => {
+            const account = resolveAccount(cfg ?? {});
+            const result = await listTasks(account, {
+              status: args.status,
+              assigned_to: args.assigned_to
+            });
+            if (!result.ok) {
+              return {
+                content: [{ type: "text", text: `\u274C Failed to list tasks: ${result.error}` }],
+                details: { ok: false, error: result.error }
+              };
+            }
+            const tasks = result.data.tasks;
+            if (tasks.length === 0) {
+              const filterDesc = [
+                args.status && `status=${args.status}`,
+                args.assigned_to && `assigned_to=${args.assigned_to}`
+              ].filter(Boolean).join(", ");
+              return {
+                content: [
+                  {
+                    type: "text",
+                    text: `\u{1F4CB} No tasks found${filterDesc ? ` (filters: ${filterDesc})` : ""}.`
+                  }
+                ],
+                details: { ok: true, tasks: [] }
+              };
+            }
+            const lines = [`\u{1F4CB} **${tasks.length} task(s) found:**`, ""];
+            for (const task of tasks) {
+              const meta = [task.type, task.priority, task.status].filter(Boolean).join(", ");
+              lines.push(`- **${task.title}** [${meta}] (id: ${task.id})`);
+              if (task.description) {
+                const desc = task.description.length > 80 ? task.description.slice(0, 80) + "\u2026" : task.description;
+                lines.push(`  ${desc}`);
+              }
+            }
+            return {
+              content: [{ type: "text", text: lines.join("\n") }],
+              details: { ok: true, tasks }
+            };
+          }
+        },
+        // 4. remote_board_health
+        {
+          name: "remote_board_health",
+          label: "Get board health stats from Remote",
+          description: "Get board health and statistics from the Remote project board: pending tasks, in-progress tasks, unassigned tasks, recent activity, and your roles.",
+          parameters: Type.Object({}),
+          execute: async (_toolCallId, _args) => {
+            const account = resolveAccount(cfg ?? {});
+            const result = await getHeartbeat(account);
+            if (!result.ok) {
+              return {
+                content: [{ type: "text", text: `\u274C Failed to get board health: ${result.error}` }],
+                details: { ok: false, error: result.error }
+              };
+            }
+            const h = result.data;
+            const text = [
+              `\u{1F4CA} **Board Health Summary**`,
+              "",
+              `- **Pending tasks**: ${h.pending_tasks}`,
+              `- **In progress**: ${h.in_progress_tasks}`,
+              `- **Unassigned**: ${h.unassigned_tasks}`,
+              `- **Activity (24h)**: ${h.recent_activity_24h}`,
+              `- **My roles**: ${h.my_roles?.join(", ") || "none"}`,
+              `- **Checked at**: ${h.checked_at}`
+            ].join("\n");
+            return {
+              content: [{ type: "text", text }],
+              details: { ok: true, heartbeat: h }
+            };
+          }
+        }
+      ];
+    }),
+    agentPrompt: {
+      messageToolHints: () => [
+        "",
+        "### Remote Project Board",
+        "You are connected to a Remote project board. Messages you receive are task events (new tasks, comments, status changes, assignments).",
+        "",
+        "**Replying**: When you reply to a task notification, your reply is posted as a comment on that task.",
+        "",
+        "**Available tools**:",
+        "- `remote_create_task` \u2014 Create a new task (specify title, type, priority, etc.)",
+        "- `remote_update_task` \u2014 Update a task (change status, priority, assignment, etc.)",
+        "- `remote_list_tasks` \u2014 List/filter tasks on the board",
+        "- `remote_board_health` \u2014 Get board health stats (pending, in-progress, unassigned counts)",
+        "",
+        "**Task lifecycle**: todo \u2192 in_progress \u2192 review \u2192 done",
+        "**Task types**: feature, task, bug",
+        "**Priorities**: low, medium, high, urgent",
+        "",
+        "**Best practices**:",
+        "- When assigned a task, acknowledge it and move to in_progress",
+        "- Use comments to communicate progress and blockers",
+        "- Move tasks to review when ready for review, done when complete",
+        "- Keep task descriptions and comments clear and actionable"
+      ]
+    }
+  };
+}
+function extractTaskId(to) {
+  if (!to) return void 0;
+  const trimmed = to.trim();
+  const match = trimmed.match(/^remote:(.+)$/i);
+  if (match) return match[1];
+  if (trimmed.length > 0) return trimmed;
+  return void 0;
+}
+
+// index.ts
+var plugin = {
+  id: "remote",
+  name: "Remote",
+  description: "Remote project board channel plugin for OpenClaw",
+  configSchema: { type: "object", properties: {} },
+  register(api) {
+    setRemoteRuntime(api.runtime);
+    api.registerChannel({ plugin: createRemotePlugin() });
+  }
+};
+var index_default = plugin;
+export {
+  index_default as default
+};