@clwnt/clawnet 0.5.3 → 0.5.5

package/index.ts

@@ -29,7 +29,7 @@ const plugin = {
     loadToolDescriptions();
 
     // Register agent tools (inbox, send, status, capabilities, call)
-    registerTools(api, cfg);
+    registerTools(api);
 
     // Register CLI: `openclaw clawnet ...`
     api.registerCli(({ program }) => {

package/package.json

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

package/src/cli.ts

@@ -29,9 +29,9 @@ function sleep(ms: number): Promise<void> {
 // --- Hook mapping builder (from spec) ---
 
 const DEFAULT_HOOK_TEMPLATE =
-  "You have {{count}} new ClawNet message(s).\n\n" +
-  "Messages:\n{{messages}}\n\n" +
-  "{{context}}";
+  "You have {{count}} new ClawNet message(s). Process ONLY the new messages below — the conversation history is provided for context only.\n\n" +
+  "New messages (action required):\n{{messages}}\n\n" +
+  "Prior conversation history (for context only — do NOT re-process these):\n{{context}}";
 
 let cachedHookTemplate: string | null = null;
 
@@ -687,11 +687,11 @@ export function registerClawnetCli(params: { program: Command; api: any; cfg: Cl
       console.log("");
     });
 
-  // --- uninstall ---
+  // --- disable ---
   root
-    .command("uninstall")
-    .option("--purge", "Remove config entirely (default: just disable)")
-    .description("Disable ClawNet plugin and remove hook mapping")
+    .command("disable")
+    .option("--purge", "Also remove account config (tokens, accounts)")
+    .description("Disable ClawNet plugin and remove hook mappings")
     .action(async (opts) => {
       const currentConfig = api.runtime.config.loadConfig();
       const cfg = { ...currentConfig };
@@ -716,20 +716,69 @@ export function registerClawnetCli(params: { program: Command; api: any; cfg: Cl
       }
       const removedCount = beforeCount - (cfg.hooks?.mappings?.length ?? 0);
 
-      console.log("\n  ClawNet uninstalled.\n");
-      console.log("  - Plugin disabled");
+      console.log("\n  ClawNet disabled.\n");
+      console.log("  - Plugin disabled (polling stopped)");
+      console.log("  - Hook mappings removed");
       if (removedCount > 0) {
-        console.log(`  - ${removedCount} hook mapping(s) removed`);
+        console.log(`    (${removedCount} mapping(s) cleaned up)`);
       }
+      console.log("");
+      console.log("  To re-enable: openclaw clawnet setup");
+      console.log("  To fully remove: openclaw plugins uninstall clawnet");
 
       // Do NOT touch: hooks.enabled, hooks.token, allowedSessionKeyPrefixes, allowedAgentIds
 
       await api.runtime.config.writeConfigFile(cfg);
 
-      console.log("  - hooks.enabled, hooks.token left untouched");
       if (opts.purge) {
-        console.log("  - Plugin config purged");
+        console.log("  - Account config purged");
+      }
+      console.log("\n  Restart the Gateway to apply: openclaw gateway restart\n");
+    });
+
+  // --- enable ---
+  root
+    .command("enable")
+    .description("Re-enable a previously disabled ClawNet plugin")
+    .action(async () => {
+      const currentConfig = api.runtime.config.loadConfig();
+      const cfg = structuredClone(currentConfig);
+
+      const pluginEntry = cfg.plugins?.entries?.clawnet;
+      if (!pluginEntry) {
+        console.log("\n  No ClawNet config found. Run `openclaw clawnet setup` first.\n");
+        return;
       }
+
+      if (pluginEntry.enabled) {
+        console.log("\n  ClawNet is already enabled.\n");
+        return;
+      }
+
+      pluginEntry.enabled = true;
+
+      // Restore hook mappings from accounts
+      const accounts: any[] = pluginEntry.config?.accounts ?? [];
+      const enabled = accounts.filter((a: any) => a.enabled !== false);
+      if (enabled.length > 0) {
+        cfg.hooks ??= {};
+        let mappings = cfg.hooks.mappings ?? [];
+        for (const account of enabled) {
+          const channel = pluginEntry.config?.deliver?.channel ?? "last";
+          mappings = upsertMapping(mappings, buildClawnetMapping(
+            account.id,
+            channel,
+            account.openclawAgentId ?? account.id,
+          ));
+        }
+        cfg.hooks.mappings = mappings;
+      }
+
+      await api.runtime.config.writeConfigFile(cfg);
+
+      console.log("\n  ClawNet enabled.\n");
+      console.log(`  - Plugin enabled (${enabled.length} account(s))`);
+      console.log(`  - Hook mappings restored`);
       console.log("\n  Restart the Gateway to apply: openclaw gateway restart\n");
     });
 }

package/src/service.ts

@@ -72,7 +72,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"];
-export const PLUGIN_VERSION = "0.5.3"; // Reported to server via PATCH /me every 6h
+export const PLUGIN_VERSION = "0.5.5"; // Reported to server via PATCH /me every 6h
 
 // --- Service ---
 

package/src/tools.ts

@@ -1,10 +1,32 @@
-import type { ClawnetConfig } from "./config.js";
-import { resolveToken } from "./config.js";
+import { type ClawnetConfig, parseConfig, resolveToken } from "./config.js";
 
 // --- Helpers ---
 
-function getAccountForAgent(cfg: ClawnetConfig, openclawAgentId?: string) {
-  // Match by OpenClaw agent ID if provided (multi-agent)
+function loadFreshConfig(api: any): ClawnetConfig {
+  const raw = api.runtime.config.loadConfig()?.plugins?.entries?.clawnet?.config ?? {};
+  return parseConfig(raw as Record<string, unknown>);
+}
+
+/**
+ * Extract ClawNet account ID from session key (e.g. "hook:clawnet:tom:inbox" -> "tom").
+ */
+function accountIdFromSessionKey(sessionKey?: string): string | null {
+  if (!sessionKey) return null;
+  const match = sessionKey.match(/^hook:clawnet:([^:]+):/);
+  return match ? match[1] : null;
+}
+
+function getAccountForAgent(cfg: ClawnetConfig, openclawAgentId?: string, sessionKey?: string) {
+  // Best match: extract account ID from session key (multi-account safe)
+  const sessionAccountId = accountIdFromSessionKey(sessionKey);
+  if (sessionAccountId) {
+    const match = cfg.accounts.find((a) => a.enabled && a.id === sessionAccountId);
+    if (match) {
+      const token = resolveToken(match.token);
+      if (token) return { ...match, resolvedToken: token };
+    }
+  }
+  // Match by OpenClaw agent ID if provided (single-account or non-hook context)
   if (openclawAgentId) {
     const match = cfg.accounts.find((a) => a.enabled && a.openclawAgentId === openclawAgentId);
     if (match) {
@@ -35,8 +57,9 @@ async function apiCall(
   path: string,
   body?: unknown,
   openclawAgentId?: string,
+  sessionKey?: string,
 ): Promise<{ ok: boolean; status: number; data: any }> {
-  const account = getAccountForAgent(cfg, openclawAgentId);
+  const account = getAccountForAgent(cfg, openclawAgentId, sessionKey);
   if (!account) {
     return { ok: false, status: 0, data: { error: "no_account", message: "No ClawNet account configured. Run: openclaw clawnet setup" } };
   }
@@ -55,8 +78,9 @@ async function apiCallRaw(
   path: string,
   rawBody: string,
   openclawAgentId?: string,
+  sessionKey?: string,
 ): Promise<{ ok: boolean; status: number; data: any }> {
-  const account = getAccountForAgent(cfg, openclawAgentId);
+  const account = getAccountForAgent(cfg, openclawAgentId, sessionKey);
   if (!account) {
     return { ok: false, status: 0, data: { error: "no_account", message: "No ClawNet account configured. Run: openclaw clawnet setup" } };
   }
@@ -299,8 +323,7 @@ function toolDesc(name: string, fallback: string): string {
 
 // --- Tool registration ---
 
-export function registerTools(api: any, cfg: ClawnetConfig) {
-  // Load cached descriptions synchronously-safe (already loaded by service start)
+export function registerTools(api: any) {
   // --- Blessed tools (high-traffic, dedicated) ---
 
   api.registerTool({
@@ -310,8 +333,9 @@ export function registerTools(api: any, cfg: ClawnetConfig) {
       type: "object",
       properties: {},
     },
-    async execute(_id: string, _params: unknown, _onUpdate: unknown, ctx?: { agentId?: string }) {
-      const result = await apiCall(cfg, "GET", "/inbox/check", undefined, ctx?.agentId);
+    async execute(_id: string, _params: unknown, _onUpdate: unknown, ctx?: { agentId?: string; sessionKey?: string }) {
+      const cfg = loadFreshConfig(api);
+      const result = await apiCall(cfg, "GET", "/inbox/check", undefined, ctx?.agentId, ctx?.sessionKey);
       return textResult(result.data);
     },
   });
@@ -326,12 +350,13 @@ export function registerTools(api: any, cfg: ClawnetConfig) {
         limit: { type: "number", description: "Max messages to return (default 50, max 200)" },
       },
     },
-    async execute(_id: string, params: { status?: string; limit?: number }, _onUpdate: unknown, ctx?: { agentId?: string }) {
+    async execute(_id: string, params: { status?: string; limit?: number }, _onUpdate: unknown, ctx?: { agentId?: string; sessionKey?: string }) {
+      const cfg = loadFreshConfig(api);
       const qs = new URLSearchParams();
       if (params.status) qs.set("status", params.status);
       if (params.limit) qs.set("limit", String(params.limit));
       const query = qs.toString() ? `?${qs}` : "";
-      const result = await apiCall(cfg, "GET", `/inbox${query}`, undefined, ctx?.agentId);
+      const result = await apiCall(cfg, "GET", `/inbox${query}`, undefined, ctx?.agentId, ctx?.sessionKey);
       return textResult(result.data);
     },
   });
@@ -348,15 +373,16 @@ export function registerTools(api: any, cfg: ClawnetConfig) {
       },
       required: ["to", "message"],
     },
-    async execute(_id: string, params: { to: string; message: string; subject?: string }, _onUpdate: unknown, ctx?: { agentId?: string }) {
+    async execute(_id: string, params: { to: string; message: string; subject?: string }, _onUpdate: unknown, ctx?: { agentId?: string; sessionKey?: string }) {
+      const cfg = loadFreshConfig(api);
       if (params.to.includes("@")) {
         // Route to email endpoint
         const body: Record<string, string> = { to: params.to, body: params.message };
         if (params.subject) body.subject = params.subject;
-        const result = await apiCall(cfg, "POST", "/email/send", body, ctx?.agentId);
+        const result = await apiCall(cfg, "POST", "/email/send", body, ctx?.agentId, ctx?.sessionKey);
         return textResult(result.data);
       }
-      const result = await apiCall(cfg, "POST", "/send", { to: params.to, message: params.message }, ctx?.agentId);
+      const result = await apiCall(cfg, "POST", "/send", { to: params.to, message: params.message }, ctx?.agentId, ctx?.sessionKey);
       return textResult(result.data);
     },
   }, { optional: true });
@@ -373,10 +399,11 @@ export function registerTools(api: any, cfg: ClawnetConfig) {
       },
       required: ["message_id", "status"],
     },
-    async execute(_id: string, params: { message_id: string; status: string; snoozed_until?: string }, _onUpdate: unknown, ctx?: { agentId?: string }) {
+    async execute(_id: string, params: { message_id: string; status: string; snoozed_until?: string }, _onUpdate: unknown, ctx?: { agentId?: string; sessionKey?: string }) {
+      const cfg = loadFreshConfig(api);
       const body: Record<string, unknown> = { status: params.status };
       if (params.snoozed_until) body.snoozed_until = params.snoozed_until;
-      const result = await apiCall(cfg, "PATCH", `/messages/${params.message_id}/status`, body, ctx?.agentId);
+      const result = await apiCall(cfg, "PATCH", `/messages/${params.message_id}/status`, body, ctx?.agentId, ctx?.sessionKey);
       return textResult(result.data);
     },
   }, { optional: true });
@@ -392,12 +419,13 @@ export function registerTools(api: any, cfg: ClawnetConfig) {
         scope: { type: "string", description: "'global' for network-wide rules, 'agent' for agent-specific rules, omit for both" },
       },
     },
-    async execute(_id: string, params: { scope?: string }, _onUpdate: unknown, ctx?: { agentId?: string }) {
+    async execute(_id: string, params: { scope?: string }, _onUpdate: unknown, ctx?: { agentId?: string; sessionKey?: string }) {
+      const cfg = loadFreshConfig(api);
       const qs = new URLSearchParams();
       if (params.scope) qs.set("scope", params.scope);
       if (ctx?.agentId) qs.set("agent_id", ctx.agentId);
       const query = qs.toString() ? `?${qs}` : "";
-      const result = await apiCall(cfg, "GET", `/rules${query}`, undefined, ctx?.agentId);
+      const result = await apiCall(cfg, "GET", `/rules${query}`, undefined, ctx?.agentId, ctx?.sessionKey);
       return textResult(result.data);
     },
   });
@@ -413,7 +441,7 @@ export function registerTools(api: any, cfg: ClawnetConfig) {
         filter: { type: "string", description: "Filter by prefix (e.g. 'email', 'calendar', 'post', 'profile')" },
       },
     },
-    async execute(_id: string, params: { filter?: string }, _onUpdate: unknown, _ctx?: { agentId?: string }) {
+    async execute(_id: string, params: { filter?: string }, _onUpdate: unknown, _ctx?: { agentId?: string; sessionKey?: string }) {
       let ops = getOperations();
       if (params.filter) {
         const prefix = params.filter.toLowerCase();
@@ -449,7 +477,8 @@ export function registerTools(api: any, cfg: ClawnetConfig) {
       },
       required: ["operation"],
     },
-    async execute(_id: string, input: { operation: string; params?: Record<string, unknown> }, _onUpdate: unknown, ctx?: { agentId?: string }) {
+    async execute(_id: string, input: { operation: string; params?: Record<string, unknown> }, _onUpdate: unknown, ctx?: { agentId?: string; sessionKey?: string }) {
+      const cfg = loadFreshConfig(api);
       const op = getOperations().find((o) => o.operation === input.operation);
       if (!op) {
         return textResult({ error: "unknown_operation", message: `Unknown operation: ${input.operation}. Call clawnet_capabilities to see available operations.` });
@@ -507,8 +536,8 @@ export function registerTools(api: any, cfg: ClawnetConfig) {
       }
 
       const result = rawBody !== undefined
-        ? await apiCallRaw(cfg, op.method, path, rawBody, ctx?.agentId)
-        : await apiCall(cfg, op.method, path, body, ctx?.agentId);
+        ? await apiCallRaw(cfg, op.method, path, rawBody, ctx?.agentId, ctx?.sessionKey)
+        : await apiCall(cfg, op.method, path, body, ctx?.agentId, ctx?.sessionKey);
       return textResult(result.data);
     },
   }, { optional: true });