@garuda-agent/garuda 0.0.1 → 0.14.1

package/dist/chunk-OUCV3FCT.js

@@ -0,0 +1,205 @@
+#!/usr/bin/env node
+
+// src/jobs/proof.ts
+import { existsSync, readdirSync, readFileSync } from "fs";
+import { extname, join } from "path";
+var TEST_TAIL_LINES = 30;
+var REVIEW_DIFF_CHARS = 6e4;
+function detectTestCommand(root, profiles) {
+  try {
+    const pkg = JSON.parse(readFileSync(join(root, "package.json"), "utf8"));
+    const test = pkg.scripts?.test;
+    if (typeof test === "string" && test.trim() !== "" && !test.includes("no test specified")) {
+      if (existsSync(join(root, "pnpm-lock.yaml"))) return "pnpm test";
+      if (existsSync(join(root, "yarn.lock"))) return "yarn test";
+      return "npm test";
+    }
+  } catch {
+  }
+  if (profiles[0] !== void 0) return profiles[0].test;
+  return hasNodeTests(root) ? "node --test" : void 0;
+}
+function hasNodeTests(root) {
+  const isTest = (name) => /\.test\.[cm]?js$/.test(name);
+  for (const dir of [root, join(root, "test")]) {
+    try {
+      if (readdirSync(dir).some(isTest)) return true;
+    } catch {
+    }
+  }
+  return false;
+}
+function testSummary(run) {
+  if (run === void 0) return "not run";
+  if (run.timedOut) return `stopped after ${Math.round(run.durationMs / 1e3)} s (too long)`;
+  return `${run.exitCode === 0 ? "pass" : `fail (exit code ${run.exitCode})`} in ${Math.round(run.durationMs / 1e3)} s`;
+}
+var passed = (run) => run !== void 0 && !run.timedOut && run.exitCode === 0;
+var TEST_PATH = /(^|\/)(tests?|__tests__|spec)\/|\.(test|spec)\.[cm]?[jt]sx?$|(^|\/)test_[^/]*\.py$|_test\.(py|go)$|(^|\/)src\/test\//;
+var MANIFEST = /(^|\/)(package\.json|pnpm-lock\.yaml|package-lock\.json|yarn\.lock|pyproject\.toml|requirements[^/]*\.txt|poetry\.lock|uv\.lock|pom\.xml|build\.gradle(\.kts)?|go\.mod|go\.sum|Cargo\.toml|Cargo\.lock|Gemfile(\.lock)?)$/;
+var DELIVERY = /(^|\/)(\.github\/workflows\/|\.gitlab-ci\.yml$|Dockerfile$|docker-compose[^/]*\.ya?ml$|\.env)/;
+function riskFlags(input) {
+  const { result, test, before, after } = input;
+  const flags = [];
+  if (result.stopReason !== "done") {
+    flags.push({
+      level: "stop",
+      text: `The job did not finish: it stopped with "${result.stopReason}".`
+    });
+  }
+  if (result.error !== void 0) flags.push({ level: "stop", text: `Error: ${result.error}` });
+  if (test === void 0) {
+    flags.push({ level: "look", text: "No test command: nothing proves the change works." });
+  } else if (after !== void 0 && !passed(after)) {
+    flags.push({
+      level: "stop",
+      text: passed(before) ? "The tests passed before the job and fail after it." : "The tests fail after the job (they failed before it too)."
+    });
+  } else if (after !== void 0 && before !== void 0 && !passed(before)) {
+    flags.push({
+      level: "look",
+      text: "The tests failed before the job and pass after it: check that the change is why."
+    });
+  }
+  const tests = result.files.filter((f) => TEST_PATH.test(f.path));
+  const deletedTests = tests.filter((f) => f.status === "deleted");
+  if (deletedTests.length > 0) {
+    flags.push({
+      level: "look",
+      text: `Test files deleted: ${deletedTests.map((f) => f.path).join(", ")}.`
+    });
+  }
+  const changedTests = tests.filter((f) => f.status === "modified");
+  if (changedTests.length > 0) {
+    flags.push({
+      level: "look",
+      text: `Existing tests changed: ${changedTests.map((f) => f.path).join(", ")}. Check that they still test what they did.`
+    });
+  }
+  const manifests = result.files.filter((f) => MANIFEST.test(f.path));
+  if (manifests.length > 0) {
+    flags.push({
+      level: "look",
+      text: `Dependencies or build files changed: ${manifests.map((f) => f.path).join(", ")}.`
+    });
+  }
+  const delivery = result.files.filter((f) => DELIVERY.test(f.path));
+  if (delivery.length > 0) {
+    flags.push({
+      level: "look",
+      text: `CI, container or environment files changed: ${delivery.map((f) => f.path).join(", ")}.`
+    });
+  }
+  const lines = result.files.reduce((n, f) => n + (f.added ?? 0) + (f.removed ?? 0), 0);
+  if (result.files.length > 20 || lines > 500) {
+    flags.push({
+      level: "look",
+      text: `A large change: ${result.files.length} files, ${lines} lines.`
+    });
+  }
+  if (result.denied.length > 0) {
+    flags.push({
+      level: "look",
+      text: `${result.denied.length} call(s) were denied: the job may be incomplete.`
+    });
+  }
+  return flags;
+}
+var LANGUAGES = {
+  ts: "TypeScript",
+  tsx: "TypeScript",
+  mts: "TypeScript",
+  cts: "TypeScript",
+  js: "JavaScript",
+  jsx: "JavaScript",
+  mjs: "JavaScript",
+  cjs: "JavaScript",
+  py: "Python",
+  java: "Java",
+  kt: "Kotlin",
+  go: "Go",
+  rs: "Rust",
+  rb: "Ruby",
+  cs: "C#",
+  swift: "Swift",
+  php: "PHP",
+  scala: "Scala",
+  sql: "SQL"
+};
+function stackOf(files, profiles) {
+  const out = /* @__PURE__ */ new Set();
+  for (const f of files) {
+    const language = LANGUAGES[extname(f.path).slice(1).toLowerCase()];
+    if (language !== void 0) out.add(language);
+  }
+  for (const p of profiles) out.add(p.label);
+  return [...out];
+}
+function reviewerSystem(stack) {
+  const expert = stack.length === 0 ? "this codebase" : `${stack.join(", ")} and this codebase`;
+  return [
+    `You are a principal engineer and a domain expert in ${expert}. A staff engineer made the change below`,
+    "as an unattended job, from a plan that the user approved. You review it before the user merges it.",
+    "Check, in this order: correctness and edge cases; that the change does what the plan says, no more and",
+    "no less; that tests prove it (new behaviour tested, no test weakened); security and data risks; the",
+    "project's conventions. Judge only what the diff and the facts show. Do not invent problems; say what",
+    "you cannot see.",
+    "",
+    "Answer in exactly this form:",
+    "VERDICT: ready | needs a look",
+    "SUMMARY: one sentence",
+    "FINDINGS:",
+    "- [high|medium|low] path:line: the problem and the fix",
+    '(or "- none")'
+  ].join("\n");
+}
+function reviewPrompt(input) {
+  const diff = input.diff.length <= REVIEW_DIFF_CHARS ? input.diff : `${input.diff.slice(0, REVIEW_DIFF_CHARS)}
+[\u2026 the diff is cut here; ${input.diff.length - REVIEW_DIFF_CHARS} more characters]`;
+  return [
+    "<job>",
+    input.prompt.trim(),
+    "</job>",
+    "",
+    "<facts>",
+    `Files: ${input.files.map((f) => `${f.status} ${f.path} (+${f.added ?? "?"} \u2212${f.removed ?? "?"})`).join("; ") || "none"}`,
+    `Tests (${input.test ?? "no test command"}): before the job ${testSummary(input.before)}; after it ${testSummary(input.after)}`,
+    ...input.after !== void 0 && !passed(input.after) ? [`Test output after the job:
+${input.after.tail}`] : [],
+    `Risk flags: ${input.flags.length === 0 ? "none" : input.flags.map((f) => f.text).join(" ")}`,
+    "</facts>",
+    "",
+    "<diff>",
+    diff,
+    "</diff>"
+  ].join("\n");
+}
+function parseReview(text) {
+  const m = /^\s*VERDICT:\s*(ready|needs a look)\b/im.exec(text);
+  return { verdict: m?.[1]?.toLowerCase() === "ready" ? "ready" : "needs-look", text: text.trim() };
+}
+function jobVerdict(flags, review) {
+  if (flags.some((f) => f.level === "stop")) return "needs-look";
+  return review ?? (flags.length === 0 ? "ready" : "needs-look");
+}
+function tail(text, lines = TEST_TAIL_LINES) {
+  const all = text.trimEnd().split("\n");
+  return all.length <= lines ? all.join("\n") : `[\u2026 ${all.length - lines} lines]
+${all.slice(-lines).join("\n")}`;
+}
+
+export {
+  detectTestCommand,
+  testSummary,
+  passed,
+  TEST_PATH,
+  MANIFEST,
+  riskFlags,
+  stackOf,
+  reviewerSystem,
+  reviewPrompt,
+  parseReview,
+  jobVerdict,
+  tail
+};
+//# sourceMappingURL=chunk-OUCV3FCT.js.map

package/dist/chunk-PZS3V6P3.js

@@ -0,0 +1,46 @@
+#!/usr/bin/env node
+
+// src/mcp/sanitize.ts
+var ESCAPES = /\u001b\[[0-?]*[ -/]*[@-~]|\u001b\][^\u0007\u001b]*(?:\u0007|\u001b\\)|\u001b[@-_]|\u009b[0-?]*[ -/]*[@-~]/g;
+var CONTROLS = /[\u0000-\u0008\u000b-\u001f\u007f-\u009f]/g;
+var INVISIBLE = /[\u200b-\u200f\u202a-\u202e\u2060-\u2064\u2066-\u2069\ufeff]/g;
+var TAGS = /[\u{e0000}-\u{e007f}]/gu;
+function cleanText(text) {
+  return text.replace(/\r\n?/g, "\n").replace(ESCAPES, "").replace(CONTROLS, "").replace(INVISIBLE, "").replace(TAGS, "");
+}
+function cleanLine(text) {
+  return cleanText(text).replace(/\s+/g, " ").trim();
+}
+function capText(text, max) {
+  if (text.length <= max) return text;
+  const head = Math.floor(max * 0.7);
+  const tail = max - head;
+  return `${text.slice(0, head)}
+[\u2026 ${text.length - max} characters cut by Garuda \u2026]
+${text.slice(-tail)}`;
+}
+function cleanJson(value) {
+  if (typeof value === "string") return cleanText(value);
+  if (Array.isArray(value)) return value.map(cleanJson);
+  if (value !== null && typeof value === "object") {
+    return Object.fromEntries(
+      Object.entries(value).map(([k, v]) => [
+        cleanText(k),
+        cleanJson(v)
+      ])
+    );
+  }
+  return value;
+}
+function neutralizeTags(text) {
+  return text.replace(/<(\/?)(mcp_result|web_result|garuda_note|skill_file|skill)/gi, "<\\$1$2");
+}
+
+export {
+  cleanText,
+  cleanLine,
+  capText,
+  cleanJson,
+  neutralizeTags
+};
+//# sourceMappingURL=chunk-PZS3V6P3.js.map

package/dist/chunk-QOW5TK4L.js

@@ -0,0 +1,320 @@
+#!/usr/bin/env node
+import {
+  notificationBytes,
+  pickChannel
+} from "./chunk-N4I6YS3E.js";
+import {
+  gateProjectSettings,
+  totalTokens
+} from "./chunk-W7BPYQMW.js";
+import {
+  TrustStore
+} from "./chunk-5DEWP3YX.js";
+import {
+  cleanArgs,
+  commitJob,
+  jobChanges,
+  prepareWorktree
+} from "./chunk-YIZWYUBG.js";
+import {
+  defaultAgentEnv,
+  removeAgent
+} from "./chunk-35GMLLJW.js";
+import {
+  jobReport
+} from "./chunk-YQTGMCU6.js";
+import {
+  jobVerdict,
+  parseReview,
+  reviewPrompt,
+  reviewerSystem,
+  riskFlags,
+  stackOf,
+  testSummary
+} from "./chunk-OUCV3FCT.js";
+import {
+  JobGitError,
+  git,
+  hostCommand
+} from "./chunk-ZGZ2ZADL.js";
+import {
+  createExecutor,
+  loadSettings
+} from "./chunk-D5O5CIWK.js";
+import {
+  JOBS_DIR,
+  loadJob,
+  saveJob
+} from "./chunk-KKB5W47S.js";
+import {
+  parseRule
+} from "./chunk-3NJNVZTK.js";
+
+// src/cli/jobCommand.ts
+import { writeFile } from "fs/promises";
+import { join } from "path";
+var JOB_TEST_TIMEOUT_MS = 10 * 6e4;
+async function testsBefore(prepared, runtime, renderer, git2 = createExecutor("host").executor) {
+  const { job } = prepared;
+  if (job.test === void 0) return;
+  renderer.info(`Tests before the job: ${job.test}`);
+  prepared.testsBefore = await runtime.runCheck(
+    job.test,
+    JOB_TEST_TIMEOUT_MS,
+    new AbortController().signal
+  );
+  renderer.info(`Tests before the job: ${testSummary(prepared.testsBefore)}`);
+  await git(git2, job.worktree, ["checkout", "--", "."], { check: false });
+  await git(git2, job.worktree, cleanArgs(job.links), { check: false });
+}
+async function proveJob(prepared, result, runtime, renderer, git2) {
+  const { job } = prepared;
+  const signal = new AbortController().signal;
+  let after;
+  if (job.test !== void 0) {
+    after = await runtime.runCheck(job.test, JOB_TEST_TIMEOUT_MS, signal);
+    renderer.info(`Tests after the job: ${testSummary(after)}`);
+  }
+  const before = prepared.testsBefore;
+  const flags = riskFlags({
+    result,
+    ...job.test === void 0 ? {} : { test: job.test },
+    ...before === void 0 ? {} : { before },
+    ...after === void 0 ? {} : { after }
+  });
+  if (result.commit === void 0) flags.push({ level: "look", text: "No file changed." });
+  const proof = {
+    verdict: "needs-look",
+    ...before === void 0 ? {} : { before },
+    ...after === void 0 ? {} : { after },
+    flags
+  };
+  if (job.review !== false && result.commit !== void 0) {
+    renderer.info("Reviewing the diff (a principal engineer's review)\u2026");
+    try {
+      const diff = (await git(git2, job.root, ["diff", "--no-renames", job.base, job.branch], {
+        check: false
+      })).stdout;
+      const answer = await runtime.askModel(
+        reviewerSystem(stackOf(result.files, runtime.profiles)),
+        reviewPrompt({
+          prompt: job.prompt,
+          files: result.files,
+          ...job.test === void 0 ? {} : { test: job.test },
+          ...before === void 0 ? {} : { before },
+          ...after === void 0 ? {} : { after },
+          flags,
+          diff
+        }),
+        signal
+      );
+      const parsed = parseReview(answer.text);
+      proof.review = {
+        ...parsed,
+        ...answer.costUsd === void 0 ? {} : { costUsd: answer.costUsd }
+      };
+    } catch (error) {
+      proof.reviewError = error.message;
+    }
+  }
+  proof.verdict = jobVerdict(flags, proof.review?.verdict);
+  return proof;
+}
+async function prepareJob(mainRoot, id, at, renderer, git2 = createExecutor("host").executor, launchd = {}, trustHome) {
+  const prepared = await prepare(mainRoot, id, at, renderer, git2, trustHome);
+  if (typeof prepared === "number" && launchd.fromLaunchd === true) {
+    const job = await loadJob(mainRoot, id).catch(() => void 0);
+    if (job !== void 0) await removeAgent(git2, job, launchd.env ?? defaultAgentEnv());
+  }
+  return prepared;
+}
+async function prepare(mainRoot, id, at, renderer, git2, trustHome) {
+  let job;
+  try {
+    job = await loadJob(mainRoot, id);
+  } catch (error) {
+    renderer.error(error.message);
+    return 1;
+  }
+  if (job.status === "running") {
+    renderer.error(
+      `Job ${id} is marked as running. If no other garuda runs it, set "status" to "stopped" in ${JOBS_DIR}/${id}.json and try again.`
+    );
+    return 1;
+  }
+  if (job.status === "done") {
+    renderer.error(`Job ${id} is done. Its report: ${join(JOBS_DIR, `${id}.md`)}`);
+    return 1;
+  }
+  if (at !== void 0) {
+    const waited = await waitUntil(at, renderer, job);
+    if (waited !== 0) return waited;
+  }
+  try {
+    await prepareWorktree(git2, job);
+  } catch (error) {
+    if (!(error instanceof JobGitError)) throw error;
+    renderer.error(`The job's worktree failed: ${error.message}`);
+    return 1;
+  }
+  const gate = await gateProjectSettings({
+    root: job.root,
+    settings: await loadSettings(job.worktree),
+    trust: trustHome === void 0 ? void 0 : await TrustStore.open(trustHome)
+  });
+  if (gate.notice !== void 0) renderer.info(gate.notice);
+  const project = gate.settings;
+  const links = job.links.map((name) => join(job.root, name));
+  const { network: _projectNetwork, ...projectRest } = project;
+  const settings = {
+    ...projectRest,
+    ...job.network === void 0 ? {} : { network: { allow: job.network } },
+    allow: [...project.allow, ...job.allow.map((rule) => parseRule(rule))],
+    maxSteps: job.maxSteps,
+    sandbox: {
+      ...project.sandbox,
+      // Linked folders (node_modules …) live in the checkout: tools may write their caches there.
+      writePaths: [...project.sandbox?.writePaths ?? [], ...links]
+    }
+  };
+  job.status = "running";
+  job.startedAt = (/* @__PURE__ */ new Date()).toISOString();
+  await saveJob(job);
+  renderer.info(
+    `Job ${job.id}: ${job.title}
+Branch ${job.branch} \xB7 worktree ${job.worktree}
+Approved: ${job.allow.length === 0 ? "nothing beyond the sandbox" : job.allow.join(", ")}`
+  );
+  return { job, root: job.worktree, settings, denied: [], startedAt: Date.now() };
+}
+async function waitUntil(at, renderer, job) {
+  const match = /^([01]\d|2[0-3]):([0-5]\d)$/.exec(at);
+  if (match === null) {
+    renderer.error(`"${at}" is not a time. Use HH:MM, for example 01:00.`);
+    return 1;
+  }
+  const ms = msUntil(Number(match[1]), Number(match[2]));
+  const hours = Math.floor(ms / 36e5);
+  const minutes = Math.round(ms % 36e5 / 6e4);
+  renderer.info(
+    `Job ${job.id} waits until ${at} (in ${hours} h ${minutes} min). Keep this terminal open and the Mac awake and on power. Ctrl-C cancels the wait.`
+  );
+  const cancelled = await new Promise((resolve) => {
+    const timer = setTimeout(() => {
+      process.off("SIGINT", cancel);
+      resolve(false);
+    }, ms);
+    const cancel = () => {
+      clearTimeout(timer);
+      resolve(true);
+    };
+    process.once("SIGINT", cancel);
+  });
+  if (cancelled) {
+    renderer.warn(`The wait was cancelled. Job ${job.id} is still scheduled.`);
+    return 130;
+  }
+  return 0;
+}
+function msUntil(hour, minute, now = /* @__PURE__ */ new Date()) {
+  const next = new Date(now);
+  next.setHours(hour, minute, 0, 0);
+  if (next.getTime() <= now.getTime()) next.setDate(next.getDate() + 1);
+  return next.getTime() - now.getTime();
+}
+async function finishJob(prepared, outcome, runtime, renderer, git2 = createExecutor("host").executor, launchd = {}) {
+  const { job } = prepared;
+  const hadAgent = job.launchd !== void 0 || launchd.fromLaunchd === true;
+  delete job.launchd;
+  const result = {
+    stopReason: outcome.kind === "done" ? outcome.result.stopReason : outcome.kind,
+    steps: outcome.kind === "done" ? outcome.result.steps : 0,
+    tokens: runtime.session === void 0 ? 0 : totalTokens(runtime.session.usage),
+    ...runtime.session?.costUsd === void 0 ? {} : { costUsd: runtime.session.costUsd },
+    durationMs: Date.now() - prepared.startedAt,
+    ...runtime.session === void 0 ? {} : { sessionId: runtime.session.id },
+    files: [],
+    denied: prepared.denied,
+    answer: lastAnswer(runtime),
+    ...prepared.deadline === void 0 ? {} : {
+      modelCalls: {
+        batch: prepared.deadline.calls.primary,
+        normal: prepared.deadline.calls.fallback,
+        slow: prepared.deadline.calls.slow,
+        ...prepared.deadline.calls.switchedAt === void 0 ? {} : { switchedAt: prepared.deadline.calls.switchedAt.toISOString() }
+      }
+    },
+    ...outcome.kind === "error" ? { error: outcome.message } : {}
+  };
+  try {
+    const commit = await commitJob(
+      git2,
+      job,
+      `Garuda job ${job.id}: ${job.title}${outcome.kind === "done" && outcome.result.stopReason === "done" ? "" : ` (${result.stopReason})`}`
+    );
+    if (commit !== void 0) result.commit = commit;
+    result.files = await jobChanges(git2, job);
+  } catch (error) {
+    if (!(error instanceof JobGitError)) throw error;
+    result.error = [result.error, `commit: ${error.message}`].filter(Boolean).join("; ");
+  }
+  if (outcome.kind !== "interrupted") {
+    result.proof = await proveJob(prepared, result, runtime, renderer, git2);
+  }
+  job.status = outcome.kind === "error" ? "failed" : outcome.kind === "interrupted" ? "stopped" : "done";
+  job.endedAt = (/* @__PURE__ */ new Date()).toISOString();
+  job.result = result;
+  await saveJob(job);
+  const report = jobReport(job);
+  const file = join(job.root, JOBS_DIR, `${job.id}.md`);
+  await writeFile(file, `${report}
+`, { mode: 384 });
+  renderer.info(`
+${report}
+
+Report: ${file}`);
+  const verdict = result.proof === void 0 ? "" : result.proof.verdict === "ready" ? ", ready to merge" : ", needs a look";
+  const note = `Garuda: job ${job.id} ${job.status}${verdict} (${result.files.length} file(s) changed)`;
+  if (process.stdout.isTTY) {
+    process.stdout.write(
+      notificationBytes(pickChannel(runtime.notificationSettings?.channel), note)
+    );
+  } else if (launchd.fromLaunchd === true && process.platform === "darwin") {
+    await hostCommand(
+      git2,
+      job.root,
+      [
+        "osascript",
+        "-e",
+        "on run argv",
+        "-e",
+        'display notification (item 1 of argv) with title "Garuda"',
+        "-e",
+        "end run",
+        note
+      ],
+      { check: false }
+    );
+  }
+  if (hadAgent) await removeAgent(git2, job, launchd.env ?? defaultAgentEnv());
+}
+function lastAnswer(runtime) {
+  const messages = runtime.session?.messages ?? [];
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const m = messages[i];
+    if (m?.role !== "assistant") continue;
+    const text = m.content.map((b) => b.type === "text" ? b.text : "").join("").trim();
+    if (text !== "") return text.length <= 8e3 ? text : `${text.slice(0, 8e3)}
+\u2026 [cut]`;
+  }
+  return "";
+}
+
+export {
+  JOB_TEST_TIMEOUT_MS,
+  testsBefore,
+  prepareJob,
+  msUntil,
+  finishJob
+};
+//# sourceMappingURL=chunk-QOW5TK4L.js.map

package/dist/chunk-U4OQVT2T.js

@@ -0,0 +1,73 @@
+#!/usr/bin/env node
+import {
+  MANAGED,
+  jdtlsInstallCommand,
+  managedDir
+} from "./chunk-EU7PA45O.js";
+import {
+  DEFAULT_ENV_ALLOWLIST
+} from "./chunk-D5O5CIWK.js";
+
+// src/lsp/install.ts
+import { mkdir } from "fs/promises";
+var INSTALL_TIMEOUT_MS = 3e5;
+var NPM_ENV = [
+  "HTTP_PROXY",
+  "HTTPS_PROXY",
+  "NO_PROXY",
+  "http_proxy",
+  "https_proxy",
+  "no_proxy",
+  "NODE_EXTRA_CA_CERTS",
+  "npm_config_registry",
+  "NPM_CONFIG_REGISTRY"
+];
+function installCommand(language, dir) {
+  const managed = MANAGED[language];
+  if (managed.kind === "eclipse") return jdtlsInstallCommand(dir, quote);
+  return [
+    "npm",
+    "install",
+    "--prefix",
+    quote(dir),
+    "--ignore-scripts",
+    "--no-audit",
+    "--no-fund",
+    "--loglevel=error",
+    ...managed.packages
+  ].join(" ");
+}
+async function installServer(language, options) {
+  const dir = managedDir(language, options.home);
+  await mkdir(dir, { recursive: true });
+  const command = installCommand(language, dir);
+  const policy = {
+    root: dir,
+    sandbox: false,
+    writePaths: [],
+    denyWritePaths: [],
+    denyReadPaths: [],
+    network: true,
+    envAllowlist: [...DEFAULT_ENV_ALLOWLIST, ...NPM_ENV],
+    timeoutMs: INSTALL_TIMEOUT_MS,
+    maxOutputBytes: 2e4
+  };
+  const result = await options.executor.run(
+    command,
+    policy,
+    options.signal === void 0 ? {} : { signal: options.signal }
+  );
+  if (result.exitCode === 0) return { ok: true, dir, command };
+  const why = result.timedOut ? `npm took longer than ${INSTALL_TIMEOUT_MS / 1e3} s.` : [result.stderr.text, result.stdout.text].join("\n").trim().split("\n").slice(-8).join("\n");
+  return { ok: false, dir, command, output: why || `npm exited with ${result.exitCode}.` };
+}
+function quote(text) {
+  return /^[\w./:@-]+$/.test(text) ? text : `'${text.replaceAll("'", `'\\''`)}'`;
+}
+
+export {
+  INSTALL_TIMEOUT_MS,
+  installCommand,
+  installServer
+};
+//# sourceMappingURL=chunk-U4OQVT2T.js.map