@agentapprove/opencode 0.1.3 → 0.1.4

package/dist/index.js

@@ -9,7 +9,7 @@ import { homedir as homedir3 } from "os";
 import { execSync } from "child_process";
 
 // src/e2e-crypto.ts
-import { createHash, createHmac, createCipheriv, randomBytes } from "crypto";
+import { createHash, createHmac, createCipheriv, createDecipheriv, randomBytes, timingSafeEqual } from "crypto";
 import { readFileSync as readFileSync2, writeFileSync as writeFileSync2, existsSync as existsSync2, copyFileSync } from "fs";
 import { join as join2 } from "path";
 import { homedir as homedir2 } from "os";
@@ -135,6 +135,33 @@ function e2eEncrypt(keyHex, plaintext) {
   const hmac = createHmac("sha256", macKey).update(Buffer.concat([iv, ciphertext])).digest("hex");
   return `E2E:v1:${kid}:${ivHex}:${ciphertextBase64}:${hmac}`;
 }
+function isE2EEncrypted(value) {
+  return value.startsWith("E2E:v1:");
+}
+function e2eDecrypt(keyHex, encrypted) {
+  try {
+    if (!isE2EEncrypted(encrypted)) return null;
+    const parts = encrypted.split(":");
+    if (parts.length !== 6) return null;
+    const ivHex = parts[3];
+    const ciphertextBase64 = parts[4];
+    const hmacHex = parts[5];
+    const encKey = deriveEncKey(keyHex);
+    const macKey = deriveMacKey(keyHex);
+    const iv = Buffer.from(ivHex, "hex");
+    const ciphertext = Buffer.from(ciphertextBase64, "base64");
+    const expectedHmac = createHmac("sha256", macKey).update(Buffer.concat([iv, ciphertext])).digest();
+    const actualHmac = Buffer.from(hmacHex, "hex");
+    if (expectedHmac.length !== actualHmac.length || !timingSafeEqual(expectedHmac, actualHmac)) {
+      return null;
+    }
+    const decipher = createDecipheriv("aes-256-ctr", encKey, iv);
+    const plaintext = Buffer.concat([decipher.update(ciphertext), decipher.final()]);
+    return plaintext.toString("utf-8");
+  } catch {
+    return null;
+  }
+}
 function applyApprovalE2E(payload, userKey, serverKey) {
   const sensitiveFields = {};
   for (const field of ["command", "toolInput", "cwd"]) {
@@ -731,6 +758,45 @@ async function sendApprovalRequest(request, config, pluginPath) {
   processConfigSync(parsed, config);
   return parsed;
 }
+async function sendStopRequest(request, config, pluginPath) {
+  if (!config.token) {
+    throw new Error("No Agent Approve token configured");
+  }
+  const payload = applyEventPrivacyFilter(
+    { ...request },
+    config.privacyTier
+  );
+  const bodyStr = JSON.stringify(payload);
+  const pluginHash = getPluginHash(pluginPath, config.debug);
+  const hmacHeaders = buildHMACHeaders(bodyStr, config.token, config.hookVersion, pluginHash);
+  const headers = {
+    "Authorization": `Bearer ${config.token}`,
+    ...hmacHeaders
+  };
+  const url = `${config.apiUrl}/${config.apiVersion}/stop`;
+  const stopTimeoutMs = 3e5;
+  if (config.debug) {
+    debugLog(`Sending stop request to ${url}`);
+    debugLog(`=== SENT TO ${url} ===`);
+    debugLogRawInline(bodyStr);
+    debugLog("=== END SENT ===");
+  }
+  const response = await httpPost(url, bodyStr, headers, stopTimeoutMs);
+  if (config.debug) {
+    debugLog(`Stop response: ${response.body || "<empty>"}`);
+  }
+  if (response.status !== 200) {
+    throw new Error(`Stop API returned status ${response.status}: ${response.body.slice(0, 200)}`);
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(response.body);
+  } catch {
+    parsed = {};
+  }
+  processConfigSync(parsed, config);
+  return parsed;
+}
 async function sendEvent(event, config, pluginPath) {
   if (!config.token) return;
   const eventType = event.eventType;
@@ -795,9 +861,11 @@ var fallbackSessionId = randomBytes2(12).toString("hex");
 var COMPACTION_DEDUP_WINDOW_MS = 2e3;
 var openCodeClient = void 0;
 var lastCompactionEventAt = 0;
+var processingIdleSessions = /* @__PURE__ */ new Set();
 var seenUnmappedEventTypes = /* @__PURE__ */ new Set();
 var sentFinalMessageIds = /* @__PURE__ */ new Set();
 var messageParts = /* @__PURE__ */ new Map();
+var NOISY_EVENT_TYPES = /* @__PURE__ */ new Set(["message.part.delta"]);
 function classifyTool(toolName) {
   const lower = toolName.toLowerCase();
   if (lower === "bash") {
@@ -1109,10 +1177,11 @@ async function plugin(input) {
     "event": async (input2) => {
       const eventName = input2.event?.type;
       if (!eventName) return;
+      if (NOISY_EVENT_TYPES.has(eventName)) return;
       const eventProperties = input2.event.properties || {};
       const eventSessionId = getEventSessionId(eventName, eventProperties);
       const ids = resolveIds(eventSessionId);
-      if (config.debug && !seenUnmappedEventTypes.has(`_logged_${eventName}`)) {
+      if (config.debug) {
         debugLog(`Event received: ${eventName}`, HOOK_EVENT);
       }
       if (eventName === "message.part.updated") {
@@ -1190,40 +1259,71 @@ async function plugin(input) {
       }
       if (eventName === "session.idle") return;
       const status = eventProperties.status;
+      if (eventName === "session.status" && status?.type !== "idle") {
+        processingIdleSessions.delete(ids.sessionId);
+        return;
+      }
       if (eventName === "session.status" && status?.type === "idle") {
+        if (processingIdleSessions.has(ids.sessionId)) {
+          if (config.debug) {
+            debugLog("Skipping duplicate session.status idle (already processing)", HOOK_EVENT);
+          }
+          return;
+        }
+        processingIdleSessions.add(ids.sessionId);
         if (config.debug) {
-          debugLog(`Session idle detected via session.status, sending blocking stop event`, HOOK_EVENT);
+          debugLog("Session idle detected via session.status, sending stop request", HOOK_EVENT);
         }
         const stopRequest = {
-          toolName: "session_idle",
-          toolType: "session",
           agent: config.agentType,
           agentName: config.agentName,
-          hookType: "stop",
+          eventType: "stop",
+          status: "completed",
+          loopCount: 0,
           sessionId: ids.sessionId,
           conversationId: ids.conversationId,
-          projectPath,
-          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+          timestamp: Date.now(),
+          ...config.e2eEnabled && config.e2eUserKey ? { e2eKeyId: keyId(config.e2eUserKey) } : {}
         };
         try {
-          const response = await sendApprovalRequest(stopRequest, config, pluginFilePath);
-          if ((response.decision === "approve" || response.decision === "allow") && response.reason && openCodeClient) {
+          const response = await sendStopRequest(stopRequest, config, pluginFilePath);
+          if (config.debug) {
+            debugLog(`Stop response: followup=${response.followup_message ? "yes" : "no"}`, HOOK_EVENT);
+          }
+          if (response.followup_message && openCodeClient) {
+            let followupText = response.followup_message;
+            if (config.e2eEnabled && config.e2eUserKey && isE2EEncrypted(followupText)) {
+              const decrypted = e2eDecrypt(config.e2eUserKey, followupText);
+              if (decrypted) {
+                if (config.debug) {
+                  debugLog(`Decrypted follow-up: ${decrypted.slice(0, 50)}...`, HOOK_EVENT);
+                }
+                followupText = decrypted;
+              } else {
+                if (config.debug) {
+                  debugLog("E2E decryption failed for follow-up message, skipping injection", HOOK_EVENT);
+                }
+                return;
+              }
+            }
             if (config.debug) {
-              debugLog(`Stop approved with follow-up input: ${response.reason.slice(0, 100)}`, HOOK_EVENT);
+              debugLog(`Injecting user follow-up: ${followupText.slice(0, 100)}`, HOOK_EVENT);
             }
             try {
-              await openCodeClient.tui.appendPrompt({ body: { text: response.reason } });
+              await openCodeClient.tui.appendPrompt({ body: { text: followupText } });
               await openCodeClient.tui.submitPrompt();
             } catch (injectionError) {
               if (config.debug) {
-                debugLog(`Failed to inject follow-up input: ${injectionError instanceof Error ? injectionError.message : String(injectionError)}`, HOOK_EVENT);
+                debugLog(`Failed to inject follow-up: ${injectionError instanceof Error ? injectionError.message : String(injectionError)}`, HOOK_EVENT);
               }
             }
           }
         } catch (error) {
           if (config.debug) {
-            debugLog(`Stop event error: ${error instanceof Error ? error.message : String(error)}`, HOOK_EVENT);
+            debugLog(`Stop request error: ${error instanceof Error ? error.message : String(error)}`, HOOK_EVENT);
           }
+        } finally {
+          processingIdleSessions.delete(ids.sessionId);
         }
         return;
       }

package/package.json

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