dsh-desktop-kit 2.2.1 → 2.7.2

package/plugins/dsh-github-review/lib/gh.js

@@ -0,0 +1,494 @@
+/**
+ * dsh-github-review — `gh` CLI transport.
+ *
+ * Every call is an argv array with `shell: false` (Node's default), a hard
+ * timeout and captured output; nothing is concatenated into a command string,
+ * so a PR number, repository name or comment body can never become shell
+ * syntax. Output that becomes a tool result is scrubbed of tokens first.
+ *
+ * Reads use `gh`/`git`; the only mutation is `gh pr comment` and it is exposed
+ * only through the explicitly confirmed `comment` action.
+ */
+
+import { spawn, spawnSync } from "node:child_process";
+import fs from "node:fs";
+import path from "node:path";
+
+import {
+  LIMITS,
+  clampDiffBytes,
+  parseChecksText,
+  parseGhAuthStatus,
+  parseGitRemoteUrl,
+  parsePrNumber,
+  parseRepoFromPrUrl,
+  parseRepoSpec,
+  repoArgument,
+  scrubOutput,
+  snippet,
+  stripAnsi,
+} from "./normalize.js";
+
+const VERSION_TIMEOUT_MS = 10_000;
+const AUTH_TIMEOUT_MS = 15_000;
+const GIT_TIMEOUT_MS = 8_000;
+const VIEW_TIMEOUT_MS = 30_000;
+const CHECKS_TIMEOUT_MS = 30_000;
+const COMMENTS_TIMEOUT_MS = 35_000;
+const DIFF_TIMEOUT_MS = 45_000;
+const COMMENT_TIMEOUT_MS = 30_000;
+const MAX_BUFFER = 8 * 1024 * 1024;
+const MAX_STDERR = 16 * 1024;
+
+/** Fields requested from `gh pr view --json`. */
+export const PR_VIEW_FIELDS = [
+  "number",
+  "title",
+  "body",
+  "state",
+  "isDraft",
+  "url",
+  "author",
+  "baseRefName",
+  "headRefName",
+  "baseRefOid",
+  "headRefOid",
+  "additions",
+  "deletions",
+  "changedFiles",
+  "files",
+  "commits",
+  "reviewDecision",
+  "mergeable",
+  "labels",
+  "createdAt",
+  "updatedAt",
+];
+
+/** Non-interactive environment for gh: no prompts, no pager, no colour noise. */
+function buildEnv() {
+  return {
+    ...process.env,
+    GH_PROMPT_DISABLED: "1",
+    GH_NO_UPDATE_NOTIFIER: "1",
+    NO_COLOR: "1",
+    CLICOLOR: "0",
+  };
+}
+
+function scrub(value) {
+  return scrubOutput(value, process.env);
+}
+
+function shortDetail(value, max = 1_200) {
+  const text = scrub(value).trim();
+  if (text.length === 0) return "";
+  return snippet(text, max);
+}
+
+/* ------------------------------------------------------------------ */
+/* Process primitives                                                 */
+/* ------------------------------------------------------------------ */
+
+/**
+ * Synchronous argv runner. Never uses a shell; `timeout` kills the child.
+ * `error.code === "ENOENT"` on a valid cwd means the executable is missing.
+ */
+export function runProcessSync(command, args, { cwd, timeoutMs = GIT_TIMEOUT_MS, input, maxBuffer = MAX_BUFFER } = {}) {
+  let result;
+  try {
+    result = spawnSync(command, args, {
+      cwd,
+      encoding: "utf8",
+      timeout: timeoutMs,
+      windowsHide: true,
+      maxBuffer,
+      input,
+      env: buildEnv(),
+    });
+  } catch (error) {
+    return { ok: false, code: "throw", status: null, stdout: "", stderr: scrub(String(error)), missing: false };
+  }
+  if (result.error) {
+    const code = result.error.code;
+    const missing = code === "ENOENT";
+    return {
+      ok: false,
+      code: missing ? "missing" : code === "ETIMEDOUT" ? "timeout" : String(code ?? "error"),
+      status: result.status ?? null,
+      stdout: result.stdout ?? "",
+      stderr: scrub(result.error.message ?? String(result.error)),
+      missing,
+    };
+  }
+  const status = result.status;
+  return {
+    ok: status === 0,
+    code: status === 0 ? "ok" : String(status ?? "signal"),
+    status,
+    stdout: result.stdout ?? "",
+    stderr: result.stderr ?? "",
+    missing: false,
+  };
+}
+
+/**
+ * Streaming runner used for `gh pr diff`: keeps at most `maxBytes` of stdout in
+ * memory and stops the child once the budget is spent. This is the byte cap
+ * from the requirements, enforced before any string is built.
+ */
+export function runProcessStream(command, args, { cwd, timeoutMs = DIFF_TIMEOUT_MS, maxBytes = LIMITS.diffBytes } = {}) {
+  return new Promise((resolve) => {
+    let child;
+    try {
+      child = spawn(command, args, { cwd, windowsHide: true, env: buildEnv(), stdio: ["ignore", "pipe", "pipe"] });
+    } catch (error) {
+      resolve({ ok: false, code: "throw", missing: false, stdout: "", stderr: scrub(String(error)), truncated: false, timedOut: false, bytes: 0 });
+      return;
+    }
+    const chunks = [];
+    let bytes = 0;
+    let stderr = "";
+    let capped = false;
+    let timedOut = false;
+    let settled = false;
+
+    const kill = () => {
+      try {
+        child.kill();
+      } catch {
+        /* already gone */
+      }
+    };
+    const timer = setTimeout(() => {
+      if (settled) return;
+      timedOut = true;
+      kill();
+    }, timeoutMs);
+    timer.unref?.();
+
+    const finish = (code) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      const buffer = Buffer.concat(chunks);
+      resolve({
+        ok: !timedOut && !capped && code === 0,
+        code: timedOut ? "timeout" : capped ? "capped" : code === 0 ? "ok" : String(code ?? "signal"),
+        status: code,
+        missing: false,
+        stdout: buffer.toString("utf8"),
+        stderr: scrub(stderr),
+        truncated: capped,
+        timedOut,
+        bytes,
+      });
+    };
+
+    child.stdout?.on("data", (chunk) => {
+      const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(String(chunk));
+      const remaining = maxBytes - bytes;
+      if (remaining <= 0) {
+        capped = true;
+        kill();
+        return;
+      }
+      if (buffer.length > remaining) {
+        chunks.push(buffer.subarray(0, remaining));
+        bytes += remaining;
+        capped = true;
+        kill();
+        return;
+      }
+      chunks.push(buffer);
+      bytes += buffer.length;
+    });
+    child.stderr?.on("data", (chunk) => {
+      stderr = `${stderr}${chunk.toString()}`.slice(-MAX_STDERR);
+    });
+    child.on("error", (error) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      const missing = error?.code === "ENOENT";
+      resolve({ ok: false, code: missing ? "missing" : "error", status: null, missing, stdout: "", stderr: scrub(String(error)), truncated: capped, timedOut, bytes });
+    });
+    child.on("close", (code) => finish(code));
+  });
+}
+
+function gh(args, options = {}) {
+  return runProcessSync("gh", args, { cwd: options.cwd, timeoutMs: options.timeoutMs ?? VIEW_TIMEOUT_MS, input: options.input });
+}
+
+function git(args, cwd) {
+  return runProcessSync("git", args, { cwd, timeoutMs: GIT_TIMEOUT_MS });
+}
+
+/** Map a failed gh run to a stable, human-readable error code. */
+export function classifyGhError(result, fallback = "gh завершился с ошибкой") {
+  const text = shortDetail(`${result?.stderr ?? ""}\n${result?.stdout ?? ""}`) || fallback;
+  if (result?.missing) return { code: "gh-missing", detail: text };
+  if (result?.code === "timeout") return { code: "timeout", detail: text };
+  if (/not logged in|no oauth token|authentication required|gh auth login|HTTP 401|bad credentials/iu.test(text)) {
+    return { code: "not-authenticated", detail: text };
+  }
+  if (/no pull requests? found|could not find (?:an? )?(?:open )?pull ?request|could not resolve to a pull ?request/iu.test(text)) {
+    return { code: "no-pr", detail: text };
+  }
+  if (/could not resolve to a repository|repository not found|HTTP 404|not found/iu.test(text)) {
+    return { code: "repo-not-found", detail: text };
+  }
+  if (/rate limit|HTTP 403|secondary rate/iu.test(text)) return { code: "rate-limited", detail: text };
+  return { code: "gh-failed", detail: text };
+}
+
+function pushRepo(args, repo) {
+  const value = repoArgument(repo);
+  if (value) args.push("--repo", value);
+  return args;
+}
+
+/* ------------------------------------------------------------------ */
+/* Status: version, auth, repository                                  */
+/* ------------------------------------------------------------------ */
+
+export function ghVersion() {
+  const result = gh(["--version"], { timeoutMs: VERSION_TIMEOUT_MS });
+  if (!result.ok) {
+    return {
+      installed: false,
+      version: null,
+      detail: result.missing ? "gh CLI не найден в PATH" : shortDetail(result.stderr || result.stdout) || null,
+    };
+  }
+  const first = stripAnsi(result.stdout).trim().split(/\r?\n/u)[0] ?? "";
+  const version = /gh version\s+(\S+)/iu.exec(first)?.[1] ?? null;
+  return { installed: true, version, detail: null };
+}
+
+export function ghAuth() {
+  const result = gh(["auth", "status"], { timeoutMs: AUTH_TIMEOUT_MS });
+  const parsed = parseGhAuthStatus(`${result.stdout ?? ""}\n${result.stderr ?? ""}`);
+  return {
+    ...parsed,
+    exitOk: result.ok,
+    missing: result.missing === true,
+    detail: result.ok ? "" : shortDetail(result.stderr || result.stdout),
+  };
+}
+
+/**
+ * Repository for the current session: explicit `repo` argument first, then the
+ * local git origin remote. No network call is made for detection.
+ */
+export function detectRepo({ cwd, repo } = {}) {
+  const resolvedCwd = path.resolve(cwd ?? process.cwd());
+  const result = {
+    cwd: resolvedCwd,
+    root: undefined,
+    branch: undefined,
+    repo: null,
+    source: null,
+    gitInstalled: true,
+    error: undefined,
+  };
+  if (!fs.existsSync(resolvedCwd)) {
+    result.error = `рабочий каталог не найден: ${resolvedCwd}`;
+    return result;
+  }
+  const top = git(["rev-parse", "--show-toplevel"], resolvedCwd);
+  if (top.missing) {
+    result.gitInstalled = false;
+  } else if (top.ok) {
+    result.root = top.stdout.trim();
+    const branch = git(["rev-parse", "--abbrev-ref", "HEAD"], resolvedCwd);
+    if (branch.ok) result.branch = branch.stdout.trim() || undefined;
+    const remote = git(["remote", "get-url", "origin"], resolvedCwd);
+    if (remote.ok) {
+      const parsed = parseGitRemoteUrl(remote.stdout.trim());
+      if (parsed) {
+        result.repo = parsed;
+        result.source = "git-remote";
+      }
+    }
+  }
+  const requested = String(repo ?? "").trim();
+  if (requested.length > 0) {
+    const spec = parseRepoSpec(requested);
+    if (!spec) {
+      /* An invalid override must not silently fall back to the git remote. */
+      result.repo = null;
+      result.source = null;
+      result.error = `некорректный repo «${requested}»: нужен owner/name или host/owner/name`;
+      return result;
+    }
+    result.repo = spec;
+    result.source = "explicit";
+  }
+  return result;
+}
+
+/** Everything `status` needs: gh version, auth state and detected repository. */
+export function probeStatus({ cwd, repo } = {}) {
+  const version = ghVersion();
+  const auth = version.installed
+    ? ghAuth()
+    : { authenticated: false, notLoggedIn: false, host: "", accounts: [], active: null, scopes: [], exitOk: false, missing: true, detail: null };
+  return { gh: version, auth, repo: detectRepo({ cwd, repo }) };
+}
+
+/* ------------------------------------------------------------------ */
+/* Reads                                                               */
+/* ------------------------------------------------------------------ */
+
+/**
+ * Resolve the PR of the current branch when no explicit number is given.
+ *
+ * `gh pr view --repo owner/name` refuses to infer the branch (it prints
+ * "argument required when using the --repo flag"), so when a repository and a
+ * local branch are both known we pass the branch explicitly; without a
+ * repository we let gh infer everything from the cwd git context.
+ */
+export function resolvePrNumber({ cwd, repo, branch } = {}) {
+  const args = ["pr", "view"];
+  if (repo) {
+    if (typeof branch !== "string" || branch.length === 0) {
+      return { ok: false, failure: { code: "no-pr", detail: "репозиторий задан без локальной ветки — укажите явный pr=<номер>" } };
+    }
+    args.push(branch);
+  }
+  args.push("--json", "number");
+  if (repo) pushRepo(args, repo);
+  const result = gh(args, { cwd, timeoutMs: VIEW_TIMEOUT_MS });
+  if (!result.ok) return { ok: false, failure: classifyGhError(result, "не удалось определить PR текущей ветки") };
+  let json;
+  try {
+    json = JSON.parse(result.stdout);
+  } catch {
+    return { ok: false, failure: { code: "bad-json", detail: "gh pr view вернул невалидный JSON" } };
+  }
+  const number = parsePrNumber(json?.number);
+  if (number === undefined) return { ok: false, failure: { code: "no-pr", detail: "PR для текущей ветки не найден" } };
+  return { ok: true, number };
+}
+
+/** `gh pr view --json ...`; `number` optional (current branch PR). */
+export function fetchPrView({ cwd, repo, number } = {}) {
+  const args = ["pr", "view"];
+  if (number !== undefined && number !== null) args.push(String(number));
+  args.push("--json", PR_VIEW_FIELDS.join(","));
+  pushRepo(args, repo);
+  const result = gh(args, { cwd, timeoutMs: VIEW_TIMEOUT_MS });
+  if (!result.ok) return { ok: false, failure: classifyGhError(result, "не удалось получить PR") };
+  let json;
+  try {
+    json = JSON.parse(result.stdout);
+  } catch {
+    return { ok: false, failure: { code: "bad-json", detail: "gh pr view вернул невалидный JSON" } };
+  }
+  if (json === null || typeof json !== "object" || Array.isArray(json)) {
+    return { ok: false, failure: { code: "bad-json", detail: "gh pr view вернул неожиданный JSON" } };
+  }
+  return { ok: true, json };
+}
+
+/**
+ * `gh pr checks --json ...` with a plain-text fallback for older gh builds
+ * that do not support `--json` on this command.
+ */
+export function fetchChecks({ cwd, repo, number } = {}) {
+  const jsonArgs = ["pr", "checks"];
+  if (number !== undefined && number !== null) jsonArgs.push(String(number));
+  jsonArgs.push("--json", "name,state,bucket,description,link,startedAt,completedAt");
+  pushRepo(jsonArgs, repo);
+  const result = gh(jsonArgs, { cwd, timeoutMs: CHECKS_TIMEOUT_MS });
+  const noChecks = /no checks reported/iu.test(`${result.stderr ?? ""}\n${result.stdout ?? ""}`);
+  if (!result.ok && noChecks) return { ok: true, format: "json", rows: [] };
+  if (result.ok) {
+    try {
+      const parsed = JSON.parse(result.stdout);
+      const rows = Array.isArray(parsed) ? parsed : parsed && typeof parsed === "object" ? [parsed] : [];
+      return { ok: true, format: "json", rows };
+    } catch {
+      return { ok: false, failure: { code: "bad-json", detail: "gh pr checks вернул невалидный JSON" } };
+    }
+  }
+  const jsonUnsupported = !result.missing && result.code !== "timeout"
+    && /unknown flag:?\s*--json|flag provided but not defined[^\n]*json|unknown shorthand flag/iu.test(`${result.stderr ?? ""}\n${result.stdout ?? ""}`);
+  if (!jsonUnsupported) return { ok: false, failure: classifyGhError(result, "не удалось получить CI checks") };
+  const textArgs = ["pr", "checks"];
+  if (number !== undefined && number !== null) textArgs.push(String(number));
+  pushRepo(textArgs, repo);
+  const textResult = gh(textArgs, { cwd, timeoutMs: CHECKS_TIMEOUT_MS });
+  if (!textResult.ok && /no checks reported/iu.test(`${textResult.stderr ?? ""}\n${textResult.stdout ?? ""}`)) {
+    return { ok: true, format: "text", rows: [] };
+  }
+  if (!textResult.ok) return { ok: false, failure: classifyGhError(textResult, "не удалось получить CI checks") };
+  return { ok: true, format: "text", rows: parseChecksText(textResult.stdout) };
+}
+
+/** PR view plus inline review comments (threads) from the REST API. */
+export function fetchComments({ cwd, repo, number } = {}) {
+  const view = fetchPrView({ cwd, repo, number });
+  if (!view.ok) return view;
+  const json = view.json;
+  const prNumber = parsePrNumber(json.number) ?? number;
+  let spec = repo;
+  if (!spec) spec = parseRepoFromPrUrl(json.url);
+  const inline = { ok: false, rows: [], failure: null };
+  if (spec && prNumber !== undefined) {
+    const apiPath = `repos/${spec.owner}/${spec.name}/pulls/${prNumber}/comments?per_page=${LIMITS.inlineComments}`;
+    const result = gh(["api", "--method", "GET", "-H", "Accept: application/vnd.github+json", apiPath], { cwd, timeoutMs: COMMENTS_TIMEOUT_MS });
+    if (result.ok) {
+      try {
+        const parsed = JSON.parse(result.stdout);
+        inline.ok = true;
+        inline.rows = Array.isArray(parsed) ? parsed : [];
+      } catch {
+        inline.failure = { code: "bad-json", detail: "gh api вернул невалидный JSON" };
+      }
+    } else {
+      inline.failure = classifyGhError(result, "не удалось получить inline-комментарии");
+    }
+  } else {
+    inline.failure = { code: "unknown-repo", detail: "репозиторий не определён — inline-комментарии пропущены" };
+  }
+  return { ok: true, json, inline };
+}
+
+/**
+ * `gh pr diff` with a streaming byte cap. The stream keeps at most
+ * `limit + 4 KiB` so the caller can still cut the tail on a line boundary and
+ * return a clean diff of at most `limit` bytes; truncation is always reported.
+ */
+export async function fetchDiff({ cwd, repo, number, maxBytes } = {}) {
+  const limit = clampDiffBytes(maxBytes);
+  const args = pushRepo(["pr", "diff", String(number)], repo);
+  const result = await runProcessStream("gh", args, { cwd, timeoutMs: DIFF_TIMEOUT_MS, maxBytes: limit + 4096 });
+  if (result.missing) return { ok: false, failure: { code: "gh-missing", detail: "gh CLI не найден в PATH" } };
+  if (result.timedOut) {
+    return { ok: false, failure: { code: "timeout", detail: `gh pr diff не ответил за ${Math.round(DIFF_TIMEOUT_MS / 1000)} с` } };
+  }
+  if (!result.ok && !result.truncated) {
+    return { ok: false, failure: classifyGhError({ ...result, code: result.status === 0 ? "gh-failed" : result.code }, "не удалось получить diff PR") };
+  }
+  return { ok: true, text: result.stdout, truncated: result.truncated === true, bytes: result.bytes, limit };
+}
+
+/* ------------------------------------------------------------------ */
+/* The single mutation                                                */
+/* ------------------------------------------------------------------ */
+
+/**
+ * Post one top-level PR comment. The body is piped through stdin
+ * (`--body-file -`), never placed on the command line. Callers must have
+ * passed the explicit confirmation gate before reaching this function.
+ */
+export function postComment({ cwd, repo, number, body } = {}) {
+  const args = pushRepo(["pr", "comment", String(number), "--body-file", "-"], repo);
+  const result = gh(args, { cwd, timeoutMs: COMMENT_TIMEOUT_MS, input: body });
+  if (!result.ok) return { ok: false, failure: classifyGhError(result, "не удалось отправить комментарий") };
+  const url = /https?:\/\/\S+\/pull\/\d+#issuecomment-\d+/u.exec(scrub(result.stdout))?.[0] ?? "";
+  return { ok: true, url, output: snippet(scrub(result.stdout), 300) };
+}