@trim21/personal-pi-extensions 0.1.612 → 0.1.619

package/src/bwrap/network-stack.ts

@@ -1,6 +1,6 @@
 import { type ChildProcess, spawn } from "node:child_process";
 import { randomUUID } from "node:crypto";
-import { mkdir, readFile, readlink, writeFile } from "node:fs/promises";
+import { mkdir, readFile, readlink, rm, writeFile } from "node:fs/promises";
 import { join } from "node:path";
 import { fileURLToPath } from "node:url";
 
@@ -84,7 +84,9 @@ const HOLDER_PATH = fileURLToPath(new URL("holder.js", import.meta.url));
 const SBIN_PATH_SUFFIX = "/usr/local/sbin:/usr/sbin:/sbin";
 
 function killProcess(pid: number | undefined, signal: NodeJS.Signals = "SIGTERM"): void {
-  if (!pid) return;
+  if (!pid) {
+    return;
+  }
   try {
     process.kill(pid, signal);
   } catch {
@@ -92,6 +94,17 @@ function killProcess(pid: number | undefined, signal: NodeJS.Signals = "SIGTERM"
   }
 }
 
+/**
+ * 终止 holder（unshare 包装进程）必须用 SIGKILL：util-linux 的 unshare 在 fork 前
+ * `sigprocmask(SIG_BLOCK, {SIGINT, SIGTERM})`，且只在子进程里恢复掩码——父进程永久
+ * 阻塞这两个信号，发给它的 SIGTERM 只会 pending 永不投递（实测 3s 后仍存活）。
+ * SIGKILL 不可阻塞，unshare 立即退出；其子进程（pid ns 的 init）经 --kill-child 的
+ * PDEATHSIG 收到 SIGTERM，走优雅退出并触发内核清理整个 pid ns。
+ */
+function killHolder(pid: number | undefined): void {
+  killProcess(pid, "SIGKILL");
+}
+
 /** 轮询等待进程退出（进程消失即返回）。 */
 async function waitForExit(pid: number, timeoutMs = 2000): Promise<void> {
   const deadline = Date.now() + timeoutMs;
@@ -105,7 +118,7 @@ async function waitForExit(pid: number, timeoutMs = 2000): Promise<void> {
   }
 }
 
-/** 读取进程的直接子进程 pid：--kill-child 只转发信号给 fork 的子进程，兜底直接 SIGKILL 用。 */
+/** 读取 holder 的直接子进程 pid（pid ns 的 init）：PDEATHSIG 未生效时的 SIGKILL 兜底用。 */
 async function readChildPids(pid: number): Promise<number[]> {
   try {
     const content = await readFile(`/proc/${pid}/task/${pid}/children`, "utf8");
@@ -136,7 +149,9 @@ async function waitForNewUserns(pid: number, timeoutMs = 5000): Promise<void> {
   const deadline = Date.now() + timeoutMs;
   while (Date.now() < deadline) {
     try {
-      if ((await readlink(`/proc/${pid}/ns/user`)) !== self) return;
+      if ((await readlink(`/proc/${pid}/ns/user`)) !== self) {
+        return;
+      }
     } catch {
       // /proc/<pid> 尚未就绪，重试
     }
@@ -153,12 +168,16 @@ function waitForMihomoStarted(holder: ChildProcess, timeoutMs = 20000): Promise<
   return new Promise((resolve, reject) => {
     let settled = false;
     const timer = setTimeout(() => {
-      if (settled) return;
+      if (settled) {
+        return;
+      }
       settled = true;
       reject(new Error("Timed out waiting for mihomo to start"));
     }, timeoutMs);
     const onReady = (): void => {
-      if (settled) return;
+      if (settled) {
+        return;
+      }
       settled = true;
       clearTimeout(timer);
       resolve();
@@ -168,7 +187,9 @@ function waitForMihomoStarted(holder: ChildProcess, timeoutMs = 20000): Promise<
       if (stream) {
         // 不提前停止：holder 生命周期内持续消费输出，避免流无消费者触发背压
         void forEachLine(stream, (line) => {
-          if (line.includes("Tun adapter listening")) onReady();
+          if (line.includes("Tun adapter listening")) {
+            onReady();
+          }
         }).catch(() => {
           // 就绪判定由超时与 holder exit 兜底，流的 error 忽略
         });
@@ -178,7 +199,9 @@ function waitForMihomoStarted(holder: ChildProcess, timeoutMs = 20000): Promise<
 }
 
 function killChild(pid: number | undefined): void {
-  if (!pid) return;
+  if (!pid) {
+    return;
+  }
   try {
     process.kill(-pid, "SIGKILL");
   } catch {
@@ -223,14 +246,19 @@ export interface NetworkStack {
 interface NetworkStackState {
   holderPid: number;
   slirpPid: number;
+  /** 过滤进程的工作目录：GC 兜底路径也要把它删掉。 */
+  mihomoHome: string;
 }
 
-/** 兜底：调用方忘记 stop() 时，对象被 GC 回收后 kill 残留进程。 */
+/** 兜底：调用方忘记 stop() 时，对象被 GC 回收后 kill 残留进程并清掉工作目录。 */
 const stackFinalizer = new FinalizationRegistry<NetworkStackState>((state) => {
-  // SIGTERM 经 unshare --kill-child 转发给 init，内核清理 pid ns 内全部进程；
+  // holder 退出触发内核清理 pid ns 内全部进程；
   // slirp4netns 在宿主侧持有 tap fd，单独终止
-  killProcess(state.holderPid);
+  killHolder(state.holderPid);
   killProcess(state.slirpPid);
+  // FinalizationRegistry 回调不能 await：尽力而为，删不掉就留下（宿主崩溃时同样如此）
+  // eslint-disable-next-line unicorn/no-useless-undefined
+  void rm(state.mihomoHome, { recursive: true, force: true }).catch(() => undefined);
 });
 
 /**
@@ -252,7 +280,8 @@ export async function startNetworkStack(options: NetworkStackOptions): Promise<N
 
   // mihomo 工作目录（-d）：cache.db 等落在这里，而不是它默认的 ~/.config/mihomo/
   //（后者不存在时 mihomo 每次启动都告警且 fakeip 映射无持久化）。每次启动用独立
-  // uuid 目录，避免并发的多个 holder 争抢 bbolt 文件锁。
+  // uuid 目录，避免并发的多个 holder 争抢 bbolt 文件锁；正常停栈与 GC 兜底删除该
+  // 目录（见 stop / stackFinalizer），启动失败时保留作诊断材料（见 catch）。
   const mihomoHome = join(getAgentDir(), "tmp", `mihomo-${randomUUID()}`);
   await mkdir(mihomoHome, { recursive: true });
 
@@ -263,7 +292,8 @@ export async function startNetworkStack(options: NetworkStackOptions): Promise<N
   try {
     // unshare -p --fork：node 成为 pid namespace 的 init，任何方式退出（含 SIGKILL）
     // 内核都会清理 pid ns 内全部进程（mihomo），ns 引用随之归零；
-    // --kill-child=SIGTERM：宿主侧 SIGTERM unshare 时转发给 init 走优雅退出
+    // --kill-child=SIGTERM：init 拿到 PR_SET_PDEATHSIG，unshare 死亡时收到 SIGTERM
+    // 走优雅退出（注意 unshare 自身阻塞 SIGINT/SIGTERM，终止它只能靠 SIGKILL，见 killHolder）
     holder = spawn(
       "unshare",
       [
@@ -359,7 +389,7 @@ export async function startNetworkStack(options: NetworkStackOptions): Promise<N
       mihomoReady.catch(() => undefined);
     });
 
-    const state: NetworkStackState = { holderPid, slirpPid: slirp.pid };
+    const state: NetworkStackState = { holderPid, slirpPid: slirp.pid, mihomoHome };
     const stack: NetworkStack = {
       exec: async (execOptions: NetworkStackExecOptions) => {
         const child = spawn(
@@ -404,14 +434,20 @@ export async function startNetworkStack(options: NetworkStackOptions): Promise<N
           execOptions.signal?.addEventListener("abort", onAbort, { once: true });
 
           child.once("error", (error) => {
-            if (settled) return;
+            if (settled) {
+              return;
+            }
             settled = true;
             reject(error);
           });
           child.once("close", (exitCode) => {
-            if (settled) return;
+            if (settled) {
+              return;
+            }
             settled = true;
-            if (timeoutHandle) clearTimeout(timeoutHandle);
+            if (timeoutHandle) {
+              clearTimeout(timeoutHandle);
+            }
             execOptions.signal?.removeEventListener("abort", onAbort);
             // 中断：reject signal.reason（默认是 name=AbortError 的 DOMException）
             if (execOptions.signal?.aborted) {
@@ -423,7 +459,9 @@ export async function startNetworkStack(options: NetworkStackOptions): Promise<N
             } else if (timedOut) {
               // 超时：name=TimeoutError（对齐标准错误分类）
               reject(new TimeoutError(execOptions.timeout));
-            } else resolve({ exitCode });
+            } else {
+              resolve({ exitCode });
+            }
           });
         });
       },
@@ -432,35 +470,42 @@ export async function startNetworkStack(options: NetworkStackOptions): Promise<N
         // slirp4netns 持有 tap fd（pin 住 netns），必须随 holder 一起显式终止；
         // 先杀它再杀 holder，避免 stop() 与 exit-fd HUP 的收尾时序竞争
         killProcess(state.slirpPid);
-        // SIGTERM unshare → --kill-child 转发 SIGTERM 给 init（pid ns 的 pid 1），
-        // init 优雅停 mihomo 后退出，内核清理 pid ns 内全部进程，ns 引用随之归零
-        killProcess(state.holderPid);
+        // SIGKILL holder → init 经 PDEATHSIG 收到 SIGTERM，优雅停 mihomo 后退出，
+        // 内核清理 pid ns 内全部进程，ns 引用随之归零（毫秒级，见 killHolder）
+        killHolder(state.holderPid);
         await waitForExit(state.holderPid);
         await waitForExit(state.slirpPid);
         // 兜底：init 未在超时内退出 → SIGKILL init → 内核清 pid ns
         for (const pid of children) {
           killProcess(pid, "SIGKILL");
         }
+        // 工作目录只服务本次实例（mihomo 的 cache.db 等运行时缓存），随停栈删除；
+        // best-effort：删除失败不外抛，避免掩盖命令结果
+        // eslint-disable-next-line unicorn/no-useless-undefined
+        await rm(state.mihomoHome, { recursive: true, force: true }).catch(() => undefined);
       },
       holderPid,
     };
     stackFinalizer.register(stack, state);
     return stack;
   } catch (error) {
-    // 失败清理：holder（unshare）的 SIGTERM 经 --kill-child 转发给 init，
-    // init 退出时内核清理 pid ns 内全部进程；slirp4netns 在宿主侧，需单独终止
+    // 失败清理：SIGKILL holder（unshare）→ init 经 PDEATHSIG 收到 SIGTERM 后退出，
+    // 内核清理 pid ns 内全部进程；slirp4netns 在宿主侧，需单独终止
     //（exit-fd 写端也会随 holder 死亡关闭，这里主动杀只是不等到 HUP 轮询）
     if (slirp?.pid) {
       killProcess(slirp.pid);
     }
     if (holder?.pid) {
       const children = await readChildPids(holder.pid);
-      killProcess(holder.pid);
+      killHolder(holder.pid);
       await waitForExit(holder.pid);
       for (const pid of children) {
         killProcess(pid, "SIGKILL");
       }
     }
+    // 这里刻意不删 mihomoHome：启动失败时它属于现场材料，与下面落盘的诊断日志
+    //（holder / slirp 输出 + 错误本身）配套保留，便于事后排查；失败路径罕见，
+    // 留一个目录不构成泄漏
     const logPath = await writeFailureLog(error, [holderLog.join(""), slirpLog.join("")]);
     if (logPath !== undefined && error instanceof Error) {
       throw new Error(`${error.message}\n(sandbox startup diagnostics: ${logPath})`, {

package/src/bwrap/runtime.ts

@@ -166,7 +166,9 @@ const BASH_TAIL_LIMIT_BYTES = 1024 * 1024;
 function countNewlines(data: Buffer): number {
   let count = 0;
   for (const byte of data) {
-    if (byte === 0x0a) count++;
+    if (byte === 0x0a) {
+      count++;
+    }
   }
   return count;
 }
@@ -219,7 +221,9 @@ class BashOutput {
   }
 
   close(): Promise<void> {
-    if (!this.stream) return Promise.resolve();
+    if (!this.stream) {
+      return Promise.resolve();
+    }
     const stream = this.stream;
     this.stream = undefined;
     return new Promise((resolve) => {
@@ -286,8 +290,12 @@ function notifyChange(
   ctx: { ui: { notify: (message: string, type?: "info" | "warning" | "error") => void } },
   change: SandboxChange,
 ): void {
-  if (change.fs !== undefined) ctx.ui.notify(FS_LABELS[change.fs], "info");
-  if (change.network !== undefined) ctx.ui.notify(NETWORK_LABELS[change.network], "info");
+  if (change.fs !== undefined) {
+    ctx.ui.notify(FS_LABELS[change.fs], "info");
+  }
+  if (change.network !== undefined) {
+    ctx.ui.notify(NETWORK_LABELS[change.network], "info");
+  }
 }
 
 /** 沙箱默认写边界：根只读、工作区与 /tmp 可写、.git 只读。不展开用户配置的额外可写路径。 */
@@ -342,7 +350,9 @@ export function describeSandbox(
   unsandboxed: boolean,
   fixed = false,
 ): string | undefined {
-  if (unsandboxed) return undefined;
+  if (unsandboxed) {
+    return undefined;
+  }
   return [
     "<system-reminder>",
     `This command ran in a sandbox: ${describeLimits(resolved)}.`,
@@ -464,7 +474,9 @@ export class BwrapRuntime {
 
     // 固定沙箱（创建时显式传入配置）不注册 /bwrap-* 命令：切模式与恢复提权审批
     // 都可能放宽声明的沙箱
-    if (this.config === undefined) this.registerCommands(pi);
+    if (this.config === undefined) {
+      this.registerCommands(pi);
+    }
   }
 
   setMode(cwd: string, change: SandboxChange): ResolvedBwrap {
@@ -663,7 +675,9 @@ export class BwrapRuntime {
   }
 
   private resolve(ctx: Pick<ExtensionContext, "cwd">): ResolvedBwrap {
-    if (!this.resolved) this.resolved = resolveBwrap(this.config ?? loadBwrapConfig(ctx.cwd));
+    if (!this.resolved) {
+      this.resolved = resolveBwrap(this.config ?? loadBwrapConfig(ctx.cwd));
+    }
     return this.resolved;
   }
 
@@ -674,7 +688,9 @@ export class BwrapRuntime {
     execCwd: string,
   ): Promise<FullAccessGrant> {
     // hasUI 判定推迟到审批时刻：无 UI 会话弹不了审批框，按用户点 Deny 的标准文案拒绝
-    if (!ctx.hasUI) throw new Error(UNSANDBOXED_DENIED);
+    if (!ctx.hasUI) {
+      throw new Error(UNSANDBOXED_DENIED);
+    }
     const decision = await this.approveFullAccessUI(ctx, command, reason, execCwd);
     // 关闭对话框 = 中断并拒绝，不循环重问
     if (decision === undefined) {
@@ -802,7 +818,9 @@ export class BwrapRuntime {
       const verdict = await selectWithOptionalInput(description + pending, actions, ctx.ui, {
         signal: ctx.signal,
       });
-      if (verdict === undefined) return undefined;
+      if (verdict === undefined) {
+        return undefined;
+      }
       if (verdict.label !== EDIT_RULES) {
         return {
           result: verdict.label,
@@ -826,7 +844,9 @@ export class BwrapRuntime {
     patterns?: string[],
   ): Promise<void> {
     const rulePatterns = patterns ?? (await commandPatternsFor(command));
-    if (rulePatterns.length === 0) return; // 解析失败：本次处理，不写规则
+    if (rulePatterns.length === 0) {
+      return; // 解析失败：本次处理，不写规则
+    }
     const newRules: ApprovalRule[] = rulePatterns.map((pattern) => ({ action: "allow", pattern }));
     const { project } = getBwrapConfigPaths(ctx.cwd);
     let config: Record<string, unknown> = {};

package/src/bwrap/sandbox.ts

@@ -117,7 +117,7 @@ export async function runInSandbox(
   const workspace = expandHome(options.workspace);
   const commandCwd = expandHome(options.commandCwd ?? workspace);
   const local = options.unsandboxed === true || !resolved.bwrapEnabled;
-  // 每次执行现建网络栈（启动约 140ms），作用域结束即停栈：allowlist 变更即时生效
+  // 每次执行现建现停网络栈（起栈 ~40ms、停栈 ~100ms），作用域结束即停栈：allowlist 变更即时生效
   const stack = local ? undefined : await createNetworkStack(resolved, options.log);
   try {
     if (stack) {

package/src/claude-code/common.ts

@@ -14,7 +14,9 @@ export function resolveToolFilePath(filePath: string, cwd: string): string {
 
 /** Resolve a search root path against the working directory. */
 export function searchRoot(path: string | undefined, cwd: string): string {
-  if (!path) return cwd;
+  if (!path) {
+    return cwd;
+  }
   return isAbsolute(path) ? path : resolve(cwd, path);
 }
 
@@ -82,6 +84,8 @@ export async function suggestPathUnderCwd(
 /** "Did you mean" 建议：优先 cwd 重定位，其次同名不同扩展（对齐 Claude Code）。 */
 export async function didYouMean(filePath: string, cwd: string): Promise<string | undefined> {
   const cwdSuggestion = await suggestPathUnderCwd(filePath, cwd);
-  if (cwdSuggestion) return cwdSuggestion;
+  if (cwdSuggestion) {
+    return cwdSuggestion;
+  }
   return findSimilarFile(filePath);
 }

package/src/claude-code/edit-utils.ts

@@ -12,6 +12,8 @@
  * convertLeadingTabsToSpaces）。仅用于 details 里展示的 diff，不影响写盘内容。
  */
 export function convertLeadingTabsToSpaces(content: string): string {
-  if (!content.includes("\t")) return content;
+  if (!content.includes("\t")) {
+    return content;
+  }
   return content.replaceAll(/^\t+/gm, (tabs) => "  ".repeat(tabs.length));
 }

package/src/claude-code/files.ts

@@ -44,9 +44,15 @@ const MAX_READ_TOKENS = 25_000;
 const MAX_EDIT_FILE_SIZE = 1024 * 1024 * 1024; // 1 GiB
 
 function formatFileSize(bytes: number): string {
-  if (bytes < 1024) return `${bytes} B`;
-  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
-  if (bytes < 1024 * 1024 * 1024) return `${(bytes / 1024 / 1024).toFixed(1)} MB`;
+  if (bytes < 1024) {
+    return `${bytes} B`;
+  }
+  if (bytes < 1024 * 1024) {
+    return `${(bytes / 1024).toFixed(1)} KB`;
+  }
+  if (bytes < 1024 * 1024 * 1024) {
+    return `${(bytes / 1024 / 1024).toFixed(1)} MB`;
+  }
   return `${(bytes / 1024 / 1024 / 1024).toFixed(1)} GB`;
 }
 
@@ -81,7 +87,9 @@ async function assertReadableFile(filePath: string): Promise<Stats> {
   if (value.isDirectory()) {
     throw new Error(`EISDIR: illegal operation on a directory, read '${filePath}'`);
   }
-  if (!value.isFile()) throw new Error(`File not found: ${filePath}`);
+  if (!value.isFile()) {
+    throw new Error(`File not found: ${filePath}`);
+  }
   await access(filePath, constants.R_OK);
   return value;
 }
@@ -89,8 +97,12 @@ async function assertReadableFile(filePath: string): Promise<Stats> {
 function isBinary(sample: Uint8Array): boolean {
   let suspicious = 0;
   for (const byte of sample) {
-    if (byte === 0) return true;
-    if (byte < 9 || (byte > 13 && byte < 32)) suspicious++;
+    if (byte === 0) {
+      return true;
+    }
+    if (byte < 9 || (byte > 13 && byte < 32)) {
+      suspicious++;
+    }
   }
   return sample.length > 0 && suspicious / sample.length > 0.3;
 }
@@ -104,7 +116,9 @@ function isBinary(sample: Uint8Array): boolean {
  */
 function splitFileLines(content: string): string[] {
   const text = content.replace(/^\uFEFF/, "");
-  if (text === "") return [];
+  if (text === "") {
+    return [];
+  }
   return (text.endsWith("\n") ? text : `${text}\n`)
     .split("\n")
     .map((line) => (line.endsWith("\r") ? line.slice(0, -1) : line));
@@ -157,7 +171,9 @@ export function formatReadOutput(
 }
 
 function countMatches(content: string, needle: string): number {
-  if (needle === "") return 0;
+  if (needle === "") {
+    return 0;
+  }
   let count = 0;
   let index = 0;
   while ((index = content.indexOf(needle, index)) !== -1) {
@@ -173,17 +189,24 @@ export function exactReplace(
   newString: string,
   replaceAll = false,
 ): string {
-  if (oldString === newString)
+  if (oldString === newString) {
     throw new Error("No changes to apply: old_string and new_string are identical.");
-  if (oldString === "") throw new Error("old_string must not be empty.");
+  }
+  if (oldString === "") {
+    throw new Error("old_string must not be empty.");
+  }
   const matches = countMatches(content, oldString);
-  if (matches === 0) throw new Error("String to replace not found in file.");
+  if (matches === 0) {
+    throw new Error("String to replace not found in file.");
+  }
   if (!replaceAll && matches > 1) {
     throw new Error(
       `Found ${matches} matches of the string to replace, but replace_all is false. To replace all occurrences, set replace_all to true. To replace only one occurrence, provide more context to make old_string unique.`,
     );
   }
-  if (replaceAll) return content.split(oldString).join(newString);
+  if (replaceAll) {
+    return content.split(oldString).join(newString);
+  }
   const index = content.indexOf(oldString);
   return content.slice(0, index) + newString + content.slice(index + oldString.length);
 }
@@ -284,8 +307,9 @@ export function registerFileTools(
       const key = await readStateKey(filePath);
       const buffer = await readFile(filePath);
 
-      if (isBinary(buffer.subarray(0, SAMPLE_BYTES)))
+      if (isBinary(buffer.subarray(0, SAMPLE_BYTES))) {
         throw new Error(`Cannot read binary file: ${filePath}`);
+      }
       // 全读（limit 未传）时受字节上限约束（对齐 Claude Code）
       if (params.limit === undefined && buffer.length > MAX_READ_SIZE_BYTES) {
         throw new Error(
@@ -398,7 +422,9 @@ export function registerFileTools(
               throw error;
             }
           }
-          if (!exists) await mkdir(dirname(filePath), { recursive: true });
+          if (!exists) {
+            await mkdir(dirname(filePath), { recursive: true });
+          }
           await writeFile(filePath, newString, "utf8");
           const snapshot = snapshotOf(newString);
           const key = await readStateKey(filePath);

package/src/claude-code/glob.ts

@@ -40,11 +40,15 @@ function extractGlobBaseDirectory(pattern: string): {
   }
   const staticPrefix = pattern.slice(0, match.index);
   const lastSepIndex = Math.max(staticPrefix.lastIndexOf("/"), staticPrefix.lastIndexOf(sep));
-  if (lastSepIndex === -1) return { baseDir: "", relativePattern: pattern };
+  if (lastSepIndex === -1) {
+    return { baseDir: "", relativePattern: pattern };
+  }
   let baseDir = staticPrefix.slice(0, lastSepIndex);
   const relativePattern = pattern.slice(lastSepIndex + 1);
   // 根目录 pattern（如 /*.txt）：baseDir 为空但应使用 "/"
-  if (baseDir === "" && lastSepIndex === 0) baseDir = "/";
+  if (baseDir === "" && lastSepIndex === 0) {
+    baseDir = "/";
+  }
   return { baseDir, relativePattern };
 }
 
@@ -89,7 +93,9 @@ export async function globFiles(
   } catch (error) {
     // rg exit code 1 = 搜索完成但无匹配，对齐 Claude Code 的 ripGrep（正常空结果）
     const code = (error as { code?: unknown }).code;
-    if (code === 1) return { files: [], truncated: false };
+    if (code === 1) {
+      return { files: [], truncated: false };
+    }
     const detail =
       (error as { stderr?: string }).stderr?.trim() ||
       (error instanceof Error ? error.message : String(error));
@@ -143,7 +149,9 @@ export function registerGlobTool(pi: ExtensionAPI): void {
           }
           throw error;
         }
-        if (!stats.isDirectory()) throw new Error(`Path is not a directory: ${params.path}`);
+        if (!stats.isDirectory()) {
+          throw new Error(`Path is not a directory: ${params.path}`);
+        }
       }
       const { files, truncated } = await globFiles(params.pattern, root, signal);
       const filenames = files.map((filePath) => toRelativePath(filePath, ctx.cwd));

package/src/claude-code/grep.ts

@@ -35,7 +35,9 @@ const VCS_DIRECTORIES_TO_EXCLUDE = [".git", ".svn", ".hg", ".bzr", ".jj", ".sl"]
 const DEFAULT_HEAD_LIMIT = 250;
 
 function truncateOutput(output: string, maxCharacters = 30_000): string {
-  if (output.length <= maxCharacters) return output;
+  if (output.length <= maxCharacters) {
+    return output;
+  }
   return `${output.slice(0, maxCharacters)}\n\n[Output truncated at ${maxCharacters} characters]`;
 }
 
@@ -102,22 +104,36 @@ export function buildGrepArguments(params: GrepParameters, cwd: string): string[
     case "content": {
       args.push("--no-heading", "--with-filename");
       const showLineNumbers = params["-n"] === true || params["-n"] === undefined;
-      if (showLineNumbers) args.push("--line-number");
+      if (showLineNumbers) {
+        args.push("--line-number");
+      }
       const before = params["-B"];
       const after = params["-A"];
       const around = params.context ?? params["-C"];
       if (around === undefined) {
-        if (before !== undefined) args.push("--before-context", String(before));
-        if (after !== undefined) args.push("--after-context", String(after));
-      } else args.push("--context", String(around));
+        if (before !== undefined) {
+          args.push("--before-context", String(before));
+        }
+        if (after !== undefined) {
+          args.push("--after-context", String(after));
+        }
+      } else {
+        args.push("--context", String(around));
+      }
 
       break;
     }
     // No default
   }
-  if (params["-i"] === true) args.push("--ignore-case");
-  if (params.type) args.push("--type", params.type);
-  if (params.multiline === true) args.push("--multiline", "--multiline-dotall");
+  if (params["-i"] === true) {
+    args.push("--ignore-case");
+  }
+  if (params.type) {
+    args.push("--type", params.type);
+  }
+  if (params.multiline === true) {
+    args.push("--multiline", "--multiline-dotall");
+  }
   // glob 按逗号/空格拆分（花括号模式不拆），对齐 Claude Code
   if (params.glob) {
     const globPatterns: string[] = [];
@@ -129,12 +145,17 @@ export function buildGrepArguments(params: GrepParameters, cwd: string): string[
       }
     }
     for (const globPattern of globPatterns) {
-      if (globPattern) args.push("--glob", globPattern);
+      if (globPattern) {
+        args.push("--glob", globPattern);
+      }
     }
   }
   // 以 - 开头的 pattern 用 -e 显式声明，防止被 rg 当作选项
-  if (params.pattern.startsWith("-")) args.push("-e", params.pattern);
-  else args.push(params.pattern);
+  if (params.pattern.startsWith("-")) {
+    args.push("-e", params.pattern);
+  } else {
+    args.push(params.pattern);
+  }
   args.push(searchRoot(params.path, cwd));
   return args;
 }
@@ -147,7 +168,9 @@ export function buildGrepArguments(params: GrepParameters, cwd: string): string[
  */
 export async function sortFilesByMtime(output: string): Promise<string> {
   const paths = output.replace(/\n$/, "").split("\n").filter(Boolean);
-  if (paths.length <= 1) return output;
+  if (paths.length <= 1) {
+    return output;
+  }
   const stats = await Promise.allSettled(paths.map((path) => stat(path)));
   const sorted = paths
     .map((path, index) => ({
@@ -208,8 +231,12 @@ function formatLimitInfo(
   appliedOffset: number | undefined,
 ): string {
   const parts: string[] = [];
-  if (appliedLimit !== undefined) parts.push(`limit: ${appliedLimit}`);
-  if (appliedOffset) parts.push(`offset: ${appliedOffset}`);
+  if (appliedLimit !== undefined) {
+    parts.push(`limit: ${appliedLimit}`);
+  }
+  if (appliedOffset) {
+    parts.push(`offset: ${appliedOffset}`);
+  }
   return parts.join(", ");
 }