ummaya 0.2.3 → 0.2.5

package/tui/src/tools/PowerShellTool/acceptEditsCommandValidation.ts

@@ -0,0 +1,162 @@
+import type { PermissionResult } from '../../utils/permissions/PermissionResult.js'
+import type { ParsedPowerShellCommand } from '../../utils/powershell/parser.js'
+import { getPipelineSegments } from '../../utils/powershell/parser.js'
+import {
+  argLeaksValue,
+  isAllowlistedPipelineTail,
+  isCwdChangingCmdlet,
+  isSafeOutputCommand,
+  resolveToCanonical,
+} from './readOnlyValidation.js'
+import { isSymlinkCreatingCommand } from './symlinkModeValidation.js'
+
+const ACCEPT_EDITS_ALLOWED_CMDLETS = new Set([
+  'set-content',
+  'add-content',
+  'remove-item',
+  'clear-content',
+])
+
+export function isAcceptEditsAllowedCmdlet(name: string): boolean {
+  return ACCEPT_EDITS_ALLOWED_CMDLETS.has(resolveToCanonical(name))
+}
+
+function checkCompoundGuards(
+  segments: ReturnType<typeof getPipelineSegments>,
+): PermissionResult | null {
+  const totalCommands = segments.reduce(
+    (sum, segment) => sum + segment.commands.length,
+    0,
+  )
+  if (totalCommands <= 1) return null
+
+  let hasCdCommand = false
+  let hasSymlinkCreate = false
+  let hasWriteCommand = false
+  for (const segment of segments) {
+    for (const cmd of segment.commands) {
+      if (cmd.elementType !== 'CommandAst') continue
+      if (isCwdChangingCmdlet(cmd.name)) hasCdCommand = true
+      if (isSymlinkCreatingCommand(cmd)) hasSymlinkCreate = true
+      if (isAcceptEditsAllowedCmdlet(cmd.name)) hasWriteCommand = true
+    }
+  }
+
+  if (hasCdCommand && hasWriteCommand) {
+    return {
+      behavior: 'passthrough',
+      message:
+        'Compound command contains a directory-changing command with a write operation; path validation would use a stale cwd',
+    }
+  }
+  if (hasSymlinkCreate) {
+    return {
+      behavior: 'passthrough',
+      message:
+        'Compound command creates a filesystem link; path validation cannot follow just-created links',
+    }
+  }
+  return null
+}
+
+function checkCommandAst(
+  cmd: ReturnType<typeof getPipelineSegments>[number]['commands'][number],
+  command: string,
+  nested: boolean,
+): PermissionResult | null {
+  if (cmd.elementType !== 'CommandAst') {
+    return {
+      behavior: 'passthrough',
+      message: `${nested ? 'Nested expression' : 'Pipeline source'} element (${cmd.elementType}) cannot be statically validated`,
+    }
+  }
+  if (cmd.nameType === 'application') {
+    return {
+      behavior: 'passthrough',
+      message: `${nested ? 'Nested command' : 'Command'} '${cmd.name}' resolved from a path-like name and requires approval`,
+    }
+  }
+  if (isSafeOutputCommand(cmd.name) || isAllowlistedPipelineTail(cmd, command)) {
+    return null
+  }
+  if (!isAcceptEditsAllowedCmdlet(cmd.name)) {
+    return {
+      behavior: 'passthrough',
+      message: `No mode-specific handling for '${cmd.name}' in acceptEdits mode`,
+    }
+  }
+  if (argLeaksValue(cmd.name, cmd)) {
+    return {
+      behavior: 'passthrough',
+      message: `Arguments in '${cmd.name}' cannot be statically validated in acceptEdits mode`,
+    }
+  }
+  return null
+}
+
+function checkCommandArguments(
+  cmd: ReturnType<typeof getPipelineSegments>[number]['commands'][number],
+): PermissionResult | null {
+  if (cmd.elementType !== 'CommandAst' || !cmd.elementTypes) return null
+
+  for (let index = 1; index < cmd.elementTypes.length; index++) {
+    const elementType = cmd.elementTypes[index]
+    if (elementType !== 'StringConstant' && elementType !== 'Parameter') {
+      return {
+        behavior: 'passthrough',
+        message: `Command argument has unvalidatable type (${elementType})`,
+      }
+    }
+    if (elementType !== 'Parameter') continue
+
+    const arg = cmd.args[index - 1] ?? ''
+    const colonIdx = arg.indexOf(':')
+    if (colonIdx > 0 && /[$(@{[]/.test(arg.slice(colonIdx + 1))) {
+      return {
+        behavior: 'passthrough',
+        message:
+          'Colon-bound parameter contains an expression that cannot be statically validated',
+      }
+    }
+  }
+  return null
+}
+
+export function checkAcceptEditsCommands(
+  input: { command: string },
+  parsed: ParsedPowerShellCommand,
+): PermissionResult {
+  const segments = getPipelineSegments(parsed)
+  if (segments.length === 0) {
+    return {
+      behavior: 'passthrough',
+      message: 'No commands found to validate for acceptEdits mode',
+    }
+  }
+
+  const compoundResult = checkCompoundGuards(segments)
+  if (compoundResult !== null) return compoundResult
+
+  for (const segment of segments) {
+    for (const cmd of segment.commands) {
+      const argumentResult = checkCommandArguments(cmd)
+      if (argumentResult !== null) return argumentResult
+      const commandResult = checkCommandAst(cmd, input.command, false)
+      if (commandResult !== null) return commandResult
+    }
+
+    for (const cmd of segment.nestedCommands ?? []) {
+      const commandResult = checkCommandAst(cmd, input.command, true)
+      if (commandResult !== null) return commandResult
+    }
+  }
+
+  return {
+    behavior: 'allow',
+    updatedInput: input,
+    decisionReason: {
+      type: 'mode',
+      mode: 'acceptEdits',
+    },
+  }
+}

package/tui/src/tools/PowerShellTool/call.ts

@@ -0,0 +1,179 @@
+import type { CanUseToolFn } from 'src/hooks/useCanUseTool.js';
+import { type AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS, logEvent } from '../../services/analytics/index.js';
+import type { ToolCallProgress, ToolUseContext } from '../../Tool.js';
+import type { AssistantMessage } from '../../types/message.js';
+import type { PowerShellProgress } from '../../types/tools.js';
+import { extractClaudeCodeHints } from '../../utils/claudeCodeHints.js';
+import { ShellError } from '../../utils/errors.js';
+import { maybeRecordPluginHint } from '../../utils/plugins/hintRecommendation.js';
+import type { ExecResult } from '../../utils/ShellCommand.js';
+import { EndTruncatingAccumulator } from '../../utils/stringUtils.js';
+import { trackGitOperations } from '../shared/gitOperationTracking.js';
+import { resetShellCwdIfOutsideProject } from '../BashTool/cwdReset.js';
+import { isImageOutput, resizeShellImageOutput, stdErrAppendShellResetMessage, stripEmptyLines } from '../BashTool/shellOutputUtils.js';
+import { getCommandTypeForLogging } from './commandClassification.js';
+import { interpretCommandResult } from './commandSemantics.js';
+import { persistLargePowerShellOutput } from './outputPersistence.js';
+import { runPowerShellCommand } from './shellExecution.js';
+import { isWindowsSandboxPolicyViolation, WINDOWS_SANDBOX_POLICY_REFUSAL } from './validation.js';
+import type { Out, PowerShellToolInput } from './schemas.js';
+
+const EOL = '\n';
+
+export async function callPowerShellTool(
+  input: PowerShellToolInput,
+  toolUseContext: ToolUseContext,
+  _canUseTool?: CanUseToolFn,
+  _parentMessage?: AssistantMessage,
+  onProgress?: ToolCallProgress<PowerShellProgress>
+): Promise<{ readonly data: Out }> {
+  if (isWindowsSandboxPolicyViolation()) {
+    throw new Error(WINDOWS_SANDBOX_POLICY_REFUSAL);
+  }
+  const { abortController, setToolJSX } = toolUseContext;
+  const isMainThread = !toolUseContext.agentId;
+  try {
+    const result = await consumePowerShellCommand({ input, toolUseContext, isMainThread, onProgress });
+    const isPreFlightSentinel = result.code === 0 && !result.stdout && result.stderr && !result.backgroundTaskId;
+    if (!isPreFlightSentinel) {
+      trackGitOperations(input.command, result.code, result.stdout);
+    }
+    const isInterrupt = result.interrupted && abortController.signal.reason === 'interrupt';
+    const stderrForShellReset = getShellResetStderr(toolUseContext, isMainThread);
+    if (result.backgroundTaskId) {
+      return buildBackgroundResult(input.command, result, stderrForShellReset, isMainThread);
+    }
+    const stdout = prepareCompletedStdout(result, input.command, isMainThread);
+    const interpretation = interpretCommandResult(input.command, result.code, stdout, result.stderr || '');
+    if (result.preSpawnError) {
+      throw new Error(result.preSpawnError);
+    }
+    if (interpretation.isError && !isInterrupt) {
+      throw new ShellError(stdout, result.stderr || '', result.code, result.interrupted);
+    }
+    const persisted = await persistLargePowerShellOutput(result);
+    const imageResult = await normalizeImageOutput(stdout, result.outputFilePath, persisted.size);
+    const finalStderr = [result.stderr || '', stderrForShellReset].filter(Boolean).join('\n');
+    logEvent('tengu_powershell_tool_command_executed', {
+      command_type: getCommandTypeForLogging(input.command),
+      stdout_length: imageResult.stdout.length,
+      stderr_length: finalStderr.length,
+      exit_code: result.code,
+      interrupted: result.interrupted
+    });
+    return {
+      data: {
+        stdout: imageResult.stdout,
+        stderr: finalStderr,
+        interrupted: result.interrupted,
+        returnCodeInterpretation: interpretation.message,
+        isImage: imageResult.isImage,
+        persistedOutputPath: persisted.path,
+        persistedOutputSize: persisted.size
+      }
+    };
+  } finally {
+    if (setToolJSX) setToolJSX(null);
+  }
+}
+
+type ConsumeInput = {
+  readonly input: PowerShellToolInput;
+  readonly toolUseContext: ToolUseContext;
+  readonly isMainThread: boolean;
+  readonly onProgress?: ToolCallProgress<PowerShellProgress>;
+};
+
+async function consumePowerShellCommand({
+  input,
+  toolUseContext,
+  isMainThread,
+  onProgress
+}: ConsumeInput): Promise<ExecResult> {
+  const commandGenerator = runPowerShellCommand({
+    input,
+    abortController: toolUseContext.abortController,
+    setAppState: toolUseContext.setAppStateForTasks ?? toolUseContext.setAppState,
+    setToolJSX: toolUseContext.setToolJSX,
+    preventCwdChanges: !isMainThread,
+    isMainThread,
+    toolUseId: toolUseContext.toolUseId,
+    agentId: toolUseContext.agentId
+  });
+  let progressCounter = 0;
+  let generatorResult;
+  do {
+    generatorResult = await commandGenerator.next();
+    if (!generatorResult.done && onProgress) {
+      const progress = generatorResult.value;
+      onProgress({
+        toolUseID: `ps-progress-${progressCounter++}`,
+        data: {
+          type: 'powershell_progress',
+          output: progress.output,
+          fullOutput: progress.fullOutput,
+          elapsedTimeSeconds: progress.elapsedTimeSeconds,
+          totalLines: progress.totalLines,
+          totalBytes: progress.totalBytes,
+          timeoutMs: progress.timeoutMs,
+          taskId: progress.taskId
+        }
+      });
+    }
+  } while (!generatorResult.done);
+  return generatorResult.value;
+}
+
+function getShellResetStderr(toolUseContext: ToolUseContext, isMainThread: boolean): string {
+  if (!isMainThread) {
+    return '';
+  }
+  const appState = toolUseContext.getAppState();
+  return resetShellCwdIfOutsideProject(appState.toolPermissionContext) ? stdErrAppendShellResetMessage('') : '';
+}
+
+function buildBackgroundResult(command: string, result: ExecResult, stderrForShellReset: string, isMainThread: boolean): { readonly data: Out } {
+  const extracted = extractClaudeCodeHints(result.stdout || '', command);
+  if (isMainThread && extracted.hints.length > 0) {
+    for (const hint of extracted.hints) maybeRecordPluginHint(hint);
+  }
+  return {
+    data: {
+      stdout: extracted.stripped,
+      stderr: [result.stderr || '', stderrForShellReset].filter(Boolean).join('\n'),
+      interrupted: false,
+      backgroundTaskId: result.backgroundTaskId,
+      backgroundedByUser: result.backgroundedByUser,
+      assistantAutoBackgrounded: result.assistantAutoBackgrounded
+    }
+  };
+}
+
+function prepareCompletedStdout(result: ExecResult, command: string, isMainThread: boolean): string {
+  const stdoutAccumulator = new EndTruncatingAccumulator();
+  const processedStdout = (result.stdout || '').trimEnd();
+  stdoutAccumulator.append(processedStdout + EOL);
+  let stdout = stripEmptyLines(stdoutAccumulator.toString());
+  const extracted = extractClaudeCodeHints(stdout, command);
+  stdout = extracted.stripped;
+  if (isMainThread && extracted.hints.length > 0) {
+    for (const hint of extracted.hints) maybeRecordPluginHint(hint);
+  }
+  return stdout;
+}
+
+type ImageOutput = {
+  readonly stdout: string;
+  readonly isImage: boolean;
+};
+
+async function normalizeImageOutput(stdout: string, outputFilePath?: string, persistedOutputSize?: number): Promise<ImageOutput> {
+  if (!isImageOutput(stdout)) {
+    return { stdout, isImage: false };
+  }
+  const resized = await resizeShellImageOutput(stdout, outputFilePath, persistedOutputSize);
+  if (resized) {
+    return { stdout: resized, isImage: true };
+  }
+  return { stdout, isImage: false };
+}

package/tui/src/tools/PowerShellTool/callLoader.ts

@@ -0,0 +1,37 @@
+import { createRequire } from 'node:module'
+import type { CanUseToolFn } from 'src/hooks/useCanUseTool.js'
+import type { ToolCallProgress, ToolUseContext } from '../../Tool.js'
+import type { AssistantMessage } from '../../types/message.js'
+import type { PowerShellProgress } from '../../types/tools.js'
+import type { Out, PowerShellToolInput } from './schemas.js'
+
+type PowerShellCallRuntime = {
+  readonly callPowerShellTool: (
+    input: PowerShellToolInput,
+    toolUseContext: ToolUseContext,
+    canUseTool?: CanUseToolFn,
+    parentMessage?: AssistantMessage,
+    onProgress?: ToolCallProgress<PowerShellProgress>,
+  ) => Promise<{ readonly data: Out }>
+}
+
+const requireModule = createRequire(import.meta.url)
+let cachedRuntime: PowerShellCallRuntime | undefined
+
+function isPowerShellCallRuntime(
+  value: unknown,
+): value is PowerShellCallRuntime {
+  if (typeof value !== 'object' || value === null) return false
+  const module = value as Partial<Record<keyof PowerShellCallRuntime, unknown>>
+  return typeof module.callPowerShellTool === 'function'
+}
+
+export function loadPowerShellCallRuntime(): PowerShellCallRuntime {
+  if (cachedRuntime !== undefined) return cachedRuntime
+  const loaded: unknown = requireModule('./call.js')
+  if (!isPowerShellCallRuntime(loaded)) {
+    throw new Error('PowerShell call module did not expose expected lifecycle')
+  }
+  cachedRuntime = loaded
+  return loaded
+}

package/tui/src/tools/PowerShellTool/commandClassification.ts

@@ -0,0 +1,86 @@
+import type { AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS } from '../../services/analytics/index.js';
+import { resolveToCanonical } from './readOnlyValidation.js';
+
+const PS_SEARCH_COMMANDS = new Set(['select-string', 'get-childitem', 'findstr', 'where.exe']);
+const PS_READ_COMMANDS = new Set(['get-content', 'get-item', 'test-path', 'resolve-path', 'get-process', 'get-service', 'get-childitem', 'get-location', 'get-filehash', 'get-acl', 'format-hex']);
+const PS_SEMANTIC_NEUTRAL_COMMANDS = new Set(['write-output', 'write-host']);
+const DISALLOWED_AUTO_BACKGROUND_COMMANDS = ['start-sleep', 'sleep'];
+const COMMON_BACKGROUND_COMMANDS = ['npm', 'yarn', 'pnpm', 'node', 'python', 'python3', 'go', 'cargo', 'make', 'docker', 'terraform', 'webpack', 'vite', 'jest', 'pytest', 'curl', 'Invoke-WebRequest', 'build', 'test', 'serve', 'watch', 'dev'] as const;
+
+type SearchReadClassification = {
+  readonly isSearch: boolean;
+  readonly isRead: boolean;
+};
+
+const NOT_SEARCH_OR_READ: SearchReadClassification = {
+  isSearch: false,
+  isRead: false
+};
+
+export function isSearchOrReadPowerShellCommand(command: string): SearchReadClassification {
+  const trimmed = command.trim();
+  if (!trimmed) {
+    return NOT_SEARCH_OR_READ;
+  }
+  const parts = trimmed.split(/\s*[;|]\s*/).filter(Boolean);
+  if (parts.length === 0) {
+    return NOT_SEARCH_OR_READ;
+  }
+  let hasSearch = false;
+  let hasRead = false;
+  let hasNonNeutralCommand = false;
+  for (const part of parts) {
+    const baseCommand = part.trim().split(/\s+/)[0];
+    if (!baseCommand) {
+      continue;
+    }
+    const canonical = resolveToCanonical(baseCommand);
+    if (PS_SEMANTIC_NEUTRAL_COMMANDS.has(canonical)) {
+      continue;
+    }
+    hasNonNeutralCommand = true;
+    const isPartSearch = PS_SEARCH_COMMANDS.has(canonical);
+    const isPartRead = PS_READ_COMMANDS.has(canonical);
+    if (!isPartSearch && !isPartRead) {
+      return NOT_SEARCH_OR_READ;
+    }
+    if (isPartSearch) hasSearch = true;
+    if (isPartRead) hasRead = true;
+  }
+  if (!hasNonNeutralCommand) {
+    return NOT_SEARCH_OR_READ;
+  }
+  return {
+    isSearch: hasSearch,
+    isRead: hasRead
+  };
+}
+
+export function isAutobackgroundingAllowed(command: string): boolean {
+  const firstWord = command.trim().split(/\s+/)[0];
+  if (!firstWord) return true;
+  const canonical = resolveToCanonical(firstWord);
+  return !DISALLOWED_AUTO_BACKGROUND_COMMANDS.includes(canonical);
+}
+
+export function detectBlockedSleepPattern(command: string): string | null {
+  const first = command.trim().split(/[;|&\r\n]/)[0]?.trim() ?? '';
+  const match = /^(?:start-sleep|sleep)(?:\s+-s(?:econds)?)?\s+(\d+)\s*$/i.exec(first);
+  const secondsText = match?.[1];
+  if (!secondsText) return null;
+  const seconds = parseInt(secondsText, 10);
+  if (seconds < 2) return null;
+  const rest = command.trim().slice(first.length).replace(/^[\s;|&]+/, '');
+  return rest ? `Start-Sleep ${seconds} followed by: ${rest}` : `standalone Start-Sleep ${seconds}`;
+}
+
+export function getCommandTypeForLogging(command: string): AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS {
+  const trimmed = command.trim();
+  const firstWord = trimmed.split(/\s+/)[0] || '';
+  for (const cmd of COMMON_BACKGROUND_COMMANDS) {
+    if (firstWord.toLowerCase() === cmd.toLowerCase()) {
+      return cmd as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS;
+    }
+  }
+  return 'other' as AnalyticsMetadata_I_VERIFIED_THIS_IS_NOT_CODE_OR_FILEPATHS;
+}