@agentapprove/openclaw 0.1.0

package/LICENSE

@@ -0,0 +1,13 @@
+Copyright (c) 2026 Agent Approve LLC. All rights reserved.
+
+This software is proprietary and confidential. Unauthorized copying,
+modification, distribution, or use of this software, via any medium,
+is strictly prohibited without the express written permission of
+Agent Approve LLC.
+
+Use of this software is subject to the Agent Approve Terms of Service:
+https://www.agentapprove.com/terms
+
+Privacy Policy: https://www.agentapprove.com/privacy
+
+For licensing inquiries, contact: hello@agentapprove.com

package/README.md

@@ -0,0 +1,77 @@
+# @agentapprove/openclaw
+
+[Agent Approve](https://agentapprove.com) plugin for [OpenClaw](https://openclaw.ai). Approve or deny AI agent tool calls from your iPhone and Apple Watch.
+
+## Why Agent Approve?
+
+- **Visibility** -- see what your OpenClaw agent is doing in real time from your mobile device
+- **Centralized policy** -- define your default stance (allow, deny, or ask) and manage custom allowlists and denylists for tools, parameters, and commands
+- **Mobile approval** -- when human approval is required, review and respond from your iPhone or Apple Watch with a tap
+
+You decide the rules. Agent Approve enforces them.
+
+## How it works
+
+This plugin hooks into OpenClaw's agent loop to enforce your approval policy:
+
+- **before_tool_call** -- evaluates each tool call against your policy. Auto-allows or auto-denies based on your lists, or sends an approval request to your device when manual review is needed.
+- **after_tool_call** -- logs tool completion to your activity feed
+- **command/message events** -- monitors session activity
+
+## Install
+
+```bash
+openclaw plugins install @agentapprove/openclaw
+```
+
+## Setup
+
+1. **Download Agent Approve** from the [App Store](https://agentapprove.com) and start your 7-day free trial
+2. **Follow the in-app onboarding** which will prompt you to run the installer on each machine where you have agents:
+
+```bash
+npx agentapprove
+```
+
+The installer handles pairing, token setup, and plugin activation. Select OpenClaw when prompted for which agents to configure.
+
+3. **Restart the OpenClaw gateway** to load the plugin
+
+That's it. Tool calls will now be evaluated against your policy, and approval requests will appear on your paired device when needed.
+
+## Configuration
+
+Plugin settings in `~/.openclaw/openclaw.json`:
+
+```json
+{
+  "plugins": {
+    "entries": {
+      "agentapprove": {
+        "enabled": true,
+        "config": {
+          "timeout": 300,
+          "failBehavior": "ask",
+          "privacyTier": "full"
+        }
+      }
+    }
+  }
+}
+```
+
+| Setting | Default | Description |
+|---------|---------|-------------|
+| `timeout` | `300` | Seconds to wait for an approval response |
+| `failBehavior` | `ask` | Default policy when API is unreachable: `allow`, `deny`, or `ask` |
+| `privacyTier` | `full` | What tool data is stored in event logs: `minimal`, `summary`, or `full` |
+| `debug` | `false` | Write debug logs to `~/.agentapprove/hook-debug.log` |
+
+## 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.
+
+## Links
+
+- [Agent Approve](https://agentapprove.com)
+- [OpenClaw](https://openclaw.ai)

package/dist/index.js

@@ -0,0 +1,468 @@
+// src/index.ts
+import { fileURLToPath } from "url";
+
+// src/config.ts
+import { readFileSync, existsSync, statSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+import { execSync } from "child_process";
+var CONFIG_PATH = join(homedir(), ".agentapprove", "env");
+var KEYCHAIN_SERVICE = "com.agentapprove";
+var KEYCHAIN_ACCOUNT = "api-token";
+function parseConfigValue(content, key) {
+  const lines = content.split("\n");
+  let value;
+  for (const raw of lines) {
+    const line = raw.replace(/^export\s+/, "").trim();
+    if (!line.startsWith(`${key}=`)) continue;
+    let v = line.slice(key.length + 1);
+    if (v.startsWith('"') && v.endsWith('"') || v.startsWith("'") && v.endsWith("'")) {
+      v = v.slice(1, -1);
+    }
+    if (/[`$(){};<>|&!\\]/.test(v)) continue;
+    value = v;
+  }
+  return value;
+}
+function normalizeApiUrl(url) {
+  let result = url.trim();
+  while (result.endsWith("/")) {
+    result = result.slice(0, -1);
+  }
+  return result;
+}
+function normalizeApiVersion(version) {
+  const cleaned = version.trim().replace(/^\/+/, "").replace(/\/+$/, "");
+  return cleaned || "v001";
+}
+function getKeychainToken() {
+  if (process.platform !== "darwin") return void 0;
+  try {
+    const result = execSync(
+      `security find-generic-password -s "${KEYCHAIN_SERVICE}" -a "${KEYCHAIN_ACCOUNT}" -w 2>/dev/null`,
+      { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }
+    ).trim();
+    return result || void 0;
+  } catch {
+    return void 0;
+  }
+}
+function checkPermissions(logger) {
+  if (!existsSync(CONFIG_PATH)) return;
+  try {
+    const stat = statSync(CONFIG_PATH);
+    const mode = stat.mode & 511;
+    if (mode & 54) {
+      logger?.warn(
+        `Config file ${CONFIG_PATH} is group or world readable/writable. Run: chmod 600 ${CONFIG_PATH}`
+      );
+    }
+  } catch {
+  }
+}
+function loadConfig(openclawConfig, logger) {
+  checkPermissions(logger);
+  let fileContent = "";
+  if (existsSync(CONFIG_PATH)) {
+    fileContent = readFileSync(CONFIG_PATH, "utf-8");
+  }
+  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.");
+  }
+  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";
+  const apiUrl = normalizeApiUrl(rawApiUrl);
+  const apiVersion = normalizeApiVersion(rawApiVersion);
+  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 agentName = process.env.AGENTAPPROVE_AGENT_NAME || parseConfigValue(fileContent, "AGENTAPPROVE_OPENCLAW_NAME") || "OpenClaw";
+  const e2eEnabled = parseConfigValue(fileContent, "AGENTAPPROVE_E2E_ENABLED") === "true";
+  const e2eKeyPath = join(homedir(), ".agentapprove", "e2e-key");
+  let e2eUserKey;
+  let e2eServerKey;
+  if (e2eEnabled && existsSync(e2eKeyPath)) {
+    try {
+      const keyData = JSON.parse(readFileSync(e2eKeyPath, "utf-8"));
+      e2eUserKey = keyData.userKey;
+      e2eServerKey = keyData.serverKey;
+    } catch {
+      logger?.warn("Failed to load E2E encryption keys");
+    }
+  }
+  return {
+    apiUrl,
+    apiVersion,
+    token,
+    timeout,
+    failBehavior,
+    privacyTier,
+    debug,
+    hookVersion: "1.1.0",
+    agentName,
+    e2eEnabled,
+    e2eUserKey,
+    e2eServerKey
+  };
+}
+
+// src/api-client.ts
+import { request as httpsRequest } from "https";
+import { request as httpRequest } from "http";
+import { URL } from "url";
+
+// src/hmac.ts
+import crypto from "crypto";
+import { readFileSync as readFileSync2 } from "fs";
+function generateHMACSignature(body, token, hookVersion) {
+  const timestamp = Math.floor(Date.now() / 1e3);
+  const message = `${hookVersion}:${timestamp}:${body}`;
+  const signature = crypto.createHmac("sha256", token).update(message).digest("hex");
+  return { timestamp, signature };
+}
+function computePluginHash(pluginPath) {
+  try {
+    const content = readFileSync2(pluginPath, "utf-8");
+    return crypto.createHash("sha256").update(content).digest("hex");
+  } catch {
+    return "";
+  }
+}
+function buildHMACHeaders(body, token, hookVersion, pluginHash) {
+  const { timestamp, signature } = generateHMACSignature(body, token, hookVersion);
+  return {
+    "X-Hook-Version": hookVersion,
+    "X-Hook-Timestamp": String(timestamp),
+    "X-Hook-Signature": signature,
+    "X-Hook-Hash": pluginHash
+  };
+}
+
+// src/privacy.ts
+var SUMMARY_MAX_LENGTH = 50;
+function applyPrivacyFilter(request, privacyTier) {
+  if (privacyTier === "full") {
+    return request;
+  }
+  const filtered = { ...request };
+  if (privacyTier === "minimal") {
+    delete filtered.command;
+    filtered.toolInput = void 0;
+    delete filtered.cwd;
+    return filtered;
+  }
+  if (filtered.command && filtered.command.length > SUMMARY_MAX_LENGTH) {
+    filtered.command = filtered.command.slice(0, SUMMARY_MAX_LENGTH) + "...";
+  }
+  if (filtered.toolInput) {
+    const inputStr = JSON.stringify(filtered.toolInput);
+    if (inputStr.length > SUMMARY_MAX_LENGTH) {
+      filtered.toolInput = { _summary: inputStr.slice(0, SUMMARY_MAX_LENGTH) + "..." };
+    }
+  }
+  return filtered;
+}
+
+// src/debug.ts
+import { appendFileSync, existsSync as existsSync2, mkdirSync, statSync as statSync2, readFileSync as readFileSync3, writeFileSync } from "fs";
+import { join as join2, dirname } from "path";
+import { homedir as homedir2 } from "os";
+var DEBUG_LOG_PATH = join2(homedir2(), ".agentapprove", "hook-debug.log");
+var MAX_SIZE = 5 * 1024 * 1024;
+var KEEP_SIZE = 2 * 1024 * 1024;
+function ensureLogFile() {
+  const dir = dirname(DEBUG_LOG_PATH);
+  if (!existsSync2(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+  if (!existsSync2(DEBUG_LOG_PATH)) {
+    writeFileSync(DEBUG_LOG_PATH, "", { mode: 384 });
+    return;
+  }
+  try {
+    const stat = statSync2(DEBUG_LOG_PATH);
+    if (stat.size > MAX_SIZE) {
+      const content = readFileSync3(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)
+`);
+    }
+  } catch {
+  }
+}
+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}
+`);
+  } catch {
+  }
+}
+
+// src/api-client.ts
+var cachedPluginHash;
+function getPluginHash(pluginPath) {
+  if (!cachedPluginHash) {
+    cachedPluginHash = computePluginHash(pluginPath);
+    if (cachedPluginHash) {
+      debugLog(`Plugin hash computed: ${cachedPluginHash.slice(0, 16)}...`);
+    }
+  }
+  return cachedPluginHash || "";
+}
+function httpPost(url, body, headers, timeoutMs) {
+  return new Promise((resolve, reject) => {
+    const parsed = new URL(url);
+    const isHttps = parsed.protocol === "https:";
+    const reqFn = isHttps ? httpsRequest : httpRequest;
+    const req = reqFn(
+      {
+        hostname: parsed.hostname,
+        port: parsed.port || (isHttps ? 443 : 80),
+        path: parsed.pathname + parsed.search,
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "Content-Length": Buffer.byteLength(body),
+          ...headers
+        },
+        timeout: timeoutMs
+      },
+      (res) => {
+        let data = "";
+        res.on("data", (chunk) => {
+          data += chunk;
+        });
+        res.on("end", () => {
+          resolve({ status: res.statusCode || 0, body: data });
+        });
+      }
+    );
+    req.on("error", reject);
+    req.on("timeout", () => {
+      req.destroy();
+      reject(new Error(`Request timed out after ${timeoutMs}ms`));
+    });
+    req.write(body);
+    req.end();
+  });
+}
+async function sendApprovalRequest(request, config, pluginPath) {
+  if (!config.token) {
+    throw new Error("No Agent Approve token configured");
+  }
+  const filtered = applyPrivacyFilter(request, config.privacyTier);
+  const bodyStr = JSON.stringify(filtered);
+  const pluginHash = getPluginHash(pluginPath);
+  const hmacHeaders = buildHMACHeaders(bodyStr, config.token, config.hookVersion, pluginHash);
+  const headers = {
+    "Authorization": `Bearer ${config.token}`,
+    ...hmacHeaders
+  };
+  const url = `${config.apiUrl}/${config.apiVersion}/approve`;
+  if (config.debug) {
+    debugLog(`Sending approval request to ${url} for tool: ${request.toolName}`);
+  }
+  const response = await httpPost(url, bodyStr, headers, config.timeout * 1e3);
+  if (config.debug) {
+    debugLog(`Response status: ${response.status}, body: ${response.body.slice(0, 200)}`);
+  }
+  if (response.status !== 200) {
+    throw new Error(`API returned status ${response.status}: ${response.body.slice(0, 200)}`);
+  }
+  try {
+    return JSON.parse(response.body);
+  } catch {
+    throw new Error(`Failed to parse API response: ${response.body.slice(0, 200)}`);
+  }
+}
+async function sendEvent(event, config, pluginPath) {
+  if (!config.token) return;
+  try {
+    const bodyStr = JSON.stringify(event);
+    const pluginHash = getPluginHash(pluginPath);
+    const hmacHeaders = buildHMACHeaders(bodyStr, config.token, config.hookVersion, pluginHash);
+    const headers = {
+      "Authorization": `Bearer ${config.token}`,
+      ...hmacHeaders
+    };
+    const url = `${config.apiUrl}/${config.apiVersion}/events`;
+    await httpPost(url, bodyStr, headers, 5e3);
+  } catch {
+    if (config.debug) {
+      debugLog(`Failed to send event: ${JSON.stringify(event).slice(0, 100)}`);
+    }
+  }
+}
+
+// src/index.ts
+var pluginFilePath;
+try {
+  pluginFilePath = fileURLToPath(import.meta.url);
+} catch {
+  pluginFilePath = __filename;
+}
+function classifyTool(toolName) {
+  const lower = toolName.toLowerCase();
+  if (lower === "exec" || lower === "process") {
+    return { toolType: "shell_command", displayName: toolName };
+  }
+  if (lower === "write" || lower === "edit" || lower === "apply_patch") {
+    return { toolType: "file_write", displayName: toolName };
+  }
+  if (lower === "read") {
+    return { toolType: "file_read", displayName: toolName };
+  }
+  if (lower === "browser" || lower.startsWith("browser_")) {
+    return { toolType: "browser", displayName: toolName };
+  }
+  if (lower === "message" || lower === "agent_send") {
+    return { toolType: "message", displayName: toolName };
+  }
+  if (lower === "sessions_spawn" || lower === "sessions_send") {
+    return { toolType: "session", displayName: toolName };
+  }
+  if (lower === "llm_task") {
+    return { toolType: "llm", displayName: toolName };
+  }
+  return { toolType: "tool_use", displayName: toolName };
+}
+function extractCommand(toolName, params) {
+  const lower = toolName.toLowerCase();
+  if (lower === "exec" || lower === "process") {
+    return params.command || void 0;
+  }
+  if (lower === "write" || lower === "edit") {
+    return params.file_path || params.path || void 0;
+  }
+  if (lower === "read") {
+    return params.file_path || params.path || void 0;
+  }
+  if (lower === "apply_patch") {
+    return "apply_patch";
+  }
+  return void 0;
+}
+function handleFailBehavior(config, error, toolName, logger) {
+  logger.warn(`Agent Approve API error for tool "${toolName}": ${error.message}`);
+  debugLog(`API error: ${error.message}, failBehavior: ${config.failBehavior}`);
+  switch (config.failBehavior) {
+    case "deny":
+      return { block: true, blockReason: "Agent Approve unavailable, denying by policy" };
+    case "allow":
+      return void 0;
+    // Don't block
+    case "ask":
+    default:
+      return void 0;
+  }
+}
+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;
+  }
+  api.logger.info(`Agent Approve: Plugin loaded (privacy: ${config.privacyTier}, fail: ${config.failBehavior})`);
+  debugLog(`Plugin loaded, API: ${config.apiUrl}, agent: ${config.agentName}`);
+  api.on("before_tool_call", async (event, ctx) => {
+    const { toolType, displayName } = classifyTool(event.toolName);
+    const command = extractCommand(event.toolName, event.params);
+    const request = {
+      toolName: displayName,
+      toolType,
+      command,
+      toolInput: event.params,
+      agent: config.agentName,
+      hookType: "before_tool_call",
+      cwd: event.params.workdir || void 0,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    try {
+      const response = await sendApprovalRequest(request, config, pluginFilePath);
+      if (response.decision === "approve") {
+        debugLog(`Tool "${event.toolName}" approved${response.reason ? ": " + response.reason : ""}`);
+        return void 0;
+      }
+      debugLog(`Tool "${event.toolName}" denied${response.reason ? ": " + response.reason : ""}`);
+      return {
+        block: true,
+        blockReason: response.reason || "Denied by Agent Approve"
+      };
+    } catch (error) {
+      return handleFailBehavior(
+        config,
+        error instanceof Error ? error : new Error(String(error)),
+        event.toolName,
+        api.logger
+      );
+    }
+  });
+  api.on("after_tool_call", async (event, _ctx) => {
+    const { toolType } = classifyTool(event.toolName);
+    void sendEvent({
+      toolName: event.toolName,
+      toolType,
+      agent: config.agentName,
+      hookType: "after_tool_call",
+      status: event.error ? "error" : "success",
+      error: event.error,
+      durationMs: event.durationMs,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    }, config, pluginFilePath);
+  });
+  api.registerHook(
+    ["command:new", "command:stop", "command:reset"],
+    async (event) => {
+      void sendEvent({
+        toolName: `command:${event.action}`,
+        toolType: "command",
+        agent: config.agentName,
+        hookType: "command_event",
+        timestamp: event.timestamp.toISOString(),
+        metadata: { sessionKey: event.sessionKey, action: event.action }
+      }, config, pluginFilePath);
+    },
+    { name: "agentapprove-command-monitor", description: "Log command events to Agent Approve" }
+  );
+  api.registerHook(
+    ["message:received", "message:sent"],
+    async (event) => {
+      const direction = event.action === "received" ? "inbound" : "outbound";
+      const payload = {
+        toolName: `message:${event.action}`,
+        toolType: "message_event",
+        agent: config.agentName,
+        hookType: "session_event",
+        timestamp: event.timestamp.toISOString(),
+        metadata: {
+          direction,
+          channelId: event.context.channelId,
+          sessionKey: event.sessionKey
+        }
+      };
+      if (config.privacyTier === "full" && event.context.content) {
+        payload.metadata.contentPreview = event.context.content.slice(0, 100);
+      }
+      void sendEvent(payload, config, pluginFilePath);
+    },
+    { name: "agentapprove-session-monitor", description: "Log message events to Agent Approve" }
+  );
+  api.logger.info("Agent Approve: Registered before_tool_call, after_tool_call, and event monitoring hooks");
+}
+var index_default = {
+  id: "agentapprove",
+  name: "Agent Approve",
+  description: "Mobile approval for AI agent tool execution",
+  register
+};
+export {
+  index_default as default,
+  register
+};

package/openclaw.plugin.json

@@ -0,0 +1,49 @@
+{
+  "id": "agentapprove",
+  "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.0",
+  "homepage": "https://agentapprove.com",
+  "configSchema": {
+    "type": "object",
+    "additionalProperties": false,
+    "properties": {
+      "apiUrl": {
+        "type": "string",
+        "description": "Agent Approve API URL",
+        "default": "https://api.agentapprove.com"
+      },
+      "timeout": {
+        "type": "number",
+        "description": "Max seconds to wait for approval response",
+        "default": 300,
+        "minimum": 10,
+        "maximum": 600
+      },
+      "failBehavior": {
+        "type": "string",
+        "description": "Action when API is unreachable",
+        "enum": ["allow", "deny", "ask"],
+        "default": "ask"
+      },
+      "privacyTier": {
+        "type": "string",
+        "description": "What tool data to send to the API",
+        "enum": ["minimal", "summary", "full"],
+        "default": "full"
+      },
+      "debug": {
+        "type": "boolean",
+        "description": "Enable debug logging to ~/.agentapprove/hook-debug.log",
+        "default": false
+      }
+    }
+  },
+  "uiHints": {
+    "apiUrl": { "label": "API URL", "placeholder": "https://api.agentapprove.com" },
+    "timeout": { "label": "Approval Timeout (seconds)" },
+    "failBehavior": { "label": "On API Error" },
+    "privacyTier": { "label": "Privacy Tier" },
+    "debug": { "label": "Debug Logging" }
+  }
+}

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@agentapprove/openclaw",
+  "version": "0.1.0",
+  "description": "Agent Approve plugin for OpenClaw - approve or deny AI agent tool calls from your iPhone and Apple Watch",
+  "main": "dist/index.js",
+  "scripts": {
+    "build": "esbuild src/index.ts --bundle --platform=node --target=node18 --outfile=dist/index.js --format=esm --external:crypto --external:fs --external:path --external:os --external:https --external:http --external:url --external:child_process",
+    "hash": "shasum -a 256 dist/index.js | cut -d' ' -f1",
+    "dev": "esbuild src/index.ts --bundle --platform=node --target=node18 --outfile=dist/index.js --format=esm --external:crypto --external:fs --external:path --external:os --external:https --external:http --external:url --external:child_process --watch"
+  },
+  "openclaw": {
+    "extensions": ["./dist/index.js"]
+  },
+  "files": [
+    "dist/",
+    "openclaw.plugin.json",
+    "README.md"
+  ],
+  "keywords": [
+    "openclaw",
+    "agentapprove",
+    "agent-approve",
+    "approval",
+    "governance",
+    "ai-safety",
+    "iphone",
+    "apple-watch",
+    "tool-approval"
+  ],
+  "author": "Agent Approve LLC <hello@agentapprove.com> (https://agentapprove.com)",
+  "license": "SEE LICENSE IN LICENSE",
+  "homepage": "https://www.agentapprove.com",
+  "bugs": {
+    "url": "https://github.com/agentapprove/support/issues"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "devDependencies": {
+    "esbuild": "^0.24.0",
+    "typescript": "^5.0.0"
+  }
+}