agentwrangler 0.1.0

package/dist/hook/danger-guard-hook.mjs

@@ -0,0 +1,167 @@
+/**
+ * Claude Code PreToolUse guard for catastrophic Bash commands.
+ *
+ * Warn-first by design: it hard-DENIES only an unambiguous catastrophe list and
+ * ASKS for the ambiguous shapes. It has no package dependencies.
+ *
+ * Failure asymmetry is deliberate:
+ *  - malformed stdin fails OPEN (allow) — a guard must never brick a session;
+ *  - a missing / empty / unparseable deny-list data file fails CLOSED to the
+ *    embedded baseline below, so deleting one file cannot silently downgrade
+ *    every hard-deny to ask.
+ *
+ * Deny responses use the JSON `permissionDecision:"deny"` form, which holds even
+ * under bypass permissions mode — not an exit-code-only block. The hook always
+ * exits 0 and never echoes the raw command back (SEC-101).
+ */
+
+import * as fs from "node:fs";
+import * as path from "node:path";
+import process from "node:process";
+import { fileURLToPath } from "node:url";
+
+/**
+ * The release-time catastrophe baseline, embedded so the guard still denies the
+ * worst commands when the on-disk deny-list is absent or corrupt. The shipped
+ * data file (`danger-guard-denylist.json`) is the extensible copy; users edit
+ * THAT, not this. Patterns are JS RegExp sources (no flags); each rule carries a
+ * static reason — never the command text.
+ */
+export const EMBEDDED_BASELINE = {
+  deny: [
+    {
+      pattern:
+        "(?:^|[\\s;&|(])rm\\s+(?:-\\S*\\s+)*-\\S*r\\S*\\s+(?:[^;&|]*\\s)?(?:/|~|\\$HOME)(?:\\s|/|\\*|$)",
+      reason: "recursive delete targeting your home directory or the filesystem root",
+    },
+    {
+      pattern: "git\\s+push\\b(?=[^;&|]*(?:--force|-f)\\b)(?=[^;&|]*\\b(?:main|master)\\b)",
+      reason: "force-push to a protected branch (main/master)",
+    },
+    {
+      pattern: "\\b(?:curl|wget)\\b[^;&|]*\\|\\s*(?:sudo\\s+)?(?:sh|bash|zsh|dash|ksh)\\b",
+      reason: "piping a downloaded script straight into a shell",
+    },
+  ],
+  ask: [
+    {
+      pattern: "(?:^|[\\s;&|(])rm\\s+(?:-\\S*\\s+)*-\\S*r\\S*\\b",
+      reason: "recursive delete — confirm the target before running",
+    },
+    {
+      pattern: "git\\s+push\\b(?=[^;&|]*(?:--force|-f)\\b)",
+      reason: "force-push — confirm the branch before running",
+    },
+  ],
+};
+
+/** Compile a raw ruleset ({deny,ask} of {pattern,reason}) to RegExp rules. Throws on bad shape. */
+export function compileRuleset(raw) {
+  if (raw === null || typeof raw !== "object") throw new Error("deny-list must be an object");
+  const compileList = (list) => {
+    if (!Array.isArray(list)) throw new Error("deny-list section must be an array");
+    return list.map((item) => {
+      if (item === null || typeof item !== "object") throw new Error("rule must be an object");
+      const { pattern, reason } = item;
+      if (typeof pattern !== "string" || typeof reason !== "string") {
+        throw new Error("rule needs string pattern and reason");
+      }
+      return { re: new RegExp(pattern), reason };
+    });
+  };
+  return { deny: compileList(raw.deny ?? []), ask: compileList(raw.ask ?? []) };
+}
+
+/**
+ * Load and compile the on-disk deny-list. Any failure (missing file, unreadable,
+ * unparseable JSON, bad shape, invalid regex) falls back to the embedded baseline
+ * — fail-closed on the deny tier.
+ */
+export function loadDenyList(filePath) {
+  try {
+    const raw = JSON.parse(fs.readFileSync(filePath, "utf8"));
+    return compileRuleset(raw);
+  } catch {
+    return compileRuleset(EMBEDDED_BASELINE);
+  }
+}
+
+/** Evaluate a command against a compiled ruleset. Deny wins over ask; otherwise allow. */
+export function evaluateCommand(command, ruleset) {
+  if (typeof command !== "string" || command.length === 0) return { action: "allow" };
+  for (const rule of ruleset.deny)
+    if (rule.re.test(command)) return { action: "deny", reason: rule.reason };
+  for (const rule of ruleset.ask)
+    if (rule.re.test(command)) return { action: "ask", reason: rule.reason };
+  return { action: "allow" };
+}
+
+/** Render a decision as the only PreToolUse output it may emit (allow → silence). */
+export function decisionToStdout(decision) {
+  if (decision.action === "deny") {
+    return JSON.stringify({
+      hookSpecificOutput: {
+        hookEventName: "PreToolUse",
+        permissionDecision: "deny",
+        permissionDecisionReason: `AgentWrangler blocked a dangerous command: ${decision.reason}.`,
+      },
+      systemMessage: `AgentWrangler blocked a dangerous command: ${decision.reason}.`,
+    });
+  }
+  if (decision.action === "ask") {
+    return JSON.stringify({
+      hookSpecificOutput: {
+        hookEventName: "PreToolUse",
+        permissionDecision: "ask",
+        permissionDecisionReason: `AgentWrangler flagged a risky command: ${decision.reason}.`,
+      },
+    });
+  }
+  return "";
+}
+
+/** True when running under CI / headless automation, where the guard must no-op. */
+function inCI() {
+  const ci = process.env.CI;
+  return typeof ci === "string" && ci !== "" && ci !== "false" && ci !== "0";
+}
+
+function denyListPath() {
+  return (
+    process.env.AW_DANGER_DENYLIST ??
+    path.join(path.dirname(fileURLToPath(import.meta.url)), "danger-guard-denylist.json")
+  );
+}
+
+function readStdin() {
+  return new Promise((resolve, reject) => {
+    let raw = "";
+    process.stdin.setEncoding("utf8");
+    process.stdin.on("data", (chunk) => {
+      raw += chunk;
+    });
+    process.stdin.on("end", () => resolve(raw));
+    process.stdin.on("error", reject);
+  });
+}
+
+async function main() {
+  // No-op in CI: block nothing in headless runs (a top researched backfire).
+  if (inCI()) return;
+  try {
+    const input = JSON.parse(await readStdin());
+    // Defensive: the matcher scopes us to Bash, but ignore anything else.
+    if (typeof input?.tool_name === "string" && input.tool_name !== "Bash") return;
+    const command = input?.tool_input?.command;
+    if (typeof command !== "string") return;
+    const decision = evaluateCommand(command, loadDenyList(denyListPath()));
+    const output = decisionToStdout(decision);
+    if (output) process.stdout.write(output);
+  } catch {
+    // Fail open: a malformed payload must never block Claude Code.
+  }
+}
+
+const invoked =
+  process.argv[1] !== undefined && path.resolve(process.argv[1]) === fileURLToPath(import.meta.url);
+if (invoked) void main();

package/dist/hook/limit-burn-hook.mjs

@@ -0,0 +1,127 @@
+/**
+ * Fail-open Claude Code PreToolUse hook for AgentWrangler rate-limit burn.
+ * It intentionally has no package dependencies and never exits non-zero.
+ */
+
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+
+const WARN_PCT = 0.15;
+const CHECKPOINT_PCT = 0.5;
+const DEBOUNCE_SECONDS = 300;
+
+/** Return the warning stage for a burn-status payload without side effects. */
+export function stageFromStatus(status) {
+  if (!status || status.available === false) return null;
+
+  const fiveHour = status.five_hour?.utilization;
+  const sevenDay = status.seven_day?.utilization;
+  const atCheckpoint = fiveHour >= CHECKPOINT_PCT || sevenDay >= CHECKPOINT_PCT;
+  if (atCheckpoint) return "checkpoint";
+  if (fiveHour >= WARN_PCT || sevenDay >= WARN_PCT) return "soft";
+  return null;
+}
+
+/** Convert an endpoint stage to the only hook output it may emit. */
+export function stageToStdout(stage) {
+  if (stage === "checkpoint") {
+    return JSON.stringify({
+      hookSpecificOutput: {
+        hookEventName: "PreToolUse",
+        permissionDecision: "allow",
+      },
+      additionalContext:
+        "AgentWrangler: 5h or 7d rate-limit cap >=50% consumed. Checkpoint your work now.",
+    });
+  }
+  if (stage === "soft") {
+    return JSON.stringify({
+      hookSpecificOutput: {
+        hookEventName: "PreToolUse",
+        permissionDecision: "allow",
+      },
+      additionalContext:
+        "AgentWrangler: 5h or 7d rate-limit cap >=15% consumed. Consider checkpointing.",
+    });
+  }
+  return "";
+}
+
+function markerPath(sessionId) {
+  const markerRoot = path.join(os.homedir(), ".agentwrangler", "hook-markers");
+  return path.join(markerRoot, `limit-burn-${encodeURIComponent(sessionId)}.marker`);
+}
+
+function shouldEmit(sessionId) {
+  const file = markerPath(sessionId);
+  const now = Math.floor(Date.now() / 1_000);
+  try {
+    const previous = Number(fs.readFileSync(file, "utf8"));
+    if (Number.isFinite(previous) && now - previous < DEBOUNCE_SECONDS) return false;
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    fs.writeFileSync(file, String(now), { encoding: "utf8", mode: 0o600 });
+    return true;
+  } catch (error) {
+    if (error && typeof error === "object" && error.code === "ENOENT") {
+      try {
+        fs.mkdirSync(path.dirname(file), { recursive: true });
+        fs.writeFileSync(file, String(now), { encoding: "utf8", mode: 0o600 });
+        return true;
+      } catch {
+        // Marker write failed — degrade to no-debounce so warnings are never silently dropped.
+        return true;
+      }
+    }
+    // Unexpected error — degrade to no-debounce so warnings are never silently dropped.
+    return true;
+  }
+}
+
+function readStdin() {
+  return new Promise((resolve, reject) => {
+    let raw = "";
+    process.stdin.setEncoding("utf8");
+    process.stdin.on("data", (chunk) => {
+      raw += chunk;
+    });
+    process.stdin.on("end", () => resolve(raw));
+    process.stdin.on("error", reject);
+  });
+}
+
+async function fetchBurnStatus() {
+  const port = process.env.AW_PORT ?? 47821;
+  const response = await fetch(`http://127.0.0.1:${port}/api/burn-status`, {
+    signal: AbortSignal.timeout(500),
+  });
+  if (response.status !== 200) return null;
+  return response.json();
+}
+
+async function main() {
+  try {
+    const input = JSON.parse(await readStdin());
+    const sessionId = input?.session_id;
+    if (typeof sessionId !== "string" || sessionId.length === 0) return;
+
+    const status = await fetchBurnStatus();
+    if (!status || status.available === false) return;
+
+    const stage = stageFromStatus(status);
+    if (!stage || !shouldEmit(sessionId)) return;
+
+    const output = stageToStdout(stage);
+    if (output) process.stdout.write(output);
+  } catch {
+    // Hooks must never block Claude Code if AgentWrangler is unavailable.
+  }
+}
+
+const invoked =
+  process.argv[1] !== undefined &&
+  path.resolve(process.argv[1]) ===
+    path.normalize(
+      decodeURIComponent(new URL(import.meta.url).pathname).replace(/^\/([A-Za-z]:)/, "$1"),
+    );
+if (invoked) void main();

package/dist/hook/loop-guard-hook.mjs

@@ -0,0 +1,104 @@
+/**
+ * Fail-open Claude Code PreToolUse hook for AgentWrangler's D7 loop guard.
+ * It deliberately exposes neither tool input nor tool output.
+ */
+
+import * as http from "node:http";
+import * as path from "node:path";
+import process from "node:process";
+import { fileURLToPath } from "node:url";
+
+const REQUEST_TIMEOUT_MS = 500;
+
+/** Convert a loop-guard stage to the only hook output it may emit. */
+export function stageToStdout(stage, reason) {
+  if (stage === "block") {
+    return JSON.stringify({
+      hookSpecificOutput: {
+        hookEventName: "PreToolUse",
+        permissionDecision: "deny",
+        permissionDecisionReason:
+          "Repeated identical failures detected. Restate the latest failure and change the approach before retrying.",
+      },
+      systemMessage:
+        "AgentWrangler: repeated identical failures detected. Restate the latest failure and change the approach before retrying.",
+    });
+  }
+  if (stage === "warn") {
+    return JSON.stringify({
+      hookSpecificOutput: {
+        hookEventName: "PreToolUse",
+        permissionDecision: "allow",
+        permissionDecisionReason:
+          "Repeated identical failures are approaching the guard threshold.",
+      },
+      additionalContext:
+        "Repeated identical failures are approaching the guard threshold. Restate the latest failure and change the approach before retrying.",
+      systemMessage:
+        "AgentWrangler: repeated identical failures are approaching the guard threshold. Change the approach before retrying.",
+    });
+  }
+  void reason;
+  return "";
+}
+
+function readStdin() {
+  return new Promise((resolve, reject) => {
+    let raw = "";
+    process.stdin.setEncoding("utf8");
+    process.stdin.on("data", (chunk) => {
+      raw += chunk;
+    });
+    process.stdin.on("end", () => resolve(raw));
+    process.stdin.on("error", reject);
+  });
+}
+
+function fetchGuard(sessionId) {
+  return new Promise((resolve, reject) => {
+    const port = process.env.AW_PORT ?? "47821";
+    const request = http.get(
+      `http://127.0.0.1:${port}/api/loop-guard?session_id=${encodeURIComponent(sessionId)}`,
+      (response) => {
+        if (response.statusCode !== 200) {
+          response.resume();
+          reject(new Error("non-200 response"));
+          return;
+        }
+        let raw = "";
+        response.setEncoding("utf8");
+        response.on("data", (chunk) => {
+          raw += chunk;
+        });
+        response.on("end", () => {
+          try {
+            resolve(JSON.parse(raw)?.data);
+          } catch {
+            reject(new Error("invalid response"));
+          }
+        });
+      },
+    );
+    request.setTimeout(REQUEST_TIMEOUT_MS, () => request.destroy(new Error("timeout")));
+    request.on("error", reject);
+  });
+}
+
+async function main() {
+  try {
+    const input = JSON.parse(await readStdin());
+    const sessionId = input?.session_id;
+    if (typeof sessionId !== "string" || sessionId.length === 0) return;
+    const guard = await fetchGuard(sessionId);
+    const output = stageToStdout(guard?.stage, guard?.reason);
+    if (output) await new Promise((resolve) => process.stdout.write(output, resolve));
+  } catch {
+    // Hooks must never block Claude Code when AgentWrangler is unavailable.
+  } finally {
+    process.exit(0);
+  }
+}
+
+const invoked =
+  process.argv[1] !== undefined && path.resolve(process.argv[1]) === fileURLToPath(import.meta.url);
+if (invoked) void main();

package/dist/hook/precompact-checkpoint-hook.mjs

@@ -0,0 +1,123 @@
+/**
+ * Claude Code PreCompact hook: snapshot the transcript before compaction discards
+ * detail. Copies the transcript to ~/.agentwrangler/checkpoints/<session>-<ts>.jsonl
+ * (mode 0o600), enforces a retention cap by count and total bytes, and ALWAYS exits 0
+ * so it can never block compaction. No package dependencies.
+ *
+ * Known gap (GH #13572): PreCompact may not fire on a manual `/compact`. No fallback in
+ * v1 — this covers auto-compaction, which is the lossy path that matters most.
+ *
+ * SEC-101: snapshots live under the user-profile checkpoints dir (local runtime, never
+ * committed). The hook writes no transcript content to stdout/stderr.
+ */
+
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import process from "node:process";
+import { fileURLToPath } from "node:url";
+
+const MAX_COUNT = 20;
+const MAX_BYTES = 500 * 1024 * 1024; // 500 MiB across all snapshots
+
+// Monotonic counter so two firings in the same millisecond get distinct filenames
+// that still sort in write order (the timestamp dominates; this breaks same-ms ties).
+let snapshotCounter = 0;
+
+/** The directory snapshots are written to (overridable for tests). */
+export function checkpointDir() {
+  return process.env.AW_CHECKPOINT_DIR ?? path.join(os.homedir(), ".agentwrangler", "checkpoints");
+}
+
+/** Filename-safe snapshot name for a session at a given time. */
+export function snapshotName(sessionId, now) {
+  snapshotCounter = (snapshotCounter + 1) % 1_000_000;
+  const stamp = now.toISOString().replace(/[:.]/g, "-");
+  return `${encodeURIComponent(sessionId)}-${stamp}-${String(snapshotCounter).padStart(6, "0")}.jsonl`;
+}
+
+/**
+ * Copy the transcript into `dir` with mode 0o600. Returns the snapshot path, or null if
+ * the transcript is missing/unreadable (a missing transcript is not an error to report).
+ */
+export function writeCheckpoint(transcriptPath, sessionId, dir, now = new Date()) {
+  if (typeof transcriptPath !== "string" || !fs.existsSync(transcriptPath)) return null;
+  fs.mkdirSync(dir, { recursive: true });
+  const dest = path.join(dir, snapshotName(sessionId, now));
+  fs.copyFileSync(transcriptPath, dest);
+  try {
+    fs.chmodSync(dest, 0o600);
+  } catch {
+    // chmod is a no-op boundary on Windows; the user-profile ACL is the equivalent guard.
+  }
+  return dest;
+}
+
+/** Prune oldest snapshots beyond the count cap, then beyond the total-byte cap. */
+export function enforceRetention(dir, maxCount = MAX_COUNT, maxBytes = MAX_BYTES) {
+  let entries;
+  try {
+    entries = fs
+      .readdirSync(dir)
+      .filter((name) => name.endsWith(".jsonl"))
+      .sort() // timestamp-derived names sort chronologically
+      .map((name) => {
+        const full = path.join(dir, name);
+        return { full, size: fs.statSync(full).size };
+      });
+  } catch {
+    return; // dir missing or unreadable — nothing to prune
+  }
+
+  const removeOldest = () => {
+    const victim = entries.shift();
+    if (!victim) return;
+    try {
+      fs.rmSync(victim.full);
+    } catch {
+      // A locked or already-removed snapshot is not worth failing for.
+    }
+  };
+
+  while (entries.length > maxCount) removeOldest();
+  let total = entries.reduce((sum, entry) => sum + entry.size, 0);
+  while (entries.length > 0 && total > maxBytes) {
+    total -= entries[0].size;
+    removeOldest();
+  }
+}
+
+/** True when running under CI / headless automation, where the hook must no-op. */
+function inCI() {
+  const ci = process.env.CI;
+  return typeof ci === "string" && ci !== "" && ci !== "false" && ci !== "0";
+}
+
+function readStdin() {
+  return new Promise((resolve, reject) => {
+    let raw = "";
+    process.stdin.setEncoding("utf8");
+    process.stdin.on("data", (chunk) => {
+      raw += chunk;
+    });
+    process.stdin.on("end", () => resolve(raw));
+    process.stdin.on("error", reject);
+  });
+}
+
+async function main() {
+  if (inCI()) return;
+  try {
+    const input = JSON.parse(await readStdin());
+    const sessionId = typeof input?.session_id === "string" ? input.session_id : "unknown";
+    const transcriptPath = input?.transcript_path;
+    const dir = checkpointDir();
+    if (writeCheckpoint(transcriptPath, sessionId, dir)) enforceRetention(dir);
+  } catch {
+    // Never block compaction, never emit noise.
+  }
+}
+
+const invoked =
+  process.argv[1] !== undefined && path.resolve(process.argv[1]) === fileURLToPath(import.meta.url);
+if (invoked) void main();

package/dist/ingest/churn-collector.js

@@ -0,0 +1,122 @@
+import { spawnSync } from "node:child_process";
+const WINDOW_DAYS = 14;
+const DAY_MS = 24 * 60 * 60 * 1000;
+const SHA_PATTERN = /^[0-9a-f]{40}$/i;
+const PORCELAIN_HEADER = /^([0-9a-f]{40})\s/;
+export function collectSessionChurn(db, opts = {}) {
+    const now = opts.now ?? new Date();
+    const measuredAt = now.toISOString();
+    const sessions = db
+        .prepare(`SELECT sessions.session_id, workspaces.repo_path
+       FROM sessions
+       LEFT JOIN workspaces ON workspaces.workspace_id = sessions.workspace_id`)
+        .all();
+    const authoredCommits = db.prepare(`SELECT DISTINCT commit_sha
+     FROM tool_events
+     WHERE session_id = ? AND commit_sha IS NOT NULL`);
+    const upsert = db.prepare(`INSERT INTO session_churn
+       (session_id, status, window_days, authored_lines, churned_lines, churn_ratio,
+        commit_count, commit_shas, measured_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+     ON CONFLICT(session_id) DO UPDATE SET
+       status=excluded.status,
+       window_days=excluded.window_days,
+       authored_lines=excluded.authored_lines,
+       churned_lines=excluded.churned_lines,
+       churn_ratio=excluded.churn_ratio,
+       commit_count=excluded.commit_count,
+       commit_shas=excluded.commit_shas,
+       measured_at=excluded.measured_at`);
+    for (const session of sessions) {
+        if (session.repo_path === null || session.repo_path === "") {
+            upsert.run(session.session_id, "NO_REPO", WINDOW_DAYS, 0, 0, null, 0, "[]", measuredAt);
+            continue;
+        }
+        const git = createGitRunner(session.repo_path, opts.git);
+        let authoredLines = 0;
+        let churnedLines = 0;
+        let immature = false;
+        const maturedShas = [];
+        const commits = authoredCommits.all(session.session_id);
+        for (const { commit_sha: sha } of commits) {
+            if (!SHA_PATTERN.test(sha) || git(["cat-file", "-e", `${sha}^{commit}`]) === null)
+                continue;
+            const merge = git(["rev-list", "--no-walk", "--merges", sha]);
+            if (merge === null || merge.stdout.trim() !== "")
+                continue;
+            const timestamp = git(["show", "-s", "--format=%cI", sha]);
+            if (timestamp === null)
+                continue;
+            const committedAt = new Date(timestamp.stdout.trim());
+            if (Number.isNaN(committedAt.getTime()))
+                continue;
+            const horizonAt = new Date(committedAt.getTime() + WINDOW_DAYS * DAY_MS);
+            if (horizonAt > now) {
+                immature = true;
+                continue;
+            }
+            const numstat = git(["show", "--numstat", "--no-renames", "--format=", sha]);
+            if (numstat === null)
+                continue;
+            let authoredForCommit = 0;
+            const touchedPaths = new Set();
+            for (const line of numstat.stdout.split(/\r?\n/)) {
+                const [added, , filePath] = line.split("\t", 3);
+                if (added === undefined || filePath === undefined || added === "-")
+                    continue;
+                const count = Number(added);
+                if (Number.isInteger(count) && count >= 0) {
+                    authoredForCommit += count;
+                    touchedPaths.add(filePath);
+                }
+            }
+            const horizon = git([
+                "rev-list",
+                "-1",
+                "--first-parent",
+                `--before=${horizonAt.toISOString()}`,
+                "HEAD",
+            ]);
+            if (horizon === null)
+                continue;
+            const horizonSha = horizon.stdout.trim();
+            let survivedForCommit = authoredForCommit;
+            if (horizonSha !== sha) {
+                survivedForCommit = 0;
+                for (const filePath of touchedPaths) {
+                    const blame = git(["blame", "-w", "--line-porcelain", horizonSha, "--", filePath]);
+                    if (blame === null)
+                        continue;
+                    for (const line of blame.stdout.split(/\r?\n/)) {
+                        if (PORCELAIN_HEADER.exec(line)?.[1]?.toLowerCase() === sha.toLowerCase()) {
+                            survivedForCommit += 1;
+                        }
+                    }
+                }
+            }
+            authoredLines += authoredForCommit;
+            churnedLines += Math.max(0, authoredForCommit - survivedForCommit);
+            maturedShas.push(sha);
+        }
+        upsert.run(session.session_id, immature ? "PARTIAL" : "MEASURED", WINDOW_DAYS, authoredLines, churnedLines, authoredLines === 0 ? null : churnedLines / authoredLines, maturedShas.length, JSON.stringify(maturedShas), measuredAt);
+    }
+}
+function createGitRunner(repoPath, injected) {
+    if (injected !== undefined) {
+        return (args) => injected(["-C", repoPath, ...args]);
+    }
+    return (args) => {
+        try {
+            const result = spawnSync("git", ["-C", repoPath, ...args], {
+                encoding: "utf8",
+                windowsHide: true,
+            });
+            if (result.error !== undefined || result.status !== 0)
+                return null;
+            return { status: result.status, stdout: result.stdout };
+        }
+        catch {
+            return null;
+        }
+    };
+}