@xelauvas/xela-cli 0.1.0

package/src/components/permissions/WebFetchPermissionRequest/WebFetchPermissionRequest.tsx

@@ -0,0 +1,258 @@
+import { c as _c } from "react/compiler-runtime";
+import React, { useMemo } from 'react';
+import { Box, Text, useTheme } from '../../../ink.js';
+import { WebFetchTool } from '../../../tools/WebFetchTool/WebFetchTool.js';
+import { shouldShowAlwaysAllowOptions } from '../../../utils/permissions/permissionsLoader.js';
+import { type OptionWithDescription, Select } from '../../CustomSelect/select.js';
+import { type UnaryEvent, usePermissionRequestLogging } from '../hooks.js';
+import { PermissionDialog } from '../PermissionDialog.js';
+import type { PermissionRequestProps } from '../PermissionRequest.js';
+import { PermissionRuleExplanation } from '../PermissionRuleExplanation.js';
+import { logUnaryPermissionEvent } from '../utils.js';
+function inputToPermissionRuleContent(input: {
+  [k: string]: unknown;
+}): string {
+  try {
+    const parsedInput = WebFetchTool.inputSchema.safeParse(input);
+    if (!parsedInput.success) {
+      return `input:${input.toString()}`;
+    }
+    const {
+      url
+    } = parsedInput.data;
+    const hostname = new URL(url).hostname;
+    return `domain:${hostname}`;
+  } catch {
+    return `input:${input.toString()}`;
+  }
+}
+export function WebFetchPermissionRequest(t0) {
+  const $ = _c(41);
+  const {
+    toolUseConfirm,
+    onDone,
+    onReject,
+    verbose,
+    workerBadge
+  } = t0;
+  const [theme] = useTheme();
+  const {
+    url
+  } = toolUseConfirm.input as {
+    url: string;
+  };
+  let t1;
+  if ($[0] !== url) {
+    t1 = new URL(url);
+    $[0] = url;
+    $[1] = t1;
+  } else {
+    t1 = $[1];
+  }
+  const hostname = t1.hostname;
+  let t2;
+  if ($[2] === Symbol.for("react.memo_cache_sentinel")) {
+    t2 = {
+      completion_type: "tool_use_single",
+      language_name: "none"
+    };
+    $[2] = t2;
+  } else {
+    t2 = $[2];
+  }
+  const unaryEvent = t2;
+  usePermissionRequestLogging(toolUseConfirm, unaryEvent);
+  let t3;
+  if ($[3] === Symbol.for("react.memo_cache_sentinel")) {
+    t3 = shouldShowAlwaysAllowOptions();
+    $[3] = t3;
+  } else {
+    t3 = $[3];
+  }
+  const showAlwaysAllowOptions = t3;
+  let t4;
+  if ($[4] === Symbol.for("react.memo_cache_sentinel")) {
+    t4 = {
+      label: "Yes",
+      value: "yes"
+    };
+    $[4] = t4;
+  } else {
+    t4 = $[4];
+  }
+  let result;
+  if ($[5] !== hostname) {
+    result = [t4];
+    if (showAlwaysAllowOptions) {
+      const t5 = <Text bold={true}>{hostname}</Text>;
+      let t6;
+      if ($[7] !== t5) {
+        t6 = {
+          label: <Text>Yes, and don't ask again for {t5}</Text>,
+          value: "yes-dont-ask-again-domain"
+        };
+        $[7] = t5;
+        $[8] = t6;
+      } else {
+        t6 = $[8];
+      }
+      result.push(t6);
+    }
+    let t5;
+    if ($[9] === Symbol.for("react.memo_cache_sentinel")) {
+      t5 = {
+        label: <Text>No, and tell Claude what to do differently <Text bold={true}>(esc)</Text></Text>,
+        value: "no"
+      };
+      $[9] = t5;
+    } else {
+      t5 = $[9];
+    }
+    result.push(t5);
+    $[5] = hostname;
+    $[6] = result;
+  } else {
+    result = $[6];
+  }
+  const options = result;
+  let t5;
+  if ($[10] !== onDone || $[11] !== onReject || $[12] !== toolUseConfirm) {
+    t5 = function onChange(newValue) {
+      bb8: switch (newValue) {
+        case "yes":
+          {
+            logUnaryPermissionEvent("tool_use_single", toolUseConfirm, "accept");
+            toolUseConfirm.onAllow(toolUseConfirm.input, []);
+            onDone();
+            break bb8;
+          }
+        case "yes-dont-ask-again-domain":
+          {
+            logUnaryPermissionEvent("tool_use_single", toolUseConfirm, "accept");
+            const ruleContent = inputToPermissionRuleContent(toolUseConfirm.input);
+            const ruleValue = {
+              toolName: toolUseConfirm.tool.name,
+              ruleContent
+            };
+            toolUseConfirm.onAllow(toolUseConfirm.input, [{
+              type: "addRules",
+              rules: [ruleValue],
+              behavior: "allow",
+              destination: "localSettings"
+            }]);
+            onDone();
+            break bb8;
+          }
+        case "no":
+          {
+            logUnaryPermissionEvent("tool_use_single", toolUseConfirm, "reject");
+            toolUseConfirm.onReject();
+            onReject();
+            onDone();
+          }
+      }
+    };
+    $[10] = onDone;
+    $[11] = onReject;
+    $[12] = toolUseConfirm;
+    $[13] = t5;
+  } else {
+    t5 = $[13];
+  }
+  const onChange = t5;
+  let t6;
+  if ($[14] !== theme || $[15] !== toolUseConfirm.input || $[16] !== verbose) {
+    t6 = WebFetchTool.renderToolUseMessage(toolUseConfirm.input as {
+      url: string;
+      prompt: string;
+    }, {
+      theme,
+      verbose
+    });
+    $[14] = theme;
+    $[15] = toolUseConfirm.input;
+    $[16] = verbose;
+    $[17] = t6;
+  } else {
+    t6 = $[17];
+  }
+  let t7;
+  if ($[18] !== t6) {
+    t7 = <Text>{t6}</Text>;
+    $[18] = t6;
+    $[19] = t7;
+  } else {
+    t7 = $[19];
+  }
+  let t8;
+  if ($[20] !== toolUseConfirm.description) {
+    t8 = <Text dimColor={true}>{toolUseConfirm.description}</Text>;
+    $[20] = toolUseConfirm.description;
+    $[21] = t8;
+  } else {
+    t8 = $[21];
+  }
+  let t9;
+  if ($[22] !== t7 || $[23] !== t8) {
+    t9 = <Box flexDirection="column" paddingX={2} paddingY={1}>{t7}{t8}</Box>;
+    $[22] = t7;
+    $[23] = t8;
+    $[24] = t9;
+  } else {
+    t9 = $[24];
+  }
+  let t10;
+  if ($[25] !== toolUseConfirm.permissionResult) {
+    t10 = <PermissionRuleExplanation permissionResult={toolUseConfirm.permissionResult} toolType="tool" />;
+    $[25] = toolUseConfirm.permissionResult;
+    $[26] = t10;
+  } else {
+    t10 = $[26];
+  }
+  let t11;
+  if ($[27] === Symbol.for("react.memo_cache_sentinel")) {
+    t11 = <Text>Do you want to allow Claude to fetch this content?</Text>;
+    $[27] = t11;
+  } else {
+    t11 = $[27];
+  }
+  let t12;
+  if ($[28] !== onChange) {
+    t12 = () => onChange("no");
+    $[28] = onChange;
+    $[29] = t12;
+  } else {
+    t12 = $[29];
+  }
+  let t13;
+  if ($[30] !== onChange || $[31] !== options || $[32] !== t12) {
+    t13 = <Select options={options} onChange={onChange} onCancel={t12} />;
+    $[30] = onChange;
+    $[31] = options;
+    $[32] = t12;
+    $[33] = t13;
+  } else {
+    t13 = $[33];
+  }
+  let t14;
+  if ($[34] !== t10 || $[35] !== t13) {
+    t14 = <Box flexDirection="column">{t10}{t11}{t13}</Box>;
+    $[34] = t10;
+    $[35] = t13;
+    $[36] = t14;
+  } else {
+    t14 = $[36];
+  }
+  let t15;
+  if ($[37] !== t14 || $[38] !== t9 || $[39] !== workerBadge) {
+    t15 = <PermissionDialog title="Fetch" workerBadge={workerBadge}>{t9}{t14}</PermissionDialog>;
+    $[37] = t14;
+    $[38] = t9;
+    $[39] = workerBadge;
+    $[40] = t15;
+  } else {
+    t15 = $[40];
+  }
+  return t15;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["React","useMemo","Box","Text","useTheme","WebFetchTool","shouldShowAlwaysAllowOptions","OptionWithDescription","Select","UnaryEvent","usePermissionRequestLogging","PermissionDialog","PermissionRequestProps","PermissionRuleExplanation","logUnaryPermissionEvent","inputToPermissionRuleContent","input","k","parsedInput","inputSchema","safeParse","success","toString","url","data","hostname","URL","WebFetchPermissionRequest","t0","$","_c","toolUseConfirm","onDone","onReject","verbose","workerBadge","theme","t1","t2","Symbol","for","completion_type","language_name","unaryEvent","t3","showAlwaysAllowOptions","t4","label","value","result","t5","t6","push","options","onChange","newValue","bb8","onAllow","ruleContent","ruleValue","toolName","tool","name","type","rules","behavior","destination","renderToolUseMessage","prompt","t7","t8","description","t9","t10","permissionResult","t11","t12","t13","t14","t15"],"sources":["WebFetchPermissionRequest.tsx"],"sourcesContent":["import React, { useMemo } from 'react'\nimport { Box, Text, useTheme } from '../../../ink.js'\nimport { WebFetchTool } from '../../../tools/WebFetchTool/WebFetchTool.js'\nimport { shouldShowAlwaysAllowOptions } from '../../../utils/permissions/permissionsLoader.js'\nimport {\n  type OptionWithDescription,\n  Select,\n} from '../../CustomSelect/select.js'\nimport { type UnaryEvent, usePermissionRequestLogging } from '../hooks.js'\nimport { PermissionDialog } from '../PermissionDialog.js'\nimport type { PermissionRequestProps } from '../PermissionRequest.js'\nimport { PermissionRuleExplanation } from '../PermissionRuleExplanation.js'\nimport { logUnaryPermissionEvent } from '../utils.js'\n\nfunction inputToPermissionRuleContent(input: { [k: string]: unknown }): string {\n  try {\n    const parsedInput = WebFetchTool.inputSchema.safeParse(input)\n    if (!parsedInput.success) {\n      return `input:${input.toString()}`\n    }\n    const { url } = parsedInput.data\n    const hostname = new URL(url).hostname\n    return `domain:${hostname}`\n  } catch {\n    return `input:${input.toString()}`\n  }\n}\n\nexport function WebFetchPermissionRequest({\n  toolUseConfirm,\n  onDone,\n  onReject,\n  verbose,\n  workerBadge,\n}: PermissionRequestProps): React.ReactNode {\n  const [theme] = useTheme()\n  // url is already validated by the input schema\n  const { url } = toolUseConfirm.input as { url: string }\n\n  // Extract hostname from URL\n  const hostname = new URL(url).hostname\n\n  const unaryEvent = useMemo<UnaryEvent>(\n    () => ({ completion_type: 'tool_use_single', language_name: 'none' }),\n    [],\n  )\n\n  usePermissionRequestLogging(toolUseConfirm, unaryEvent)\n\n  // Generate permission options specific to domains\n  const showAlwaysAllowOptions = shouldShowAlwaysAllowOptions()\n  const options = useMemo((): OptionWithDescription<string>[] => {\n    const result: OptionWithDescription<string>[] = [\n      {\n        label: 'Yes',\n        value: 'yes',\n      },\n    ]\n\n    if (showAlwaysAllowOptions) {\n      result.push({\n        label: (\n          <Text>\n            Yes, and don&apos;t ask again for <Text bold>{hostname}</Text>\n          </Text>\n        ),\n        value: 'yes-dont-ask-again-domain',\n      })\n    }\n\n    result.push({\n      label: (\n        <Text>\n          No, and tell Claude what to do differently <Text bold>(esc)</Text>\n        </Text>\n      ),\n      value: 'no',\n    })\n\n    return result\n  }, [hostname, showAlwaysAllowOptions])\n\n  function onChange(newValue: string) {\n    switch (newValue) {\n      case 'yes':\n        logUnaryPermissionEvent('tool_use_single', toolUseConfirm, 'accept')\n        toolUseConfirm.onAllow(toolUseConfirm.input, [])\n        onDone()\n        break\n      case 'yes-dont-ask-again-domain': {\n        logUnaryPermissionEvent('tool_use_single', toolUseConfirm, 'accept')\n        const ruleContent = inputToPermissionRuleContent(toolUseConfirm.input)\n        const ruleValue = {\n          toolName: toolUseConfirm.tool.name,\n          ruleContent,\n        }\n\n        // Pass permission update directly to onAllow\n        toolUseConfirm.onAllow(toolUseConfirm.input, [\n          {\n            type: 'addRules',\n            rules: [ruleValue],\n            behavior: 'allow',\n            destination: 'localSettings',\n          },\n        ])\n        onDone()\n        break\n      }\n      case 'no':\n        logUnaryPermissionEvent('tool_use_single', toolUseConfirm, 'reject')\n        toolUseConfirm.onReject()\n        onReject()\n        onDone()\n        break\n    }\n  }\n\n  return (\n    <PermissionDialog title=\"Fetch\" workerBadge={workerBadge}>\n      <Box flexDirection=\"column\" paddingX={2} paddingY={1}>\n        <Text>\n          {WebFetchTool.renderToolUseMessage(\n            toolUseConfirm.input as { url: string; prompt: string },\n            {\n              theme,\n              verbose,\n            },\n          )}\n        </Text>\n        <Text dimColor>{toolUseConfirm.description}</Text>\n      </Box>\n\n      <Box flexDirection=\"column\">\n        <PermissionRuleExplanation\n          permissionResult={toolUseConfirm.permissionResult}\n          toolType=\"tool\"\n        />\n        <Text>Do you want to allow Claude to fetch this content?</Text>\n        <Select\n          options={options}\n          onChange={onChange}\n          onCancel={() => onChange('no')}\n        />\n      </Box>\n    </PermissionDialog>\n  )\n}\n"],"mappings":"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","ignoreList":[]}

package/src/components/permissions/WorkerBadge.tsx

@@ -0,0 +1,49 @@
+import { c as _c } from "react/compiler-runtime";
+import * as React from 'react';
+import { BLACK_CIRCLE } from '../../constants/figures.js';
+import { Box, Text } from '../../ink.js';
+import { toInkColor } from '../../utils/ink.js';
+export type WorkerBadgeProps = {
+  name: string;
+  color: string;
+};
+
+/**
+ * Renders a colored badge showing the worker's name for permission prompts.
+ * Used to indicate which swarm worker is requesting the permission.
+ */
+export function WorkerBadge(t0) {
+  const $ = _c(7);
+  const {
+    name,
+    color
+  } = t0;
+  let t1;
+  if ($[0] !== color) {
+    t1 = toInkColor(color);
+    $[0] = color;
+    $[1] = t1;
+  } else {
+    t1 = $[1];
+  }
+  const inkColor = t1;
+  let t2;
+  if ($[2] !== name) {
+    t2 = <Text bold={true}>@{name}</Text>;
+    $[2] = name;
+    $[3] = t2;
+  } else {
+    t2 = $[3];
+  }
+  let t3;
+  if ($[4] !== inkColor || $[5] !== t2) {
+    t3 = <Box flexDirection="row" gap={1}><Text color={inkColor}>{BLACK_CIRCLE} {t2}</Text></Box>;
+    $[4] = inkColor;
+    $[5] = t2;
+    $[6] = t3;
+  } else {
+    t3 = $[6];
+  }
+  return t3;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/src/components/permissions/WorkerPendingPermission.tsx

@@ -0,0 +1,105 @@
+import { c as _c } from "react/compiler-runtime";
+import * as React from 'react';
+import { Box, Text } from '../../ink.js';
+import { getAgentName, getTeammateColor, getTeamName } from '../../utils/teammate.js';
+import { Spinner } from '../Spinner.js';
+import { WorkerBadge } from './WorkerBadge.js';
+type Props = {
+  toolName: string;
+  description: string;
+};
+
+/**
+ * Visual indicator shown on workers while waiting for leader to approve a permission request.
+ * Displays the pending tool with a spinner and information about what's being requested.
+ */
+export function WorkerPendingPermission(t0) {
+  const $ = _c(15);
+  const {
+    toolName,
+    description
+  } = t0;
+  let t1;
+  if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
+    t1 = getTeamName();
+    $[0] = t1;
+  } else {
+    t1 = $[0];
+  }
+  const teamName = t1;
+  let t2;
+  if ($[1] === Symbol.for("react.memo_cache_sentinel")) {
+    t2 = getAgentName();
+    $[1] = t2;
+  } else {
+    t2 = $[1];
+  }
+  const agentName = t2;
+  let t3;
+  if ($[2] === Symbol.for("react.memo_cache_sentinel")) {
+    t3 = getTeammateColor();
+    $[2] = t3;
+  } else {
+    t3 = $[2];
+  }
+  const agentColor = t3;
+  let t4;
+  let t5;
+  if ($[3] === Symbol.for("react.memo_cache_sentinel")) {
+    t4 = <Box marginBottom={1}><Spinner /><Text color="warning" bold={true}>{" "}Waiting for team lead approval</Text></Box>;
+    t5 = agentName && agentColor && <Box marginBottom={1}><WorkerBadge name={agentName} color={agentColor} /></Box>;
+    $[3] = t4;
+    $[4] = t5;
+  } else {
+    t4 = $[3];
+    t5 = $[4];
+  }
+  let t6;
+  if ($[5] === Symbol.for("react.memo_cache_sentinel")) {
+    t6 = <Text dimColor={true}>Tool: </Text>;
+    $[5] = t6;
+  } else {
+    t6 = $[5];
+  }
+  let t7;
+  if ($[6] !== toolName) {
+    t7 = <Box>{t6}<Text>{toolName}</Text></Box>;
+    $[6] = toolName;
+    $[7] = t7;
+  } else {
+    t7 = $[7];
+  }
+  let t8;
+  if ($[8] === Symbol.for("react.memo_cache_sentinel")) {
+    t8 = <Text dimColor={true}>Action: </Text>;
+    $[8] = t8;
+  } else {
+    t8 = $[8];
+  }
+  let t9;
+  if ($[9] !== description) {
+    t9 = <Box>{t8}<Text>{description}</Text></Box>;
+    $[9] = description;
+    $[10] = t9;
+  } else {
+    t9 = $[10];
+  }
+  let t10;
+  if ($[11] === Symbol.for("react.memo_cache_sentinel")) {
+    t10 = teamName && <Box marginTop={1}><Text dimColor={true}>Permission request sent to team {"\""}{teamName}{"\""} leader</Text></Box>;
+    $[11] = t10;
+  } else {
+    t10 = $[11];
+  }
+  let t11;
+  if ($[12] !== t7 || $[13] !== t9) {
+    t11 = <Box flexDirection="column" borderStyle="round" borderColor="warning" paddingX={1}>{t4}{t5}{t7}{t9}{t10}</Box>;
+    $[12] = t7;
+    $[13] = t9;
+    $[14] = t11;
+  } else {
+    t11 = $[14];
+  }
+  return t11;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/src/components/permissions/hooks.ts

@@ -0,0 +1,209 @@
+import { feature } from 'bun:bundle'
+import { useEffect, useRef } from 'react'
+import {
+  type AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
+  logEvent,
+} from 'src/services/analytics/index.js'
+import { sanitizeToolNameForAnalytics } from 'src/services/analytics/metadata.js'
+import { BashTool } from 'src/tools/BashTool/BashTool.js'
+import { splitCommand_DEPRECATED } from 'src/utils/bash/commands.js'
+import type {
+  PermissionDecisionReason,
+  PermissionResult,
+} from 'src/utils/permissions/PermissionResult.js'
+import {
+  extractRules,
+  hasRules,
+} from 'src/utils/permissions/PermissionUpdate.js'
+import { permissionRuleValueToString } from 'src/utils/permissions/permissionRuleParser.js'
+import { SandboxManager } from 'src/utils/sandbox/sandbox-adapter.js'
+import type { ToolUseConfirm } from '../../components/permissions/PermissionRequest.js'
+import { useSetAppState } from '../../state/AppState.js'
+import { env } from '../../utils/env.js'
+import { jsonStringify } from '../../utils/slowOperations.js'
+import { type CompletionType, logUnaryEvent } from '../../utils/unaryLogging.js'
+
+export type UnaryEvent = {
+  completion_type: CompletionType
+  language_name: string | Promise<string>
+}
+
+function permissionResultToLog(permissionResult: PermissionResult): string {
+  switch (permissionResult.behavior) {
+    case 'allow':
+      return 'allow'
+    case 'ask': {
+      const rules = extractRules(permissionResult.suggestions)
+      const suggestions =
+        rules.length > 0
+          ? rules.map(r => permissionRuleValueToString(r)).join(', ')
+          : 'none'
+      return `ask: ${permissionResult.message}, 
+suggestions: ${suggestions}
+reason: ${decisionReasonToString(permissionResult.decisionReason)}`
+    }
+    case 'deny':
+      return `deny: ${permissionResult.message},
+reason: ${decisionReasonToString(permissionResult.decisionReason)}`
+    case 'passthrough': {
+      const rules = extractRules(permissionResult.suggestions)
+      const suggestions =
+        rules.length > 0
+          ? rules.map(r => permissionRuleValueToString(r)).join(', ')
+          : 'none'
+      return `passthrough: ${permissionResult.message},
+suggestions: ${suggestions}
+reason: ${decisionReasonToString(permissionResult.decisionReason)}`
+    }
+  }
+}
+
+function decisionReasonToString(
+  decisionReason: PermissionDecisionReason | undefined,
+): string {
+  if (!decisionReason) {
+    return 'No decision reason'
+  }
+  if (
+    (feature('BASH_CLASSIFIER') || feature('TRANSCRIPT_CLASSIFIER')) &&
+    decisionReason.type === 'classifier'
+  ) {
+    return `Classifier: ${decisionReason.classifier}, Reason: ${decisionReason.reason}`
+  }
+  switch (decisionReason.type) {
+    case 'rule':
+      return `Rule: ${permissionRuleValueToString(decisionReason.rule.ruleValue)}`
+    case 'mode':
+      return `Mode: ${decisionReason.mode}`
+    case 'subcommandResults':
+      return `Subcommand Results: ${Array.from(decisionReason.reasons.entries())
+        .map(([key, value]) => `${key}: ${permissionResultToLog(value)}`)
+        .join(', \n')}`
+    case 'permissionPromptTool':
+      return `Permission Tool: ${decisionReason.permissionPromptToolName}, Result: ${jsonStringify(decisionReason.toolResult)}`
+    case 'hook':
+      return `Hook: ${decisionReason.hookName}${decisionReason.reason ? `, Reason: ${decisionReason.reason}` : ''}`
+    case 'workingDir':
+      return `Working Directory: ${decisionReason.reason}`
+    case 'safetyCheck':
+      return `Safety check: ${decisionReason.reason}`
+    case 'other':
+      return `Other: ${decisionReason.reason}`
+    default:
+      return jsonStringify(decisionReason, null, 2)
+  }
+}
+
+/**
+ * Logs permission request events using analytics and unary logging.
+ * Handles both the analytics event and the unary event logging.
+ */
+export function usePermissionRequestLogging(
+  toolUseConfirm: ToolUseConfirm,
+  unaryEvent: UnaryEvent,
+): void {
+  const setAppState = useSetAppState()
+  // Guard against effect re-firing if toolUseConfirm's object reference
+  // changes during a single dialog's lifetime (e.g., parent re-renders with a
+  // fresh object). Without this, the unconditional setAppState below can
+  // cascade into an infinite microtask loop — each re-fire does another
+  // setAppState spread + (ant builds) splitCommand → shell-quote regex,
+  // pegging CPU at 100% and leaking ~500MB/min in JSRopeString/RegExp allocs.
+  // The component is keyed by toolUseID, so this ref resets on remount —
+  // we only need to dedupe re-fires WITHIN one dialog instance.
+  const loggedToolUseID = useRef<string | null>(null)
+
+  useEffect(() => {
+    if (loggedToolUseID.current === toolUseConfirm.toolUseID) {
+      return
+    }
+    loggedToolUseID.current = toolUseConfirm.toolUseID
+
+    // Increment permission prompt count for attribution tracking
+    setAppState(prev => ({
+      ...prev,
+      attribution: {
+        ...prev.attribution,
+        permissionPromptCount: prev.attribution.permissionPromptCount + 1,
+      },
+    }))
+
+    // Log analytics event
+    logEvent('tengu_tool_use_show_permission_request', {
+      messageID: toolUseConfirm.assistantMessage.message
+        .id as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
+      toolName: sanitizeToolNameForAnalytics(toolUseConfirm.tool.name),
+      isMcp: toolUseConfirm.tool.isMcp ?? false,
+      decisionReasonType: toolUseConfirm.permissionResult.decisionReason
+        ?.type as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
+      sandboxEnabled: SandboxManager.isSandboxingEnabled(),
+    })
+
+    if (process.env.USER_TYPE === 'ant') {
+      const permissionResult = toolUseConfirm.permissionResult
+      if (
+        toolUseConfirm.tool.name === BashTool.name &&
+        permissionResult.behavior === 'ask' &&
+        !hasRules(permissionResult.suggestions)
+      ) {
+        // Log if no rule suggestions ("always allow") are provided
+        logEvent('tengu_internal_tool_use_permission_request_no_always_allow', {
+          messageID: toolUseConfirm.assistantMessage.message
+            .id as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
+          toolName: sanitizeToolNameForAnalytics(toolUseConfirm.tool.name),
+          isMcp: toolUseConfirm.tool.isMcp ?? false,
+          decisionReasonType: (permissionResult.decisionReason?.type ??
+            'unknown') as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
+          sandboxEnabled: SandboxManager.isSandboxingEnabled(),
+
+          // This DOES contain code/filepaths and should not be logged in the public build!
+          decisionReasonDetails: decisionReasonToString(
+            permissionResult.decisionReason,
+          ) as never,
+        })
+      }
+    }
+
+    // [ANT-ONLY] Log bash tool calls, so we can categorize
+    // & burn down calls that should have been allowed
+    if (process.env.USER_TYPE === 'ant') {
+      const parsedInput = BashTool.inputSchema.safeParse(toolUseConfirm.input)
+      if (
+        toolUseConfirm.tool.name === BashTool.name &&
+        toolUseConfirm.permissionResult.behavior === 'ask' &&
+        parsedInput.success
+      ) {
+        // Note: All metadata fields in this event contain code/filepaths
+        let split = [parsedInput.data.command]
+        try {
+          split = splitCommand_DEPRECATED(parsedInput.data.command)
+        } catch {
+          // Ignore parse errors here - just log the full command
+        }
+        logEvent('tengu_internal_bash_tool_use_permission_request', {
+          parts: jsonStringify(
+            split,
+          ) as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
+          input: jsonStringify(
+            toolUseConfirm.input,
+          ) as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
+          decisionReasonType: toolUseConfirm.permissionResult.decisionReason
+            ?.type as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
+          decisionReason: decisionReasonToString(
+            toolUseConfirm.permissionResult.decisionReason,
+          ) as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS,
+        })
+      }
+    }
+
+    void logUnaryEvent({
+      completion_type: unaryEvent.completion_type,
+      event: 'response',
+      metadata: {
+        language_name: unaryEvent.language_name,
+        message_id: toolUseConfirm.assistantMessage.message.id,
+        platform: env.platform,
+      },
+    })
+  }, [toolUseConfirm, unaryEvent, setAppState])
+}