minimal-agent 0.11.0 → 0.13.0

package/src/tools/powershell/powershell.js

@@ -11,6 +11,8 @@ import { killTree } from '../shared/killTree.js';
 import { startBackgroundTask } from '../tasks/backgroundTaskService.js';
 import { processExecutionMetadata } from '../tasks/processEvidence.js';
 import { DEFAULT_MAX_RESULT_SIZE_CHARS } from '../types.js';
+import { permanentDeleteReason } from '../shared/permanentDeleteGuard.js';
+import { ToolOutputStore } from '../shared/toolOutputStore.js';
 const MAX_TIMEOUT_MS = 600_000;
 function findPowerShell() {
     if (process.platform !== 'win32')
@@ -35,23 +37,42 @@ const inputSchema = z.object({
     run_in_background: z.boolean().optional(),
 });
 function invocation(command) {
-    return ['-NoLogo', '-NoProfile', '-NonInteractive', '-Command', `$OutputEncoding=[Console]::OutputEncoding=[Text.UTF8Encoding]::new(); ${command}`];
+    return [
+        '-NoLogo',
+        '-NoProfile',
+        '-NonInteractive',
+        '-Command',
+        `$OutputEncoding=[Console]::OutputEncoding=[Text.UTF8Encoding]::new(); ${command}`,
+    ];
 }
 async function approved(command, signal) {
+    const permanentDelete = permanentDeleteReason(command, 'powershell');
+    if (permanentDelete)
+        return {
+            ok: false,
+            error: `永久删除检查拒绝执行：${permanentDelete}\n命令：${command}`,
+        };
     const forbidden = checkForbidden(command);
     if (forbidden)
-        return { ok: false, error: `安全检查拒绝执行：${forbidden}\n命令：${command}` };
+        return {
+            ok: false,
+            error: `安全检查拒绝执行：${forbidden}\n命令：${command}`,
+        };
     const irreversible = classifyCommand(command);
     if (!irreversible)
         return undefined;
-    const [answer] = await requestUserChoice([{
-            question: `这条命令不可逆：${irreversible.why}。\n\n命令：${command}\n\n确认执行吗？`, header: '不可逆操作',
+    const [answer] = await requestUserChoice([
+        {
+            question: `这条命令不可逆：${irreversible.why}。\n\n命令：${command}\n\n确认执行吗？`,
+            header: '不可逆操作',
             options: [
                 { label: '取消，不执行 (推荐)', description: '放弃并改用可回滚做法' },
                 { label: '我已确认后果，执行', description: '继续执行不可逆操作' },
             ],
-        }], signal);
-    return answer?.selected?.[0]?.includes('执行') && !answer.selected[0]?.includes('取消')
+        },
+    ], signal);
+    return answer?.selected?.[0]?.includes('执行') &&
+        !answer.selected[0]?.includes('取消')
         ? undefined
         : { ok: false, error: `已拒绝执行不可逆 PowerShell 命令：${command}` };
 }
@@ -66,45 +87,128 @@ async function call(input, signal, context) {
     const cwd = context?.cwd ?? getWorkingDir();
     if (input.run_in_background) {
         try {
-            const task = await startBackgroundTask({ command: input.command, executable, args, cwd, env: sanitizedChildEnv(), sessionId: context?.sessionId, shellKind: 'powershell' }, context?.sessionState?.backgroundTasks);
+            const task = await startBackgroundTask({
+                command: input.command,
+                executable,
+                args,
+                cwd,
+                env: sanitizedChildEnv(),
+                sessionId: context?.sessionId,
+                workspaceId: context?.workspaceId,
+                shellKind: 'powershell',
+            }, context?.sessionState?.backgroundTasks);
             return {
                 ok: true,
-                content: `PowerShell 后台任务已启动。task_id=${task.id}\nlog=${task.logPath}`,
-                metadata: processExecutionMetadata({ shell: 'powershell', mode: 'background', command: input.command, status: 'started', taskId: task.id }),
+                content: `PowerShell 后台任务已启动。task_id=${task.id.replace(/^proc_/, '')}\nprocess_id=${task.id}\nlog=${task.logPath}`,
+                metadata: processExecutionMetadata({
+                    shell: 'powershell',
+                    mode: 'background',
+                    command: input.command,
+                    status: 'started',
+                    taskId: task.id,
+                }),
             };
         }
         catch (error) {
-            return { ok: false, error: `PowerShell 后台任务启动失败：${error.message}` };
+            return {
+                ok: false,
+                error: `PowerShell 后台任务启动失败：${error.message}`,
+            };
         }
     }
     return await new Promise((resolvePromise) => {
-        const child = spawn(executable, args, { cwd, env: sanitizedChildEnv(), windowsHide: true, detached: false });
-        let stdout = '';
-        let stderr = '';
+        const child = spawn(executable, args, {
+            cwd,
+            env: sanitizedChildEnv(),
+            windowsHide: true,
+            detached: false,
+        });
         let finished = false;
-        const finish = (result) => { if (finished)
-            return; finished = true; clearTimeout(timer); signal?.removeEventListener('abort', abort); resolvePromise(result); };
-        const abort = () => { killTree(child); finish({ ok: false, error: `PowerShell 命令被中断\n${stdout}\n${stderr}`.slice(0, DEFAULT_MAX_RESULT_SIZE_CHARS), metadata: processExecutionMetadata({ shell: 'powershell', mode: 'foreground', command: input.command, status: 'stopped', exitCode: null }) }); };
+        const store = new ToolOutputStore({
+            workspaceId: context?.workspaceId,
+            sessionId: context?.sessionId,
+        });
+        const finish = async (status, code, prefix = '') => {
+            if (finished)
+                return;
+            finished = true;
+            clearTimeout(timer);
+            signal?.removeEventListener('abort', abort);
+            const output = await store.finish();
+            const reference = output.path
+                ? `\n[完整输出: ${output.path}; bytes=${output.bytes}; sha256=${output.sha256}; complete=${output.complete}]`
+                : '';
+            let text = `${prefix}${output.stdout ? `<stdout>\n${output.stdout.trimEnd()}\n</stdout>\n` : ''}${output.stderr ? `<stderr>\n${output.stderr.trimEnd()}\n</stderr>\n` : ''}[exit code: ${code ?? 'killed'}]`;
+            if (text.length + reference.length > DEFAULT_MAX_RESULT_SIZE_CHARS) {
+                const suffix = `\n... (输出预览已截断)${reference}`;
+                text =
+                    text.slice(0, Math.max(0, DEFAULT_MAX_RESULT_SIZE_CHARS - suffix.length)) + suffix;
+            }
+            else
+                text += reference;
+            const metadata = processExecutionMetadata({
+                shell: 'powershell',
+                mode: 'foreground',
+                command: input.command,
+                status,
+                exitCode: code,
+            });
+            resolvePromise(status === 'completed'
+                ? { ok: true, content: text, metadata }
+                : { ok: false, error: text, metadata });
+        };
+        const abort = () => {
+            killTree(child);
+            void finish('stopped', null, 'PowerShell 命令被中断\n');
+        };
         const timeout = input.timeout ?? 120_000;
-        const timer = setTimeout(() => { killTree(child); finish({ ok: false, error: `PowerShell 命令超时（${timeout}ms）\n${stdout}\n${stderr}`.slice(0, DEFAULT_MAX_RESULT_SIZE_CHARS), metadata: processExecutionMetadata({ shell: 'powershell', mode: 'foreground', command: input.command, status: 'failed', exitCode: null }) }); }, timeout);
+        const timer = setTimeout(() => {
+            killTree(child);
+            void finish('failed', null, `PowerShell 命令超时（${timeout}ms）\n`);
+        }, timeout);
         signal?.addEventListener('abort', abort, { once: true });
         child.stdout?.setEncoding('utf8');
         child.stderr?.setEncoding('utf8');
-        child.stdout?.on('data', (chunk) => { if (stdout.length < DEFAULT_MAX_RESULT_SIZE_CHARS * 2)
-            stdout += chunk; });
-        child.stderr?.on('data', (chunk) => { if (stderr.length < DEFAULT_MAX_RESULT_SIZE_CHARS * 2)
-            stderr += chunk; });
-        child.once('error', (error) => finish({ ok: false, error: `PowerShell 启动失败：${error.message}`, metadata: processExecutionMetadata({ shell: 'powershell', mode: 'foreground', command: input.command, status: 'failed', exitCode: null }) }));
+        child.stdout?.on('data', (chunk) => {
+            if (!store.append('stdout', chunk)) {
+                child.stdout?.pause();
+                store.onDrain(() => child.stdout?.resume());
+            }
+        });
+        child.stderr?.on('data', (chunk) => {
+            if (!store.append('stderr', chunk)) {
+                child.stderr?.pause();
+                store.onDrain(() => child.stderr?.resume());
+            }
+        });
+        child.once('error', (error) => {
+            void finish('failed', null, `PowerShell 启动失败：${error.message}\n`);
+        });
         child.once('close', (code) => {
-            const text = `${stdout ? `<stdout>\n${stdout.trimEnd()}\n</stdout>\n` : ''}${stderr ? `<stderr>\n${stderr.trimEnd()}\n</stderr>\n` : ''}[exit code: ${code}]`.slice(0, DEFAULT_MAX_RESULT_SIZE_CHARS);
-            const metadata = processExecutionMetadata({ shell: 'powershell', mode: 'foreground', command: input.command, status: code === 0 ? 'completed' : 'failed', exitCode: code });
-            finish(code === 0 ? { ok: true, content: text, metadata } : { ok: false, error: text, metadata });
+            void finish(code === 0 ? 'completed' : 'failed', code);
         });
     });
 }
 export const powerShellTool = {
     name: 'PowerShell',
-    description: 'Executes native PowerShell on Windows. Use for Windows-specific administration and scripts; use run_in_background for long builds, tests, or servers, then TaskOutput/TaskStop.',
+    description: `Executes native PowerShell on Windows. Use for Windows-specific administration and scripts; use run_in_background for long builds, tests, or servers, then TaskOutput/TaskStop.
+
+# Safety - two levels, from strict to lenient
+
+## 1. Blocked outright (fails before execution - do NOT retry with variants)
+
+Catastrophic commands (no legitimate use): \`rm -rf /\`-class deletions of root/$HOME/system directories, \`mkfs\`, \`format X:\`, \`dd\` to raw devices, shutdown/reboot, fork bombs, pipe-to-shell from network (\`curl ... | sh\`), \`chmod 777 /\`, full-disk \`del /s\` / \`rmdir /s\`, \`diskpart\`.
+
+Permanent deletion (bypasses the Recycle Bin - use the Trash tool instead): \`Remove-Item\`, \`Clear-RecycleBin\`, \`del\` / \`erase\` / \`rd\` / \`rmdir\` / \`rm\` / \`ri\`, and \`.Delete()\` method calls - all fail before execution.
+To delete files or directories use the **Trash** tool (\`action: "move"\` - recoverable); to clean Git untracked files use Trash with \`action: "git-clean"\`. Do NOT try other deletion spellings - they are blocked the same way. If a permanent deletion is truly required, ask the user to run it themselves.
+
+## 2. Requires user confirmation (irreversible)
+
+These have legitimate uses but destroy the last copy - execution pauses and asks the user to confirm. In non-interactive contexts they are automatically cancelled.
+ - \`git push --force\` / \`-f\` / \`+refspec\`, \`git push --delete <branch>\`
+ - \`git filter-branch\` / \`git filter-repo\`, \`git reflog expire --expire=now\` / \`git gc --prune=now\`
+ - \`shred -u\` / \`shred --remove\`
+ - SQL data destruction: \`DROP DATABASE\`, \`DROP TABLE\`, \`TRUNCATE TABLE\``,
     inputSchema,
     parameters: toToolParameters(inputSchema),
     isReadOnly: false,
@@ -113,7 +217,10 @@ export const powerShellTool = {
     interruptBehavior: () => 'block',
     resolveAvailability: () => {
         const executable = findPowerShell();
-        return { available: Boolean(executable), signature: executable ?? 'unavailable' };
+        return {
+            available: Boolean(executable),
+            signature: executable ?? 'unavailable',
+        };
     },
     call: (input, signal) => call(input, signal),
     callWithContext: (input, signal, context) => call(input, signal, context),

package/src/tools/powershell/powershell.ts

@@ -13,6 +13,8 @@ import { killTree } from '../shared/killTree.js';
 import { startBackgroundTask } from '../tasks/backgroundTaskService.js';
 import { processExecutionMetadata } from '../tasks/processEvidence.js';
 import { DEFAULT_MAX_RESULT_SIZE_CHARS } from '../types.js';
+import { permanentDeleteReason } from '../shared/permanentDeleteGuard.js';
+import { ToolOutputStore } from '../shared/toolOutputStore.js';
 
 const MAX_TIMEOUT_MS = 600_000;
 function findPowerShell(): string | undefined {
@@ -25,7 +27,13 @@ function findPowerShell(): string | undefined {
       if (existsSync(path)) return path;
     }
   }
-  const system = join(process.env.SystemRoot ?? 'C:\\Windows', 'System32', 'WindowsPowerShell', 'v1.0', 'powershell.exe');
+  const system = join(
+    process.env.SystemRoot ?? 'C:\\Windows',
+    'System32',
+    'WindowsPowerShell',
+    'v1.0',
+    'powershell.exe',
+  );
   return existsSync(system) ? system : undefined;
 }
 
@@ -38,27 +46,57 @@ const inputSchema = z.object({
 type PowerShellInput = z.infer<typeof inputSchema>;
 
 function invocation(command: string): string[] {
-  return ['-NoLogo', '-NoProfile', '-NonInteractive', '-Command', `$OutputEncoding=[Console]::OutputEncoding=[Text.UTF8Encoding]::new(); ${command}`];
+  return [
+    '-NoLogo',
+    '-NoProfile',
+    '-NonInteractive',
+    '-Command',
+    `$OutputEncoding=[Console]::OutputEncoding=[Text.UTF8Encoding]::new(); ${command}`,
+  ];
 }
 
-async function approved(command: string, signal?: AbortSignal): Promise<ToolResult | undefined> {
+async function approved(
+  command: string,
+  signal?: AbortSignal,
+): Promise<ToolResult | undefined> {
+  const permanentDelete = permanentDeleteReason(command, 'powershell');
+  if (permanentDelete)
+    return {
+      ok: false,
+      error: `永久删除检查拒绝执行：${permanentDelete}\n命令：${command}`,
+    };
   const forbidden = checkForbidden(command);
-  if (forbidden) return { ok: false, error: `安全检查拒绝执行：${forbidden}\n命令：${command}` };
+  if (forbidden)
+    return {
+      ok: false,
+      error: `安全检查拒绝执行：${forbidden}\n命令：${command}`,
+    };
   const irreversible = classifyCommand(command);
   if (!irreversible) return undefined;
-  const [answer] = await requestUserChoice([{
-    question: `这条命令不可逆：${irreversible.why}。\n\n命令：${command}\n\n确认执行吗？`, header: '不可逆操作',
-    options: [
-      { label: '取消，不执行 (推荐)', description: '放弃并改用可回滚做法' },
-      { label: '我已确认后果，执行', description: '继续执行不可逆操作' },
+  const [answer] = await requestUserChoice(
+    [
+      {
+        question: `这条命令不可逆：${irreversible.why}。\n\n命令：${command}\n\n确认执行吗？`,
+        header: '不可逆操作',
+        options: [
+          { label: '取消，不执行 (推荐)', description: '放弃并改用可回滚做法' },
+          { label: '我已确认后果，执行', description: '继续执行不可逆操作' },
+        ],
+      },
     ],
-  }], signal);
-  return answer?.selected?.[0]?.includes('执行') && !answer.selected[0]?.includes('取消')
+    signal,
+  );
+  return answer?.selected?.[0]?.includes('执行') &&
+    !answer.selected[0]?.includes('取消')
     ? undefined
     : { ok: false, error: `已拒绝执行不可逆 PowerShell 命令：${command}` };
 }
 
-async function call(input: PowerShellInput, signal?: AbortSignal, context?: ToolCallContext): Promise<ToolResult> {
+async function call(
+  input: PowerShellInput,
+  signal?: AbortSignal,
+  context?: ToolCallContext,
+): Promise<ToolResult> {
   const executable = findPowerShell();
   if (!executable) return { ok: false, error: '当前宿主没有可用的 PowerShell' };
   const refusal = await approved(input.command, signal);
@@ -67,38 +105,138 @@ async function call(input: PowerShellInput, signal?: AbortSignal, context?: Tool
   const cwd = context?.cwd ?? getWorkingDir();
   if (input.run_in_background) {
     try {
-      const task = await startBackgroundTask({ command: input.command, executable, args, cwd, env: sanitizedChildEnv(), sessionId: context?.sessionId, shellKind: 'powershell' }, context?.sessionState?.backgroundTasks);
+      const task = await startBackgroundTask(
+        {
+          command: input.command,
+          executable,
+          args,
+          cwd,
+          env: sanitizedChildEnv(),
+          sessionId: context?.sessionId,
+          workspaceId: context?.workspaceId,
+          shellKind: 'powershell',
+        },
+        context?.sessionState?.backgroundTasks,
+      );
       return {
         ok: true,
-        content: `PowerShell 后台任务已启动。task_id=${task.id}\nlog=${task.logPath}`,
-        metadata: processExecutionMetadata({ shell: 'powershell', mode: 'background', command: input.command, status: 'started', taskId: task.id }),
+        content: `PowerShell 后台任务已启动。task_id=${task.id.replace(/^proc_/, '')}\nprocess_id=${task.id}\nlog=${task.logPath}`,
+        metadata: processExecutionMetadata({
+          shell: 'powershell',
+          mode: 'background',
+          command: input.command,
+          status: 'started',
+          taskId: task.id,
+        }),
       };
-    } catch (error) { return { ok: false, error: `PowerShell 后台任务启动失败：${(error as Error).message}` }; }
+    } catch (error) {
+      return {
+        ok: false,
+        error: `PowerShell 后台任务启动失败：${(error as Error).message}`,
+      };
+    }
   }
 
   return await new Promise<ToolResult>((resolvePromise) => {
-    const child = spawn(executable, args, { cwd, env: sanitizedChildEnv(), windowsHide: true, detached: false });
-    let stdout = ''; let stderr = ''; let finished = false;
-    const finish = (result: ToolResult) => { if (finished) return; finished = true; clearTimeout(timer); signal?.removeEventListener('abort', abort); resolvePromise(result); };
-    const abort = () => { killTree(child); finish({ ok: false, error: `PowerShell 命令被中断\n${stdout}\n${stderr}`.slice(0, DEFAULT_MAX_RESULT_SIZE_CHARS), metadata: processExecutionMetadata({ shell: 'powershell', mode: 'foreground', command: input.command, status: 'stopped', exitCode: null }) }); };
+    const child = spawn(executable, args, {
+      cwd,
+      env: sanitizedChildEnv(),
+      windowsHide: true,
+      detached: false,
+    });
+    let finished = false;
+    const store = new ToolOutputStore({
+      workspaceId: context?.workspaceId,
+      sessionId: context?.sessionId,
+    });
+    const finish = async (
+      status: 'completed' | 'failed' | 'stopped',
+      code: number | null,
+      prefix = '',
+    ) => {
+      if (finished) return;
+      finished = true;
+      clearTimeout(timer);
+      signal?.removeEventListener('abort', abort);
+      const output = await store.finish();
+      const reference = output.path
+        ? `\n[完整输出: ${output.path}; bytes=${output.bytes}; sha256=${output.sha256}; complete=${output.complete}]`
+        : '';
+      let text = `${prefix}${output.stdout ? `<stdout>\n${output.stdout.trimEnd()}\n</stdout>\n` : ''}${output.stderr ? `<stderr>\n${output.stderr.trimEnd()}\n</stderr>\n` : ''}[exit code: ${code ?? 'killed'}]`;
+      if (text.length + reference.length > DEFAULT_MAX_RESULT_SIZE_CHARS) {
+        const suffix = `\n... (输出预览已截断)${reference}`;
+        text =
+          text.slice(
+            0,
+            Math.max(0, DEFAULT_MAX_RESULT_SIZE_CHARS - suffix.length),
+          ) + suffix;
+      } else text += reference;
+      const metadata = processExecutionMetadata({
+        shell: 'powershell',
+        mode: 'foreground',
+        command: input.command,
+        status,
+        exitCode: code,
+      });
+      resolvePromise(
+        status === 'completed'
+          ? { ok: true, content: text, metadata }
+          : { ok: false, error: text, metadata },
+      );
+    };
+    const abort = () => {
+      killTree(child);
+      void finish('stopped', null, 'PowerShell 命令被中断\n');
+    };
     const timeout = input.timeout ?? 120_000;
-    const timer = setTimeout(() => { killTree(child); finish({ ok: false, error: `PowerShell 命令超时（${timeout}ms）\n${stdout}\n${stderr}`.slice(0, DEFAULT_MAX_RESULT_SIZE_CHARS), metadata: processExecutionMetadata({ shell: 'powershell', mode: 'foreground', command: input.command, status: 'failed', exitCode: null }) }); }, timeout);
+    const timer = setTimeout(() => {
+      killTree(child);
+      void finish('failed', null, `PowerShell 命令超时（${timeout}ms）\n`);
+    }, timeout);
     signal?.addEventListener('abort', abort, { once: true });
-    child.stdout?.setEncoding('utf8'); child.stderr?.setEncoding('utf8');
-    child.stdout?.on('data', (chunk) => { if (stdout.length < DEFAULT_MAX_RESULT_SIZE_CHARS * 2) stdout += chunk; });
-    child.stderr?.on('data', (chunk) => { if (stderr.length < DEFAULT_MAX_RESULT_SIZE_CHARS * 2) stderr += chunk; });
-    child.once('error', (error) => finish({ ok: false, error: `PowerShell 启动失败：${error.message}`, metadata: processExecutionMetadata({ shell: 'powershell', mode: 'foreground', command: input.command, status: 'failed', exitCode: null }) }));
+    child.stdout?.setEncoding('utf8');
+    child.stderr?.setEncoding('utf8');
+    child.stdout?.on('data', (chunk) => {
+      if (!store.append('stdout', chunk)) {
+        child.stdout?.pause();
+        store.onDrain(() => child.stdout?.resume());
+      }
+    });
+    child.stderr?.on('data', (chunk) => {
+      if (!store.append('stderr', chunk)) {
+        child.stderr?.pause();
+        store.onDrain(() => child.stderr?.resume());
+      }
+    });
+    child.once('error', (error) => {
+      void finish('failed', null, `PowerShell 启动失败：${error.message}\n`);
+    });
     child.once('close', (code) => {
-      const text = `${stdout ? `<stdout>\n${stdout.trimEnd()}\n</stdout>\n` : ''}${stderr ? `<stderr>\n${stderr.trimEnd()}\n</stderr>\n` : ''}[exit code: ${code}]`.slice(0, DEFAULT_MAX_RESULT_SIZE_CHARS);
-      const metadata = processExecutionMetadata({ shell: 'powershell', mode: 'foreground', command: input.command, status: code === 0 ? 'completed' : 'failed', exitCode: code });
-      finish(code === 0 ? { ok: true, content: text, metadata } : { ok: false, error: text, metadata });
+      void finish(code === 0 ? 'completed' : 'failed', code);
     });
   });
 }
 
 export const powerShellTool: Tool<PowerShellInput> = {
   name: 'PowerShell',
-  description: 'Executes native PowerShell on Windows. Use for Windows-specific administration and scripts; use run_in_background for long builds, tests, or servers, then TaskOutput/TaskStop.',
+  description: `Executes native PowerShell on Windows. Use for Windows-specific administration and scripts; use run_in_background for long builds, tests, or servers, then TaskOutput/TaskStop.
+
+# Safety - two levels, from strict to lenient
+
+## 1. Blocked outright (fails before execution - do NOT retry with variants)
+
+Catastrophic commands (no legitimate use): \`rm -rf /\`-class deletions of root/$HOME/system directories, \`mkfs\`, \`format X:\`, \`dd\` to raw devices, shutdown/reboot, fork bombs, pipe-to-shell from network (\`curl ... | sh\`), \`chmod 777 /\`, full-disk \`del /s\` / \`rmdir /s\`, \`diskpart\`.
+
+Permanent deletion (bypasses the Recycle Bin - use the Trash tool instead): \`Remove-Item\`, \`Clear-RecycleBin\`, \`del\` / \`erase\` / \`rd\` / \`rmdir\` / \`rm\` / \`ri\`, and \`.Delete()\` method calls - all fail before execution.
+To delete files or directories use the **Trash** tool (\`action: "move"\` - recoverable); to clean Git untracked files use Trash with \`action: "git-clean"\`. Do NOT try other deletion spellings - they are blocked the same way. If a permanent deletion is truly required, ask the user to run it themselves.
+
+## 2. Requires user confirmation (irreversible)
+
+These have legitimate uses but destroy the last copy - execution pauses and asks the user to confirm. In non-interactive contexts they are automatically cancelled.
+ - \`git push --force\` / \`-f\` / \`+refspec\`, \`git push --delete <branch>\`
+ - \`git filter-branch\` / \`git filter-repo\`, \`git reflog expire --expire=now\` / \`git gc --prune=now\`
+ - \`shred -u\` / \`shred --remove\`
+ - SQL data destruction: \`DROP DATABASE\`, \`DROP TABLE\`, \`TRUNCATE TABLE\``,
   inputSchema,
   parameters: toToolParameters(inputSchema),
   isReadOnly: false,
@@ -107,7 +245,10 @@ export const powerShellTool: Tool<PowerShellInput> = {
   interruptBehavior: () => 'block',
   resolveAvailability: () => {
     const executable = findPowerShell();
-    return { available: Boolean(executable), signature: executable ?? 'unavailable' };
+    return {
+      available: Boolean(executable),
+      signature: executable ?? 'unavailable',
+    };
   },
   call: (input, signal) => call(input, signal),
   callWithContext: (input, signal, context) => call(input, signal, context),

package/src/tools/presentresult/presentresult.js

@@ -7,17 +7,27 @@ import { getWorkingDir } from '../../bootstrap/workingDir.js';
 import { toToolParameters } from '../../utils/zodToJson.js';
 const MIME_BY_EXT = {
     '.csv': 'text/csv',
+    '.css': 'text/css',
     '.docx': 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+    '.gif': 'image/gif',
     '.html': 'text/html',
+    '.js': 'text/javascript',
     '.jpeg': 'image/jpeg',
     '.jpg': 'image/jpeg',
     '.json': 'application/json',
     '.md': 'text/markdown',
+    '.mp4': 'video/mp4',
     '.pdf': 'application/pdf',
     '.png': 'image/png',
     '.pptx': 'application/vnd.openxmlformats-officedocument.presentationml.presentation',
+    '.py': 'text/x-python',
+    '.svg': 'image/svg+xml',
+    '.ts': 'text/typescript',
+    '.tsx': 'text/typescript',
     '.txt': 'text/plain',
+    '.webp': 'image/webp',
     '.xlsx': 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+    '.zip': 'application/zip',
 };
 const verificationSchema = z.enum(['passed', 'failed', 'not_run']).default('not_run');
 const inputSchema = z.object({

package/src/tools/presentresult/presentresult.ts

@@ -10,17 +10,27 @@ import { toToolParameters } from '../../utils/zodToJson.js';
 
 const MIME_BY_EXT: Record<string, string> = {
   '.csv': 'text/csv',
+  '.css': 'text/css',
   '.docx': 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+  '.gif': 'image/gif',
   '.html': 'text/html',
+  '.js': 'text/javascript',
   '.jpeg': 'image/jpeg',
   '.jpg': 'image/jpeg',
   '.json': 'application/json',
   '.md': 'text/markdown',
+  '.mp4': 'video/mp4',
   '.pdf': 'application/pdf',
   '.png': 'image/png',
   '.pptx': 'application/vnd.openxmlformats-officedocument.presentationml.presentation',
+  '.py': 'text/x-python',
+  '.svg': 'image/svg+xml',
+  '.ts': 'text/typescript',
+  '.tsx': 'text/typescript',
   '.txt': 'text/plain',
+  '.webp': 'image/webp',
   '.xlsx': 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+  '.zip': 'application/zip',
 };
 
 const verificationSchema = z.enum(['passed', 'failed', 'not_run']).default('not_run');