@xelauvas/xela-cli 0.1.0

package/src/tools/PowerShellTool/UI.tsx

@@ -0,0 +1,131 @@
+import type { ToolResultBlockParam } from '@anthropic-ai/sdk/resources/index.mjs';
+import * as React from 'react';
+import { KeyboardShortcutHint } from '../../components/design-system/KeyboardShortcutHint.js';
+import { FallbackToolUseErrorMessage } from '../../components/FallbackToolUseErrorMessage.js';
+import { MessageResponse } from '../../components/MessageResponse.js';
+import { OutputLine } from '../../components/shell/OutputLine.js';
+import { ShellProgressMessage } from '../../components/shell/ShellProgressMessage.js';
+import { ShellTimeDisplay } from '../../components/shell/ShellTimeDisplay.js';
+import { Box, Text } from '../../ink.js';
+import type { Tool } from '../../Tool.js';
+import type { ProgressMessage } from '../../types/message.js';
+import type { PowerShellProgress } from '../../types/tools.js';
+import type { ThemeName } from '../../utils/theme.js';
+import type { Out, PowerShellToolInput } from './PowerShellTool.js';
+
+// Constants for command display
+const MAX_COMMAND_DISPLAY_LINES = 2;
+const MAX_COMMAND_DISPLAY_CHARS = 160;
+export function renderToolUseMessage(input: Partial<PowerShellToolInput>, {
+  verbose,
+  theme: _theme
+}: {
+  verbose: boolean;
+  theme: ThemeName;
+}): React.ReactNode {
+  const {
+    command
+  } = input;
+  if (!command) {
+    return null;
+  }
+  const displayCommand = command;
+  if (!verbose) {
+    const lines = displayCommand.split('\n');
+    const needsLineTruncation = lines.length > MAX_COMMAND_DISPLAY_LINES;
+    const needsCharTruncation = displayCommand.length > MAX_COMMAND_DISPLAY_CHARS;
+    if (needsLineTruncation || needsCharTruncation) {
+      let truncated = displayCommand;
+      if (needsLineTruncation) {
+        truncated = lines.slice(0, MAX_COMMAND_DISPLAY_LINES).join('\n');
+      }
+      if (truncated.length > MAX_COMMAND_DISPLAY_CHARS) {
+        truncated = truncated.slice(0, MAX_COMMAND_DISPLAY_CHARS);
+      }
+      return <Text>{truncated.trim()}…</Text>;
+    }
+  }
+  return displayCommand;
+}
+export function renderToolUseProgressMessage(progressMessagesForMessage: ProgressMessage<PowerShellProgress>[], {
+  verbose,
+  tools: _tools,
+  terminalSize: _terminalSize,
+  inProgressToolCallCount: _inProgressToolCallCount
+}: {
+  tools: Tool[];
+  verbose: boolean;
+  terminalSize?: {
+    columns: number;
+    rows: number;
+  };
+  inProgressToolCallCount?: number;
+}): React.ReactNode {
+  const lastProgress = progressMessagesForMessage.at(-1);
+  if (!lastProgress || !lastProgress.data) {
+    return <MessageResponse height={1}>
+        <Text dimColor>Running…</Text>
+      </MessageResponse>;
+  }
+  const data = lastProgress.data;
+  return <ShellProgressMessage fullOutput={data.fullOutput} output={data.output} elapsedTimeSeconds={data.elapsedTimeSeconds} totalLines={data.totalLines} totalBytes={data.totalBytes} timeoutMs={data.timeoutMs} taskId={data.taskId} verbose={verbose} />;
+}
+export function renderToolUseQueuedMessage(): React.ReactNode {
+  return <MessageResponse height={1}>
+      <Text dimColor>Waiting…</Text>
+    </MessageResponse>;
+}
+export function renderToolResultMessage(content: Out, progressMessagesForMessage: ProgressMessage<PowerShellProgress>[], {
+  verbose,
+  theme: _theme,
+  tools: _tools,
+  style: _style
+}: {
+  verbose: boolean;
+  theme: ThemeName;
+  tools: Tool[];
+  style?: 'condensed';
+}): React.ReactNode {
+  const lastProgress = progressMessagesForMessage.at(-1);
+  const timeoutMs = lastProgress?.data?.timeoutMs;
+  const {
+    stdout,
+    stderr,
+    interrupted,
+    returnCodeInterpretation,
+    isImage,
+    backgroundTaskId
+  } = content;
+  if (isImage) {
+    return <MessageResponse height={1}>
+        <Text dimColor>[Image data detected and sent to Claude]</Text>
+      </MessageResponse>;
+  }
+  return <Box flexDirection="column">
+      {stdout !== '' ? <OutputLine content={stdout} verbose={verbose} /> : null}
+      {stderr.trim() !== '' ? <OutputLine content={stderr} verbose={verbose} isError /> : null}
+      {stdout === '' && stderr.trim() === '' ? <MessageResponse height={1}>
+          <Text dimColor>
+            {backgroundTaskId ? <>
+                Running in the background{' '}
+                <KeyboardShortcutHint shortcut="↓" action="manage" parens />
+              </> : interrupted ? 'Interrupted' : returnCodeInterpretation || '(No output)'}
+          </Text>
+        </MessageResponse> : null}
+      {timeoutMs ? <MessageResponse>
+          <ShellTimeDisplay timeoutMs={timeoutMs} />
+        </MessageResponse> : null}
+    </Box>;
+}
+export function renderToolUseErrorMessage(result: ToolResultBlockParam['content'], {
+  verbose,
+  progressMessagesForMessage: _progressMessagesForMessage,
+  tools: _tools
+}: {
+  verbose: boolean;
+  progressMessagesForMessage: ProgressMessage<PowerShellProgress>[];
+  tools: Tool[];
+}): React.ReactNode {
+  return <FallbackToolUseErrorMessage result={result} verbose={verbose} />;
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["ToolResultBlockParam","React","KeyboardShortcutHint","FallbackToolUseErrorMessage","MessageResponse","OutputLine","ShellProgressMessage","ShellTimeDisplay","Box","Text","Tool","ProgressMessage","PowerShellProgress","ThemeName","Out","PowerShellToolInput","MAX_COMMAND_DISPLAY_LINES","MAX_COMMAND_DISPLAY_CHARS","renderToolUseMessage","input","Partial","verbose","theme","_theme","ReactNode","command","displayCommand","lines","split","needsLineTruncation","length","needsCharTruncation","truncated","slice","join","trim","renderToolUseProgressMessage","progressMessagesForMessage","tools","_tools","terminalSize","_terminalSize","inProgressToolCallCount","_inProgressToolCallCount","columns","rows","lastProgress","at","data","fullOutput","output","elapsedTimeSeconds","totalLines","totalBytes","timeoutMs","taskId","renderToolUseQueuedMessage","renderToolResultMessage","content","style","_style","stdout","stderr","interrupted","returnCodeInterpretation","isImage","backgroundTaskId","renderToolUseErrorMessage","result","_progressMessagesForMessage"],"sources":["UI.tsx"],"sourcesContent":["import type { ToolResultBlockParam } from '@anthropic-ai/sdk/resources/index.mjs'\nimport * as React from 'react'\nimport { KeyboardShortcutHint } from '../../components/design-system/KeyboardShortcutHint.js'\nimport { FallbackToolUseErrorMessage } from '../../components/FallbackToolUseErrorMessage.js'\nimport { MessageResponse } from '../../components/MessageResponse.js'\nimport { OutputLine } from '../../components/shell/OutputLine.js'\nimport { ShellProgressMessage } from '../../components/shell/ShellProgressMessage.js'\nimport { ShellTimeDisplay } from '../../components/shell/ShellTimeDisplay.js'\nimport { Box, Text } from '../../ink.js'\nimport type { Tool } from '../../Tool.js'\nimport type { ProgressMessage } from '../../types/message.js'\nimport type { PowerShellProgress } from '../../types/tools.js'\nimport type { ThemeName } from '../../utils/theme.js'\nimport type { Out, PowerShellToolInput } from './PowerShellTool.js'\n\n// Constants for command display\nconst MAX_COMMAND_DISPLAY_LINES = 2\nconst MAX_COMMAND_DISPLAY_CHARS = 160\n\nexport function renderToolUseMessage(\n  input: Partial<PowerShellToolInput>,\n  { verbose, theme: _theme }: { verbose: boolean; theme: ThemeName },\n): React.ReactNode {\n  const { command } = input\n  if (!command) {\n    return null\n  }\n\n  const displayCommand = command\n\n  if (!verbose) {\n    const lines = displayCommand.split('\\n')\n    const needsLineTruncation = lines.length > MAX_COMMAND_DISPLAY_LINES\n    const needsCharTruncation =\n      displayCommand.length > MAX_COMMAND_DISPLAY_CHARS\n\n    if (needsLineTruncation || needsCharTruncation) {\n      let truncated = displayCommand\n\n      if (needsLineTruncation) {\n        truncated = lines.slice(0, MAX_COMMAND_DISPLAY_LINES).join('\\n')\n      }\n\n      if (truncated.length > MAX_COMMAND_DISPLAY_CHARS) {\n        truncated = truncated.slice(0, MAX_COMMAND_DISPLAY_CHARS)\n      }\n\n      return <Text>{truncated.trim()}…</Text>\n    }\n  }\n\n  return displayCommand\n}\n\nexport function renderToolUseProgressMessage(\n  progressMessagesForMessage: ProgressMessage<PowerShellProgress>[],\n  {\n    verbose,\n    tools: _tools,\n    terminalSize: _terminalSize,\n    inProgressToolCallCount: _inProgressToolCallCount,\n  }: {\n    tools: Tool[]\n    verbose: boolean\n    terminalSize?: { columns: number; rows: number }\n    inProgressToolCallCount?: number\n  },\n): React.ReactNode {\n  const lastProgress = progressMessagesForMessage.at(-1)\n\n  if (!lastProgress || !lastProgress.data) {\n    return (\n      <MessageResponse height={1}>\n        <Text dimColor>Running…</Text>\n      </MessageResponse>\n    )\n  }\n\n  const data = lastProgress.data\n\n  return (\n    <ShellProgressMessage\n      fullOutput={data.fullOutput}\n      output={data.output}\n      elapsedTimeSeconds={data.elapsedTimeSeconds}\n      totalLines={data.totalLines}\n      totalBytes={data.totalBytes}\n      timeoutMs={data.timeoutMs}\n      taskId={data.taskId}\n      verbose={verbose}\n    />\n  )\n}\n\nexport function renderToolUseQueuedMessage(): React.ReactNode {\n  return (\n    <MessageResponse height={1}>\n      <Text dimColor>Waiting…</Text>\n    </MessageResponse>\n  )\n}\n\nexport function renderToolResultMessage(\n  content: Out,\n  progressMessagesForMessage: ProgressMessage<PowerShellProgress>[],\n  {\n    verbose,\n    theme: _theme,\n    tools: _tools,\n    style: _style,\n  }: {\n    verbose: boolean\n    theme: ThemeName\n    tools: Tool[]\n    style?: 'condensed'\n  },\n): React.ReactNode {\n  const lastProgress = progressMessagesForMessage.at(-1)\n  const timeoutMs = lastProgress?.data?.timeoutMs\n  const {\n    stdout,\n    stderr,\n    interrupted,\n    returnCodeInterpretation,\n    isImage,\n    backgroundTaskId,\n  } = content\n\n  if (isImage) {\n    return (\n      <MessageResponse height={1}>\n        <Text dimColor>[Image data detected and sent to Claude]</Text>\n      </MessageResponse>\n    )\n  }\n\n  return (\n    <Box flexDirection=\"column\">\n      {stdout !== '' ? <OutputLine content={stdout} verbose={verbose} /> : null}\n      {stderr.trim() !== '' ? (\n        <OutputLine content={stderr} verbose={verbose} isError />\n      ) : null}\n      {stdout === '' && stderr.trim() === '' ? (\n        <MessageResponse height={1}>\n          <Text dimColor>\n            {backgroundTaskId ? (\n              <>\n                Running in the background{' '}\n                <KeyboardShortcutHint shortcut=\"↓\" action=\"manage\" parens />\n              </>\n            ) : interrupted ? (\n              'Interrupted'\n            ) : (\n              returnCodeInterpretation || '(No output)'\n            )}\n          </Text>\n        </MessageResponse>\n      ) : null}\n      {timeoutMs ? (\n        <MessageResponse>\n          <ShellTimeDisplay timeoutMs={timeoutMs} />\n        </MessageResponse>\n      ) : null}\n    </Box>\n  )\n}\n\nexport function renderToolUseErrorMessage(\n  result: ToolResultBlockParam['content'],\n  {\n    verbose,\n    progressMessagesForMessage: _progressMessagesForMessage,\n    tools: _tools,\n  }: {\n    verbose: boolean\n    progressMessagesForMessage: ProgressMessage<PowerShellProgress>[]\n    tools: Tool[]\n  },\n): React.ReactNode {\n  return <FallbackToolUseErrorMessage result={result} verbose={verbose} />\n}\n"],"mappings":"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","ignoreList":[]}

package/src/tools/PowerShellTool/clmTypes.ts

@@ -0,0 +1,211 @@
+/**
+ * PowerShell Constrained Language Mode allowed types.
+ *
+ * Microsoft's CLM restricts .NET type usage to this allowlist when PS runs
+ * under AppLocker/WDAC system lockdown. Any type NOT in this set is considered
+ * unsafe for untrusted code execution.
+ *
+ * We invert this: type literals not in this set → ask. One canonical check
+ * replaces enumerating individual dangerous types (named pipes, reflection,
+ * process spawning, P/Invoke marshaling, etc.). Microsoft maintains the list.
+ *
+ * Source: https://learn.microsoft.com/en-us/powershell/module/microsoft.powershell.core/about/about_language_modes
+ *
+ * Normalization: entries stored lowercase, short AND full names where both
+ * exist (PS resolves type accelerators like [int] → System.Int32 at runtime;
+ * we match against what the AST emits, which is the literal text).
+ */
+export const CLM_ALLOWED_TYPES: ReadonlySet<string> = new Set(
+  [
+    // Type accelerators (short names as they appear in AST TypeName.Name)
+    // SECURITY: 'adsi' and 'adsisearcher' REMOVED. Both are Active Directory
+    // Service Interface types that perform NETWORK BINDS when cast:
+    //   [adsi]'LDAP://evil.com/...' → connects to LDAP server
+    //   [adsisearcher]'(objectClass=user)' → binds to AD and queries
+    // Microsoft's CLM allows these because it's for Windows admins in trusted
+    // domains; we block them since the target isn't validated.
+    'alias',
+    'allowemptycollection',
+    'allowemptystring',
+    'allownull',
+    'argumentcompleter',
+    'argumentcompletions',
+    'array',
+    'bigint',
+    'bool',
+    'byte',
+    'char',
+    'cimclass',
+    'cimconverter',
+    'ciminstance',
+    // 'cimsession' REMOVED — see wmi/adsi comment below
+    'cimtype',
+    'cmdletbinding',
+    'cultureinfo',
+    'datetime',
+    'decimal',
+    'double',
+    'dsclocalconfigurationmanager',
+    'dscproperty',
+    'dscresource',
+    'experimentaction',
+    'experimental',
+    'experimentalfeature',
+    'float',
+    'guid',
+    'hashtable',
+    'int',
+    'int16',
+    'int32',
+    'int64',
+    'ipaddress',
+    'ipendpoint',
+    'long',
+    'mailaddress',
+    'norunspaceaffinity',
+    'nullstring',
+    'objectsecurity',
+    'ordered',
+    'outputtype',
+    'parameter',
+    'physicaladdress',
+    'pscredential',
+    'pscustomobject',
+    'psdefaultvalue',
+    'pslistmodifier',
+    'psobject',
+    'psprimitivedictionary',
+    'pstypenameattribute',
+    'ref',
+    'regex',
+    'sbyte',
+    'securestring',
+    'semver',
+    'short',
+    'single',
+    'string',
+    'supportswildcards',
+    'switch',
+    'timespan',
+    'uint',
+    'uint16',
+    'uint32',
+    'uint64',
+    'ulong',
+    'uri',
+    'ushort',
+    'validatecount',
+    'validatedrive',
+    'validatelength',
+    'validatenotnull',
+    'validatenotnullorempty',
+    'validatenotnullorwhitespace',
+    'validatepattern',
+    'validaterange',
+    'validatescript',
+    'validateset',
+    'validatetrusteddata',
+    'validateuserdrive',
+    'version',
+    'void',
+    'wildcardpattern',
+    // SECURITY: 'wmi', 'wmiclass', 'wmisearcher', 'cimsession' REMOVED.
+    // WMI type casts perform WMI queries which can target remote computers
+    // (network request) and access dangerous classes like Win32_Process.
+    // cimsession creates a CIM session (network connection to remote host).
+    //   [wmi]'\\evil-host\root\cimv2:Win32_Process.Handle="1"' → remote WMI
+    //   [wmisearcher]'SELECT * FROM Win32_Process' → runs WQL query
+    // Same rationale as adsi/adsisearcher removal above.
+    'x500distinguishedname',
+    'x509certificate',
+    'xml',
+    // Full names for accelerators that resolve to System.* (AST may emit either)
+    'system.array',
+    'system.boolean',
+    'system.byte',
+    'system.char',
+    'system.datetime',
+    'system.decimal',
+    'system.double',
+    'system.guid',
+    'system.int16',
+    'system.int32',
+    'system.int64',
+    'system.numerics.biginteger',
+    'system.sbyte',
+    'system.single',
+    'system.string',
+    'system.timespan',
+    'system.uint16',
+    'system.uint32',
+    'system.uint64',
+    'system.uri',
+    'system.version',
+    'system.void',
+    'system.collections.hashtable',
+    'system.text.regularexpressions.regex',
+    'system.globalization.cultureinfo',
+    'system.net.ipaddress',
+    'system.net.ipendpoint',
+    'system.net.mail.mailaddress',
+    'system.net.networkinformation.physicaladdress',
+    'system.security.securestring',
+    'system.security.cryptography.x509certificates.x509certificate',
+    'system.security.cryptography.x509certificates.x500distinguishedname',
+    'system.xml.xmldocument',
+    // System.Management.Automation.* — FQ equivalents of PS-specific accelerators
+    'system.management.automation.pscredential',
+    'system.management.automation.pscustomobject',
+    'system.management.automation.pslistmodifier',
+    'system.management.automation.psobject',
+    'system.management.automation.psprimitivedictionary',
+    'system.management.automation.psreference',
+    'system.management.automation.semanticversion',
+    'system.management.automation.switchparameter',
+    'system.management.automation.wildcardpattern',
+    'system.management.automation.language.nullstring',
+    // Microsoft.Management.Infrastructure.* — FQ equivalents of CIM accelerators
+    // SECURITY: cimsession FQ REMOVED — same network-bind hazard as short name
+    // (creates a CIM session to a remote host).
+    'microsoft.management.infrastructure.cimclass',
+    'microsoft.management.infrastructure.cimconverter',
+    'microsoft.management.infrastructure.ciminstance',
+    'microsoft.management.infrastructure.cimtype',
+    // FQ equivalents of remaining short-name accelerators
+    // SECURITY: DirectoryEntry/DirectorySearcher/ManagementObject/
+    // ManagementClass/ManagementObjectSearcher FQ REMOVED — same network-bind
+    // hazard as short names adsi/adsisearcher/wmi/wmiclass/wmisearcher
+    // (LDAP bind, remote WMI). See short-name removal comments above.
+    'system.collections.specialized.ordereddictionary',
+    'system.security.accesscontrol.objectsecurity',
+    // Arrays of allowed types are allowed (e.g. [string[]])
+    // normalizeTypeName strips [] before lookup, so store the base name
+    'object',
+    'system.object',
+    // ModuleSpecification — full qualified name
+    'microsoft.powershell.commands.modulespecification',
+  ].map(t => t.toLowerCase()),
+)
+
+/**
+ * Normalize a type name from AST TypeName.FullName or TypeName.Name.
+ * Handles array suffix ([]) and generic brackets.
+ */
+export function normalizeTypeName(name: string): string {
+  // Strip array suffix: "String[]" → "string" (arrays of allowed types are allowed)
+  // Strip generic args: "List[int]" → "list" (conservative — the generic wrapper
+  // might be unsafe even if the type arg is safe, so we check the outer type)
+  return name
+    .toLowerCase()
+    .replace(/\[\]$/, '')
+    .replace(/\[.*\]$/, '')
+    .trim()
+}
+
+/**
+ * True if typeName (from AST) is in Microsoft's CLM allowlist.
+ * Types NOT in this set trigger ask — they access system APIs CLM blocks.
+ */
+export function isClmAllowedType(typeName: string): boolean {
+  return CLM_ALLOWED_TYPES.has(normalizeTypeName(typeName))
+}

package/src/tools/PowerShellTool/commandSemantics.ts

@@ -0,0 +1,142 @@
+/**
+ * Command semantics configuration for interpreting exit codes in PowerShell.
+ *
+ * PowerShell-native cmdlets do NOT need exit-code semantics:
+ *   - Select-String (grep equivalent) exits 0 on no-match (returns $null)
+ *   - Compare-Object (diff equivalent) exits 0 regardless
+ *   - Test-Path exits 0 regardless (returns bool via pipeline)
+ * Native cmdlets signal failure via terminating errors ($?), not exit codes.
+ *
+ * However, EXTERNAL executables invoked from PowerShell DO set $LASTEXITCODE,
+ * and many use non-zero codes to convey information rather than failure:
+ *   - grep.exe / rg.exe (Git for Windows, scoop, etc.): 1 = no match
+ *   - findstr.exe (Windows native): 1 = no match
+ *   - robocopy.exe (Windows native): 0-7 = success, 8+ = error (notorious!)
+ *
+ * Without this module, PowerShellTool throws ShellError on any non-zero exit,
+ * so `robocopy` reporting "files copied successfully" (exit 1) shows as an error.
+ */
+
+export type CommandSemantic = (
+  exitCode: number,
+  stdout: string,
+  stderr: string,
+) => {
+  isError: boolean
+  message?: string
+}
+
+/**
+ * Default semantic: treat only 0 as success, everything else as error
+ */
+const DEFAULT_SEMANTIC: CommandSemantic = (exitCode, _stdout, _stderr) => ({
+  isError: exitCode !== 0,
+  message:
+    exitCode !== 0 ? `Command failed with exit code ${exitCode}` : undefined,
+})
+
+/**
+ * grep / ripgrep: 0 = matches found, 1 = no matches, 2+ = error
+ */
+const GREP_SEMANTIC: CommandSemantic = (exitCode, _stdout, _stderr) => ({
+  isError: exitCode >= 2,
+  message: exitCode === 1 ? 'No matches found' : undefined,
+})
+
+/**
+ * Command-specific semantics for external executables.
+ * Keys are lowercase command names WITHOUT .exe suffix.
+ *
+ * Deliberately omitted:
+ *   - 'diff': Ambiguous. Windows PowerShell 5.1 aliases `diff` → Compare-Object
+ *     (exit 0 on differ), but PS Core / Git for Windows may resolve to diff.exe
+ *     (exit 1 on differ). Cannot reliably interpret.
+ *   - 'fc': Ambiguous. PowerShell aliases `fc` → Format-Custom (a native cmdlet),
+ *     but `fc.exe` is the Windows file compare utility (exit 1 = files differ).
+ *     Same aliasing problem as `diff`.
+ *   - 'find': Ambiguous. Windows find.exe (text search) vs Unix find.exe
+ *     (file search via Git for Windows) have different semantics.
+ *   - 'test', '[': Not PowerShell constructs.
+ *   - 'select-string', 'compare-object', 'test-path': Native cmdlets exit 0.
+ */
+const COMMAND_SEMANTICS: Map<string, CommandSemantic> = new Map([
+  // External grep/ripgrep (Git for Windows, scoop, choco)
+  ['grep', GREP_SEMANTIC],
+  ['rg', GREP_SEMANTIC],
+
+  // findstr.exe: Windows native text search
+  // 0 = match found, 1 = no match, 2 = error
+  ['findstr', GREP_SEMANTIC],
+
+  // robocopy.exe: Windows native robust file copy
+  // Exit codes are a BITFIELD — 0-7 are success, 8+ indicates at least one failure:
+  //   0 = no files copied, no mismatch, no failures (already in sync)
+  //   1 = files copied successfully
+  //   2 = extra files/dirs detected (no copy)
+  //   4 = mismatched files/dirs detected
+  //   8 = some files/dirs could not be copied (copy errors)
+  //  16 = serious error (robocopy did not copy any files)
+  // This is the single most common "CI failed but nothing's wrong" Windows gotcha.
+  [
+    'robocopy',
+    (exitCode, _stdout, _stderr) => ({
+      isError: exitCode >= 8,
+      message:
+        exitCode === 0
+          ? 'No files copied (already in sync)'
+          : exitCode >= 1 && exitCode < 8
+            ? exitCode & 1
+              ? 'Files copied successfully'
+              : 'Robocopy completed (no errors)'
+            : undefined,
+    }),
+  ],
+])
+
+/**
+ * Extract the command name from a single pipeline segment.
+ * Strips leading `&` / `.` call operators and `.exe` suffix, lowercases.
+ */
+function extractBaseCommand(segment: string): string {
+  // Strip PowerShell call operators: & "cmd", . "cmd"
+  // (& and . at segment start followed by whitespace invoke the next token)
+  const stripped = segment.trim().replace(/^[&.]\s+/, '')
+  const firstToken = stripped.split(/\s+/)[0] || ''
+  // Strip surrounding quotes if command was invoked as & "grep.exe"
+  const unquoted = firstToken.replace(/^["']|["']$/g, '')
+  // Strip path: C:\bin\grep.exe → grep.exe, .\rg.exe → rg.exe
+  const basename = unquoted.split(/[\\/]/).pop() || unquoted
+  // Strip .exe suffix (Windows is case-insensitive)
+  return basename.toLowerCase().replace(/\.exe$/, '')
+}
+
+/**
+ * Extract the primary command from a PowerShell command line.
+ * Takes the LAST pipeline segment since that determines the exit code.
+ *
+ * Heuristic split on `;` and `|` — may get it wrong for quoted strings or
+ * complex constructs. Do NOT depend on this for security; it's only used
+ * for exit-code interpretation (false negatives just fall back to default).
+ */
+function heuristicallyExtractBaseCommand(command: string): string {
+  const segments = command.split(/[;|]/).filter(s => s.trim())
+  const last = segments[segments.length - 1] || command
+  return extractBaseCommand(last)
+}
+
+/**
+ * Interpret command result based on semantic rules
+ */
+export function interpretCommandResult(
+  command: string,
+  exitCode: number,
+  stdout: string,
+  stderr: string,
+): {
+  isError: boolean
+  message?: string
+} {
+  const baseCommand = heuristicallyExtractBaseCommand(command)
+  const semantic = COMMAND_SEMANTICS.get(baseCommand) ?? DEFAULT_SEMANTIC
+  return semantic(exitCode, stdout, stderr)
+}

package/src/tools/PowerShellTool/commonParameters.ts

@@ -0,0 +1,30 @@
+/**
+ * PowerShell Common Parameters (available on all cmdlets via [CmdletBinding()]).
+ * Source: about_CommonParameters (PowerShell docs) + Get-Command output.
+ *
+ * Shared between pathValidation.ts (merges into per-cmdlet known-param sets)
+ * and readOnlyValidation.ts (merges into safeFlags check). Split out to break
+ * what would otherwise be an import cycle between those two files.
+ *
+ * Stored lowercase with leading dash — callers `.toLowerCase()` their input.
+ */
+
+export const COMMON_SWITCHES = ['-verbose', '-debug']
+
+export const COMMON_VALUE_PARAMS = [
+  '-erroraction',
+  '-warningaction',
+  '-informationaction',
+  '-progressaction',
+  '-errorvariable',
+  '-warningvariable',
+  '-informationvariable',
+  '-outvariable',
+  '-outbuffer',
+  '-pipelinevariable',
+]
+
+export const COMMON_PARAMETERS: ReadonlySet<string> = new Set([
+  ...COMMON_SWITCHES,
+  ...COMMON_VALUE_PARAMS,
+])

package/src/tools/PowerShellTool/destructiveCommandWarning.ts

@@ -0,0 +1,109 @@
+/**
+ * Detects potentially destructive PowerShell commands and returns a warning
+ * string for display in the permission dialog. This is purely informational
+ * -- it doesn't affect permission logic or auto-approval.
+ */
+
+type DestructivePattern = {
+  pattern: RegExp
+  warning: string
+}
+
+const DESTRUCTIVE_PATTERNS: DestructivePattern[] = [
+  // Remove-Item with -Recurse and/or -Force (and common aliases)
+  // Anchored to statement start (^, |, ;, &, newline, {, () so `git rm --force`
+  // doesn't match — \b would match `rm` after any word boundary. The `{(`
+  // chars catch scriptblock/group bodies: `{ rm -Force ./x }`. The stopper
+  // adds only `}` (NOT `)`) — `}` ends a block so flags after it belong to a
+  // different statement (`if {rm} else {... -Force}`), but `)` closes a path
+  // grouping and flags after it are still this command's flags:
+  // `Remove-Item (Join-Path $r "tmp") -Recurse -Force` must still warn.
+  {
+    pattern:
+      /(?:^|[|;&\n({])\s*(Remove-Item|rm|del|rd|rmdir|ri)\b[^|;&\n}]*-Recurse\b[^|;&\n}]*-Force\b/i,
+    warning: 'Note: may recursively force-remove files',
+  },
+  {
+    pattern:
+      /(?:^|[|;&\n({])\s*(Remove-Item|rm|del|rd|rmdir|ri)\b[^|;&\n}]*-Force\b[^|;&\n}]*-Recurse\b/i,
+    warning: 'Note: may recursively force-remove files',
+  },
+  {
+    pattern:
+      /(?:^|[|;&\n({])\s*(Remove-Item|rm|del|rd|rmdir|ri)\b[^|;&\n}]*-Recurse\b/i,
+    warning: 'Note: may recursively remove files',
+  },
+  {
+    pattern:
+      /(?:^|[|;&\n({])\s*(Remove-Item|rm|del|rd|rmdir|ri)\b[^|;&\n}]*-Force\b/i,
+    warning: 'Note: may force-remove files',
+  },
+
+  // Clear-Content on broad paths
+  {
+    pattern: /\bClear-Content\b[^|;&\n]*\*/i,
+    warning: 'Note: may clear content of multiple files',
+  },
+
+  // Format-Volume and Clear-Disk
+  {
+    pattern: /\bFormat-Volume\b/i,
+    warning: 'Note: may format a disk volume',
+  },
+  {
+    pattern: /\bClear-Disk\b/i,
+    warning: 'Note: may clear a disk',
+  },
+
+  // Git destructive operations (same as BashTool)
+  {
+    pattern: /\bgit\s+reset\s+--hard\b/i,
+    warning: 'Note: may discard uncommitted changes',
+  },
+  {
+    pattern: /\bgit\s+push\b[^|;&\n]*\s+(--force|--force-with-lease|-f)\b/i,
+    warning: 'Note: may overwrite remote history',
+  },
+  {
+    pattern:
+      /\bgit\s+clean\b(?![^|;&\n]*(?:-[a-zA-Z]*n|--dry-run))[^|;&\n]*-[a-zA-Z]*f/i,
+    warning: 'Note: may permanently delete untracked files',
+  },
+  {
+    pattern: /\bgit\s+stash\s+(drop|clear)\b/i,
+    warning: 'Note: may permanently remove stashed changes',
+  },
+
+  // Database operations
+  {
+    pattern: /\b(DROP|TRUNCATE)\s+(TABLE|DATABASE|SCHEMA)\b/i,
+    warning: 'Note: may drop or truncate database objects',
+  },
+
+  // System operations
+  {
+    pattern: /\bStop-Computer\b/i,
+    warning: 'Note: will shut down the computer',
+  },
+  {
+    pattern: /\bRestart-Computer\b/i,
+    warning: 'Note: will restart the computer',
+  },
+  {
+    pattern: /\bClear-RecycleBin\b/i,
+    warning: 'Note: permanently deletes recycled files',
+  },
+]
+
+/**
+ * Checks if a PowerShell command matches known destructive patterns.
+ * Returns a human-readable warning string, or null if no destructive pattern is detected.
+ */
+export function getDestructiveCommandWarning(command: string): string | null {
+  for (const { pattern, warning } of DESTRUCTIVE_PATTERNS) {
+    if (pattern.test(command)) {
+      return warning
+    }
+  }
+  return null
+}