@agentapprove/openclaw 0.1.6 → 0.1.8

package/README.md

@@ -10,6 +10,13 @@
 
 You decide the rules. Agent Approve enforces them.
 
+## Important
+
+- A valid Agent Approve subscription is required to use this plugin.
+- You must download the iOS app, run `npx agentapprove`, and pair your device.
+- This plugin is currently pre-launch software. Public App Store availability is not open yet.
+- If a valid token is not configured, tool calls are blocked with setup guidance.
+
 ## How it works
 
 This plugin hooks into OpenClaw's agent loop to enforce your approval policy:
@@ -67,6 +74,11 @@ Plugin settings in `~/.openclaw/openclaw.json`:
 | `privacyTier` | `full` | What tool data is stored in event logs: `minimal`, `summary`, or `full` |
 | `debug` | `false` | Write debug logs to `~/.agentapprove/hook-debug.log` |
 
+## Requirements
+
+- OpenClaw runtime
+- Agent Approve iOS app and active subscription ($9.99/month or $99/year, 7-day free trial)
+
 ## Supported agents
 
 Agent Approve works with OpenClaw, Claude Code, Cursor, Gemini CLI, VS Code Agent, Copilot CLI, OpenAI Codex (coming soon), and more. Run `npx agentapprove` to configure multiple agents at once.

package/dist/index.js

@@ -35,22 +35,77 @@ function ensureLogFile() {
     if (stat.size > MAX_SIZE) {
       const content = readFileSync(DEBUG_LOG_PATH, "utf-8");
       writeFileSync(DEBUG_LOG_PATH, content.slice(-KEEP_SIZE), { mode: 384 });
-      const ts = (/* @__PURE__ */ new Date()).toISOString().replace("T", " ").slice(0, 19);
-      appendFileSync(DEBUG_LOG_PATH, `[${ts}] [openclaw-plugin] Log rotated (exceeded 5MB)
+      appendFileSync(DEBUG_LOG_PATH, `[${localTimestamp()}] [debug] Log rotated (exceeded 5MB, kept last 2MB)
 `);
     }
   } catch {
   }
 }
+function localTimestamp() {
+  const d = /* @__PURE__ */ new Date();
+  const pad = (n) => String(n).padStart(2, "0");
+  return `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())} ${pad(d.getHours())}:${pad(d.getMinutes())}:${pad(d.getSeconds())}`;
+}
 function debugLog(message, hookName = "openclaw-plugin") {
   try {
     ensureLogFile();
-    const ts = (/* @__PURE__ */ new Date()).toISOString().replace("T", " ").slice(0, 19);
-    appendFileSync(DEBUG_LOG_PATH, `[${ts}] [${hookName}] ${message}
+    appendFileSync(DEBUG_LOG_PATH, `[${localTimestamp()}] [${hookName}] ${message}
+`);
+  } catch {
+  }
+}
+function debugLogRawInline(data) {
+  try {
+    ensureLogFile();
+    appendFileSync(DEBUG_LOG_PATH, `${data}
 `);
   } catch {
   }
 }
+function safeStringify(value) {
+  try {
+    const seen = /* @__PURE__ */ new WeakSet();
+    return JSON.stringify(value, (_key, current) => {
+      if (typeof current === "bigint") return `BigInt(${current.toString()})`;
+      if (typeof current === "function") {
+        const fn = current;
+        return `[Function ${fn.name || "anonymous"}]`;
+      }
+      if (typeof current === "symbol") return current.toString();
+      if (current instanceof Error) {
+        return {
+          name: current.name,
+          message: current.message,
+          stack: current.stack
+        };
+      }
+      if (current && typeof current === "object") {
+        const obj = current;
+        if (seen.has(obj)) return "[Circular]";
+        seen.add(obj);
+      }
+      return current;
+    }) ?? "null";
+  } catch (error) {
+    const msg = error instanceof Error ? error.message : String(error);
+    return `"[Unserializable: ${msg}]"`;
+  }
+}
+function debugLogRaw(data, hookName = "openclaw-plugin") {
+  try {
+    ensureLogFile();
+    const ts = localTimestamp();
+    const rawData = typeof data === "string" ? data : safeStringify(data);
+    appendFileSync(
+      DEBUG_LOG_PATH,
+      `[${ts}] [${hookName}] === RAW INPUT ===
+${rawData}
+[${ts}] [${hookName}] === END RAW ===
+`
+    );
+  } catch {
+  }
+}
 
 // src/e2e-crypto.ts
 function keyId(keyHex) {
@@ -284,7 +339,7 @@ function loadConfig(openclawConfig, logger) {
   }
   let token = process.env.AGENTAPPROVE_TOKEN || getKeychainToken() || parseConfigValue(fileContent, "AGENTAPPROVE_TOKEN") || "";
   if (!token) {
-    logger?.warn("No Agent Approve token found. Run the Agent Approve installer to set up.");
+    logger?.warn("Missing token. Download the iOS app, run npx agentapprove, and pair your device. Subscription required.");
   }
   const rawApiUrl = openclawConfig?.apiUrl || process.env.AGENTAPPROVE_API || parseConfigValue(fileContent, "AGENTAPPROVE_API") || "https://api.agentapprove.com";
   const rawApiVersion = process.env.AGENTAPPROVE_API_VERSION || parseConfigValue(fileContent, "AGENTAPPROVE_API_VERSION") || "v001";
@@ -331,7 +386,8 @@ function loadConfig(openclawConfig, logger) {
     failBehavior,
     privacyTier,
     debug,
-    hookVersion: "1.1.3",
+    hookVersion: "1.1.4",
+    agentType: "openclaw",
     agentName,
     e2eEnabled,
     e2eUserKey,
@@ -418,6 +474,7 @@ var CONTENT_FIELDS = [
   "command",
   "toolInput",
   "response",
+  "responsePreview",
   "text",
   "textPreview",
   "prompt",
@@ -585,11 +642,11 @@ function getLocalConfigSetAt() {
 
 // src/api-client.ts
 var cachedPluginHash;
-function getPluginHash(pluginPath, debug = false) {
+function getPluginHash(pluginPath, debug = false, hookName = "openclaw-plugin") {
   if (!cachedPluginHash) {
     cachedPluginHash = computePluginHash(pluginPath);
     if (cachedPluginHash && debug) {
-      debugLog(`Plugin hash computed: ${cachedPluginHash.slice(0, 16)}...`);
+      debugLog(`Plugin hash computed: ${cachedPluginHash.slice(0, 16)}...`, hookName);
     }
   }
   return cachedPluginHash || "";
@@ -631,21 +688,21 @@ function httpPost(url, body, headers, timeoutMs) {
     req.end();
   });
 }
-async function sendApprovalRequest(request, config, pluginPath) {
+async function sendApprovalRequest(request, config, pluginPath, hookName = "openclaw-plugin") {
   if (!config.token) {
-    throw new Error("No Agent Approve token configured");
+    throw new Error("Missing token. Download the iOS app, run npx agentapprove, and pair your device. Subscription required.");
   }
   let payload;
   if (config.e2eEnabled && config.e2eUserKey) {
     payload = applyApprovalE2E(request, config.e2eUserKey, config.e2eServerKey);
     if (config.debug) {
-      debugLog("E2E encryption applied to approval request");
+      debugLog("E2E encryption applied to approval request", hookName);
     }
   } else {
     payload = applyPrivacyFilter(request, config.privacyTier);
   }
   const bodyStr = JSON.stringify(payload);
-  const pluginHash = getPluginHash(pluginPath, config.debug);
+  const pluginHash = getPluginHash(pluginPath, config.debug, hookName);
   const hmacHeaders = buildHMACHeaders(bodyStr, config.token, config.hookVersion, pluginHash);
   const headers = {
     "Authorization": `Bearer ${config.token}`,
@@ -653,11 +710,14 @@ async function sendApprovalRequest(request, config, pluginPath) {
   };
   const url = `${config.apiUrl}/${config.apiVersion}/approve`;
   if (config.debug) {
-    debugLog(`Sending approval request to ${url} for tool: ${request.toolName}`);
+    debugLog(`Requesting approval from ${url}`, hookName);
+    debugLog(`=== SENT TO ${url} ===`, hookName);
+    debugLogRawInline(bodyStr);
+    debugLog("=== END SENT ===", hookName);
   }
   const response = await httpPost(url, bodyStr, headers, config.timeout * 1e3);
   if (config.debug) {
-    debugLog(`Response status: ${response.status}, body: ${response.body.slice(0, 200)}`);
+    debugLog(`Response: ${response.body || "<empty>"}`, hookName);
   }
   if (response.status !== 200) {
     throw new Error(`API returned status ${response.status}: ${response.body.slice(0, 200)}`);
@@ -671,23 +731,23 @@ async function sendApprovalRequest(request, config, pluginPath) {
   processConfigSync(parsed, config);
   return parsed;
 }
-async function sendEvent(event, config, pluginPath) {
+async function sendEvent(event, config, pluginPath, hookName = "openclaw-plugin") {
   if (!config.token) return;
   const eventType = event.eventType;
   const toolName = event.toolName;
   if (config.debug) {
-    debugLog(`Sending ${eventType || "event"}${toolName ? ` (${toolName})` : ""} (privacy: ${config.privacyTier})`);
+    debugLog(`Sending ${eventType || "event"}${toolName ? ` (${toolName})` : ""} (privacy: ${config.privacyTier})`, hookName);
   }
   try {
     let payload = applyEventPrivacyFilter(event, config.privacyTier);
     if (config.e2eEnabled && config.e2eUserKey) {
       payload = applyEventE2E(payload, config.e2eUserKey);
       if (config.debug) {
-        debugLog(`E2E applied to event (type=${eventType})`);
+        debugLog(`E2E applied to event (type=${eventType})`, hookName);
       }
     }
     const bodyStr = JSON.stringify(payload);
-    const pluginHash = getPluginHash(pluginPath, config.debug);
+    const pluginHash = getPluginHash(pluginPath, config.debug, hookName);
     const hmacHeaders = buildHMACHeaders(bodyStr, config.token, config.hookVersion, pluginHash);
     const headers = {
       "Authorization": `Bearer ${config.token}`,
@@ -695,13 +755,13 @@ async function sendEvent(event, config, pluginPath) {
     };
     const url = `${config.apiUrl}/${config.apiVersion}/events`;
     if (config.debug) {
-      debugLog(`=== SENT TO ${url} ===`);
-      debugLog(bodyStr.slice(0, 500));
-      debugLog("=== END SENT ===");
+      debugLog(`=== SENT TO ${url} ===`, hookName);
+      debugLogRawInline(bodyStr);
+      debugLog("=== END SENT ===", hookName);
     }
     const response = await httpPost(url, bodyStr, headers, 5e3);
     if (config.debug) {
-      debugLog(`send_event response: ${response.body.slice(0, 200)}`);
+      debugLog(`send_event response: ${response.body || "<empty>"}`, hookName);
     }
     if (response.status === 200) {
       try {
@@ -712,7 +772,7 @@ async function sendEvent(event, config, pluginPath) {
     }
   } catch (err) {
     if (config.debug) {
-      debugLog(`Failed to send ${eventType || "event"}: ${err instanceof Error ? err.message : String(err)}`);
+      debugLog(`Failed to send ${eventType || "event"}: ${err instanceof Error ? err.message : String(err)}`, hookName);
     }
   }
 }
@@ -728,6 +788,19 @@ var gatewaySessionId = randomBytes2(12).toString("hex");
 var DEDUP_WINDOW_MS = 1200;
 var DEDUP_MAX_SIZE = 300;
 var recentCompletions = /* @__PURE__ */ new Map();
+var HOOK_PLUGIN = "openclaw-plugin";
+var HOOK_BEFORE_TOOL = "openclaw-before-tool";
+var HOOK_AFTER_TOOL = "openclaw-after-tool";
+var HOOK_SESSION_START = "openclaw-session-start";
+var HOOK_SESSION_END = "openclaw-session-end";
+var HOOK_LLM_INPUT = "openclaw-llm-input";
+var HOOK_LLM_OUTPUT = "openclaw-llm-output";
+var HOOK_AGENT_END = "openclaw-agent-end";
+var HOOK_BEFORE_COMPACTION = "openclaw-before-compaction";
+var HOOK_SUBAGENT_SPAWNED = "openclaw-subagent-spawned";
+var HOOK_SUBAGENT_ENDED = "openclaw-subagent-ended";
+var HOOK_COMMAND = "openclaw-command";
+var HOOK_MESSAGE = "openclaw-message";
 function resolveConversationId() {
   return gatewaySessionId;
 }
@@ -826,10 +899,10 @@ function extractResultPreview(toolName, params, result, maxLen = 300) {
   if (str.length <= maxLen) return str;
   return str.slice(0, maxLen) + "...";
 }
-function handleFailBehavior(config, error, toolName, logger) {
+function handleFailBehavior(config, error, toolName, logger, hookName = HOOK_PLUGIN) {
   logger.warn(`Agent Approve API error for tool "${toolName}": ${error.message}`);
   if (config.debug) {
-    debugLog(`API error: ${error.message}, failBehavior: ${config.failBehavior}`);
+    debugLog(`API error: ${error.message}, failBehavior: ${config.failBehavior}`, hookName);
   }
   switch (config.failBehavior) {
     case "deny":
@@ -844,46 +917,65 @@ function handleFailBehavior(config, error, toolName, logger) {
 }
 function register(api) {
   const config = loadConfig(api.pluginConfig, api.logger);
-  if (!config.token) {
-    api.logger.warn(
-      "Agent Approve: No token found. Run the Agent Approve installer to pair with your account."
-    );
-    return;
+  const missingTokenMessage = "Missing token. Download the iOS app, run npx agentapprove, and pair your device. Subscription required.";
+  const noTokenConfigured = !config.token;
+  if (noTokenConfigured) {
+    api.logger.warn(`Agent Approve: ${missingTokenMessage}`);
+  } else {
+    api.logger.info(`Agent Approve: Plugin loaded (privacy: ${config.privacyTier}, fail: ${config.failBehavior})`);
   }
-  api.logger.info(`Agent Approve: Plugin loaded (privacy: ${config.privacyTier}, fail: ${config.failBehavior})`);
   if (config.debug) {
     const e2eStatus = !config.e2eEnabled ? "disabled" : !config.e2eUserKey ? "enabled (key missing)" : "enabled";
     debugLog(
-      `Plugin loaded: v${config.hookVersion}, api=${config.apiUrl}, privacy=${config.privacyTier}, e2e=${e2eStatus}, debug=${config.debug}`
+      `Plugin loaded: v${config.hookVersion}, api=${config.apiUrl}, privacy=${config.privacyTier}, e2e=${e2eStatus}, debug=${config.debug}`,
+      HOOK_PLUGIN
     );
-    debugLog(`Full config: agent=${config.agentName}, timeout=${config.timeout}s, fail=${config.failBehavior}`);
+    debugLog(`Full config: agent=${config.agentName}, timeout=${config.timeout}s, fail=${config.failBehavior}`, HOOK_PLUGIN);
   }
   api.on("before_tool_call", async (event, ctx) => {
+    if (config.debug) {
+      debugLogRaw({ event, ctx }, HOOK_BEFORE_TOOL);
+      debugLog("Started before_tool_call hook", HOOK_BEFORE_TOOL);
+    }
     const conversationId = resolveConversationId();
     const { toolType, displayName } = classifyTool(event.toolName, event.params);
     const command = extractCommand(event.toolName, event.params);
+    if (config.debug) {
+      debugLog(`Tool: ${displayName} (${toolType}) [agent: ${config.agentName}]`, HOOK_BEFORE_TOOL);
+    }
+    if (noTokenConfigured) {
+      return {
+        block: true,
+        blockReason: missingTokenMessage
+      };
+    }
     const request = {
       toolName: displayName,
       toolType,
       command,
       toolInput: event.params,
-      agent: config.agentName,
+      agent: config.agentType,
+      agentName: config.agentName,
       hookType: "before_tool_call",
       sessionId: conversationId,
       conversationId,
       cwd: event.params.workdir || void 0,
+      projectPath: process.cwd(),
       timestamp: (/* @__PURE__ */ new Date()).toISOString()
     };
     try {
-      const response = await sendApprovalRequest(request, config, pluginFilePath);
+      const response = await sendApprovalRequest(request, config, pluginFilePath, HOOK_BEFORE_TOOL);
+      if (config.debug) {
+        debugLog(`Decision: ${response.decision}, Reason: ${response.reason || ""}`, HOOK_BEFORE_TOOL);
+      }
       if (response.decision === "approve" || response.decision === "allow") {
         if (config.debug) {
-          debugLog(`Tool "${event.toolName}" approved${response.reason ? ": " + response.reason : ""}`);
+          debugLog("Tool approved", HOOK_BEFORE_TOOL);
         }
         return void 0;
       }
       if (config.debug) {
-        debugLog(`Tool "${event.toolName}" denied${response.reason ? ": " + response.reason : ""}`);
+        debugLog("Tool denied", HOOK_BEFORE_TOOL);
       }
       return {
         block: true,
@@ -894,73 +986,89 @@ function register(api) {
         config,
         error instanceof Error ? error : new Error(String(error)),
         event.toolName,
-        api.logger
+        api.logger,
+        HOOK_BEFORE_TOOL
       );
     }
   });
   api.on("after_tool_call", async (event, ctx) => {
+    if (config.debug) {
+      debugLogRaw({ event, ctx }, HOOK_AFTER_TOOL);
+    }
     const conversationId = resolveConversationId();
     if (isDuplicateCompletion(event.toolName, event.params)) {
       if (config.debug) {
-        debugLog(`Skipping duplicate tool_complete for "${event.toolName}"`);
+        debugLog(`Skipping duplicate tool_complete for "${event.toolName}"`, HOOK_AFTER_TOOL);
       }
       return;
     }
     const { toolType } = classifyTool(event.toolName, event.params);
     const resultPreview = extractResultPreview(event.toolName, event.params, event.result);
+    const resultStr = event.result != null ? typeof event.result === "string" ? event.result : JSON.stringify(event.result) : void 0;
+    const longPreview = resultStr && resultStr.length > 1e3 ? resultStr.slice(0, 1e3) + "..." : resultStr;
     void sendEvent({
       toolName: event.toolName,
       toolType,
       eventType: "tool_complete",
-      agent: config.agentName,
+      agent: config.agentType,
+      agentName: config.agentName,
       hookType: "after_tool_call",
       sessionId: conversationId,
       conversationId,
       command: extractCommand(event.toolName, event.params),
+      toolInput: event.params,
       status: event.error ? "error" : "success",
       response: event.error || resultPreview || void 0,
+      responsePreview: longPreview,
       durationMs: event.durationMs,
+      cwd: event.params?.workdir || void 0,
       timestamp: (/* @__PURE__ */ new Date()).toISOString()
-    }, config, pluginFilePath);
+    }, config, pluginFilePath, HOOK_AFTER_TOOL);
   });
   api.on("session_start", async (event, ctx) => {
-    const conversationId = resolveConversationId();
     if (config.debug) {
-      debugLog(`Session started: ${event.sessionId}${event.resumedFrom ? ` (resumed from ${event.resumedFrom})` : ""}`);
+      debugLogRaw({ event, ctx }, HOOK_SESSION_START);
+      debugLog(`Session started: ${event.sessionId}${event.resumedFrom ? ` (resumed from ${event.resumedFrom})` : ""}`, HOOK_SESSION_START);
     }
+    const conversationId = resolveConversationId();
     void sendEvent({
       eventType: "session_start",
-      agent: config.agentName,
+      agent: config.agentType,
+      agentName: config.agentName,
       hookType: "session_start",
       sessionId: conversationId,
       conversationId,
       timestamp: (/* @__PURE__ */ new Date()).toISOString()
-    }, config, pluginFilePath);
+    }, config, pluginFilePath, HOOK_SESSION_START);
   });
   api.on("session_end", async (event, ctx) => {
-    const conversationId = resolveConversationId();
     if (config.debug) {
-      debugLog(`Session ended: ${event.sessionId} (${event.messageCount} messages, ${event.durationMs ?? "?"}ms)`);
+      debugLogRaw({ event, ctx }, HOOK_SESSION_END);
+      debugLog(`Session ended: ${event.sessionId} (${event.messageCount} messages, ${event.durationMs ?? "?"}ms)`, HOOK_SESSION_END);
     }
+    const conversationId = resolveConversationId();
     void sendEvent({
       eventType: "session_end",
-      agent: config.agentName,
+      agent: config.agentType,
+      agentName: config.agentName,
       hookType: "session_end",
       sessionId: conversationId,
       conversationId,
       durationMs: event.durationMs,
       sessionStats: { messageCount: event.messageCount },
       timestamp: (/* @__PURE__ */ new Date()).toISOString()
-    }, config, pluginFilePath);
+    }, config, pluginFilePath, HOOK_SESSION_END);
   });
   api.on("llm_input", async (event, ctx) => {
-    const conversationId = resolveConversationId();
     if (config.debug) {
-      debugLog(`LLM input: model=${event.model}, prompt length=${event.prompt?.length ?? 0}`);
+      debugLogRaw({ event, ctx }, HOOK_LLM_INPUT);
+      debugLog(`LLM input: model=${event.model}, prompt length=${event.prompt?.length ?? 0}`, HOOK_LLM_INPUT);
     }
+    const conversationId = resolveConversationId();
     void sendEvent({
       eventType: "user_prompt",
-      agent: config.agentName,
+      agent: config.agentType,
+      agentName: config.agentName,
       hookType: "llm_input",
       sessionId: conversationId,
       conversationId,
@@ -968,18 +1076,20 @@ function register(api) {
       prompt: event.prompt,
       textLength: event.prompt?.length ?? 0,
       timestamp: (/* @__PURE__ */ new Date()).toISOString()
-    }, config, pluginFilePath);
+    }, config, pluginFilePath, HOOK_LLM_INPUT);
   });
   api.on("llm_output", async (event, ctx) => {
     const conversationId = resolveConversationId();
     const responseText = event.assistantTexts?.join("\n") || "";
     const textLength = responseText.length;
     if (config.debug) {
-      debugLog(`LLM output: model=${event.model}, length=${textLength}${event.usage?.total ? `, tokens=${event.usage.total}` : ""}`);
+      debugLogRaw({ event, ctx }, HOOK_LLM_OUTPUT);
+      debugLog(`LLM output: model=${event.model}, length=${textLength}${event.usage?.total ? `, tokens=${event.usage.total}` : ""}`, HOOK_LLM_OUTPUT);
     }
     void sendEvent({
       eventType: "response",
-      agent: config.agentName,
+      agent: config.agentType,
+      agentName: config.agentName,
       hookType: "llm_output",
       sessionId: conversationId,
       conversationId,
@@ -988,16 +1098,18 @@ function register(api) {
       textPreview: responseText.slice(0, 200),
       textLength,
       timestamp: (/* @__PURE__ */ new Date()).toISOString()
-    }, config, pluginFilePath);
+    }, config, pluginFilePath, HOOK_LLM_OUTPUT);
   });
   api.on("agent_end", async (event, ctx) => {
-    const conversationId = resolveConversationId();
     if (config.debug) {
-      debugLog(`Agent ended: success=${event.success}${event.durationMs ? `, duration=${event.durationMs}ms` : ""}${event.error ? `, error=${event.error}` : ""}`);
+      debugLogRaw({ event, ctx }, HOOK_AGENT_END);
+      debugLog(`Agent ended: success=${event.success}${event.durationMs ? `, duration=${event.durationMs}ms` : ""}${event.error ? `, error=${event.error}` : ""}`, HOOK_AGENT_END);
     }
+    const conversationId = resolveConversationId();
     void sendEvent({
       eventType: "stop",
-      agent: config.agentName,
+      agent: config.agentType,
+      agentName: config.agentName,
       hookType: "agent_end",
       sessionId: conversationId,
       conversationId,
@@ -1005,31 +1117,35 @@ function register(api) {
       durationMs: event.durationMs,
       response: event.error || void 0,
       timestamp: (/* @__PURE__ */ new Date()).toISOString()
-    }, config, pluginFilePath);
+    }, config, pluginFilePath, HOOK_AGENT_END);
   });
   api.on("before_compaction", async (event, ctx) => {
-    const conversationId = resolveConversationId();
     if (config.debug) {
-      debugLog(`Context compaction: ${event.messageCount} messages${event.tokenCount ? `, ${event.tokenCount} tokens` : ""}`);
+      debugLogRaw({ event, ctx }, HOOK_BEFORE_COMPACTION);
+      debugLog(`Context compaction: ${event.messageCount} messages${event.tokenCount ? `, ${event.tokenCount} tokens` : ""}`, HOOK_BEFORE_COMPACTION);
     }
+    const conversationId = resolveConversationId();
     void sendEvent({
       eventType: "context_compact",
-      agent: config.agentName,
+      agent: config.agentType,
+      agentName: config.agentName,
       hookType: "before_compaction",
       sessionId: conversationId,
       conversationId,
       trigger: `${event.messageCount} messages${event.tokenCount ? `, ${event.tokenCount} tokens` : ""}`,
       timestamp: (/* @__PURE__ */ new Date()).toISOString()
-    }, config, pluginFilePath);
+    }, config, pluginFilePath, HOOK_BEFORE_COMPACTION);
   });
   api.on("subagent_spawned", async (event, ctx) => {
-    const conversationId = resolveConversationId();
     if (config.debug) {
-      debugLog(`Subagent spawned: ${event.agentId} (${event.mode}${event.label ? `, label=${event.label}` : ""})`);
+      debugLogRaw({ event, ctx }, HOOK_SUBAGENT_SPAWNED);
+      debugLog(`Subagent spawned: ${event.agentId} (${event.mode}${event.label ? `, label=${event.label}` : ""})`, HOOK_SUBAGENT_SPAWNED);
     }
+    const conversationId = resolveConversationId();
     void sendEvent({
       eventType: "subagent_start",
-      agent: config.agentName,
+      agent: config.agentType,
+      agentName: config.agentName,
       hookType: "subagent_spawned",
       sessionId: conversationId,
       conversationId,
@@ -1037,16 +1153,18 @@ function register(api) {
       subagentMode: event.mode,
       subagentLabel: event.label,
       timestamp: (/* @__PURE__ */ new Date()).toISOString()
-    }, config, pluginFilePath);
+    }, config, pluginFilePath, HOOK_SUBAGENT_SPAWNED);
   });
   api.on("subagent_ended", async (event, ctx) => {
-    const conversationId = resolveConversationId();
     if (config.debug) {
-      debugLog(`Subagent ended: ${event.targetKind} reason=${event.reason}${event.outcome ? `, outcome=${event.outcome}` : ""}`);
+      debugLogRaw({ event, ctx }, HOOK_SUBAGENT_ENDED);
+      debugLog(`Subagent ended: ${event.targetKind} reason=${event.reason}${event.outcome ? `, outcome=${event.outcome}` : ""}`, HOOK_SUBAGENT_ENDED);
     }
+    const conversationId = resolveConversationId();
     void sendEvent({
       eventType: "subagent_stop",
-      agent: config.agentName,
+      agent: config.agentType,
+      agentName: config.agentName,
       hookType: "subagent_ended",
       sessionId: conversationId,
       conversationId,
@@ -1054,7 +1172,7 @@ function register(api) {
       subagentType: event.targetKind,
       response: event.error || void 0,
       timestamp: (/* @__PURE__ */ new Date()).toISOString()
-    }, config, pluginFilePath);
+    }, config, pluginFilePath, HOOK_SUBAGENT_ENDED);
   });
   api.registerHook(
     ["command:new", "command:stop", "command:reset"],
@@ -1065,18 +1183,20 @@ function register(api) {
         reset: "session_start"
       };
       if (config.debug) {
-        debugLog(`Command event: ${event.action}`);
+        debugLogRaw(event, HOOK_COMMAND);
+        debugLog(`Command event: ${event.action}`, HOOK_COMMAND);
       }
       void sendEvent({
         toolName: `command:${event.action}`,
         toolType: "command",
         eventType: eventTypeMap[event.action] || "command_event",
-        agent: config.agentName,
+        agent: config.agentType,
+        agentName: config.agentName,
         hookType: "command_event",
         sessionId: resolveConversationId(),
         conversationId: resolveConversationId(),
         timestamp: event.timestamp.toISOString()
-      }, config, pluginFilePath);
+      }, config, pluginFilePath, HOOK_COMMAND);
     },
     { name: "agentapprove-command-monitor", description: "Log command events to Agent Approve" }
   );
@@ -1088,13 +1208,15 @@ function register(api) {
       const peer = isInbound ? event.context.from : event.context.to;
       const channelLabel = [provider, peer].filter(Boolean).join(":") || void 0;
       if (config.debug) {
-        debugLog(`Message event: ${event.action} ${channelLabel || "(no channel)"}`);
+        debugLogRaw(event, HOOK_MESSAGE);
+        debugLog(`Message event: ${event.action} ${channelLabel || "(no channel)"}`, HOOK_MESSAGE);
       }
       const payload = {
         toolName: `message:${event.action}`,
         toolType: "message_event",
         eventType: isInbound ? "user_prompt" : "response",
-        agent: config.agentName,
+        agent: config.agentType,
+        agentName: config.agentName,
         hookType: "session_event",
         sessionId: resolveConversationId(),
         conversationId: resolveConversationId(),
@@ -1110,7 +1232,7 @@ function register(api) {
           payload.prompt = `${peer}: ${content}`;
         }
       }
-      void sendEvent(payload, config, pluginFilePath);
+      void sendEvent(payload, config, pluginFilePath, HOOK_MESSAGE);
     },
     { name: "agentapprove-session-monitor", description: "Log message events to Agent Approve" }
   );

package/openclaw.plugin.json

@@ -2,7 +2,7 @@
   "id": "openclaw",
   "name": "Agent Approve",
   "description": "Mobile approval for AI agent tool execution. Approve or deny tool calls from your iPhone and Apple Watch.",
-  "version": "0.1.6",
+  "version": "0.1.7",
   "homepage": "https://agentapprove.com",
   "configSchema": {
     "type": "object",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agentapprove/openclaw",
-  "version": "0.1.6",
+  "version": "0.1.8",
   "description": "Agent Approve plugin for OpenClaw - approve or deny AI agent tool calls from your iPhone and Apple Watch",
   "main": "dist/index.js",
   "scripts": {