@xdevops/issue-auto-finish 1.0.87 → 1.0.89

package/dist/chunk-R32Q3RGK.js

@@ -0,0 +1,666 @@
+import {
+  isShuttingDown
+} from "./chunk-G7QI5WDI.js";
+import {
+  logger
+} from "./chunk-GF2RRYHB.js";
+
+// src/ai-runner/SdkRunner.ts
+import fs from "fs";
+import path from "path";
+
+// src/ai-runner/sdk/ClaudeCodeSDK.ts
+import { spawn } from "child_process";
+import { createInterface } from "readline";
+
+// src/ai-runner/sdk/Stream.ts
+var Stream = class {
+  queue = [];
+  readResolve;
+  readReject;
+  isDone = false;
+  hasError;
+  started = false;
+  [Symbol.asyncIterator]() {
+    if (this.started) {
+      throw new Error("Stream can only be iterated once");
+    }
+    this.started = true;
+    return this;
+  }
+  async next() {
+    if (this.queue.length > 0) {
+      return { done: false, value: this.queue.shift() };
+    }
+    if (this.isDone) {
+      return { done: true, value: void 0 };
+    }
+    if (this.hasError) {
+      throw this.hasError;
+    }
+    return new Promise((resolve, reject) => {
+      this.readResolve = resolve;
+      this.readReject = reject;
+    });
+  }
+  enqueue(value) {
+    if (this.readResolve) {
+      const resolve = this.readResolve;
+      this.readResolve = void 0;
+      this.readReject = void 0;
+      resolve({ done: false, value });
+    } else {
+      this.queue.push(value);
+    }
+  }
+  done() {
+    this.isDone = true;
+    if (this.readResolve) {
+      const resolve = this.readResolve;
+      this.readResolve = void 0;
+      this.readReject = void 0;
+      resolve({ done: true, value: void 0 });
+    }
+  }
+  error(error) {
+    this.hasError = error;
+    if (this.readReject) {
+      const reject = this.readReject;
+      this.readResolve = void 0;
+      this.readReject = void 0;
+      reject(error);
+    }
+  }
+  async return() {
+    this.isDone = true;
+    return { done: true, value: void 0 };
+  }
+};
+
+// src/ai-runner/sdk/types.ts
+var AbortError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "AbortError";
+  }
+};
+
+// src/ai-runner/sdk/ClaudeCodeSDK.ts
+var logger2 = logger.child("ClaudeCodeSDK");
+var Query = class {
+  constructor(child, childStdin, processExitPromise, canCallTool) {
+    this.childStdin = childStdin;
+    this.child = child;
+    this.canCallTool = canCallTool;
+    this.readMessages(processExitPromise);
+    this.sdkMessages = this.readSdkMessages();
+  }
+  pendingControlResponses = /* @__PURE__ */ new Map();
+  cancelControllers = /* @__PURE__ */ new Map();
+  sdkMessages;
+  inputStream = new Stream();
+  canCallTool;
+  /** The underlying child process — exposed for kill/abort by SdkRunner. */
+  child;
+  setError(error) {
+    this.inputStream.error(error);
+  }
+  // -- AsyncIterableIterator -------------------------------------------------
+  next() {
+    return this.sdkMessages.next();
+  }
+  return(value) {
+    if (this.sdkMessages.return) {
+      return this.sdkMessages.return(value);
+    }
+    return Promise.resolve({ done: true, value: void 0 });
+  }
+  throw(e) {
+    if (this.sdkMessages.throw) {
+      return this.sdkMessages.throw(e);
+    }
+    return Promise.reject(e);
+  }
+  [Symbol.asyncIterator]() {
+    return this.sdkMessages;
+  }
+  // -- Internal: read stdout JSON lines --------------------------------------
+  async readMessages(processExitPromise) {
+    const rl = createInterface({ input: this.child.stdout });
+    try {
+      for await (const line of rl) {
+        if (!line.trim()) continue;
+        try {
+          const message = JSON.parse(line);
+          if (message.type === "control_response") {
+            const controlResponse = message;
+            const handler = this.pendingControlResponses.get(
+              controlResponse.response.request_id
+            );
+            if (handler) {
+              handler(controlResponse.response);
+            }
+            continue;
+          }
+          if (message.type === "control_request") {
+            await this.handleControlRequest(
+              message
+            );
+            continue;
+          }
+          if (message.type === "control_cancel_request") {
+            this.handleControlCancelRequest(
+              message
+            );
+            continue;
+          }
+          this.inputStream.enqueue(message);
+        } catch {
+          logger2.debug("Non-JSON line from Claude stdout: " + line.slice(0, 200));
+        }
+      }
+      await processExitPromise;
+    } catch (error) {
+      this.inputStream.error(error);
+    } finally {
+      this.inputStream.done();
+      this.cleanupControllers();
+      rl.close();
+    }
+  }
+  async *readSdkMessages() {
+    for await (const message of this.inputStream) {
+      yield message;
+    }
+  }
+  // -- Control request handling (tool permissions) ---------------------------
+  async handleControlRequest(request) {
+    if (!this.childStdin) {
+      logger2.debug("Cannot handle control request \u2014 no stdin available");
+      return;
+    }
+    const controller = new AbortController();
+    this.cancelControllers.set(request.request_id, controller);
+    try {
+      const response = await this.processControlRequest(
+        request,
+        controller.signal
+      );
+      const controlResponse = {
+        type: "control_response",
+        response: {
+          subtype: "success",
+          request_id: request.request_id,
+          response
+        }
+      };
+      this.childStdin.write(JSON.stringify(controlResponse) + "\n");
+    } catch (error) {
+      const controlErrorResponse = {
+        type: "control_response",
+        response: {
+          subtype: "error",
+          request_id: request.request_id,
+          error: error instanceof Error ? error.message : String(error)
+        }
+      };
+      this.childStdin.write(JSON.stringify(controlErrorResponse) + "\n");
+    } finally {
+      this.cancelControllers.delete(request.request_id);
+    }
+  }
+  handleControlCancelRequest(request) {
+    const controller = this.cancelControllers.get(request.request_id);
+    if (controller) {
+      controller.abort();
+      this.cancelControllers.delete(request.request_id);
+    }
+  }
+  async processControlRequest(request, signal) {
+    if (request.request.subtype === "can_use_tool") {
+      if (!this.canCallTool) {
+        throw new Error("canCallTool callback is not provided.");
+      }
+      return this.canCallTool(
+        request.request.tool_name,
+        request.request.input,
+        { signal }
+      );
+    }
+    throw new Error(
+      "Unsupported control request subtype: " + request.request.subtype
+    );
+  }
+  cleanupControllers() {
+    for (const [, controller] of this.cancelControllers) {
+      controller.abort();
+    }
+    this.cancelControllers.clear();
+  }
+};
+function query(config) {
+  const {
+    prompt,
+    binary,
+    options: {
+      allowedTools = [],
+      disallowedTools = [],
+      cwd,
+      model,
+      permissionMode = "default",
+      canCallTool,
+      resume,
+      continueConversation,
+      appendSystemPrompt,
+      maxTurns,
+      abort
+    } = {}
+  } = config;
+  const args = ["--output-format", "stream-json", "--verbose"];
+  if (appendSystemPrompt) args.push("--append-system-prompt", appendSystemPrompt);
+  if (maxTurns) args.push("--max-turns", maxTurns.toString());
+  if (model) args.push("--model", model);
+  if (continueConversation) args.push("--continue");
+  if (resume) args.push("--resume", resume);
+  if (allowedTools.length > 0) args.push("--allowedTools", allowedTools.join(","));
+  if (disallowedTools.length > 0) args.push("--disallowedTools", disallowedTools.join(","));
+  if (permissionMode) args.push("--permission-mode", permissionMode);
+  if (canCallTool) {
+    args.push("--permission-prompt-tool", "stdio");
+    args.push("--input-format", "stream-json");
+  }
+  if (!canCallTool) {
+    args.push("--print", prompt.trim());
+  }
+  const { CLAUDECODE: _, ...cleanEnv } = process.env;
+  logger2.info("Spawning Claude Code process", {
+    binary,
+    argCount: args.length,
+    cwd,
+    hasCanCallTool: !!canCallTool
+  });
+  logger2.debug("Claude Code args", { args });
+  const child = spawn(binary, args, {
+    cwd,
+    stdio: ["pipe", "pipe", "pipe"],
+    signal: abort,
+    env: cleanEnv,
+    windowsHide: true
+  });
+  let childStdin = null;
+  if (!canCallTool) {
+    child.stdin.end();
+  } else {
+    childStdin = child.stdin;
+    const userMessage = {
+      type: "user",
+      message: {
+        role: "user",
+        content: prompt.trim()
+      }
+    };
+    childStdin.write(JSON.stringify(userMessage) + "\n");
+  }
+  child.stderr.on("data", (data) => {
+    logger2.debug("Claude Code stderr: " + data.toString().trimEnd());
+  });
+  const cleanup = () => {
+    if (!child.killed) {
+      child.kill("SIGTERM");
+    }
+  };
+  abort?.addEventListener("abort", cleanup);
+  process.on("exit", cleanup);
+  const processExitPromise = new Promise((resolve, reject) => {
+    child.on("close", (code) => {
+      if (abort?.aborted) {
+        reject(new AbortError("Claude Code process aborted"));
+      } else if (code !== 0) {
+        reject(new Error(`Claude Code process exited with code ${code}`));
+      } else {
+        resolve();
+      }
+    });
+  });
+  const q = new Query(child, childStdin, processExitPromise, canCallTool);
+  child.on("error", (error) => {
+    if (abort?.aborted) {
+      q.setError(new AbortError("Claude Code process aborted"));
+    } else {
+      q.setError(
+        new Error(`Failed to spawn Claude Code process: ${error.message}`)
+      );
+    }
+  });
+  processExitPromise.catch(() => {
+  }).finally(() => {
+    cleanup();
+    abort?.removeEventListener("abort", cleanup);
+  });
+  return q;
+}
+
+// src/ai-runner/SdkRunner.ts
+var logger3 = logger.child("SdkRunner");
+var SIGKILL_GRACE_MS = 1e4;
+var IDLE_CHECK_INTERVAL_MS = 5e3;
+var SdkRunner = class {
+  constructor(binary, nvmNodeVersion, model) {
+    this.binary = binary;
+    this.nvmNodeVersion = nvmNodeVersion;
+    this.model = model;
+  }
+  activeProcesses = /* @__PURE__ */ new Map();
+  // -- AIRunner interface ----------------------------------------------------
+  async run(options) {
+    if (isShuttingDown()) {
+      logger3.warn("SdkRunner skipped \u2014 service is shutting down");
+      return { success: false, output: "Service shutting down", exitCode: null };
+    }
+    const {
+      prompt,
+      workDir,
+      timeoutMs,
+      idleTimeoutMs,
+      onStreamEvent,
+      mode,
+      artifactPaths
+    } = options;
+    logger3.info("SdkRunner.run()", {
+      workDir,
+      timeoutMs,
+      mode,
+      phaseName: options.phaseName
+    });
+    const abortController = new AbortController();
+    const isPlanMode = mode === "plan";
+    let planContent;
+    const queryOptions = {
+      cwd: workDir,
+      model: this.model,
+      abort: abortController.signal
+    };
+    if (isPlanMode) {
+      queryOptions.permissionMode = "plan";
+      queryOptions.allowedTools = ["Read", "Grep", "Glob", "WebSearch"];
+      queryOptions.canCallTool = async (toolName, input, _opts) => {
+        if (toolName === "ExitPlanMode" || toolName === "exit_plan_mode") {
+          const planInput = input;
+          planContent = typeof planInput?.plan === "string" ? planInput.plan : void 0;
+          logger3.info("ExitPlanMode intercepted", {
+            hasPlan: !!planContent,
+            planLength: planContent?.length
+          });
+          if (planContent && artifactPaths && artifactPaths.length > 0) {
+            for (const targetPath of artifactPaths) {
+              const targetDir = path.dirname(targetPath);
+              if (!fs.existsSync(targetDir)) {
+                fs.mkdirSync(targetDir, { recursive: true });
+              }
+              fs.writeFileSync(targetPath, planContent, "utf-8");
+              logger3.info("Plan written to artifact path", { target: targetPath });
+            }
+          }
+          return { behavior: "deny", message: "Plan captured by SdkRunner" };
+        }
+        return {
+          behavior: "allow",
+          updatedInput: input && typeof input === "object" ? input : {}
+        };
+      };
+    } else {
+      queryOptions.permissionMode = "bypassPermissions";
+    }
+    if (options.continueSession && options.sessionId) {
+      queryOptions.resume = options.sessionId;
+    }
+    const q = query({
+      prompt,
+      binary: this.binary,
+      options: queryOptions
+    });
+    const entry = {
+      child: q.child,
+      workDir,
+      abort: abortController
+    };
+    this.activeProcesses.set(q.child, entry);
+    const outputParts = [];
+    const stderrParts = [];
+    let sessionId;
+    let resultMessage;
+    let caughtError;
+    let lastActivityTime = Date.now();
+    let timedOut = false;
+    let timeoutType;
+    let wasActiveAtTimeout = false;
+    q.child.stderr.on("data", (data) => {
+      stderrParts.push(data.toString());
+    });
+    const graceWindowMs = options.timeoutGraceMs ?? 6e4;
+    const extensionMs = options.timeoutExtensionMs ?? 6e5;
+    const maxExtensions = options.timeoutMaxExtensions ?? 3;
+    let extensions = 0;
+    const scheduleWallTimer = (delayMs) => {
+      return setTimeout(() => {
+        const recentMs = Date.now() - lastActivityTime;
+        const isActive = recentMs < graceWindowMs;
+        if (isActive && extensions < maxExtensions) {
+          extensions++;
+          logger3.info("Wall-clock timeout extended (agent still active)", {
+            extensions,
+            maxExtensions,
+            lastOutputAgoMs: recentMs
+          });
+          wallTimer = scheduleWallTimer(extensionMs);
+          return;
+        }
+        timedOut = true;
+        timeoutType = "wall-clock";
+        wasActiveAtTimeout = isActive;
+        abortController.abort();
+      }, delayMs);
+    };
+    let wallTimer = scheduleWallTimer(timeoutMs);
+    const effectiveIdleMs = idleTimeoutMs ?? 6e5;
+    const idleCheck = setInterval(() => {
+      const idleMs = Date.now() - lastActivityTime;
+      if (idleMs >= effectiveIdleMs) {
+        timedOut = true;
+        timeoutType = "idle";
+        wasActiveAtTimeout = false;
+        abortController.abort();
+      }
+    }, IDLE_CHECK_INTERVAL_MS);
+    try {
+      for await (const message of q) {
+        lastActivityTime = Date.now();
+        this.processMessage(
+          message,
+          outputParts,
+          onStreamEvent,
+          (sid) => {
+            sessionId = sid;
+          },
+          (result) => {
+            resultMessage = result;
+          }
+        );
+      }
+    } catch (error) {
+      caughtError = error;
+      if (error instanceof AbortError) {
+        logger3.info("Claude Code process aborted", { timedOut, timeoutType });
+      } else {
+        logger3.error("Unexpected error during SDK message iteration", {
+          error: error.message
+        });
+      }
+    } finally {
+      clearTimeout(wallTimer);
+      clearInterval(idleCheck);
+      this.activeProcesses.delete(q.child);
+    }
+    const output = outputParts.join("");
+    const success = !timedOut && resultMessage != null && !resultMessage.is_error;
+    let errorMessage;
+    if (!success) {
+      const parts = [];
+      if (timedOut) {
+        parts.push(
+          timeoutType === "idle" ? "AI \u957F\u65F6\u95F4\u65E0\u54CD\u5E94\uFF0C\u5DF2\u8D85\u65F6\u7EC8\u6B62" : "\u6267\u884C\u8D85\u65F6"
+        );
+      }
+      if (resultMessage?.is_error && resultMessage.result) {
+        parts.push(resultMessage.result);
+      }
+      if (!resultMessage && caughtError && !(caughtError instanceof AbortError)) {
+        parts.push(caughtError.message);
+      }
+      const stderr = stderrParts.join("").trim();
+      if (stderr && parts.length === 0) {
+        parts.push(stderr.slice(0, 500));
+      }
+      errorMessage = parts.join(" | ") || "Claude Code \u8FDB\u7A0B\u5F02\u5E38\u9000\u51FA\uFF08\u65E0\u8F93\u51FA\uFF09";
+    }
+    logger3.info("SdkRunner completed", {
+      workDir,
+      success,
+      timedOut,
+      timeoutType,
+      outputLength: output.length,
+      sessionId,
+      resultSubtype: resultMessage?.subtype
+    });
+    return {
+      success,
+      output: resultMessage?.result ?? output,
+      errorMessage,
+      sessionId: sessionId ?? resultMessage?.session_id,
+      exitCode: success ? 0 : timedOut ? null : 1,
+      timeoutType,
+      wasActiveAtTimeout
+    };
+  }
+  killAll() {
+    for (const [child, entry] of this.activeProcesses) {
+      entry.abort.abort();
+      this.forceKill(child);
+    }
+    logger3.info("SdkRunner: all active processes killed", {
+      count: this.activeProcesses.size
+    });
+    this.activeProcesses.clear();
+  }
+  killByWorkDir(targetWorkDir) {
+    let killed = 0;
+    for (const [child, entry] of this.activeProcesses) {
+      if (entry.workDir === targetWorkDir) {
+        entry.abort.abort();
+        this.forceKill(child);
+        this.activeProcesses.delete(child);
+        killed++;
+      }
+    }
+    if (killed > 0) {
+      logger3.info("SdkRunner: killed processes by workDir", {
+        workDir: targetWorkDir,
+        killed
+      });
+    }
+    return killed;
+  }
+  // -- Internal helpers ------------------------------------------------------
+  processMessage(message, outputParts, onStreamEvent, onSessionId, onResult) {
+    switch (message.type) {
+      case "system": {
+        const sys = message;
+        if (sys.session_id) onSessionId(sys.session_id);
+        if (onStreamEvent) {
+          onStreamEvent({
+            type: "system",
+            content: message,
+            timestamp: (/* @__PURE__ */ new Date()).toISOString()
+          });
+        }
+        break;
+      }
+      case "assistant": {
+        const assistant = message;
+        if (assistant.message?.content) {
+          for (const block of assistant.message.content) {
+            if (block.type === "text" && block.text) {
+              outputParts.push(block.text);
+            }
+          }
+        }
+        if (onStreamEvent) {
+          onStreamEvent({
+            type: "assistant",
+            content: message,
+            timestamp: (/* @__PURE__ */ new Date()).toISOString()
+          });
+        }
+        break;
+      }
+      case "result": {
+        const result = message;
+        onResult(result);
+        if (result.session_id) onSessionId(result.session_id);
+        if (onStreamEvent) {
+          onStreamEvent({
+            type: "result",
+            content: message,
+            timestamp: (/* @__PURE__ */ new Date()).toISOString()
+          });
+        }
+        break;
+      }
+      case "user": {
+        if (onStreamEvent) {
+          onStreamEvent({
+            type: "user",
+            content: message,
+            timestamp: (/* @__PURE__ */ new Date()).toISOString()
+          });
+        }
+        break;
+      }
+      case "log": {
+        const log = message;
+        if (log.log) {
+          logger3.debug(`Claude log [${log.log.level}]: ${log.log.message}`);
+        }
+        break;
+      }
+      default: {
+        if (onStreamEvent) {
+          onStreamEvent({
+            type: message.type || "raw",
+            content: message,
+            timestamp: (/* @__PURE__ */ new Date()).toISOString()
+          });
+        }
+        break;
+      }
+    }
+  }
+  forceKill(child) {
+    try {
+      if (child.exitCode === null) {
+        child.kill("SIGTERM");
+        setTimeout(() => {
+          if (child.exitCode === null) {
+            child.kill("SIGKILL");
+          }
+        }, SIGKILL_GRACE_MS);
+      }
+    } catch {
+    }
+  }
+};
+
+export {
+  SdkRunner
+};
+//# sourceMappingURL=chunk-R32Q3RGK.js.map