@agentapprove/openclaw 0.1.5 → 0.1.7

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) {
@@ -154,7 +209,7 @@ function deriveEpochKey(rootKeyHex, epoch) {
   }
   return current;
 }
-function migrateRootKey() {
+function migrateRootKey(debug = false) {
   if (!existsSync2(E2E_KEY_FILE) || existsSync2(E2E_ROOT_KEY_FILE)) return;
   try {
     copyFileSync(E2E_KEY_FILE, E2E_ROOT_KEY_FILE);
@@ -173,12 +228,12 @@ function migrateRootKey() {
       };
       writeFileSync2(E2E_ROTATION_FILE, JSON.stringify(config, null, 2), { mode: 384 });
     }
-    debugLog("Migrated e2e-key to e2e-root-key");
+    if (debug) debugLog("Migrated e2e-key to e2e-root-key");
   } catch {
   }
 }
-function checkAndRotateKeys(currentKeyHex) {
-  migrateRootKey();
+function checkAndRotateKeys(currentKeyHex, debug = false) {
+  migrateRootKey(debug);
   if (!existsSync2(E2E_ROTATION_FILE) || !existsSync2(E2E_ROOT_KEY_FILE)) {
     return currentKeyHex;
   }
@@ -217,7 +272,7 @@ function checkAndRotateKeys(currentKeyHex) {
     writeFileSync2(E2E_ROTATION_FILE, JSON.stringify(rotCfg, null, 2), { mode: 384 });
   } catch {
   }
-  debugLog(`E2E key rotated: epoch ${currentEpoch} -> ${expectedEpoch}`);
+  if (debug) debugLog(`E2E key rotated: epoch ${currentEpoch} -> ${expectedEpoch}`);
   return newKey;
 }
 
@@ -293,7 +348,7 @@ function loadConfig(openclawConfig, logger) {
   const timeout = openclawConfig?.timeout || parseInt(process.env.AGENTAPPROVE_TIMEOUT || "", 10) || parseInt(parseConfigValue(fileContent, "AGENTAPPROVE_TIMEOUT") || "", 10) || 300;
   const failBehavior = openclawConfig?.failBehavior || process.env.AGENTAPPROVE_FAIL_BEHAVIOR || parseConfigValue(fileContent, "AGENTAPPROVE_FAIL_BEHAVIOR") || "ask";
   const privacyTier = openclawConfig?.privacyTier || process.env.AGENTAPPROVE_PRIVACY || parseConfigValue(fileContent, "AGENTAPPROVE_PRIVACY") || "full";
-  const debug = openclawConfig?.debug || process.env.AGENTAPPROVE_DEBUG === "true" || parseConfigValue(fileContent, "AGENTAPPROVE_DEBUG") === "true" || false;
+  const debug = openclawConfig?.debug || process.env.AGENTAPPROVE_DEBUG === "true" || process.env.AGENTAPPROVE_DEBUG_LOG === "true" || parseConfigValue(fileContent, "AGENTAPPROVE_DEBUG") === "true" || parseConfigValue(fileContent, "AGENTAPPROVE_DEBUG_LOG") === "true" || false;
   const agentName = process.env.AGENTAPPROVE_AGENT_NAME || parseConfigValue(fileContent, "AGENTAPPROVE_OPENCLAW_NAME") || "OpenClaw";
   const e2eEnabled = process.env.AGENTAPPROVE_E2E_ENABLED === "true" || parseConfigValue(fileContent, "AGENTAPPROVE_E2E_ENABLED") === "true";
   const e2eUserKeyPath = join3(homedir3(), ".agentapprove", "e2e-key");
@@ -316,7 +371,7 @@ function loadConfig(openclawConfig, logger) {
       }
     }
     if (e2eUserKey) {
-      e2eUserKey = checkAndRotateKeys(e2eUserKey) || e2eUserKey;
+      e2eUserKey = checkAndRotateKeys(e2eUserKey, debug) || e2eUserKey;
     }
   }
   if (debug) {
@@ -331,7 +386,7 @@ function loadConfig(openclawConfig, logger) {
     failBehavior,
     privacyTier,
     debug,
-    hookVersion: "1.1.2",
+    hookVersion: "1.1.4",
     agentName,
     e2eEnabled,
     e2eUserKey,
@@ -453,13 +508,143 @@ function applyEventPrivacyFilter(event, privacyTier) {
   return filtered;
 }
 
+// src/config-sync.ts
+import { readFileSync as readFileSync5, writeFileSync as writeFileSync3, existsSync as existsSync4, renameSync } from "fs";
+import { join as join4 } from "path";
+import { homedir as homedir4 } from "os";
+function getAADir() {
+  return process.env.__AGENTAPPROVE_TEST_DIR || join4(homedir4(), ".agentapprove");
+}
+function getEnvPath() {
+  return join4(getAADir(), "env");
+}
+function getRotationFile() {
+  return join4(getAADir(), "e2e-rotation.json");
+}
+var VALID_PRIVACY = /* @__PURE__ */ new Set(["minimal", "summary", "full"]);
+var VALID_FAIL = /* @__PURE__ */ new Set(["allow", "deny", "ask"]);
+function updateEnvValues(updates) {
+  const envPath = getEnvPath();
+  if (!existsSync4(envPath)) return;
+  const validUpdates = Object.fromEntries(
+    Object.entries(updates).filter(([, v]) => !/[`$(){};<>|&!\\]/.test(v))
+  );
+  const updateKeys = new Set(Object.keys(validUpdates));
+  if (updateKeys.size === 0) return;
+  try {
+    const content = readFileSync5(envPath, "utf-8");
+    const lines = content.split("\n");
+    const filtered = lines.filter((line) => {
+      const trimmed = line.replace(/^export\s+/, "").trim();
+      const eqIdx = trimmed.indexOf("=");
+      if (eqIdx <= 0) return true;
+      return !updateKeys.has(trimmed.slice(0, eqIdx));
+    });
+    for (const [key, value] of Object.entries(validUpdates)) {
+      filtered.push(`export ${key}=${value}`);
+    }
+    const tmpPath = `${envPath}.tmp.${process.pid}`;
+    writeFileSync3(tmpPath, filtered.join("\n"), { mode: 384 });
+    renameSync(tmpPath, envPath);
+  } catch {
+  }
+}
+function syncRotationConfig(serverPeriod, serverStartedAt, debug) {
+  const rotationFile = getRotationFile();
+  if (!existsSync4(rotationFile)) return;
+  try {
+    const raw = readFileSync5(rotationFile, "utf-8");
+    const config = JSON.parse(raw);
+    const currentPeriod = config.periodSeconds ?? 0;
+    const newPeriod = serverPeriod ?? 0;
+    let needsUpdate = false;
+    if (typeof newPeriod === "number" && newPeriod !== currentPeriod) {
+      config.periodSeconds = newPeriod;
+      needsUpdate = true;
+    }
+    if (serverStartedAt && (!config.startedAt || config.startedAt === "null")) {
+      config.startedAt = serverStartedAt;
+      needsUpdate = true;
+    }
+    if (needsUpdate) {
+      const tmpPath = `${rotationFile}.tmp.${process.pid}`;
+      writeFileSync3(tmpPath, JSON.stringify(config, null, 2), { mode: 384 });
+      renameSync(tmpPath, rotationFile);
+      if (debug) {
+        debugLog(`E2E rotation synced: periodSeconds=${newPeriod}`);
+      }
+    }
+  } catch {
+  }
+}
+function processConfigSync(parsed, config) {
+  const sync = parsed.configSync;
+  if (!sync || !sync.configSetAt) return;
+  const localSetAt = getLocalConfigSetAt();
+  if (sync.configSetAt <= localSetAt) return;
+  if (config.debug) {
+    debugLog(`Config sync: server=${sync.configSetAt} > local=${localSetAt}, updating...`);
+  }
+  const envUpdates = {};
+  if (sync.privacyTier && VALID_PRIVACY.has(sync.privacyTier)) {
+    envUpdates["AGENTAPPROVE_PRIVACY"] = sync.privacyTier;
+    config.privacyTier = sync.privacyTier;
+    if (config.debug) debugLog(`Config synced: privacy=${sync.privacyTier}`);
+  }
+  if (sync.timeoutSeconds != null) {
+    const t = sync.timeoutSeconds;
+    if (t >= 30 && t <= 600) {
+      envUpdates["AGENTAPPROVE_TIMEOUT"] = String(t);
+      config.timeout = t;
+      if (config.debug) debugLog(`Config synced: timeout=${t}`);
+    }
+  }
+  if (sync.failBehavior && VALID_FAIL.has(sync.failBehavior)) {
+    envUpdates["AGENTAPPROVE_FAIL_BEHAVIOR"] = sync.failBehavior;
+    config.failBehavior = sync.failBehavior;
+    if (config.debug) debugLog(`Config synced: failBehavior=${sync.failBehavior}`);
+  }
+  if (sync.e2eEnabled === true || sync.e2eEnabled === false) {
+    envUpdates["AGENTAPPROVE_E2E_ENABLED"] = String(sync.e2eEnabled);
+    config.e2eEnabled = sync.e2eEnabled;
+    if (config.debug) debugLog(`Config synced: e2eEnabled=${sync.e2eEnabled}`);
+  }
+  syncRotationConfig(sync.e2eRotationPeriod, sync.e2eRotationStartedAt, config.debug);
+  if (config.e2eEnabled && config.e2eUserKey) {
+    const rotatedKey = checkAndRotateKeys(config.e2eUserKey, config.debug);
+    if (rotatedKey && rotatedKey !== config.e2eUserKey) {
+      config.e2eUserKey = rotatedKey;
+      if (config.debug) debugLog(`Key rotated after config sync`);
+    }
+  }
+  envUpdates["AGENTAPPROVE_CONFIG_SET_AT"] = String(sync.configSetAt);
+  updateEnvValues(envUpdates);
+}
+function getLocalConfigSetAt() {
+  const envPath = getEnvPath();
+  if (!existsSync4(envPath)) return 0;
+  try {
+    const content = readFileSync5(envPath, "utf-8");
+    for (const raw of content.split("\n")) {
+      const line = raw.replace(/^export\s+/, "").trim();
+      if (line.startsWith("AGENTAPPROVE_CONFIG_SET_AT=")) {
+        const val = line.slice("AGENTAPPROVE_CONFIG_SET_AT=".length).replace(/^["']|["']$/g, "");
+        const num = parseInt(val, 10);
+        return isNaN(num) ? 0 : num;
+      }
+    }
+  } catch {
+  }
+  return 0;
+}
+
 // src/api-client.ts
 var cachedPluginHash;
-function getPluginHash(pluginPath) {
+function getPluginHash(pluginPath, debug = false, hookName = "openclaw-plugin") {
   if (!cachedPluginHash) {
     cachedPluginHash = computePluginHash(pluginPath);
-    if (cachedPluginHash) {
-      debugLog(`Plugin hash computed: ${cachedPluginHash.slice(0, 16)}...`);
+    if (cachedPluginHash && debug) {
+      debugLog(`Plugin hash computed: ${cachedPluginHash.slice(0, 16)}...`, hookName);
     }
   }
   return cachedPluginHash || "";
@@ -501,7 +686,7 @@ 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");
   }
@@ -509,13 +694,13 @@ async function sendApprovalRequest(request, config, pluginPath) {
   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);
+  const pluginHash = getPluginHash(pluginPath, config.debug, hookName);
   const hmacHeaders = buildHMACHeaders(bodyStr, config.token, config.hookVersion, pluginHash);
   const headers = {
     "Authorization": `Bearer ${config.token}`,
@@ -523,38 +708,44 @@ 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)}`);
   }
+  let parsed;
   try {
-    return JSON.parse(response.body);
+    parsed = JSON.parse(response.body);
   } catch {
     throw new Error(`Failed to parse API response: ${response.body.slice(0, 200)}`);
   }
+  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);
+    const pluginHash = getPluginHash(pluginPath, config.debug, hookName);
     const hmacHeaders = buildHMACHeaders(bodyStr, config.token, config.hookVersion, pluginHash);
     const headers = {
       "Authorization": `Bearer ${config.token}`,
@@ -562,17 +753,24 @@ 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 {
+        const parsed = JSON.parse(response.body);
+        processConfigSync(parsed, config);
+      } catch {
+      }
     }
   } 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);
     }
   }
 }
@@ -588,6 +786,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;
 }
@@ -686,10 +897,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":
@@ -712,12 +923,24 @@ function register(api) {
   }
   api.logger.info(`Agent Approve: Plugin loaded (privacy: ${config.privacyTier}, fail: ${config.failBehavior})`);
   if (config.debug) {
-    debugLog(`Plugin loaded, API: ${config.apiUrl}, agent: ${config.agentName}`);
+    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}`,
+      HOOK_PLUGIN
+    );
+    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);
+    }
     const request = {
       toolName: displayName,
       toolType,
@@ -731,15 +954,18 @@ function register(api) {
       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,
@@ -750,15 +976,19 @@ 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;
     }
@@ -777,13 +1007,14 @@ function register(api) {
       response: event.error || resultPreview || void 0,
       durationMs: event.durationMs,
       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,
@@ -791,13 +1022,14 @@ function register(api) {
       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,
@@ -807,13 +1039,14 @@ function register(api) {
       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,
@@ -824,14 +1057,15 @@ 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",
@@ -844,13 +1078,14 @@ 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,
@@ -861,13 +1096,14 @@ 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,
@@ -876,13 +1112,14 @@ function register(api) {
       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,
@@ -893,13 +1130,14 @@ 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,
@@ -910,7 +1148,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"],
@@ -921,7 +1159,8 @@ 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}`,
@@ -932,7 +1171,7 @@ function register(api) {
         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" }
   );
@@ -944,7 +1183,8 @@ 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}`,
@@ -966,7 +1206,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.5",
+  "version": "0.1.7",
   "homepage": "https://agentapprove.com",
   "configSchema": {
     "type": "object",

package/package.json

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