sovr-mcp-proxy 6.0.1 → 7.0.0

package/dist/commandNormalizer.js

@@ -0,0 +1,365 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/commandNormalizer.ts
+var commandNormalizer_exports = {};
+__export(commandNormalizer_exports, {
+  getBaseCommand: () => getBaseCommand,
+  hasDestructiveEquivalent: () => hasDestructiveEquivalent,
+  hasEncodingTricks: () => hasEncodingTricks,
+  normalize: () => normalize,
+  summarize: () => summarize
+});
+module.exports = __toCommonJS(commandNormalizer_exports);
+var SHELL_WRAPPERS = [
+  // bash -c "cmd" / sh -c "cmd"
+  {
+    pattern: /^(?:bash|sh|zsh|dash|ksh)\s+-c\s+(?:"([^"]+)"|'([^']+)'|(\S+))/,
+    extract: (m) => m[1] || m[2] || m[3] || "",
+    name: "shell -c"
+  },
+  // env cmd args...
+  {
+    pattern: /^env\s+(?:-\S+\s+)*(?:\S+=\S+\s+)*(.+)/,
+    extract: (m) => m[1] || "",
+    name: "env"
+  },
+  // xargs cmd
+  {
+    pattern: /^xargs\s+(?:-\S+\s+)*(.+)/,
+    extract: (m) => m[1] || "",
+    name: "xargs"
+  },
+  // sudo cmd
+  {
+    pattern: /^sudo\s+(?:-\S+\s+)*(.+)/,
+    extract: (m) => m[1] || "",
+    name: "sudo"
+  },
+  // nohup cmd
+  {
+    pattern: /^nohup\s+(.+?)(?:\s*&\s*)?$/,
+    extract: (m) => m[1] || "",
+    name: "nohup"
+  },
+  // timeout N cmd
+  {
+    pattern: /^timeout\s+\d+[smhd]?\s+(.+)/,
+    extract: (m) => m[1] || "",
+    name: "timeout"
+  },
+  // nice -n N cmd
+  {
+    pattern: /^nice\s+(?:-n\s+\d+\s+)?(.+)/,
+    extract: (m) => m[1] || "",
+    name: "nice"
+  },
+  // strace / ltrace cmd
+  {
+    pattern: /^(?:strace|ltrace)\s+(?:-\S+\s+)*(.+)/,
+    extract: (m) => m[1] || "",
+    name: "trace"
+  },
+  // watch -n N cmd
+  {
+    pattern: /^watch\s+(?:-n\s+\d+\s+)?(.+)/,
+    extract: (m) => m[1] || "",
+    name: "watch"
+  }
+];
+var ENCODING_PATTERNS = [
+  // echo "base64" | base64 -d | bash
+  {
+    pattern: /base64\s+(?:-d|--decode)/,
+    name: "base64-decode",
+    risk: "Command may be hidden via base64 encoding"
+  },
+  // printf '\x72\x6d' (hex encoding)
+  {
+    pattern: /printf\s+.*\\x[0-9a-fA-F]{2}/,
+    name: "hex-printf",
+    risk: "Command may be hidden via hex encoding in printf"
+  },
+  // $'\x72\x6d' (ANSI-C quoting)
+  {
+    pattern: /\$'[^']*\\x[0-9a-fA-F]{2}/,
+    name: "ansi-c-quoting",
+    risk: "Command may be hidden via ANSI-C quoting"
+  },
+  // python -c "import os; os.system('rm -rf /')"
+  {
+    pattern: /python[23]?\s+-c\s+/,
+    name: "python-exec",
+    risk: "Arbitrary code execution via Python"
+  },
+  // perl -e "system('rm -rf /')"
+  {
+    pattern: /perl\s+-e\s+/,
+    name: "perl-exec",
+    risk: "Arbitrary code execution via Perl"
+  },
+  // ruby -e "system('rm -rf /')"
+  {
+    pattern: /ruby\s+-e\s+/,
+    name: "ruby-exec",
+    risk: "Arbitrary code execution via Ruby"
+  },
+  // eval "cmd"
+  {
+    pattern: /\beval\s+/,
+    name: "eval",
+    risk: "Dynamic command evaluation"
+  },
+  // curl ... | bash
+  {
+    pattern: /curl\s+.*\|\s*(?:bash|sh|zsh)/,
+    name: "curl-pipe-shell",
+    risk: "Remote code execution via curl | bash"
+  },
+  // wget ... -O - | bash
+  {
+    pattern: /wget\s+.*\|\s*(?:bash|sh|zsh)/,
+    name: "wget-pipe-shell",
+    risk: "Remote code execution via wget | bash"
+  }
+];
+var DESTRUCTIVE_EQUIVALENTS = [
+  // find / -delete (equivalent to rm -rf)
+  { pattern: /find\s+.*-delete/, equivalent: "rm -rf", description: "find -delete is equivalent to rm -rf" },
+  // find / -exec rm {} (equivalent to rm -rf)
+  { pattern: /find\s+.*-exec\s+rm/, equivalent: "rm -rf", description: "find -exec rm is equivalent to rm -rf" },
+  // TRUNCATE TABLE (equivalent to DELETE FROM)
+  { pattern: /TRUNCATE\s+TABLE/i, equivalent: "DELETE FROM", description: "TRUNCATE TABLE is equivalent to DELETE FROM" },
+  // dd if=/dev/zero of=/ (disk wipe)
+  { pattern: /dd\s+.*of=\//, equivalent: "disk-wipe", description: "dd writing to root is destructive" },
+  // mkfs (format disk)
+  { pattern: /mkfs/, equivalent: "disk-format", description: "mkfs formats a disk" },
+  // shred (secure delete)
+  { pattern: /shred\s+/, equivalent: "secure-delete", description: "shred securely deletes files" },
+  // chmod 777 / (open permissions)
+  { pattern: /chmod\s+777\s+\//, equivalent: "open-permissions", description: "chmod 777 / opens all permissions" },
+  // chown root (change ownership)
+  { pattern: /chown\s+.*\//, equivalent: "change-ownership", description: "chown on root paths is dangerous" },
+  // iptables -F (flush firewall)
+  { pattern: /iptables\s+-F/, equivalent: "flush-firewall", description: "iptables -F flushes all firewall rules" }
+];
+function normalize(command) {
+  const original = command;
+  const segments = [];
+  const suspicion_reasons = [];
+  const trimmed = command.trim();
+  if (!trimmed) {
+    return { segments: [], suspicious: false, suspicion_reasons: [], original };
+  }
+  for (const enc of ENCODING_PATTERNS) {
+    if (enc.pattern.test(trimmed)) {
+      suspicion_reasons.push(`${enc.name}: ${enc.risk}`);
+    }
+  }
+  for (const deq of DESTRUCTIVE_EQUIVALENTS) {
+    if (deq.pattern.test(trimmed)) {
+      suspicion_reasons.push(`Destructive equivalent detected: ${deq.description}`);
+    }
+  }
+  const chainSegments = splitChains(trimmed);
+  for (const chainSeg of chainSegments) {
+    const pipeSegments = splitPipes(chainSeg);
+    for (const pipeSeg of pipeSegments) {
+      const unwrapped = unwrapCommand(pipeSeg.trim());
+      if (unwrapped.unwrapped) {
+        segments.push({
+          raw: pipeSeg.trim(),
+          effective: unwrapped.effective,
+          type: "unwrapped",
+          warnings: unwrapped.warnings
+        });
+        const inner = normalize(unwrapped.effective);
+        for (const innerSeg of inner.segments) {
+          if (innerSeg.effective !== unwrapped.effective) {
+            segments.push(innerSeg);
+          }
+        }
+        suspicion_reasons.push(...inner.suspicion_reasons);
+      } else {
+        const type = pipeSegments.length > 1 ? "pipe-segment" : chainSegments.length > 1 ? "chain-segment" : "direct";
+        segments.push({
+          raw: pipeSeg.trim(),
+          effective: pipeSeg.trim(),
+          type,
+          warnings: []
+        });
+      }
+    }
+  }
+  const subshells = extractSubshells(trimmed);
+  for (const sub of subshells) {
+    segments.push({
+      raw: trimmed,
+      effective: sub,
+      type: "subshell",
+      warnings: ["Subshell command extracted for evaluation"]
+    });
+  }
+  return {
+    segments,
+    suspicious: suspicion_reasons.length > 0,
+    suspicion_reasons,
+    original
+  };
+}
+function splitChains(command) {
+  return splitRespectingQuotes(command, /\s*(?:&&|\|\||;)\s*/);
+}
+function splitPipes(command) {
+  return splitRespectingQuotes(command, /\s*\|(?!\|)\s*/);
+}
+function splitRespectingQuotes(input, delimiter) {
+  const segments = [];
+  let current = "";
+  let inSingleQuote = false;
+  let inDoubleQuote = false;
+  let escaped = false;
+  let i = 0;
+  while (i < input.length) {
+    const char = input[i];
+    if (escaped) {
+      current += char;
+      escaped = false;
+      i++;
+      continue;
+    }
+    if (char === "\\") {
+      escaped = true;
+      current += char;
+      i++;
+      continue;
+    }
+    if (char === "'" && !inDoubleQuote) {
+      inSingleQuote = !inSingleQuote;
+      current += char;
+      i++;
+      continue;
+    }
+    if (char === '"' && !inSingleQuote) {
+      inDoubleQuote = !inDoubleQuote;
+      current += char;
+      i++;
+      continue;
+    }
+    if (!inSingleQuote && !inDoubleQuote) {
+      const remaining = input.slice(i);
+      const match = remaining.match(delimiter);
+      if (match && match.index === 0) {
+        if (current.trim()) {
+          segments.push(current.trim());
+        }
+        current = "";
+        i += match[0].length;
+        continue;
+      }
+    }
+    current += char;
+    i++;
+  }
+  if (current.trim()) {
+    segments.push(current.trim());
+  }
+  return segments.length > 0 ? segments : [input];
+}
+function unwrapCommand(command) {
+  for (const wrapper of SHELL_WRAPPERS) {
+    const match = command.match(wrapper.pattern);
+    if (match) {
+      const inner = wrapper.extract(match);
+      if (inner) {
+        return {
+          unwrapped: true,
+          effective: inner.trim(),
+          wrapper: wrapper.name,
+          warnings: [`Unwrapped from ${wrapper.name}: "${command}" \u2192 "${inner.trim()}"`]
+        };
+      }
+    }
+  }
+  return { unwrapped: false, effective: command, warnings: [] };
+}
+function extractSubshells(command) {
+  const subshells = [];
+  const dollarParen = /\$\(([^)]+)\)/g;
+  let match;
+  while ((match = dollarParen.exec(command)) !== null) {
+    if (match[1]) subshells.push(match[1].trim());
+  }
+  const backtick = /`([^`]+)`/g;
+  while ((match = backtick.exec(command)) !== null) {
+    if (match[1]) subshells.push(match[1].trim());
+  }
+  return subshells;
+}
+function getBaseCommand(command) {
+  const trimmed = command.trim();
+  const firstSpace = trimmed.indexOf(" ");
+  return firstSpace === -1 ? trimmed : trimmed.slice(0, firstSpace);
+}
+function hasDestructiveEquivalent(command) {
+  const matches = [];
+  for (const deq of DESTRUCTIVE_EQUIVALENTS) {
+    if (deq.pattern.test(command)) {
+      matches.push({ equivalent: deq.equivalent, description: deq.description });
+    }
+  }
+  return { found: matches.length > 0, matches };
+}
+function hasEncodingTricks(command) {
+  const tricks = [];
+  for (const enc of ENCODING_PATTERNS) {
+    if (enc.pattern.test(command)) {
+      tricks.push({ name: enc.name, risk: enc.risk });
+    }
+  }
+  return { found: tricks.length > 0, tricks };
+}
+function summarize(result) {
+  const lines = [];
+  lines.push(`Original: ${result.original}`);
+  lines.push(`Segments: ${result.segments.length}`);
+  lines.push(`Suspicious: ${result.suspicious}`);
+  if (result.suspicion_reasons.length > 0) {
+    lines.push(`Suspicion reasons:`);
+    for (const reason of result.suspicion_reasons) {
+      lines.push(`  - ${reason}`);
+    }
+  }
+  lines.push(`Segments:`);
+  for (const seg of result.segments) {
+    lines.push(`  [${seg.type}] ${seg.effective}`);
+    for (const w of seg.warnings) {
+      lines.push(`    \u26A0 ${w}`);
+    }
+  }
+  return lines.join("\n");
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getBaseCommand,
+  hasDestructiveEquivalent,
+  hasEncodingTricks,
+  normalize,
+  summarize
+});

package/dist/commandNormalizer.mjs

@@ -0,0 +1,336 @@
+// src/commandNormalizer.ts
+var SHELL_WRAPPERS = [
+  // bash -c "cmd" / sh -c "cmd"
+  {
+    pattern: /^(?:bash|sh|zsh|dash|ksh)\s+-c\s+(?:"([^"]+)"|'([^']+)'|(\S+))/,
+    extract: (m) => m[1] || m[2] || m[3] || "",
+    name: "shell -c"
+  },
+  // env cmd args...
+  {
+    pattern: /^env\s+(?:-\S+\s+)*(?:\S+=\S+\s+)*(.+)/,
+    extract: (m) => m[1] || "",
+    name: "env"
+  },
+  // xargs cmd
+  {
+    pattern: /^xargs\s+(?:-\S+\s+)*(.+)/,
+    extract: (m) => m[1] || "",
+    name: "xargs"
+  },
+  // sudo cmd
+  {
+    pattern: /^sudo\s+(?:-\S+\s+)*(.+)/,
+    extract: (m) => m[1] || "",
+    name: "sudo"
+  },
+  // nohup cmd
+  {
+    pattern: /^nohup\s+(.+?)(?:\s*&\s*)?$/,
+    extract: (m) => m[1] || "",
+    name: "nohup"
+  },
+  // timeout N cmd
+  {
+    pattern: /^timeout\s+\d+[smhd]?\s+(.+)/,
+    extract: (m) => m[1] || "",
+    name: "timeout"
+  },
+  // nice -n N cmd
+  {
+    pattern: /^nice\s+(?:-n\s+\d+\s+)?(.+)/,
+    extract: (m) => m[1] || "",
+    name: "nice"
+  },
+  // strace / ltrace cmd
+  {
+    pattern: /^(?:strace|ltrace)\s+(?:-\S+\s+)*(.+)/,
+    extract: (m) => m[1] || "",
+    name: "trace"
+  },
+  // watch -n N cmd
+  {
+    pattern: /^watch\s+(?:-n\s+\d+\s+)?(.+)/,
+    extract: (m) => m[1] || "",
+    name: "watch"
+  }
+];
+var ENCODING_PATTERNS = [
+  // echo "base64" | base64 -d | bash
+  {
+    pattern: /base64\s+(?:-d|--decode)/,
+    name: "base64-decode",
+    risk: "Command may be hidden via base64 encoding"
+  },
+  // printf '\x72\x6d' (hex encoding)
+  {
+    pattern: /printf\s+.*\\x[0-9a-fA-F]{2}/,
+    name: "hex-printf",
+    risk: "Command may be hidden via hex encoding in printf"
+  },
+  // $'\x72\x6d' (ANSI-C quoting)
+  {
+    pattern: /\$'[^']*\\x[0-9a-fA-F]{2}/,
+    name: "ansi-c-quoting",
+    risk: "Command may be hidden via ANSI-C quoting"
+  },
+  // python -c "import os; os.system('rm -rf /')"
+  {
+    pattern: /python[23]?\s+-c\s+/,
+    name: "python-exec",
+    risk: "Arbitrary code execution via Python"
+  },
+  // perl -e "system('rm -rf /')"
+  {
+    pattern: /perl\s+-e\s+/,
+    name: "perl-exec",
+    risk: "Arbitrary code execution via Perl"
+  },
+  // ruby -e "system('rm -rf /')"
+  {
+    pattern: /ruby\s+-e\s+/,
+    name: "ruby-exec",
+    risk: "Arbitrary code execution via Ruby"
+  },
+  // eval "cmd"
+  {
+    pattern: /\beval\s+/,
+    name: "eval",
+    risk: "Dynamic command evaluation"
+  },
+  // curl ... | bash
+  {
+    pattern: /curl\s+.*\|\s*(?:bash|sh|zsh)/,
+    name: "curl-pipe-shell",
+    risk: "Remote code execution via curl | bash"
+  },
+  // wget ... -O - | bash
+  {
+    pattern: /wget\s+.*\|\s*(?:bash|sh|zsh)/,
+    name: "wget-pipe-shell",
+    risk: "Remote code execution via wget | bash"
+  }
+];
+var DESTRUCTIVE_EQUIVALENTS = [
+  // find / -delete (equivalent to rm -rf)
+  { pattern: /find\s+.*-delete/, equivalent: "rm -rf", description: "find -delete is equivalent to rm -rf" },
+  // find / -exec rm {} (equivalent to rm -rf)
+  { pattern: /find\s+.*-exec\s+rm/, equivalent: "rm -rf", description: "find -exec rm is equivalent to rm -rf" },
+  // TRUNCATE TABLE (equivalent to DELETE FROM)
+  { pattern: /TRUNCATE\s+TABLE/i, equivalent: "DELETE FROM", description: "TRUNCATE TABLE is equivalent to DELETE FROM" },
+  // dd if=/dev/zero of=/ (disk wipe)
+  { pattern: /dd\s+.*of=\//, equivalent: "disk-wipe", description: "dd writing to root is destructive" },
+  // mkfs (format disk)
+  { pattern: /mkfs/, equivalent: "disk-format", description: "mkfs formats a disk" },
+  // shred (secure delete)
+  { pattern: /shred\s+/, equivalent: "secure-delete", description: "shred securely deletes files" },
+  // chmod 777 / (open permissions)
+  { pattern: /chmod\s+777\s+\//, equivalent: "open-permissions", description: "chmod 777 / opens all permissions" },
+  // chown root (change ownership)
+  { pattern: /chown\s+.*\//, equivalent: "change-ownership", description: "chown on root paths is dangerous" },
+  // iptables -F (flush firewall)
+  { pattern: /iptables\s+-F/, equivalent: "flush-firewall", description: "iptables -F flushes all firewall rules" }
+];
+function normalize(command) {
+  const original = command;
+  const segments = [];
+  const suspicion_reasons = [];
+  const trimmed = command.trim();
+  if (!trimmed) {
+    return { segments: [], suspicious: false, suspicion_reasons: [], original };
+  }
+  for (const enc of ENCODING_PATTERNS) {
+    if (enc.pattern.test(trimmed)) {
+      suspicion_reasons.push(`${enc.name}: ${enc.risk}`);
+    }
+  }
+  for (const deq of DESTRUCTIVE_EQUIVALENTS) {
+    if (deq.pattern.test(trimmed)) {
+      suspicion_reasons.push(`Destructive equivalent detected: ${deq.description}`);
+    }
+  }
+  const chainSegments = splitChains(trimmed);
+  for (const chainSeg of chainSegments) {
+    const pipeSegments = splitPipes(chainSeg);
+    for (const pipeSeg of pipeSegments) {
+      const unwrapped = unwrapCommand(pipeSeg.trim());
+      if (unwrapped.unwrapped) {
+        segments.push({
+          raw: pipeSeg.trim(),
+          effective: unwrapped.effective,
+          type: "unwrapped",
+          warnings: unwrapped.warnings
+        });
+        const inner = normalize(unwrapped.effective);
+        for (const innerSeg of inner.segments) {
+          if (innerSeg.effective !== unwrapped.effective) {
+            segments.push(innerSeg);
+          }
+        }
+        suspicion_reasons.push(...inner.suspicion_reasons);
+      } else {
+        const type = pipeSegments.length > 1 ? "pipe-segment" : chainSegments.length > 1 ? "chain-segment" : "direct";
+        segments.push({
+          raw: pipeSeg.trim(),
+          effective: pipeSeg.trim(),
+          type,
+          warnings: []
+        });
+      }
+    }
+  }
+  const subshells = extractSubshells(trimmed);
+  for (const sub of subshells) {
+    segments.push({
+      raw: trimmed,
+      effective: sub,
+      type: "subshell",
+      warnings: ["Subshell command extracted for evaluation"]
+    });
+  }
+  return {
+    segments,
+    suspicious: suspicion_reasons.length > 0,
+    suspicion_reasons,
+    original
+  };
+}
+function splitChains(command) {
+  return splitRespectingQuotes(command, /\s*(?:&&|\|\||;)\s*/);
+}
+function splitPipes(command) {
+  return splitRespectingQuotes(command, /\s*\|(?!\|)\s*/);
+}
+function splitRespectingQuotes(input, delimiter) {
+  const segments = [];
+  let current = "";
+  let inSingleQuote = false;
+  let inDoubleQuote = false;
+  let escaped = false;
+  let i = 0;
+  while (i < input.length) {
+    const char = input[i];
+    if (escaped) {
+      current += char;
+      escaped = false;
+      i++;
+      continue;
+    }
+    if (char === "\\") {
+      escaped = true;
+      current += char;
+      i++;
+      continue;
+    }
+    if (char === "'" && !inDoubleQuote) {
+      inSingleQuote = !inSingleQuote;
+      current += char;
+      i++;
+      continue;
+    }
+    if (char === '"' && !inSingleQuote) {
+      inDoubleQuote = !inDoubleQuote;
+      current += char;
+      i++;
+      continue;
+    }
+    if (!inSingleQuote && !inDoubleQuote) {
+      const remaining = input.slice(i);
+      const match = remaining.match(delimiter);
+      if (match && match.index === 0) {
+        if (current.trim()) {
+          segments.push(current.trim());
+        }
+        current = "";
+        i += match[0].length;
+        continue;
+      }
+    }
+    current += char;
+    i++;
+  }
+  if (current.trim()) {
+    segments.push(current.trim());
+  }
+  return segments.length > 0 ? segments : [input];
+}
+function unwrapCommand(command) {
+  for (const wrapper of SHELL_WRAPPERS) {
+    const match = command.match(wrapper.pattern);
+    if (match) {
+      const inner = wrapper.extract(match);
+      if (inner) {
+        return {
+          unwrapped: true,
+          effective: inner.trim(),
+          wrapper: wrapper.name,
+          warnings: [`Unwrapped from ${wrapper.name}: "${command}" \u2192 "${inner.trim()}"`]
+        };
+      }
+    }
+  }
+  return { unwrapped: false, effective: command, warnings: [] };
+}
+function extractSubshells(command) {
+  const subshells = [];
+  const dollarParen = /\$\(([^)]+)\)/g;
+  let match;
+  while ((match = dollarParen.exec(command)) !== null) {
+    if (match[1]) subshells.push(match[1].trim());
+  }
+  const backtick = /`([^`]+)`/g;
+  while ((match = backtick.exec(command)) !== null) {
+    if (match[1]) subshells.push(match[1].trim());
+  }
+  return subshells;
+}
+function getBaseCommand(command) {
+  const trimmed = command.trim();
+  const firstSpace = trimmed.indexOf(" ");
+  return firstSpace === -1 ? trimmed : trimmed.slice(0, firstSpace);
+}
+function hasDestructiveEquivalent(command) {
+  const matches = [];
+  for (const deq of DESTRUCTIVE_EQUIVALENTS) {
+    if (deq.pattern.test(command)) {
+      matches.push({ equivalent: deq.equivalent, description: deq.description });
+    }
+  }
+  return { found: matches.length > 0, matches };
+}
+function hasEncodingTricks(command) {
+  const tricks = [];
+  for (const enc of ENCODING_PATTERNS) {
+    if (enc.pattern.test(command)) {
+      tricks.push({ name: enc.name, risk: enc.risk });
+    }
+  }
+  return { found: tricks.length > 0, tricks };
+}
+function summarize(result) {
+  const lines = [];
+  lines.push(`Original: ${result.original}`);
+  lines.push(`Segments: ${result.segments.length}`);
+  lines.push(`Suspicious: ${result.suspicious}`);
+  if (result.suspicion_reasons.length > 0) {
+    lines.push(`Suspicion reasons:`);
+    for (const reason of result.suspicion_reasons) {
+      lines.push(`  - ${reason}`);
+    }
+  }
+  lines.push(`Segments:`);
+  for (const seg of result.segments) {
+    lines.push(`  [${seg.type}] ${seg.effective}`);
+    for (const w of seg.warnings) {
+      lines.push(`    \u26A0 ${w}`);
+    }
+  }
+  return lines.join("\n");
+}
+export {
+  getBaseCommand,
+  hasDestructiveEquivalent,
+  hasEncodingTricks,
+  normalize,
+  summarize
+};