@clwnt/clawnet 0.7.12 → 0.7.14

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@clwnt/clawnet",
-  "version": "0.7.12",
+  "version": "0.7.14",
   "type": "module",
   "description": "ClawNet integration for OpenClaw — poll inbox, route messages to hooks",
   "files": [

package/src/service.ts

@@ -73,7 +73,7 @@ async function reloadOnboardingMessage(): Promise<void> {
 
 const SKILL_UPDATE_INTERVAL_MS = 6 * 60 * 60 * 1000; // 6 hours
 const SKILL_FILES = ["skill.json", "api-reference.md", "inbox-handler.md", "capabilities.json", "hook-template.txt", "tool-descriptions.json", "onboarding-message.txt", "inbox-protocol.md"];
-export const PLUGIN_VERSION = "0.7.12"; // Reported to server via PATCH /me every 6h
+export const PLUGIN_VERSION = "0.7.13"; // Reported to server via PATCH /me every 6h
 
 function loadFreshConfig(api: any): ClawnetConfig {
   const raw = api.runtime?.config?.loadConfig?.()?.plugins?.entries?.clawnet?.config ?? {};
@@ -141,6 +141,16 @@ export function createClawnetService(params: { api: any; cfg: ClawnetConfig }) {
   async function deliverBatch(accountId: string, agentId: string, messages: InboxMessage[]) {
     if (messages.length === 0) return;
 
+    // Delivery lock — respect the cooldown even from flush/debounce paths
+    const lockUntil = deliveryLock.get(accountId);
+    if (lockUntil && new Date() < lockUntil) {
+      const existing = pendingMessages.get(accountId) ?? [];
+      const existingIds = new Set(existing.map((m) => m.id));
+      const fresh = messages.filter((m) => !existingIds.has(m.id));
+      pendingMessages.set(accountId, [...existing, ...fresh]);
+      return;
+    }
+
     // Concurrency guard
     if (accountBusy.has(accountId)) {
       api.logger.info(`[clawnet] ${accountId}: LLM run in progress, requeueing ${messages.length} message(s)`);
@@ -363,19 +373,19 @@ export function createClawnetService(params: { api: any; cfg: ClawnetConfig }) {
     if (checkData.plugin_config) {
       const pc = checkData.plugin_config;
       let changed = false;
-      if (pc.poll_seconds !== cfg.pollEverySeconds) {
+      if (pc.poll_seconds !== undefined && pc.poll_seconds !== cfg.pollEverySeconds) {
         cfg.pollEverySeconds = pc.poll_seconds;
         changed = true;
       }
-      if (pc.debounce_seconds !== cfg.debounceSeconds) {
+      if (pc.debounce_seconds !== undefined && pc.debounce_seconds !== cfg.debounceSeconds) {
         cfg.debounceSeconds = pc.debounce_seconds;
         changed = true;
       }
-      if (pc.max_batch_size !== cfg.maxBatchSize) {
+      if (pc.max_batch_size !== undefined && pc.max_batch_size !== cfg.maxBatchSize) {
         cfg.maxBatchSize = pc.max_batch_size;
         changed = true;
       }
-      if (pc.deliver_channel !== cfg.deliver.channel) {
+      if (pc.deliver_channel !== undefined && pc.deliver_channel !== cfg.deliver.channel) {
         cfg.deliver.channel = pc.deliver_channel;
         changed = true;
       }
@@ -397,8 +407,9 @@ export function createClawnetService(params: { api: any; cfg: ClawnetConfig }) {
     const notifyCount = checkData.notify_count ?? (checkData.count + a2aDmCount + sentTaskUpdates);
 
     if (checkData.count === 0) {
-      // Email inbox clear — release any delivery lock (agent finished processing)
-      deliveryLock.delete(account.id);
+      // Email inbox clear — only release delivery lock if nothing else needs notification,
+      // otherwise tasks/sent-task-updates still need the lock for throttling.
+      if (notifyCount === 0) deliveryLock.delete(account.id);
       return { a2aDmCount, sentTaskUpdates, notifyCount };
     }
 
@@ -418,8 +429,8 @@ export function createClawnetService(params: { api: any; cfg: ClawnetConfig }) {
     state.lastInboxNonEmptyAt = new Date();
     api.logger.info(`[clawnet] ${account.id}: ${checkData.count} message(s) waiting (${notifyCount} to notify)`);
 
-    // Fetch full messages
-    const inboxRes = await fetch(`${cfg.baseUrl}/inbox`, { headers });
+    // Fetch full messages — request max limit so mark-notified covers everything
+    const inboxRes = await fetch(`${cfg.baseUrl}/inbox?limit=200`, { headers });
     if (!inboxRes.ok) {
       throw new Error(`/inbox returned ${inboxRes.status}`);
     }
@@ -439,6 +450,22 @@ export function createClawnetService(params: { api: any; cfg: ClawnetConfig }) {
 
     state.counters.messagesSeen += normalized.length;
 
+    // Mark ALL fetched emails as notified up front — the delivery batch is capped
+    // at maxBatchSize, but the nag timer should reset for every message the agent
+    // is being alerted about, not just the ones in the batch.
+    const allEmailIds = normalized.map((m) => m.id);
+    if (allEmailIds.length > 0) {
+      try {
+        await fetch(`${cfg.baseUrl}/inbox/mark-notified`, {
+          method: "POST",
+          headers,
+          body: JSON.stringify({ message_ids: allEmailIds }),
+        });
+      } catch {
+        // Non-fatal — deliverBatch will still mark its batch after delivery
+      }
+    }
+
     // Add to pending (dedup by ID) and schedule debounced flush
     const existing = pendingMessages.get(account.id) ?? [];
     const existingIds = new Set(existing.map((m) => m.id));
@@ -467,7 +494,7 @@ export function createClawnetService(params: { api: any; cfg: ClawnetConfig }) {
       jsonrpc: "2.0",
       id: `poll-${Date.now()}`,
       method: "tasks/list",
-      params: { status: "submitted", limit: 50 },
+      params: { status: "submitted", limit: 100 },
     };
     const res = await fetch(`${cfg.baseUrl}/a2a`, {
       method: "POST",
@@ -505,6 +532,24 @@ export function createClawnetService(params: { api: any; cfg: ClawnetConfig }) {
     });
 
     state.counters.messagesSeen += messages.length;
+
+    // Mark all fetched tasks as notified up front (same rationale as emails)
+    const allTaskIds = messages.map((m) => m.id);
+    if (allTaskIds.length > 0) {
+      try {
+        await fetch(`${cfg.baseUrl}/inbox/mark-notified`, {
+          method: "POST",
+          headers: {
+            Authorization: `Bearer ${resolvedToken}`,
+            "Content-Type": "application/json",
+          },
+          body: JSON.stringify({ task_ids: allTaskIds }),
+        });
+      } catch {
+        // Non-fatal
+      }
+    }
+
     const existing = pendingMessages.get(account.id) ?? [];
     const existingIds = new Set(existing.map((m) => m.id));
     const freshTasks = messages.filter((m) => !existingIds.has(m.id));
@@ -525,7 +570,7 @@ export function createClawnetService(params: { api: any; cfg: ClawnetConfig }) {
       jsonrpc: "2.0",
       id: `sent-poll-${Date.now()}`,
       method: "tasks/list",
-      params: { role: "sender", status: "input-required,completed,failed", limit: 50 },
+      params: { role: "sender", status: "input-required,completed,failed", limit: 100 },
     };
     const res = await fetch(`${cfg.baseUrl}/a2a`, {
       method: "POST",
@@ -560,6 +605,24 @@ export function createClawnetService(params: { api: any; cfg: ClawnetConfig }) {
     });
 
     state.counters.messagesSeen += messages.length;
+
+    // Mark all fetched sent-task updates as notified up front (same rationale as emails)
+    const allSentTaskIds = messages.map((m) => m.id);
+    if (allSentTaskIds.length > 0) {
+      try {
+        await fetch(`${cfg.baseUrl}/inbox/mark-notified`, {
+          method: "POST",
+          headers: {
+            Authorization: `Bearer ${resolvedToken}`,
+            "Content-Type": "application/json",
+          },
+          body: JSON.stringify({ task_ids: allSentTaskIds }),
+        });
+      } catch {
+        // Non-fatal
+      }
+    }
+
     const existing = pendingMessages.get(account.id) ?? [];
     const existingIds = new Set(existing.map((m) => m.id));
     const freshUpdates = messages.filter((m) => !existingIds.has(m.id));

package/src/tools.ts

@@ -468,6 +468,24 @@ export function registerTools(api: any) {
     },
   }), { optional: true });
 
+  api.registerTool((ctx: { agentId?: string; sessionKey?: string }) => ({
+    name: "clawnet_email_bulk_status",
+    description: toolDesc("clawnet_email_bulk_status", "Set the status of multiple emails at once. Use to archive, read, or snooze many emails in one call instead of one at a time."),
+    parameters: {
+      type: "object",
+      properties: {
+        message_ids: { type: "array", items: { type: "string" }, description: "Array of message IDs (e.g. ['msg_abc123', 'msg_def456'])" },
+        status: { type: "string", enum: ["archived", "read", "snoozed", "new"], description: "New status to apply to all messages" },
+      },
+      required: ["message_ids", "status"],
+    },
+    async execute(_id: string, params: { message_ids: string[]; status: string }) {
+      const cfg = loadFreshConfig(api);
+      const result = await apiCall(cfg, "PATCH", `/messages/bulk/status`, { message_ids: params.message_ids, status: params.status }, ctx?.agentId, ctx?.sessionKey);
+      return textResult(result.data);
+    },
+  }), { optional: true });
+
   api.registerTool((ctx: { agentId?: string; sessionKey?: string }) => ({
     name: "clawnet_inbox_session",
     description: toolDesc("clawnet_inbox_session", "Start an interactive inbox session. Returns your emails with assigned numbers and a triage protocol. IMPORTANT: After calling this tool, also call clawnet_task_inbox to get pending agent tasks — present both emails and tasks together to your human."),