kantban-cli 0.1.24 → 0.1.25

package/dist/index.js

@@ -31,10 +31,10 @@ async function main() {
     }
     case "pipeline": {
       if (args[0] === "stop") {
-        const { stopPipeline } = await import("./pipeline-TEE6GBNZ.js");
+        const { stopPipeline } = await import("./pipeline-IYKEQZWN.js");
         await stopPipeline(args.slice(1));
       } else {
-        const { runPipeline } = await import("./pipeline-TEE6GBNZ.js");
+        const { runPipeline } = await import("./pipeline-IYKEQZWN.js");
         await runPipeline(client, args);
       }
       break;

package/dist/{pipeline-TEE6GBNZ.js → pipeline-IYKEQZWN.js}

@@ -22,9 +22,9 @@ import {
 } from "./chunk-ZTQJMXJM.js";
 
 // src/commands/pipeline.ts
-import { mkdirSync as mkdirSync2, writeFileSync as writeFileSync3, readFileSync as readFileSync2, unlinkSync as unlinkSync2, existsSync as existsSync2, appendFileSync as appendFileSync2 } from "fs";
-import { homedir } from "os";
-import { join as join2 } from "path";
+import { mkdirSync as mkdirSync3, writeFileSync as writeFileSync4, readFileSync as readFileSync3, unlinkSync as unlinkSync3, existsSync as existsSync3, appendFileSync as appendFileSync2 } from "fs";
+import { homedir as homedir2 } from "os";
+import { join as join3 } from "path";
 
 // src/lib/tool-profiles.ts
 function resolveToolRestrictions(builtinTools, allowedTools, disallowedTools) {
@@ -3448,15 +3448,433 @@ var CodexProvider = class {
   }
 };
 
+// src/providers/gemini-provider.ts
+import { spawn as spawn3, execFileSync as execFileSync3 } from "child_process";
+import { existsSync as existsSync2, writeFileSync as writeFileSync3, mkdirSync as mkdirSync2 } from "fs";
+import { join as join2, dirname } from "path";
+import { homedir } from "os";
+import { fileURLToPath } from "url";
+import { readFileSync as readFileSync2 } from "fs";
+
+// src/providers/gemini-jsonl-parser.ts
+var GeminiJsonlParser = class {
+  buffer = "";
+  /** Accumulates lines that failed individual JSON parse (multi-line object) */
+  jsonAccum = "";
+  toolCallCount = 0;
+  inputTokens = 0;
+  outputTokens = 0;
+  lastOutput = "";
+  onEvent = () => {
+  };
+  onError = () => {
+  };
+  feed(chunk) {
+    this.buffer += chunk;
+    const lines = this.buffer.split("\n");
+    this.buffer = lines.pop() ?? "";
+    for (const line of lines) {
+      this.parseLine(line.trim());
+    }
+  }
+  flush() {
+    const trimmed = this.buffer.trim();
+    this.buffer = "";
+    if (trimmed) this.parseLine(trimmed);
+    this.tryFlushAccum();
+  }
+  getToolCallCount() {
+    return this.toolCallCount;
+  }
+  getUsage() {
+    return { inputTokens: this.inputTokens, outputTokens: this.outputTokens };
+  }
+  getLastOutput() {
+    return this.lastOutput;
+  }
+  reset() {
+    this.buffer = "";
+    this.toolCallCount = 0;
+    this.inputTokens = 0;
+    this.outputTokens = 0;
+    this.lastOutput = "";
+  }
+  parseLine(line) {
+    if (!line) return;
+    if (this.jsonAccum) {
+      this.jsonAccum += "\n" + line;
+      if (this.tryFlushAccum()) return;
+      return;
+    }
+    try {
+      const raw = JSON.parse(line);
+      this.translateEvent(raw);
+    } catch {
+      if (line.startsWith("{") || line.startsWith("[")) {
+        this.jsonAccum = line;
+      }
+    }
+  }
+  /** Try to parse the accumulated multi-line buffer as JSON. Returns true if successful. */
+  tryFlushAccum() {
+    if (!this.jsonAccum) return false;
+    try {
+      const raw = JSON.parse(this.jsonAccum);
+      this.jsonAccum = "";
+      this.translateEvent(raw);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  translateEvent(raw) {
+    const eventType = raw.type;
+    if (eventType === "message") {
+      if (raw.role === "assistant" && typeof raw.content === "string") {
+        this.onEvent({ type: "text", text: raw.content });
+      }
+    } else if (eventType === "tool_use") {
+      this.toolCallCount++;
+      this.onEvent({
+        type: "tool_call",
+        tool: raw.name ?? "unknown",
+        input: raw.args ?? raw.input
+      });
+    } else if (eventType === "tool_result") {
+      this.onEvent({
+        type: "tool_result",
+        tool: raw.name ?? "unknown",
+        output: raw.output ?? raw.result
+      });
+    } else if (eventType === "result" || raw.session_id && raw.stats) {
+      const { inTok, outTok } = this.extractTokens(raw);
+      this.inputTokens += inTok;
+      this.outputTokens += outTok;
+      if (inTok || outTok) {
+        this.onEvent({ type: "usage", inputTokens: inTok, outputTokens: outTok });
+      }
+      const tools = raw.stats?.tools;
+      if (tools?.totalCalls) this.toolCallCount = Math.max(this.toolCallCount, tools.totalCalls);
+      if (typeof raw.response === "string") {
+        this.lastOutput = raw.response;
+        this.onEvent({ type: "done", result: raw.response });
+      }
+    } else if (eventType === "error") {
+      const msg = raw.message ?? "unknown error";
+      this.lastOutput = msg;
+      this.onEvent({ type: "error", message: msg });
+    }
+  }
+  /** Extract token counts from Gemini's nested stats structure */
+  extractTokens(raw) {
+    const stats = raw.stats;
+    if (!stats) return { inTok: 0, outTok: 0 };
+    if (stats.promptTokenCount || stats.input_tokens) {
+      return {
+        inTok: stats.promptTokenCount ?? stats.input_tokens ?? 0,
+        outTok: stats.candidatesTokenCount ?? stats.output_tokens ?? 0
+      };
+    }
+    if (stats.models && typeof stats.models === "object") {
+      let inTok = 0;
+      let outTok = 0;
+      for (const model of Object.values(stats.models)) {
+        const tokens = model?.tokens;
+        if (tokens) {
+          inTok += tokens.prompt ?? tokens.input ?? 0;
+          outTok += tokens.candidates ?? tokens.output ?? 0;
+        }
+      }
+      return { inTok, outTok };
+    }
+    return { inTok: 0, outTok: 0 };
+  }
+};
+
+// src/providers/gemini-provider.ts
+var GEMINI_TIMEOUT_MS = 60 * 60 * 1e3;
+var TOOL_NAME_MAP = {
+  Write: "write_file",
+  Edit: "replace",
+  Read: "read_file",
+  Bash: "run_shell_command",
+  Grep: "grep_search",
+  Glob: "glob",
+  WebFetch: "web_fetch",
+  WebSearch: "google_web_search",
+  LS: "list_directory"
+};
+function translateToolNames(tools) {
+  return tools.map((t) => TOOL_NAME_MAP[t] ?? t);
+}
+function resolveHookScriptPath() {
+  try {
+    const thisDir = dirname(fileURLToPath(import.meta.url));
+    const candidates = [
+      join2(thisDir, "lib", "gemini-hooks.mjs"),
+      // dist/lib/ (flat bundle)
+      join2(thisDir, "..", "lib", "gemini-hooks.mjs"),
+      // dist/../lib/ (nested)
+      join2(thisDir, "..", "src", "lib", "gemini-hooks.mjs"),
+      // source from dist/
+      join2(thisDir, "..", "..", "src", "lib", "gemini-hooks.mjs")
+      // source from dist/providers/
+    ];
+    for (const p of candidates) {
+      if (existsSync2(p)) return p;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+var GeminiProvider = class {
+  id = "gemini";
+  displayName = "Gemini CLI";
+  capabilities() {
+    return {
+      supportsToolAllowlist: true,
+      supportsToolDenylist: true,
+      supportsBuiltinToolStripping: true,
+      supportsMaxTurns: true,
+      supportsMcpConfigInjection: false,
+      supportsMcpConfigOverride: true,
+      supportsWorktreeFlag: false,
+      supportsSandboxModes: true,
+      supportedModels: [
+        { id: "gemini-2.5-flash-lite", displayName: "Flash Lite", tier: "fast" },
+        { id: "gemini-2.5-flash", displayName: "Flash", tier: "default" },
+        { id: "gemini-2.5-pro", displayName: "Pro", tier: "thorough" }
+      ],
+      streamFormat: "jsonl"
+    };
+  }
+  async invoke(request) {
+    const degraded = [];
+    const args = this.buildArgs(request);
+    const startTime = Date.now();
+    if (request.workingDirectory) {
+      if (!existsSync2(request.workingDirectory)) {
+        try {
+          execFileSync3("git", ["worktree", "add", "-b", request.workingDirectory, request.workingDirectory, "HEAD"], {
+            stdio: "pipe"
+          });
+        } catch {
+          try {
+            execFileSync3("git", ["worktree", "add", request.workingDirectory, request.workingDirectory], {
+              stdio: "pipe"
+            });
+          } catch {
+            degraded.push("worktreeCreation");
+          }
+        }
+      } else {
+        try {
+          execFileSync3("git", ["-C", request.workingDirectory, "rev-parse", "--git-dir"], {
+            stdio: "pipe"
+          });
+        } catch {
+          try {
+            execFileSync3("rm", ["-rf", request.workingDirectory], { stdio: "pipe" });
+            execFileSync3("git", ["worktree", "add", "-b", request.workingDirectory, request.workingDirectory, "HEAD"], {
+              stdio: "pipe"
+            });
+          } catch {
+            try {
+              execFileSync3("git", ["worktree", "add", request.workingDirectory, request.workingDirectory], {
+                stdio: "pipe"
+              });
+            } catch {
+              degraded.push("worktreeCreation");
+            }
+          }
+        }
+      }
+      if (!degraded.includes("worktreeCreation") && existsSync2(request.workingDirectory)) {
+        ensureWorktreeRemote(request.workingDirectory);
+      }
+    }
+    const settingsDir = this.writeGeminiSettings(request, degraded);
+    const cwd = request.workingDirectory ?? settingsDir;
+    if (request.workingDirectory && settingsDir) {
+      this.copySettingsToDir(settingsDir, request.workingDirectory);
+    }
+    return new Promise((resolve) => {
+      const child = spawn3("gemini", args, {
+        stdio: ["pipe", "pipe", "pipe"],
+        cwd: cwd || void 0
+      });
+      const parser = new GeminiJsonlParser();
+      parser.onEvent = (event) => request.onStreamEvent?.(event);
+      parser.onError = (err) => process.stderr.write(`[gemini-jsonl] ${err.message}
+`);
+      let stderr = "";
+      child.stdout?.on("data", (chunk) => parser.feed(chunk.toString()));
+      child.stderr?.on("data", (chunk) => {
+        stderr += chunk.toString();
+      });
+      child.stdin?.end();
+      if (request.abortSignal) {
+        request.abortSignal.addEventListener("abort", () => {
+          try {
+            child.kill("SIGTERM");
+          } catch {
+          }
+        }, { once: true });
+      }
+      let killTimer;
+      const timeoutHandle = setTimeout(() => {
+        try {
+          child.kill("SIGTERM");
+        } catch {
+        }
+        killTimer = setTimeout(() => {
+          try {
+            child.kill("SIGKILL");
+          } catch {
+          }
+        }, 5e3);
+      }, GEMINI_TIMEOUT_MS);
+      let resolved = false;
+      const finish = (code, errorMsg) => {
+        if (resolved) return;
+        resolved = true;
+        clearTimeout(timeoutHandle);
+        if (killTimer) clearTimeout(killTimer);
+        parser.flush();
+        const usage = parser.getUsage();
+        const result = {
+          exitCode: (code === 53 ? 0 : code) ?? 1,
+          output: errorMsg ?? (parser.getLastOutput() || stderr),
+          toolCallCount: parser.getToolCallCount(),
+          usage,
+          durationMs: Date.now() - startTime
+        };
+        if (degraded.length > 0) result.degradedCapabilities = degraded;
+        resolve(result);
+      };
+      child.on("close", (code) => finish(code));
+      child.on("error", (err) => finish(1, err.message));
+    });
+  }
+  async preflight() {
+    try {
+      const whichModule = await import("which");
+      const syncFn = whichModule.default?.sync ?? whichModule.sync;
+      syncFn("gemini");
+      return { available: true, authenticated: true };
+    } catch {
+      return { available: false, authenticated: false, error: "gemini binary not found on PATH" };
+    }
+  }
+  buildArgs(request) {
+    const args = [
+      "-p",
+      request.prompt,
+      "--yolo",
+      "--output-format",
+      "json"
+    ];
+    if (request.model) args.push("--model", request.model);
+    return args;
+  }
+  writeGeminiSettings(request, degraded) {
+    try {
+      const baseDir = join2(homedir(), ".kantban", "pipelines", "gemini-tmp");
+      const dir = join2(baseDir, `session-${Date.now()}`);
+      const geminiDir = join2(dir, ".gemini");
+      mkdirSync2(geminiDir, { recursive: true, mode: 448 });
+      const settings = {};
+      if (request.mcpConfig && Object.keys(request.mcpConfig.servers).length > 0) {
+        settings.mcpServers = {};
+        for (const [name, server] of Object.entries(request.mcpConfig.servers)) {
+          settings.mcpServers[name] = {
+            command: server.command,
+            args: server.args,
+            env: server.env,
+            trust: true
+          };
+        }
+      }
+      const hookPath = resolveHookScriptPath();
+      if (hookPath) {
+        const hooks = {};
+        const hookConfig = {};
+        if (request.toolRestrictions) {
+          const tr = request.toolRestrictions;
+          hookConfig.allowedTools = tr.allowedTools ? translateToolNames(tr.allowedTools) : null;
+          hookConfig.disallowedTools = tr.disallowedTools ? translateToolNames(tr.disallowedTools) : null;
+          if (tr.tools !== void 0) hookConfig.builtinToolsMode = tr.tools;
+          const wrapperPath = join2(dir, ".kantban-hook-before-tool.sh");
+          writeFileSync3(wrapperPath, this.generateHookWrapper(hookPath, "BeforeToolSelection", join2(dir, ".kantban-hook-config.json")), { mode: 493 });
+          hooks.BeforeToolSelection = [{ matcher: "*", hooks: [{ type: "command", command: wrapperPath, timeout: 3e4 }] }];
+        }
+        if (request.maxTurns) {
+          hookConfig.maxTurns = request.maxTurns;
+          hookConfig.turnFile = join2(dir, ".kantban-turn-counter");
+          const wrapperPath = join2(dir, ".kantban-hook-after-agent.sh");
+          writeFileSync3(wrapperPath, this.generateHookWrapper(hookPath, "AfterAgent", join2(dir, ".kantban-hook-config.json")), { mode: 493 });
+          hooks.AfterAgent = [{ matcher: "*", hooks: [{ type: "command", command: wrapperPath, timeout: 3e4 }] }];
+        }
+        if (Object.keys(hookConfig).length > 0) {
+          writeFileSync3(join2(dir, ".kantban-hook-config.json"), JSON.stringify(hookConfig), { mode: 384 });
+        }
+        if (Object.keys(hooks).length > 0) {
+          settings.hooks = hooks;
+        }
+      } else {
+        if (request.maxTurns) degraded.push("maxTurns");
+        if (request.toolRestrictions?.allowedTools?.length) degraded.push("toolAllowlist");
+        if (request.toolRestrictions?.disallowedTools?.length) degraded.push("toolDenylist");
+        if (request.toolRestrictions?.tools !== void 0) degraded.push("builtinToolStripping");
+        process.stderr.write(`[gemini] Hook script not found \u2014 tool scoping and turn limits unavailable
+`);
+      }
+      writeFileSync3(join2(geminiDir, "settings.json"), JSON.stringify(settings, null, 2), { mode: 384 });
+      return dir;
+    } catch (err) {
+      process.stderr.write(`[gemini] Failed to write settings.json: ${err}
+`);
+      if (request.maxTurns) degraded.push("maxTurns");
+      if (request.toolRestrictions?.allowedTools?.length) degraded.push("toolAllowlist");
+      if (request.toolRestrictions?.disallowedTools?.length) degraded.push("toolDenylist");
+      if (request.toolRestrictions?.tools !== void 0) degraded.push("builtinToolStripping");
+      return null;
+    }
+  }
+  /** Generate a per-session bash wrapper that invokes the Node hook script.
+   *  Gemini CLI ignores `args` in hook definitions, so we embed all arguments. */
+  generateHookWrapper(hookScript, event, configFile) {
+    return `#!/bin/bash
+# KantBan pipeline hook wrapper \u2014 Gemini CLI does not pass args, so we embed them.
+STDIN_FILE=$(mktemp)
+trap 'rm -f "$STDIN_FILE"' EXIT
+cat > "$STDIN_FILE"
+node "${hookScript}" "${event}" "${configFile}" < "$STDIN_FILE"
+`;
+  }
+  copySettingsToDir(settingsDir, targetDir) {
+    try {
+      const sourceFile = join2(settingsDir, ".gemini", "settings.json");
+      const targetGeminiDir = join2(targetDir, ".gemini");
+      mkdirSync2(targetGeminiDir, { recursive: true, mode: 448 });
+      const content = readFileSync2(sourceFile, "utf-8");
+      writeFileSync3(join2(targetGeminiDir, "settings.json"), content, { mode: 384 });
+    } catch {
+    }
+  }
+};
+
 // src/commands/pipeline.ts
 function createProviderRegistry() {
   const registry = new ProviderRegistry();
   registry.register(new ClaudeProvider());
   registry.register(new CodexProvider());
+  registry.register(new GeminiProvider());
   return registry;
 }
 function readMcpConfigAsProviderConfig(filePath) {
-  const raw = JSON.parse(readFileSync2(filePath, "utf-8"));
+  const raw = JSON.parse(readFileSync3(filePath, "utf-8"));
   return { servers: raw.mcpServers };
 }
 function parseArgs(args) {
@@ -3544,7 +3962,7 @@ Flags:
   --max-iterations <n>  Override max iterations per ticket
   --max-budget <usd>    Per-ticket budget cap (USD)
   --model <model>       Override model preference
-  --provider <id>       Override default provider (claude, codex)
+  --provider <id>       Override default provider (claude, codex, gemini)
   --concurrency <n>     Override concurrency per column
   --log-retention <d>   Log retention in days (default: 7)
   --yes, -y             Skip safety confirmation`);
@@ -3553,28 +3971,28 @@ Flags:
   return { boardId, once, dryRun, columnFilter, maxIterations, maxBudget, model, provider, concurrency, logRetention, yes };
 }
 function pidDir(boardId) {
-  return join2(homedir(), ".kantban", "pipelines", boardId);
+  return join3(homedir2(), ".kantban", "pipelines", boardId);
 }
 function pidFilePath(boardId) {
-  return join2(pidDir(boardId), "orchestrator.pid");
+  return join3(pidDir(boardId), "orchestrator.pid");
 }
 function writePidFile(boardId) {
   const dir = pidDir(boardId);
-  mkdirSync2(dir, { recursive: true, mode: 448 });
-  writeFileSync3(pidFilePath(boardId), String(process.pid), { mode: 384 });
+  mkdirSync3(dir, { recursive: true, mode: 448 });
+  writeFileSync4(pidFilePath(boardId), String(process.pid), { mode: 384 });
 }
 function removePidFile(boardId) {
   try {
-    unlinkSync2(pidFilePath(boardId));
+    unlinkSync3(pidFilePath(boardId));
   } catch {
   }
 }
 function childManifestPath(boardId) {
-  return join2(pidDir(boardId), "children.pid");
+  return join3(pidDir(boardId), "children.pid");
 }
 function readChildManifest(boardId) {
   try {
-    const contents = readFileSync2(childManifestPath(boardId), "utf-8");
+    const contents = readFileSync3(childManifestPath(boardId), "utf-8");
     return contents.split("\n").map((l) => l.trim()).filter((l) => l !== "").map(Number).filter((n) => !isNaN(n) && n > 0);
   } catch {
     return [];
@@ -3582,15 +4000,15 @@ function readChildManifest(boardId) {
 }
 function removeChildManifest(boardId) {
   try {
-    unlinkSync2(childManifestPath(boardId));
+    unlinkSync3(childManifestPath(boardId));
   } catch {
   }
 }
 function cleanupOrphanedProcesses(boardId) {
   const pidPath = pidFilePath(boardId);
-  if (existsSync2(pidPath)) {
+  if (existsSync3(pidPath)) {
     try {
-      const stalePid = parseInt(readFileSync2(pidPath, "utf-8").trim(), 10);
+      const stalePid = parseInt(readFileSync3(pidPath, "utf-8").trim(), 10);
       if (stalePid && stalePid !== process.pid) {
         try {
           process.kill(stalePid, 0);
@@ -3615,10 +4033,10 @@ function cleanupOrphanedProcesses(boardId) {
     console.log(`Killed ${String(manifestPids.length)} orphaned child process(es) from manifest`);
     removeChildManifest(boardId);
   }
-  const staleReaperPath = join2(pidDir(boardId), "reaper.pid");
+  const staleReaperPath = join3(pidDir(boardId), "reaper.pid");
   try {
-    if (existsSync2(staleReaperPath)) {
-      const reaperPid = parseInt(readFileSync2(staleReaperPath, "utf-8").trim(), 10);
+    if (existsSync3(staleReaperPath)) {
+      const reaperPid = parseInt(readFileSync3(staleReaperPath, "utf-8").trim(), 10);
       if (reaperPid && !isNaN(reaperPid)) {
         try {
           process.kill(reaperPid, 0);
@@ -3627,7 +4045,7 @@ function cleanupOrphanedProcesses(boardId) {
         } catch {
         }
       }
-      unlinkSync2(staleReaperPath);
+      unlinkSync3(staleReaperPath);
     }
   } catch {
   }
@@ -3674,15 +4092,15 @@ async function runPipeline(client, args) {
       return;
     }
   }
-  const gateFilePath = join2(process.cwd(), "pipeline.gates.yaml");
+  const gateFilePath = join3(process.cwd(), "pipeline.gates.yaml");
   let gateConfig;
-  if (!existsSync2(gateFilePath)) {
+  if (!existsSync3(gateFilePath)) {
     console.error(`Error: pipeline.gates.yaml not found in ${process.cwd()}`);
     console.error('Run "kantban pipeline init" to generate a starter gate file.');
     process.exit(1);
   }
   try {
-    const gateYaml = readFileSync2(gateFilePath, "utf-8");
+    const gateYaml = readFileSync3(gateFilePath, "utf-8");
     gateConfig = parseGateConfig(gateYaml);
     console.log(`Gate config loaded: ${gateConfig.default.length} default gate(s)`);
   } catch (err) {
@@ -3710,7 +4128,7 @@ async function runPipeline(client, args) {
     intelligence_provider: opts.provider ?? void 0
   };
   const intelligenceProvider = registry.resolveForIntelligence(boardProviderConfig);
-  const logBaseDir = join2(homedir(), ".kantban", "pipelines");
+  const logBaseDir = join3(homedir2(), ".kantban", "pipelines");
   const logger = new PipelineLogger(logBaseDir, opts.boardId);
   logger.pruneOldLogs(opts.logRetention);
   let runMemory = null;
@@ -3747,7 +4165,7 @@ async function runPipeline(client, args) {
         effectiveConfig.model = registry.resolveModel(columnProvider, effectiveConfig.model);
       }
       const columnGates = resolveGatesForColumn(gateConfig, resolvedColumnName);
-      const gateCwd = effectiveConfig.worktreeName ? join2(process.cwd(), effectiveConfig.worktreeName) : void 0;
+      const gateCwd = effectiveConfig.worktreeName ? join3(process.cwd(), effectiveConfig.worktreeName) : void 0;
       const effectiveMcpConfigPath = columnGates.length > 0 ? generateGateProxyMcpConfig(
         client.baseUrl,
         client.token,
@@ -4196,7 +4614,7 @@ Received ${signal}. Shutting down gracefully...`);
   cleanupOrphanedProcesses(opts.boardId);
   writePidFile(opts.boardId);
   logger.orchestrator(`PID file written: ${String(process.pid)}`);
-  const reaperPidPath = join2(pidDir(opts.boardId), "reaper.pid");
+  const reaperPidPath = join3(pidDir(opts.boardId), "reaper.pid");
   const reaperProcess = spawnReaper({
     orchestratorPid: process.pid,
     manifestPath: childManifestPath(opts.boardId),
@@ -4359,7 +4777,7 @@ async function stopPipeline(args) {
   const pidFile = pidFilePath(boardId);
   let pid;
   try {
-    const content = readFileSync2(pidFile, "utf8").trim();
+    const content = readFileSync3(pidFile, "utf8").trim();
     pid = Number(content);
     if (isNaN(pid) || pid <= 0) {
       throw new Error("Invalid PID");
@@ -4390,4 +4808,4 @@ export {
   runPipeline,
   stopPipeline
 };
-//# sourceMappingURL=pipeline-TEE6GBNZ.js.map
+//# sourceMappingURL=pipeline-IYKEQZWN.js.map