@contextstream/mcp-server 0.4.63 → 0.4.65

package/README.md

@@ -84,7 +84,7 @@ npx @contextstream/mcp-server@latest setup
 
 The wizard handles everything: authentication, configuration, editor integration, and optional hooks that supercharge your workflow.
 
-**Works with:** Claude Code • Cursor • VS Code • Claude Desktop • Codex CLI • Antigravity
+**Works with:** Claude Code • Cursor • VS Code • Claude Desktop • Codex CLI • OpenCode • Antigravity
 
 ---
 
@@ -139,6 +139,48 @@ claude mcp update contextstream -e CONTEXTSTREAM_API_KEY=your_key
 
 </details>
 
+<details>
+<summary><b>OpenCode</b></summary>
+
+Local server:
+
+```json
+{
+  "$schema": "https://opencode.ai/config.json",
+  "mcp": {
+    "contextstream": {
+      "type": "local",
+      "command": ["npx", "-y", "contextstream-mcp"],
+      "environment": {
+        "CONTEXTSTREAM_API_KEY": "{env:CONTEXTSTREAM_API_KEY}"
+      },
+      "enabled": true
+    }
+  }
+}
+```
+
+Remote server:
+
+```json
+{
+  "$schema": "https://opencode.ai/config.json",
+  "mcp": {
+    "contextstream": {
+      "type": "remote",
+      "url": "https://mcp.contextstream.com",
+      "enabled": true
+    }
+  }
+}
+```
+
+For the local variant, export `CONTEXTSTREAM_API_KEY` before launching OpenCode.
+
+**Locations:** `./opencode.json` • `~/.config/opencode/opencode.json`
+
+</details>
+
 <details>
 <summary><b>VS Code</b></summary>
 

package/dist/hooks/auto-rules.js

@@ -994,6 +994,7 @@ function detectLanguage(filePath) {
     swift: "swift",
     scala: "scala",
     sql: "sql",
+    dart: "dart",
     md: "markdown",
     json: "json",
     yaml: "yaml",
@@ -1105,7 +1106,9 @@ var init_files = __esm({
       // Other
       "graphql",
       "proto",
-      "dockerfile"
+      "dockerfile",
+      // Dart/Flutter
+      "dart"
     ]);
     IGNORE_DIRS = /* @__PURE__ */ new Set([
       "node_modules",
@@ -1264,7 +1267,7 @@ function buildHooksConfig(options) {
       ]
     });
   }
-  if (options?.includeMediaAware !== false) {
+  if (options?.includeMediaAware === true) {
     userPromptHooks.push({
       matcher: "*",
       hooks: [
@@ -1279,7 +1282,7 @@ function buildHooksConfig(options) {
   const config = {
     PreToolUse: [
       {
-        matcher: "Glob|Grep|Search|Task|EnterPlanMode",
+        matcher: "*",
         hooks: [
           {
             type: "command",
@@ -1308,12 +1311,12 @@ function buildHooksConfig(options) {
   if (options?.includeSessionInit !== false) {
     config.SessionStart = [
       {
-        matcher: "*",
+        matcher: "startup|resume|compact",
         hooks: [
           {
             type: "command",
-            command: getHookCommand("session-init"),
-            timeout: 10
+            command: getHookCommand("session-start"),
+            timeout: 15
           }
         ]
       }
@@ -1321,6 +1324,18 @@ function buildHooksConfig(options) {
   }
   if (options?.includeSessionEnd !== false) {
     config.Stop = [
+      {
+        matcher: "*",
+        hooks: [
+          {
+            type: "command",
+            command: getHookCommand("stop"),
+            timeout: 15
+          }
+        ]
+      }
+    ];
+    config.SessionEnd = [
       {
         matcher: "*",
         hooks: [
@@ -1346,7 +1361,7 @@ function buildHooksConfig(options) {
       ]
     });
   }
-  if (options?.includeAutoRules !== false) {
+  if (options?.includeAutoRules === true) {
     postToolUseHooks.push({
       matcher: "mcp__contextstream__init|mcp__contextstream__context",
       hooks: [
@@ -1358,7 +1373,7 @@ function buildHooksConfig(options) {
       ]
     });
   }
-  if (options?.includeOnBash !== false) {
+  if (options?.includeOnBash === true) {
     postToolUseHooks.push({
       matcher: "Bash",
       hooks: [
@@ -1370,7 +1385,7 @@ function buildHooksConfig(options) {
       ]
     });
   }
-  if (options?.includeOnTask !== false) {
+  if (options?.includeOnTask === true) {
     postToolUseHooks.push({
       matcher: "Task",
       hooks: [
@@ -1382,7 +1397,7 @@ function buildHooksConfig(options) {
       ]
     });
   }
-  if (options?.includeOnRead !== false) {
+  if (options?.includeOnRead === true) {
     postToolUseHooks.push({
       matcher: "Read|Glob|Grep",
       hooks: [
@@ -1394,7 +1409,7 @@ function buildHooksConfig(options) {
       ]
     });
   }
-  if (options?.includeOnWeb !== false) {
+  if (options?.includeOnWeb === true) {
     postToolUseHooks.push({
       matcher: "WebFetch|WebSearch",
       hooks: [
@@ -1409,6 +1424,48 @@ function buildHooksConfig(options) {
   if (postToolUseHooks.length > 0) {
     config.PostToolUse = postToolUseHooks;
   }
+  config.PostToolUseFailure = [
+    {
+      matcher: "*",
+      hooks: [{ type: "command", command: getHookCommand("post-tool-use-failure"), timeout: 10 }]
+    }
+  ];
+  config.SubagentStart = [
+    {
+      matcher: "Explore|Plan|general-purpose|custom",
+      hooks: [{ type: "command", command: getHookCommand("subagent-start"), timeout: 10 }]
+    }
+  ];
+  config.SubagentStop = [
+    {
+      matcher: "Plan",
+      hooks: [{ type: "command", command: getHookCommand("subagent-stop"), timeout: 15 }]
+    }
+  ];
+  config.TaskCompleted = [
+    {
+      matcher: "*",
+      hooks: [{ type: "command", command: getHookCommand("task-completed"), timeout: 10 }]
+    }
+  ];
+  config.TeammateIdle = [
+    {
+      matcher: "*",
+      hooks: [{ type: "command", command: getHookCommand("teammate-idle"), timeout: 10 }]
+    }
+  ];
+  config.Notification = [
+    {
+      matcher: "*",
+      hooks: [{ type: "command", command: getHookCommand("notification"), timeout: 10 }]
+    }
+  ];
+  config.PermissionRequest = [
+    {
+      matcher: "*",
+      hooks: [{ type: "command", command: getHookCommand("permission-request"), timeout: 10 }]
+    }
+  ];
   return config;
 }
 async function installHookScripts(options) {
@@ -1462,18 +1519,29 @@ async function installClaudeCodeHooks(options) {
   const result = { scripts: [], settings: [] };
   result.scripts.push(
     getHookCommand("pre-tool-use"),
-    getHookCommand("user-prompt-submit")
+    getHookCommand("user-prompt-submit"),
+    getHookCommand("on-save-intent"),
+    getHookCommand("session-start"),
+    getHookCommand("stop"),
+    getHookCommand("session-end"),
+    getHookCommand("post-tool-use-failure"),
+    getHookCommand("subagent-start"),
+    getHookCommand("subagent-stop"),
+    getHookCommand("task-completed"),
+    getHookCommand("teammate-idle"),
+    getHookCommand("notification"),
+    getHookCommand("permission-request")
   );
   if (options.includePreCompact !== false) {
     result.scripts.push(getHookCommand("pre-compact"));
   }
-  if (options.includeMediaAware !== false) {
+  if (options.includeMediaAware === true) {
     result.scripts.push(getHookCommand("media-aware"));
   }
   if (options.includePostWrite !== false) {
     result.scripts.push(getHookCommand("post-write"));
   }
-  if (options.includeAutoRules !== false) {
+  if (options.includeAutoRules === true) {
     result.scripts.push(getHookCommand("auto-rules"));
   }
   const hooksConfig = buildHooksConfig({
@@ -1511,8 +1579,8 @@ All hooks run via Node.js - no Python dependency required.
 
 ### PreToolUse Hook
 - **Command:** \`npx @contextstream/mcp-server hook pre-tool-use\`
-- **Purpose:** Blocks Glob/Grep/Search/EnterPlanMode and redirects to ContextStream
-- **Blocked tools:** Glob, Grep, Search, Task(Explore), Task(Plan), EnterPlanMode
+- **Purpose:** Blocks Glob/Grep/Search/Explore/Task/EnterPlanMode and redirects to ContextStream
+- **Blocked tools:** Glob, Grep, Search, Explore, Task(Explore), Task(Plan), EnterPlanMode
 - **Disable:** Set \`CONTEXTSTREAM_HOOK_ENABLED=false\` environment variable
 
 ### UserPromptSubmit Hook
@@ -1565,7 +1633,7 @@ If you prefer to configure manually, add to \`~/.claude/settings.json\`:
 {
   "hooks": {
     "PreToolUse": [{
-      "matcher": "Glob|Grep|Search|Task|EnterPlanMode",
+      "matcher": "Glob|Grep|Search|Explore|Task|EnterPlanMode",
       "hooks": [{"type": "command", "command": "npx @contextstream/mcp-server hook pre-tool-use"}]
     }],
     "UserPromptSubmit": [
@@ -1790,6 +1858,7 @@ async function installCursorHookScripts(options) {
   const filteredBeforeSubmit = filterContextStreamHooks(existingConfig.hooks.beforeSubmitPrompt);
   const preToolUseCommand = getHookCommand("pre-tool-use");
   const userPromptCommand = getHookCommand("user-prompt-submit");
+  const saveIntentCommand = getHookCommand("on-save-intent");
   const config = {
     version: 1,
     hooks: {
@@ -1799,8 +1868,7 @@ async function installCursorHookScripts(options) {
         {
           command: preToolUseCommand,
           type: "command",
-          timeout: 5,
-          matcher: { tool_name: "Glob|Grep|search_files|list_files|ripgrep" }
+          timeout: 5
         }
       ],
       beforeSubmitPrompt: [
@@ -1809,6 +1877,11 @@ async function installCursorHookScripts(options) {
           command: userPromptCommand,
           type: "command",
           timeout: 5
+        },
+        {
+          command: saveIntentCommand,
+          type: "command",
+          timeout: 5
         }
       ]
     }
@@ -1817,7 +1890,7 @@ async function installCursorHookScripts(options) {
   const configPath = getCursorHooksConfigPath(options.scope, options.projectPath);
   return {
     preToolUse: preToolUseCommand,
-    beforeSubmitPrompt: userPromptCommand,
+    beforeSubmitPrompt: `${userPromptCommand}, ${saveIntentCommand}`,
     config: configPath
   };
 }
@@ -1973,7 +2046,7 @@ var init_hooks_config = __esm({
     PRETOOLUSE_HOOK_SCRIPT = `#!/usr/bin/env python3
 """
 ContextStream PreToolUse Hook for Claude Code
-Blocks Grep/Glob/Search/Task(Explore)/EnterPlanMode and redirects to ContextStream.
+Blocks Grep/Glob/Search/Explore/Task(Explore|Plan)/EnterPlanMode and redirects to ContextStream.
 
 Only blocks if the current project is indexed in ContextStream.
 If not indexed, allows local tools through with a suggestion to index.
@@ -2092,12 +2165,18 @@ def main():
                 print(f"STOP: Use mcp__contextstream__search(mode=\\"auto\\", query=\\"{pattern}\\") instead of {tool}.", file=sys.stderr)
             sys.exit(2)
 
+    elif tool == "Explore":
+        print("STOP: Use mcp__contextstream__search(mode=\\"auto\\", output_format=\\"paths\\") instead of Explore.", file=sys.stderr)
+        sys.exit(2)
+
     elif tool == "Task":
-        if inp.get("subagent_type", "").lower() == "explore":
+        subagent = inp.get("subagent_type", "") or inp.get("subagentType", "")
+        subagent = subagent.lower()
+        if "explore" in subagent:
             print("STOP: Use mcp__contextstream__search(mode=\\"auto\\") instead of Task(Explore).", file=sys.stderr)
             sys.exit(2)
-        if inp.get("subagent_type", "").lower() == "plan":
-            print("STOP: Use mcp__contextstream__session(action=\\"capture_plan\\") for planning. ContextStream plans persist across sessions.", file=sys.stderr)
+        if "plan" in subagent:
+            print("STOP: For planning, use mcp__contextstream__search(mode=\\"auto\\", output_format=\\"paths\\") for discovery and mcp__contextstream__session(action=\\"capture_plan\\") for persistence.", file=sys.stderr)
             sys.exit(2)
 
     elif tool == "EnterPlanMode":

package/dist/hooks/notification.js

@@ -0,0 +1,162 @@
+#!/usr/bin/env node
+
+// src/hooks/common.ts
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { homedir } from "node:os";
+var DEFAULT_API_URL = "https://api.contextstream.io";
+var HOOK_SPECIFIC_OUTPUT_EVENTS = /* @__PURE__ */ new Set(["PreToolUse", "UserPromptSubmit", "PostToolUse"]);
+function readHookInput() {
+  try {
+    return JSON.parse(fs.readFileSync(0, "utf8"));
+  } catch {
+    return {};
+  }
+}
+function writeHookOutput(output) {
+  const eventName = output?.hookEventName || (typeof process.env.HOOK_EVENT_NAME === "string" ? process.env.HOOK_EVENT_NAME.trim() : "");
+  const canUseHookSpecificOutput = HOOK_SPECIFIC_OUTPUT_EVENTS.has(eventName);
+  const payload = output && (output.additionalContext || output.blocked || output.reason) ? {
+    hookSpecificOutput: output.additionalContext && canUseHookSpecificOutput ? {
+      hookEventName: eventName,
+      additionalContext: output.additionalContext
+    } : void 0,
+    additionalContext: output.additionalContext,
+    blocked: output.blocked,
+    reason: output.reason
+  } : {};
+  console.log(JSON.stringify(payload));
+}
+function extractCwd(input) {
+  const cwd = typeof input.cwd === "string" && input.cwd.trim() ? input.cwd.trim() : process.cwd();
+  return cwd;
+}
+function loadHookConfig(cwd) {
+  let apiUrl = process.env.CONTEXTSTREAM_API_URL || DEFAULT_API_URL;
+  let apiKey = process.env.CONTEXTSTREAM_API_KEY || "";
+  let jwt = process.env.CONTEXTSTREAM_JWT || "";
+  let workspaceId = process.env.CONTEXTSTREAM_WORKSPACE_ID || null;
+  let projectId = process.env.CONTEXTSTREAM_PROJECT_ID || null;
+  let searchDir = path.resolve(cwd);
+  for (let i = 0; i < 6; i++) {
+    if (!apiKey && !jwt) {
+      const mcpPath = path.join(searchDir, ".mcp.json");
+      if (fs.existsSync(mcpPath)) {
+        try {
+          const config = JSON.parse(fs.readFileSync(mcpPath, "utf8"));
+          const env = config.mcpServers?.contextstream?.env;
+          if (env?.CONTEXTSTREAM_API_KEY) apiKey = env.CONTEXTSTREAM_API_KEY;
+          if (env?.CONTEXTSTREAM_JWT) jwt = env.CONTEXTSTREAM_JWT;
+          if (env?.CONTEXTSTREAM_API_URL) apiUrl = env.CONTEXTSTREAM_API_URL;
+          if (env?.CONTEXTSTREAM_WORKSPACE_ID && !workspaceId) workspaceId = env.CONTEXTSTREAM_WORKSPACE_ID;
+          if (env?.CONTEXTSTREAM_PROJECT_ID && !projectId) projectId = env.CONTEXTSTREAM_PROJECT_ID;
+        } catch {
+        }
+      }
+    }
+    if (!workspaceId || !projectId) {
+      const localConfigPath = path.join(searchDir, ".contextstream", "config.json");
+      if (fs.existsSync(localConfigPath)) {
+        try {
+          const localConfig = JSON.parse(fs.readFileSync(localConfigPath, "utf8"));
+          if (localConfig.workspace_id && !workspaceId) workspaceId = localConfig.workspace_id;
+          if (localConfig.project_id && !projectId) projectId = localConfig.project_id;
+        } catch {
+        }
+      }
+    }
+    const parentDir = path.dirname(searchDir);
+    if (parentDir === searchDir) break;
+    searchDir = parentDir;
+  }
+  if (!apiKey && !jwt) {
+    const homeMcpPath = path.join(homedir(), ".mcp.json");
+    if (fs.existsSync(homeMcpPath)) {
+      try {
+        const config = JSON.parse(fs.readFileSync(homeMcpPath, "utf8"));
+        const env = config.mcpServers?.contextstream?.env;
+        if (env?.CONTEXTSTREAM_API_KEY) apiKey = env.CONTEXTSTREAM_API_KEY;
+        if (env?.CONTEXTSTREAM_JWT) jwt = env.CONTEXTSTREAM_JWT;
+        if (env?.CONTEXTSTREAM_API_URL) apiUrl = env.CONTEXTSTREAM_API_URL;
+      } catch {
+      }
+    }
+  }
+  return { apiUrl, apiKey, jwt, workspaceId, projectId };
+}
+function isConfigured(config) {
+  return Boolean(config.apiKey || config.jwt);
+}
+function authHeaders(config) {
+  if (config.apiKey) {
+    return { "X-API-Key": config.apiKey };
+  }
+  if (config.jwt) {
+    return { Authorization: `Bearer ${config.jwt}` };
+  }
+  return {};
+}
+async function apiRequest(config, apiPath, init = {}) {
+  const response = await fetch(`${config.apiUrl}${apiPath}`, {
+    method: init.method || "GET",
+    headers: {
+      "Content-Type": "application/json",
+      ...authHeaders(config)
+    },
+    body: init.body !== void 0 ? JSON.stringify(init.body) : void 0
+  });
+  if (!response.ok) {
+    throw new Error(`${response.status} ${response.statusText}`);
+  }
+  const json = await response.json();
+  if (json && typeof json === "object" && "data" in json) {
+    return json.data;
+  }
+  return json;
+}
+async function postMemoryEvent(config, title, content, tags, eventType = "operation") {
+  if (!isConfigured(config) || !config.workspaceId) return;
+  await apiRequest(config, "/memory/events", {
+    method: "POST",
+    body: {
+      workspace_id: config.workspaceId,
+      project_id: config.projectId || void 0,
+      event_type: eventType,
+      title,
+      content: typeof content === "string" ? content : JSON.stringify(content),
+      metadata: {
+        tags,
+        source: "mcp_hook",
+        captured_at: (/* @__PURE__ */ new Date()).toISOString()
+      }
+    }
+  });
+}
+
+// src/hooks/notification.ts
+async function runNotificationHook() {
+  const input = readHookInput();
+  const cwd = extractCwd(input);
+  const config = loadHookConfig(cwd);
+  if (isConfigured(config)) {
+    const message = typeof input.title === "string" && input.title || typeof input.message === "string" && input.message || "Notification event";
+    await postMemoryEvent(
+      config,
+      `Notification: ${message}`,
+      {
+        notification: input,
+        captured_at: (/* @__PURE__ */ new Date()).toISOString()
+      },
+      ["hook", "notification"]
+    ).catch(() => {
+    });
+  }
+  writeHookOutput();
+}
+var isDirectRun = process.argv[1]?.includes("notification") || process.argv[2] === "notification";
+if (isDirectRun) {
+  runNotificationHook().catch(() => process.exit(0));
+}
+export {
+  runNotificationHook
+};

package/dist/hooks/permission-request.js

@@ -0,0 +1,174 @@
+#!/usr/bin/env node
+
+// src/hooks/common.ts
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { homedir } from "node:os";
+var DEFAULT_API_URL = "https://api.contextstream.io";
+var HOOK_SPECIFIC_OUTPUT_EVENTS = /* @__PURE__ */ new Set(["PreToolUse", "UserPromptSubmit", "PostToolUse"]);
+function readHookInput() {
+  try {
+    return JSON.parse(fs.readFileSync(0, "utf8"));
+  } catch {
+    return {};
+  }
+}
+function writeHookOutput(output) {
+  const eventName = output?.hookEventName || (typeof process.env.HOOK_EVENT_NAME === "string" ? process.env.HOOK_EVENT_NAME.trim() : "");
+  const canUseHookSpecificOutput = HOOK_SPECIFIC_OUTPUT_EVENTS.has(eventName);
+  const payload = output && (output.additionalContext || output.blocked || output.reason) ? {
+    hookSpecificOutput: output.additionalContext && canUseHookSpecificOutput ? {
+      hookEventName: eventName,
+      additionalContext: output.additionalContext
+    } : void 0,
+    additionalContext: output.additionalContext,
+    blocked: output.blocked,
+    reason: output.reason
+  } : {};
+  console.log(JSON.stringify(payload));
+}
+function extractCwd(input) {
+  const cwd = typeof input.cwd === "string" && input.cwd.trim() ? input.cwd.trim() : process.cwd();
+  return cwd;
+}
+function loadHookConfig(cwd) {
+  let apiUrl = process.env.CONTEXTSTREAM_API_URL || DEFAULT_API_URL;
+  let apiKey = process.env.CONTEXTSTREAM_API_KEY || "";
+  let jwt = process.env.CONTEXTSTREAM_JWT || "";
+  let workspaceId = process.env.CONTEXTSTREAM_WORKSPACE_ID || null;
+  let projectId = process.env.CONTEXTSTREAM_PROJECT_ID || null;
+  let searchDir = path.resolve(cwd);
+  for (let i = 0; i < 6; i++) {
+    if (!apiKey && !jwt) {
+      const mcpPath = path.join(searchDir, ".mcp.json");
+      if (fs.existsSync(mcpPath)) {
+        try {
+          const config = JSON.parse(fs.readFileSync(mcpPath, "utf8"));
+          const env = config.mcpServers?.contextstream?.env;
+          if (env?.CONTEXTSTREAM_API_KEY) apiKey = env.CONTEXTSTREAM_API_KEY;
+          if (env?.CONTEXTSTREAM_JWT) jwt = env.CONTEXTSTREAM_JWT;
+          if (env?.CONTEXTSTREAM_API_URL) apiUrl = env.CONTEXTSTREAM_API_URL;
+          if (env?.CONTEXTSTREAM_WORKSPACE_ID && !workspaceId) workspaceId = env.CONTEXTSTREAM_WORKSPACE_ID;
+          if (env?.CONTEXTSTREAM_PROJECT_ID && !projectId) projectId = env.CONTEXTSTREAM_PROJECT_ID;
+        } catch {
+        }
+      }
+    }
+    if (!workspaceId || !projectId) {
+      const localConfigPath = path.join(searchDir, ".contextstream", "config.json");
+      if (fs.existsSync(localConfigPath)) {
+        try {
+          const localConfig = JSON.parse(fs.readFileSync(localConfigPath, "utf8"));
+          if (localConfig.workspace_id && !workspaceId) workspaceId = localConfig.workspace_id;
+          if (localConfig.project_id && !projectId) projectId = localConfig.project_id;
+        } catch {
+        }
+      }
+    }
+    const parentDir = path.dirname(searchDir);
+    if (parentDir === searchDir) break;
+    searchDir = parentDir;
+  }
+  if (!apiKey && !jwt) {
+    const homeMcpPath = path.join(homedir(), ".mcp.json");
+    if (fs.existsSync(homeMcpPath)) {
+      try {
+        const config = JSON.parse(fs.readFileSync(homeMcpPath, "utf8"));
+        const env = config.mcpServers?.contextstream?.env;
+        if (env?.CONTEXTSTREAM_API_KEY) apiKey = env.CONTEXTSTREAM_API_KEY;
+        if (env?.CONTEXTSTREAM_JWT) jwt = env.CONTEXTSTREAM_JWT;
+        if (env?.CONTEXTSTREAM_API_URL) apiUrl = env.CONTEXTSTREAM_API_URL;
+      } catch {
+      }
+    }
+  }
+  return { apiUrl, apiKey, jwt, workspaceId, projectId };
+}
+function isConfigured(config) {
+  return Boolean(config.apiKey || config.jwt);
+}
+function authHeaders(config) {
+  if (config.apiKey) {
+    return { "X-API-Key": config.apiKey };
+  }
+  if (config.jwt) {
+    return { Authorization: `Bearer ${config.jwt}` };
+  }
+  return {};
+}
+async function apiRequest(config, apiPath, init = {}) {
+  const response = await fetch(`${config.apiUrl}${apiPath}`, {
+    method: init.method || "GET",
+    headers: {
+      "Content-Type": "application/json",
+      ...authHeaders(config)
+    },
+    body: init.body !== void 0 ? JSON.stringify(init.body) : void 0
+  });
+  if (!response.ok) {
+    throw new Error(`${response.status} ${response.statusText}`);
+  }
+  const json = await response.json();
+  if (json && typeof json === "object" && "data" in json) {
+    return json.data;
+  }
+  return json;
+}
+async function postMemoryEvent(config, title, content, tags, eventType = "operation") {
+  if (!isConfigured(config) || !config.workspaceId) return;
+  await apiRequest(config, "/memory/events", {
+    method: "POST",
+    body: {
+      workspace_id: config.workspaceId,
+      project_id: config.projectId || void 0,
+      event_type: eventType,
+      title,
+      content: typeof content === "string" ? content : JSON.stringify(content),
+      metadata: {
+        tags,
+        source: "mcp_hook",
+        captured_at: (/* @__PURE__ */ new Date()).toISOString()
+      }
+    }
+  });
+}
+
+// src/hooks/permission-request.ts
+function isHighRiskCommand(command) {
+  const lower = command.toLowerCase();
+  return ["rm -rf", "git reset --hard", "mkfs", "dd if=", "shutdown", "reboot"].some(
+    (pattern) => lower.includes(pattern)
+  );
+}
+async function runPermissionRequestHook() {
+  const input = readHookInput();
+  const cwd = extractCwd(input);
+  const config = loadHookConfig(cwd);
+  const command = typeof input.command === "string" && input.command || typeof input.cmd === "string" && input.cmd || "";
+  if (isConfigured(config)) {
+    await postMemoryEvent(
+      config,
+      "Permission request",
+      {
+        request: input,
+        captured_at: (/* @__PURE__ */ new Date()).toISOString()
+      },
+      ["hook", "permission_request"]
+    ).catch(() => {
+    });
+  }
+  if (isHighRiskCommand(command)) {
+    writeHookOutput({
+      additionalContext: "High-risk command detected. Confirm scope and prefer least-privilege execution."
+    });
+    return;
+  }
+  writeHookOutput();
+}
+var isDirectRun = process.argv[1]?.includes("permission-request") || process.argv[2] === "permission-request";
+if (isDirectRun) {
+  runPermissionRequestHook().catch(() => process.exit(0));
+}
+export {
+  runPermissionRequestHook
+};