Method execute

src/tools/shell/bash.ts:21–74

(args: z.infer<typeof ArgsSchema>, ctx: ToolContext)

  argsSchema = ArgsSchema;

  async execute(args: z.infer<typeof ArgsSchema>, ctx: ToolContext): Promise<ToolResult> {
    const cmd = args.command.trim();
    if (!cmd) return { content: '[ERROR] Empty command', isError: true };

    // Permission check
    const permReq = { tool: 'shell', operation: cmd, description: args.description };
    const decision = ctx.permissions.evaluate(permReq);
    if (decision === 'deny') {
      return { content: `[PERMISSION_DENIED] Command blocked by policy: ${cmd}\nIf you really need this, ask the user to add an allow rule.`, isError: true };
    }
    if (decision === 'ask') {
      ctx.emit({ type: 'permission-request', tool: 'shell', operation: cmd, description: args.description });
      const answer = await ctx.askUser(
        `Run: ${cmd}${args.description ? `\n  (${args.description})` : ''}`,
        ['yes', 'no', 'always'],
      );
      if (answer === 'no') {
        return { content: `[USER_REJECTED] User declined to run: ${cmd}`, isError: true };
      }
      if (answer === 'always') {
        ctx.permissions.rememberDecision(permReq, 'allow', 'pattern');
      }
    }

    const timeoutMs = (args.timeout_seconds ?? 120) * 1000;

    // Auto-snapshot: if the wiring is present and this command pattern is destructive,
    // take a git stash first so /undo can roll back. Best-effort — never blocks on
    // failure, but the failure IS surfaced in the result so the user knows /undo
    // is unavailable for this command.
    let snapshotWarning: string | null = null;
    if (ctx.snapshotService) {
      const snapshot = await import('../../safety/snapshot.js');
      const check = snapshot.isDestructiveBash(cmd);
      if (check.destructive) {
        try {
          ctx.snapshotService.takeSnapshot(
            `before bash: ${check.label} (${cmd.slice(0, 80)})`,
            ctx.currentTurn ?? 0,
          );
        } catch (e: any) {
          // Snapshot failure is non-fatal — log, surface to the user, and proceed.
          logger.warn('Auto-snapshot before bash failed (continuing)', { err: e?.message });
          snapshotWarning = '⚠ snapshot failed — /undo unavailable for this command';
        }
      }
    }

    const result = await this.runCommand(cmd, ctx, timeoutMs);
    if (snapshotWarning) {
      return { ...result, content: `${snapshotWarning}\n${result.content}` };
    }
    return result;
  }

  private runCommand(cmd: string, ctx: ToolContext, timeoutMs: number): Promise<ToolResult> {
    return new Promise(resolve => {