@linghun/tools 0.1.2 → 0.1.4

package/dist/index.js

@@ -12,51 +12,55 @@ import {
 } from "./chunk-MMJX44V6.js";
 import {
   toolPrompts
-} from "./chunk-DWXJBDPQ.js";
+} from "./chunk-ZGLZZKO6.js";
 import {
   toolUserFacingNames
-} from "./chunk-2R75FXZG.js";
+} from "./chunk-6BBM4UX3.js";
+import "./chunk-4EZHIDZ6.js";
 import "./chunk-I3Z4OKMS.js";
 import "./chunk-PS2ZOFZ6.js";
 import "./chunk-NPKLGVDQ.js";
 import "./chunk-LGZOG7IQ.js";
 import "./chunk-ZYAEUABC.js";
 import "./chunk-SWK6XRZQ.js";
-import "./chunk-4EZHIDZ6.js";
 import "./chunk-YR4HWOR2.js";
 import "./chunk-VAFW24RN.js";
+import "./chunk-TZ6QK52L.js";
+import "./chunk-K3YDFDLP.js";
 import "./chunk-GI5XI4HN.js";
 import "./chunk-WEWXKRKL.js";
 import "./chunk-A6FUAM64.js";
 import "./chunk-YCO6C7KF.js";
-import "./chunk-MFHY7PBM.js";
-import "./chunk-SZFZPQGL.js";
+import "./chunk-4567YAXM.js";
 import "./chunk-XZWSO5CM.js";
+import "./chunk-SZFZPQGL.js";
 import "./chunk-AZCQL24J.js";
 import "./chunk-HUIZOB4A.js";
 import "./chunk-MK3YP2VR.js";
-import "./chunk-VJDLOFCF.js";
-import "./chunk-3RP665TH.js";
-import "./chunk-IOC3BSPT.js";
-import "./chunk-TZ6QK52L.js";
-import "./chunk-K3YDFDLP.js";
-import "./chunk-HNIVNZIS.js";
-import "./chunk-DN3KJZRV.js";
-import "./chunk-2U4BZXAI.js";
-import "./chunk-ITBZHMZQ.js";
 import "./chunk-WLQ7DGMG.js";
 import "./chunk-SQP6SJRP.js";
 import "./chunk-BRG64AEC.js";
-import "./chunk-VZWMPUSS.js";
-import "./chunk-E75PYM7V.js";
-import "./chunk-GAWMEMXB.js";
+import "./chunk-HNIVNZIS.js";
 import "./chunk-7ZOADACP.js";
 import "./chunk-H5OOD2OS.js";
 import "./chunk-IQP3XE32.js";
+import "./chunk-DN3KJZRV.js";
+import "./chunk-2U4BZXAI.js";
+import "./chunk-ITBZHMZQ.js";
+import "./chunk-3NZ3IOPM.js";
+import "./chunk-IOC3BSPT.js";
+import "./chunk-3RP665TH.js";
+import "./chunk-2DIXRINW.js";
+import {
+  interpretCommandResult
+} from "./chunk-FI4YPDFE.js";
+import "./chunk-PKMIDA5A.js";
+import "./chunk-GAWMEMXB.js";
 
 // src/index.ts
 import { spawn } from "child_process";
 import { createHash, randomUUID } from "crypto";
+import { closeSync, createWriteStream, openSync } from "fs";
 import { mkdir, readFile, readdir, stat, writeFile } from "fs/promises";
 import { basename, dirname, isAbsolute, join, relative, resolve } from "path";
 var toolRegistryStatus = "ready";
@@ -84,7 +88,8 @@ function createToolContext(workspaceRoot = process.cwd(), options = {}) {
     todos: [],
     readSnapshots: {},
     sourcePackCandidates: options.sourcePackCandidates,
-    patchSummaries: {}
+    patchSummaries: {},
+    recentDiagnostics: []
   };
 }
 async function runTool(name, input, context) {
@@ -571,9 +576,16 @@ function validateGlobInput(input) {
 }
 function validateBashInput(input) {
   const record = validateRecord(input, "Bash");
+  const command = readOptionalString(record, "command", "Bash");
+  if (command === void 0) {
+    throw new Error("Bash.command \u5FC5\u987B\u63D0\u4F9B\u3002");
+  }
+  const runInBackground = record.runInBackground === true || record.run_in_background === true;
   return {
-    command: readString(record, "command", "Bash"),
-    timeoutMs: readOptionalPositiveInteger(record, "timeoutMs", "Bash")
+    command,
+    description: readOptionalString(record, "description", "Bash"),
+    timeoutMs: readOptionalPositiveInteger(record, "timeoutMs", "Bash"),
+    ...runInBackground ? { runInBackground: true } : {}
   };
 }
 function validateTodoInput(input) {
@@ -1009,11 +1021,41 @@ function sanitizeSecrets(text) {
   return sanitized;
 }
 async function bashTool(input, context) {
+  if (!input.command) {
+    throw new Error("Bash.command \u5FC5\u987B\u63D0\u4F9B\u3002");
+  }
   const logRoot = context.logRoot ?? join(context.workspaceRoot, ".linghun", "logs", "tools");
   await mkdir(logRoot, { recursive: true });
   const fullOutputPath = join(logRoot, `bash-${Date.now()}-${randomUUID()}.log`);
   const timeoutMs = input.timeoutMs ?? BASH_TIMEOUT_MS;
   const adapted = adaptShellCommand(input.command);
+  if (input.runInBackground === true) {
+    const taskId = randomUUID();
+    void runBackgroundBash({
+      taskId,
+      command: adapted.command,
+      originalCommand: input.command,
+      cwd: context.workspaceRoot,
+      timeoutMs,
+      fullOutputPath,
+      adapter: adapted.adapter,
+      logCommand: adapted.logCommand,
+      retainAfterReturn: isHeadlessBenchContext(context),
+      abortSignal: context.abortSignal,
+      trackChildProcess: context.trackChildProcess,
+      onComplete: context.onBackgroundBashComplete
+    });
+    return {
+      text: `\u547D\u4EE4\u5DF2\u5728\u540E\u53F0\u542F\u52A8\u3002
+taskId: ${taskId}
+outputPath: ${fullOutputPath}`,
+      data: {
+        backgroundTaskId: taskId,
+        outputPath: fullOutputPath,
+        command: sanitizeSecrets(input.command)
+      }
+    };
+  }
   const result = await runShell(
     adapted.command,
     context.workspaceRoot,
@@ -1027,23 +1069,35 @@ async function bashTool(input, context) {
     `original command ${summarizeOriginalShellCommand(input.command)}`
   ];
   const commandForLog = adapted.logCommand ?? adapted.command;
-  const fullText = [
+  const sanitizedShellOutput = sanitizeSecrets(result.output);
+  const cmdInterpretation = interpretCommandResult(input.command, result.exitCode);
+  const rawFullText = [
     `$ ${sanitizeSecrets(commandForLog)}`,
     ...adapterLines,
     `exit code ${result.exitCode}`,
     `outcome ${result.outcome}`,
+    ...cmdInterpretation.message ? [`returnCodeInterpretation: ${cmdInterpretation.message}`] : [],
     "",
-    sanitizeSecrets(result.output)
+    sanitizedShellOutput
   ].join("\n");
+  const diagnostics = createBashOutcomeDiagnostics(result.outcome);
+  const fullText = rawFullText;
   await writeFile(fullOutputPath, fullText, "utf8");
   const truncated = fullText.length > BASH_PREVIEW_LIMIT;
   const preview = truncated ? `${fullText.slice(0, BASH_PREVIEW_LIMIT)}
 ...\uFF08\u8F93\u51FA\u5DF2\u622A\u65AD\uFF0C\u5B8C\u6574\u65E5\u5FD7\u89C1 fullOutputPath\uFF09` : fullText;
   const details = createBashDetails(fullOutputPath, fullText);
+  const data = adapted.adapter === "native" ? { exitCode: result.exitCode, outcome: result.outcome } : { exitCode: result.exitCode, outcome: result.outcome, adapter: adapted.adapter };
+  const outputData = {
+    ...data,
+    ...cmdInterpretation.message ? { returnCodeInterpretation: cmdInterpretation.message } : {},
+    ...cmdInterpretation.isError === false && result.exitCode !== 0 ? { isError: false } : {},
+    ...diagnostics.length > 0 ? { diagnostics } : {}
+  };
   return {
     text: preview,
     details,
-    data: adapted.adapter === "native" ? { exitCode: result.exitCode, outcome: result.outcome } : { exitCode: result.exitCode, outcome: result.outcome, adapter: adapted.adapter },
+    data: outputData,
     truncated,
     fullOutputPath
   };
@@ -1057,6 +1111,505 @@ function createBashDetails(fullOutputPath, fullText) {
     ...tailLines(fullText, 80)
   ].join("\n");
 }
+var BINARY_HINT_EXTENSIONS = [
+  ".bin",
+  ".elf",
+  ".o",
+  ".so",
+  ".a",
+  ".exe",
+  ".dll",
+  ".7z",
+  ".zip",
+  ".gz",
+  ".png",
+  ".jpg",
+  ".jpeg",
+  ".pdf",
+  ".sqlite",
+  ".db"
+];
+var ARTIFACT_HINT_EXTENSIONS = [
+  ".txt",
+  ".json",
+  ".out",
+  ".log",
+  ".py",
+  ".html",
+  ".htm",
+  ".csv",
+  ".yaml",
+  ".yml",
+  ".toml",
+  ".md",
+  ".sh",
+  ".bin",
+  ".elf",
+  ".zip",
+  ".7z",
+  ".png",
+  ".pdf",
+  ".sqlite",
+  ".db"
+];
+function parseBashCommandIntent(command, _context) {
+  const tokens = tokenizeShellLike(command);
+  const segments = splitCommandSegments(tokens);
+  const commandNames = [];
+  const parsedSegments = [];
+  const binaryCandidates = /* @__PURE__ */ new Set();
+  const artifactCandidates = /* @__PURE__ */ new Set();
+  const serviceCandidates = [];
+  for (const segment of segments) {
+    const parsed = parseCommandSegment(segment.tokens);
+    if (!parsed) continue;
+    commandNames.push(parsed.commandName);
+    parsedSegments.push({
+      commandName: parsed.commandName,
+      argv: parsed.argv,
+      background: segment.background || parsed.background,
+      redirections: collectSegmentRedirections(parsed.argv)
+    });
+    collectSegmentBinaryCandidates(parsed, binaryCandidates);
+    collectSegmentArtifactCandidates(parsed, artifactCandidates);
+    serviceCandidates.push(...collectSegmentServiceCandidates(parsed));
+  }
+  return {
+    binaryCandidates: [...binaryCandidates],
+    serviceCandidates: dedupeServiceCandidates(serviceCandidates),
+    artifactCandidates: [...artifactCandidates],
+    backgroundLikely: isBackgroundLikely(segments, serviceCandidates),
+    commandNames: unique(commandNames.filter(Boolean)),
+    segments: parsedSegments,
+    hasShellControl: segments.length !== 1 || tokens.some((token) => isCommandSeparator(token))
+  };
+}
+var BINARY_COMMAND_NAMES = /* @__PURE__ */ new Set(["file", "xxd", "readelf", "objdump", "hexdump", "strings", "7z", "7za", "unzip", "tar"]);
+var SHELL_RESERVED_COMMAND_NAMES = /* @__PURE__ */ new Set([
+  "if",
+  "then",
+  "else",
+  "elif",
+  "fi",
+  "for",
+  "while",
+  "until",
+  "do",
+  "done",
+  "case",
+  "esac",
+  "in",
+  "function",
+  "coproc"
+]);
+var SHELL_SYNTAX_COMMAND_NAMES = /* @__PURE__ */ new Set([
+  "[",
+  "[[",
+  "test",
+  "{",
+  "}",
+  "(",
+  ")",
+  "!",
+  ":",
+  "true",
+  "false"
+]);
+var ARTIFACT_PRODUCING_COMMAND_NAMES = /* @__PURE__ */ new Set(["touch", "tee"]);
+var ARTIFACT_PRODUCING_TOKENS = /* @__PURE__ */ new Set(["write", "wrote", "written", "create", "created", "generate", "generated", "build", "built", "output"]);
+function canSafelyAliasPythonCommand(intent) {
+  const segment = intent.segments[0];
+  return intent.segments.length === 1 && !intent.hasShellControl && segment?.commandName === "python" && !segment.background && segment.redirections.length === 0;
+}
+function tokenizeShellLike(command) {
+  const tokens = [];
+  let current = "";
+  let quote;
+  let escaped = false;
+  const push = () => {
+    if (current.length > 0) tokens.push(current);
+    current = "";
+  };
+  for (let index = 0; index < command.length; index += 1) {
+    const char = command[index] ?? "";
+    if (escaped) {
+      current += char;
+      escaped = false;
+      continue;
+    }
+    if (char === "\\") {
+      escaped = true;
+      continue;
+    }
+    if (quote) {
+      if (char === quote) quote = void 0;
+      else current += char;
+      continue;
+    }
+    if (char === "'" || char === '"') {
+      quote = char;
+      continue;
+    }
+    if (/\s/u.test(char)) {
+      push();
+      continue;
+    }
+    if (char === ">" && /^\d+$/u.test(current)) {
+      const prefix = current;
+      current = "";
+      let redirect = `${prefix}>`;
+      if (command[index + 1] === ">") {
+        redirect += ">";
+        index += 1;
+      }
+      if (command[index + 1] === "&") {
+        redirect += "&";
+        index += 1;
+        while (index + 1 < command.length && /[A-Za-z0-9_/-]/u.test(command[index + 1] ?? "")) {
+          redirect += command[index + 1];
+          index += 1;
+        }
+      }
+      tokens.push(redirect);
+      continue;
+    }
+    if (char === "(" && current.length === 0) {
+      push();
+      tokens.push(char);
+      continue;
+    }
+    if ((char === "{" || char === "}") && current.length === 0) {
+      push();
+      tokens.push(char);
+      continue;
+    }
+    if (char === ")" && !current.includes("$(")) {
+      push();
+      tokens.push(char);
+      continue;
+    }
+    if (char === "|" || char === ";" || char === "&" || char === ">") {
+      push();
+      const next = command[index + 1];
+      if (char === "&" && next === "&" || char === ">" && next === ">") {
+        tokens.push(`${char}${next}`);
+        index += 1;
+      } else {
+        tokens.push(char);
+      }
+      continue;
+    }
+    current += char;
+  }
+  push();
+  return tokens;
+}
+function isCommandSeparator(token) {
+  return token === "|" || token === "&&" || token === ";" || token === "&";
+}
+function splitCommandSegments(tokens) {
+  const segments = [];
+  let current = [];
+  for (const token of tokens) {
+    if (!isCommandSeparator(token)) {
+      current.push(token);
+      continue;
+    }
+    if (current.length > 0) {
+      segments.push({ tokens: current, background: token === "&" });
+      current = [];
+    }
+  }
+  if (current.length > 0) segments.push({ tokens: current, background: false });
+  return segments;
+}
+function parseCommandSegment(tokens) {
+  const env = /* @__PURE__ */ new Map();
+  let index = 0;
+  while (index < tokens.length && isShellGroupBoundaryToken(tokens[index] ?? "")) {
+    index += 1;
+  }
+  while (index < tokens.length && isEnvironmentAssignment(tokens[index] ?? "")) {
+    const [name, ...rest] = (tokens[index] ?? "").split("=");
+    if (name) env.set(name.toUpperCase(), rest.join("="));
+    index += 1;
+  }
+  if (index >= tokens.length) return void 0;
+  let commandToken = tokens[index] ?? "";
+  if (commandToken === "nohup" || commandToken === "setsid" || commandToken === "time") {
+    index += 1;
+    commandToken = tokens[index] ?? "";
+  }
+  if (isShellReservedCommandToken(commandToken)) return void 0;
+  if (isShellSyntaxCommandToken(commandToken)) return void 0;
+  if (!commandToken) return void 0;
+  const commandName = stripExecutableToken(commandToken);
+  if (!commandName || isShellReservedCommandToken(commandName) || isShellSyntaxCommandToken(commandName)) {
+    return void 0;
+  }
+  return {
+    commandName,
+    argv: tokens.slice(index + 1).filter((token) => !isShellGroupBoundaryToken(token)),
+    env,
+    background: tokens.includes("disown")
+  };
+}
+function collectSegmentBinaryCandidates(segment, target) {
+  if (BINARY_COMMAND_NAMES.has(segment.commandName)) {
+    for (const token of segment.argv) {
+      if (!isOptionToken(token)) addPathCandidate(target, token);
+    }
+  }
+  for (const token of segment.argv) {
+    if (isBinarySuffix(token)) addPathCandidate(target, token);
+  }
+}
+function collectSegmentArtifactCandidates(segment, target) {
+  for (let index = 0; index < segment.argv.length; index += 1) {
+    const token = segment.argv[index] ?? "";
+    if (token === ">" || token === ">>") {
+      addPathCandidate(target, segment.argv[index + 1] ?? "");
+      index += 1;
+      continue;
+    }
+    if (isOutputFlag(token)) {
+      addPathCandidate(target, segment.argv[index + 1] ?? "");
+      index += 1;
+      continue;
+    }
+    if (isArtifactSuffix(token) && isArtifactProducingCommand(segment.commandName, segment.argv)) {
+      addPathCandidate(target, token);
+    }
+  }
+}
+function collectSegmentRedirections(argv) {
+  const redirections = [];
+  for (let index = 0; index < argv.length; index += 1) {
+    const token = argv[index] ?? "";
+    if (token !== ">" && token !== ">>") continue;
+    const target = argv[index + 1] ?? "";
+    if (target) redirections.push({ operator: token, target });
+    index += 1;
+  }
+  return redirections;
+}
+function collectSegmentServiceCandidates(segment) {
+  const candidates = [];
+  const envPort = parsePort(segment.env.get("PORT"));
+  const explicit = findExplicitServiceTarget(segment.argv, envPort);
+  if (isPythonHttpServer(segment)) {
+    const port = findFirstPortToken(segment.argv) ?? envPort ?? 8e3;
+    candidates.push(createServiceIntent("http-server", port, "high", "python -m http.server"));
+    return candidates;
+  }
+  if (segment.commandName === "uvicorn") {
+    if (explicit) candidates.push(createServiceIntent("framework-server", explicit.port, "high", explicit.evidence, explicit.host));
+    return candidates;
+  }
+  if (segment.commandName === "flask" && segment.argv[0]?.toLowerCase() === "run") {
+    if (explicit) candidates.push(createServiceIntent("framework-server", explicit.port, "high", explicit.evidence, explicit.host));
+    return candidates;
+  }
+  if (segment.commandName === "gunicorn") {
+    const bind = findGunicornBindTarget(segment.argv);
+    if (bind) candidates.push(createServiceIntent("framework-server", bind.port, "high", bind.evidence, bind.host));
+    return candidates;
+  }
+  if (isPackageScriptCommand(segment)) {
+    if (explicit) candidates.push(createServiceIntent("package-script", explicit.port, "medium", explicit.evidence, explicit.host));
+    return candidates;
+  }
+  if (isJsRuntimeCommand(segment.commandName)) {
+    if (explicit) candidates.push(createServiceIntent("explicit-port", explicit.port, "medium", explicit.evidence, explicit.host));
+    return candidates;
+  }
+  if (explicit && isKnownServiceCommand(segment.commandName)) {
+    candidates.push(createServiceIntent("explicit-port", explicit.port, "medium", explicit.evidence, explicit.host));
+  }
+  return candidates;
+}
+function createServiceIntent(kind, port, confidence, evidence, host = "127.0.0.1") {
+  return { kind, host: normalizeServiceHost(host), port, confidence, evidence };
+}
+function isPythonHttpServer(segment) {
+  return (segment.commandName === "python" || segment.commandName === "python3") && hasAdjacentTokens(segment.argv, "-m", "http.server");
+}
+function findExplicitServiceTarget(argv, envPort) {
+  let host = "127.0.0.1";
+  if (envPort) return { host, port: envPort, evidence: "PORT=" };
+  for (let index = 0; index < argv.length; index += 1) {
+    const token = argv[index] ?? "";
+    if (token === "--host") host = normalizeServiceHost(argv[index + 1] ?? host);
+    if (token === "--port" || token === "-p") {
+      const port = parsePort(argv[index + 1]);
+      if (port) return { host, port, evidence: token };
+    }
+    const inlinePort = parseInlineOptionPort(token);
+    if (inlinePort) return { host, port: inlinePort, evidence: token.split("=")[0] ?? token };
+    const target = parseHostPortToken(token);
+    if (target?.port) return { host: target.host ?? host, port: target.port, evidence: "host:port" };
+  }
+  return void 0;
+}
+function findGunicornBindTarget(argv) {
+  for (let index = 0; index < argv.length; index += 1) {
+    const token = argv[index] ?? "";
+    if (token !== "-b" && token !== "--bind") continue;
+    const target = parseHostPortToken(argv[index + 1] ?? "");
+    if (target?.port) return { host: target.host ?? "127.0.0.1", port: target.port, evidence: token };
+  }
+  return void 0;
+}
+function findFirstPortToken(argv) {
+  for (const token of argv) {
+    const port = parsePort(token);
+    if (port) return port;
+  }
+  return void 0;
+}
+function parseInlineOptionPort(token) {
+  if (!token.startsWith("--port=") && !token.startsWith("-p=")) return void 0;
+  return parsePort(token.slice(token.indexOf("=") + 1));
+}
+function parsePort(value) {
+  if (!value || !/^\d{1,5}$/u.test(value)) return void 0;
+  return normalizePort(Number(value));
+}
+function isPackageScriptCommand(segment) {
+  if (segment.commandName !== "npm" && segment.commandName !== "pnpm" && segment.commandName !== "yarn") return false;
+  const command = segment.argv[0]?.toLowerCase();
+  const script = segment.argv[1]?.toLowerCase();
+  return command === "start" || command === "dev" || command === "test-server" || command === "run" && (script === "start" || script === "dev" || script === "test-server");
+}
+function isJsRuntimeCommand(commandName) {
+  return commandName === "node" || commandName === "deno" || commandName === "bun";
+}
+function isKnownServiceCommand(commandName) {
+  return commandName === "grpc";
+}
+function normalizeServiceHost(host) {
+  return "127.0.0.1";
+}
+function isBackgroundLikely(segments, serviceCandidates) {
+  return segments.some(
+    (segment) => segment.background || segment.tokens[0] === "nohup" || segment.tokens[0] === "setsid" || segment.tokens.includes("disown")
+  ) || serviceCandidates.some(
+    (candidate) => candidate.kind === "http-server" || candidate.kind === "framework-server" || candidate.kind === "package-script"
+  );
+}
+function stripExecutableToken(token) {
+  const normalized = token.replace(/^\(+/u, "").replace(/\)+$/u, "");
+  if (normalized.includes("/") || normalized.includes("\\")) {
+    return normalized.replace(/\.(?:exe|cmd|bat)$/iu, "");
+  }
+  return basename(normalized).replace(/\.(?:exe|cmd|bat)$/iu, "").toLowerCase();
+}
+function addPathCandidate(target, token) {
+  if (!isStaticPathCandidate(token)) return;
+  target.add(token.replaceAll("\\", "/"));
+}
+function isOptionToken(token) {
+  return token.startsWith("-") && !/^-?\d+$/u.test(token);
+}
+function isOutputFlag(token) {
+  return token === "-o" || token === "--output" || token === "--out" || token === "--dest" || token === "--file";
+}
+function isEnvironmentAssignment(token) {
+  return /^[A-Za-z_][A-Za-z0-9_]*=.*$/u.test(token);
+}
+function isShellReservedCommandToken(token) {
+  return SHELL_RESERVED_COMMAND_NAMES.has(token.toLowerCase());
+}
+function isShellSyntaxCommandToken(token) {
+  return SHELL_SYNTAX_COMMAND_NAMES.has(token.toLowerCase());
+}
+function isShellGroupBoundaryToken(token) {
+  return token === "(" || token === ")" || token === "{" || token === "}";
+}
+function isStaticPathCandidate(token) {
+  if (!token || isOptionToken(token) || token.includes("://")) return false;
+  if (token.includes("$") || token.includes("`")) return false;
+  if (/^(?:\d+)?>{1,2}(?:&\d+)?$/u.test(token)) return false;
+  if (token === "|" || token === ";" || token === "&" || token === "<") return false;
+  if (isShellGroupBoundaryToken(token) || isShellSyntaxCommandToken(token)) return false;
+  if (/^\d+$/u.test(token)) return false;
+  if (token === "/dev/null" || token === "/dev/stdout" || token === "/dev/stderr") return false;
+  return true;
+}
+function isBinarySuffix(token) {
+  return BINARY_HINT_EXTENSIONS.some((extension) => token.toLowerCase().endsWith(extension));
+}
+function isArtifactSuffix(token) {
+  return ARTIFACT_HINT_EXTENSIONS.some((extension) => token.toLowerCase().endsWith(extension));
+}
+function isArtifactProducingCommand(commandName, tokens) {
+  if (!commandName) return false;
+  if (ARTIFACT_PRODUCING_COMMAND_NAMES.has(commandName)) return true;
+  return tokens.some((token) => ARTIFACT_PRODUCING_TOKENS.has(token.toLowerCase()));
+}
+function parseHostPortToken(token) {
+  const url = tryParseLocalUrl(token);
+  if (url) return url;
+  const separator = token.lastIndexOf(":");
+  if (separator <= 0) return void 0;
+  const host = token.slice(0, separator).replace(/^\[(.*)\]$/u, "$1");
+  const port = normalizePort(Number(token.slice(separator + 1)));
+  if (!port || !isLocalHost(host)) return void 0;
+  return normalizeHostPort(host, port);
+}
+function tryParseLocalUrl(token) {
+  try {
+    const url = new URL(token);
+    if (url.protocol !== "http:" && url.protocol !== "https:") return void 0;
+    if (!isLocalHost(url.hostname)) return void 0;
+    const port = normalizePort(Number(url.port));
+    if (!port) return void 0;
+    return normalizeHostPort(url.hostname, port);
+  } catch {
+    return void 0;
+  }
+}
+function isLocalHost(host) {
+  return host === "localhost" || host === "127.0.0.1" || host === "0.0.0.0" || host === "::1";
+}
+function hasAdjacentTokens(tokens, first, second) {
+  return tokens.some(
+    (token, index) => token.toLowerCase() === first && tokens[index + 1]?.toLowerCase() === second
+  );
+}
+function normalizePort(value) {
+  return Number.isInteger(value) && value > 0 && value <= 65535 ? value : void 0;
+}
+function dedupeServiceCandidates(candidates) {
+  const seen = /* @__PURE__ */ new Set();
+  return candidates.filter((candidate) => {
+    const key = `${candidate.host}:${candidate.port}:${candidate.kind}`;
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+}
+function normalizeHostPort(host, port) {
+  if (!Number.isInteger(port) || port <= 0 || port > 65535) return void 0;
+  return { host: host === "0.0.0.0" || host === "localhost" ? "127.0.0.1" : host.replace(/^\[(.*)\]$/u, "$1"), port };
+}
+function isHeadlessBenchContext(context) {
+  const record = context;
+  return record.headlessBench?.enabled === true || record.isHeadlessBench === true;
+}
+function createBashOutcomeDiagnostics(outcome) {
+  if (outcome === "timeout") {
+    return [
+      {
+        type: "timeout",
+        severity: "recoverable",
+        evidence: "Bash outcome timeout",
+        suggestion: "Run the smallest focused check first and avoid repeating long blind commands."
+      }
+    ];
+  }
+  return [];
+}
 function tailLines(text, limit) {
   const lines = text.split(/\r?\n/u);
   return lines.slice(Math.max(0, lines.length - limit));
@@ -1073,6 +1626,8 @@ function adaptShellCommandForPlatform(command, platform) {
       "Unsupported multi-line Unix shell syntax on Windows PowerShell; use PowerShell-safe commands or Node one-liners."
     );
   }
+  const nativePowerShell = convertNativePowerShellCommand(command);
+  if (nativePowerShell) return nativePowerShell;
   const converted = convertUnixPipelineForPowerShell(command);
   if (converted) return { command: converted, adapter: "powershell-adapted" };
   const readOnlyCommand = convertUnixReadOnlyCommandForPowerShell(command);
@@ -1085,6 +1640,22 @@ function adaptShellCommandForPlatform(command, platform) {
   if (unsupportedReadOnlyCommand) return unsupportedReadOnlyCommand;
   return { command, adapter: "native" };
 }
+function convertNativePowerShellCommand(command) {
+  const normalized = command.trim();
+  if (!normalized) return void 0;
+  if (/^(?:powershell(?:\.exe)?|pwsh(?:\.exe)?)\b/iu.test(normalized)) return void 0;
+  if (!/^(?:Get|Set|New|Remove|Select|ForEach|Where|Test|Resolve|Join|Split|Copy|Move|Write|Out|Measure|Compare|Sort|Format)-[A-Za-z]+\b/u.test(normalized)) {
+    return void 0;
+  }
+  return {
+    command: [
+      "powershell.exe -NoProfile -NonInteractive -Command",
+      quoteCmdArg(`$ErrorActionPreference='Stop'; ${normalized}`)
+    ].join(" "),
+    adapter: "powershell-adapted",
+    logCommand: `powershell.exe -NoProfile -NonInteractive -Command <powershell cmdlet>`
+  };
+}
 function convertNodeHereDocForPowerShell(command) {
   const normalized = command.replace(/\r\n/gu, "\n");
   const match = normalized.match(
@@ -2063,6 +2634,198 @@ function runShell(command, cwd, timeoutMs, signal, onProgress, trackChildProcess
     });
   });
 }
+var STALL_THRESHOLD_MS = 45e3;
+var PROMPT_PATTERNS = [
+  /\(y\/n\)\s*$/i,
+  /\[y\/n\]\s*$/i,
+  /\(yes\/no\)\s*$/i,
+  /Press Enter/i,
+  /Continue\?/i,
+  /Overwrite\?/i,
+  /password[:\s]*$/i,
+  /passphrase[:\s]*$/i,
+  /\?\s*$/
+];
+function looksLikePrompt(tail) {
+  const lastLine = tail.split(/\r?\n/).filter(Boolean).pop() ?? "";
+  return PROMPT_PATTERNS.some((re) => re.test(lastLine));
+}
+async function runBackgroundBash(opts) {
+  const {
+    taskId,
+    command,
+    originalCommand,
+    cwd,
+    timeoutMs,
+    fullOutputPath,
+    adapter,
+    logCommand,
+    retainAfterReturn,
+    abortSignal,
+    onProgress,
+    trackChildProcess,
+    onComplete
+  } = opts;
+  await mkdir(dirname(fullOutputPath), { recursive: true }).catch(() => {
+  });
+  const fileStream = createWriteStream(fullOutputPath, { encoding: "utf8" });
+  const commandForLog = logCommand ?? command;
+  const header = [
+    `$ ${sanitizeSecrets(commandForLog)}`,
+    ...adapter !== "native" ? [`adapter ${adapter}`, `original command ${summarizeOriginalShellCommand(originalCommand)}`] : [],
+    ""
+  ].join("\n");
+  fileStream.write(header);
+  const detached = process.platform !== "win32";
+  if (retainAfterReturn) {
+    fileStream.write("\n[background] retained process started\n");
+    await new Promise((resolveEnd) => fileStream.end(resolveEnd));
+    const outFd = openSync(fullOutputPath, "a");
+    const errFd = openSync(fullOutputPath, "a");
+    const child2 = spawn(command, {
+      cwd,
+      shell: true,
+      windowsHide: true,
+      detached,
+      stdio: ["ignore", outFd, errFd]
+    });
+    closeSync(outFd);
+    closeSync(errFd);
+    child2.unref();
+    trackChildProcess?.(child2, {
+      detached,
+      cwd,
+      label: `BashBg:${command.slice(0, 80)}`,
+      retainAfterExit: true
+    });
+    onComplete?.({
+      taskId,
+      exitCode: 0,
+      outcome: "completed",
+      outputPath: fullOutputPath,
+      command: sanitizeSecrets(originalCommand)
+    });
+    return;
+  }
+  const child = spawn(command, { cwd, shell: true, windowsHide: true, detached });
+  trackChildProcess?.(child, {
+    detached,
+    cwd,
+    label: `BashBg:${command.slice(0, 80)}`,
+    retainAfterExit: detached
+  });
+  let tailBuffer = "";
+  let lastOutputTime = Date.now();
+  let stallTimer;
+  let settled = false;
+  let outcome = "completed";
+  const resetStallTimer = () => {
+    lastOutputTime = Date.now();
+    if (stallTimer) clearTimeout(stallTimer);
+    stallTimer = setTimeout(checkStall, STALL_THRESHOLD_MS);
+  };
+  const checkStall = () => {
+    if (Date.now() - lastOutputTime >= STALL_THRESHOLD_MS && looksLikePrompt(tailBuffer)) {
+      const msg = "\n[stall watchdog] \u68C0\u6D4B\u5230\u4EA4\u4E92\u5F0F\u63D0\u793A\uFF0C\u53EF\u80FD\u9700\u8981\u7528\u6237\u8F93\u5165\u3002\n";
+      fileStream.write(msg);
+      onProgress?.("system", msg);
+    }
+  };
+  const finish = (exitCode) => {
+    if (settled) return;
+    settled = true;
+    if (stallTimer) clearTimeout(stallTimer);
+    clearTimeout(timer);
+    abortSignal?.removeEventListener("abort", onAbort);
+    const footer = `
+exit code ${exitCode}
+outcome ${outcome}
+`;
+    fileStream.write(footer);
+    fileStream.end();
+    onComplete?.({
+      taskId,
+      exitCode,
+      outcome,
+      outputPath: fullOutputPath,
+      command: sanitizeSecrets(originalCommand)
+    });
+  };
+  const requestStop = async (force) => {
+    if (process.platform === "win32" && child.pid) {
+      await stopWindowsProcessTree(child.pid, cwd);
+      return;
+    }
+    const sig = force ? "SIGKILL" : "SIGTERM";
+    if (detached && child.pid) {
+      try {
+        process.kill(-child.pid, sig);
+      } catch {
+        child.kill(sig);
+      }
+    } else {
+      child.kill(sig);
+    }
+  };
+  const FORCE_KILL_WAIT_MS = 3e3;
+  const waitForCloseOrForceKill = () => {
+    const forceTimer = setTimeout(() => {
+      void requestStop(true);
+      setTimeout(() => finish(1), 500);
+    }, FORCE_KILL_WAIT_MS);
+    child.once("close", () => {
+      clearTimeout(forceTimer);
+    });
+  };
+  const onAbort = () => {
+    if (settled) return;
+    outcome = "cancelled";
+    const msg = "\n[cancelled] \u5DE5\u5177\u8C03\u7528\u5DF2\u53D6\u6D88\uFF0C\u6B63\u5728\u7EC8\u6B62\u5B50\u8FDB\u7A0B\u3002\n";
+    fileStream.write(msg);
+    onProgress?.("system", msg);
+    void requestStop(false);
+    waitForCloseOrForceKill();
+  };
+  const timer = setTimeout(() => {
+    if (settled) return;
+    outcome = "timeout";
+    const msg = `
+[timeout] \u547D\u4EE4\u8D85\u65F6\uFF1A\u8D85\u8FC7 ${timeoutMs}ms\uFF0C\u5DF2\u7EC8\u6B62\u3002
+`;
+    fileStream.write(msg);
+    onProgress?.("system", msg);
+    void requestStop(false);
+    waitForCloseOrForceKill();
+  }, timeoutMs);
+  if (abortSignal?.aborted) {
+    onAbort();
+    return;
+  }
+  abortSignal?.addEventListener("abort", onAbort, { once: true });
+  child.stdout.on("data", (chunk) => {
+    const text = decodeShellChunk(chunk);
+    fileStream.write(text);
+    tailBuffer = (tailBuffer + text).slice(-2e3);
+    resetStallTimer();
+    onProgress?.("stdout", text);
+  });
+  child.stderr.on("data", (chunk) => {
+    const text = decodeShellChunk(chunk);
+    fileStream.write(text);
+    tailBuffer = (tailBuffer + text).slice(-2e3);
+    resetStallTimer();
+    onProgress?.("stderr", text);
+  });
+  child.on("close", (code) => {
+    finish(code ?? 1);
+  });
+  child.on("error", (err) => {
+    fileStream.write(`
+[error] ${err.message}
+`);
+    finish(1);
+  });
+}
 function decodeShellChunk(chunk) {
   const utf8 = chunk.toString("utf8");
   if (process.platform !== "win32") return utf8;
@@ -2190,14 +2953,21 @@ function unique(items) {
 }
 var __testGlobToRegExp = globToRegExp;
 var __testDecodeShellChunk = decodeShellChunk;
+var __testParseBashCommandIntent = parseBashCommandIntent;
+var __testCanSafelyAliasPythonCommand = canSafelyAliasPythonCommand;
+var __testRunBackgroundBash = runBackgroundBash;
 export {
+  __testCanSafelyAliasPythonCommand,
   __testDecodeShellChunk,
   __testGlobToRegExp,
+  __testParseBashCommandIntent,
+  __testRunBackgroundBash,
   adaptShellCommand,
   adaptShellCommandForPlatform,
   builtInTools,
   createTool,
   createToolContext,
+  interpretCommandResult,
   runTool,
   toolRegistryStatus
 };