@garuda-agent/garuda 0.0.1 → 0.14.1

package/dist/create-Y5SXJUXO.js

@@ -0,0 +1,223 @@
+#!/usr/bin/env node
+import {
+  jobBase,
+  linkCandidates,
+  worktreeDir
+} from "./chunk-YIZWYUBG.js";
+import {
+  agentLabel,
+  defaultAgentEnv,
+  installAgent,
+  installSpec,
+  nextTime,
+  nightAgentTime,
+  nightSpec
+} from "./chunk-35GMLLJW.js";
+import {
+  jobPrompt
+} from "./chunk-YQTGMCU6.js";
+import "./chunk-OUCV3FCT.js";
+import {
+  JobGitError
+} from "./chunk-ZGZ2ZADL.js";
+import "./chunk-D5O5CIWK.js";
+import "./chunk-WMOLXTBU.js";
+import "./chunk-HUIK3WXO.js";
+import {
+  DEFAULT_JOB_MAX_STEPS,
+  JOBS_DIR,
+  jobPath,
+  newJobId,
+  planPermissions,
+  planTitle,
+  saveJob
+} from "./chunk-KKB5W47S.js";
+import "./chunk-3NJNVZTK.js";
+
+// src/jobs/create.ts
+var DEFAULT_FINISH_BY = "07:00";
+var SWITCH_BEFORE_MS = 15 * 6e4;
+var DEFAULT_STEP_LIMIT_MINUTES = 20;
+function switchTime(finishBy) {
+  const [h, m] = finishBy.split(":").map(Number);
+  const minutes = (h * 60 + m - SWITCH_BEFORE_MS / 6e4 + 24 * 60) % (24 * 60);
+  return `${String(Math.floor(minutes / 60)).padStart(2, "0")}:${String(minutes % 60).padStart(2, "0")}`;
+}
+async function createJob(options) {
+  if (options.executor.isolation === "none") {
+    return {
+      ok: false,
+      text: "A job needs the OS sandbox (Seatbelt or bubblewrap): without it, every command would need an approval, and nobody is there to give it."
+    };
+  }
+  if (options.at !== void 0 && !/^([01]\d|2[0-3]):[0-5]\d$/.test(options.at)) {
+    return { ok: false, text: `"${options.at}" is not a time. Use HH:MM, for example 01:00.` };
+  }
+  let base;
+  try {
+    base = await jobBase(options.executor, options.root);
+  } catch (error) {
+    if (error instanceof JobGitError) return { ok: false, text: error.message };
+    throw error;
+  }
+  const { rules, problems } = planPermissions(options.plan.plan);
+  const id = newJobId(options.now);
+  const links = linkCandidates(options.root);
+  const job = {
+    version: 1,
+    id,
+    title: planTitle(options.plan.request, options.plan.plan),
+    createdAt: (options.now ?? /* @__PURE__ */ new Date()).toISOString(),
+    root: options.root,
+    base: base.commit,
+    branch: `garuda/job-${id}`,
+    worktree: worktreeDir(options.root, id, options.home),
+    prompt: jobPrompt(options.plan.request, options.plan.plan),
+    planSession: options.plan.sessionId,
+    model: options.modelId,
+    allow: rules,
+    onUnapproved: "deny-and-continue",
+    ...options.at === void 0 ? {} : { at: options.at },
+    maxSteps: options.maxSteps ?? DEFAULT_JOB_MAX_STEPS,
+    links,
+    ...options.test === void 0 ? {} : { test: options.test },
+    ...options.network === void 0 || options.network.length === 0 ? {} : { network: [...options.network] },
+    queue: true,
+    status: "scheduled"
+  };
+  const preview = [
+    `Job: ${job.title}`,
+    `Model: ${options.modelId} \xB7 up to ${job.maxSteps} steps`,
+    `Starts from: ${base.uncommitted ? "your last commit plus your uncommitted changes" : "your last commit"}${base.untracked > 0 ? ` (${base.untracked} untracked file(s) are not included)` : ""}`,
+    `Works on: branch ${job.branch}, in its own worktree; your checkout does not change.`,
+    ...links.length === 0 ? [] : [`Links: ${links.join(", ")} from your checkout.`],
+    "",
+    "Approved for this job, on top of the sandbox (reads, and commands that stay in the project):",
+    ...rules.length === 0 ? ["  (nothing: the plan listed no permissions)"] : rules.map((r) => `  ${r}`),
+    ...problems.length === 0 ? [] : ["", "Not rules, left out:", ...problems.map((p) => `  ${p}`)],
+    "",
+    "Any other call that would ask is denied at run time; the job goes on and reports it.",
+    job.network === void 0 ? "Network: none for commands." : `Network: ${job.network.join(", ")}, through Garuda's proxy; other hosts are denied and reported.`,
+    "",
+    options.test === void 0 ? 'Proof of work: no test command found (set "test" in the job file); a principal-engineer review of the diff (one model call).' : `Proof of work: \`${options.test}\` runs in the sandbox before and after the job; a principal-engineer review of the diff (one model call).`,
+    "Night shift: the job joins this project's queue; `garuda night` runs the queue (up to 3 jobs at a time) and writes one digest."
+  ].join("\n");
+  const choice = await options.approver.ask(
+    {
+      tool: "schedule",
+      target: { kind: "input", json: "{}" },
+      preview,
+      isolation: options.executor.isolation,
+      title: "Schedule this plan as a job?",
+      question: "Create the job?",
+      choices: ["once", "deny"],
+      labels: { once: "Yes, create the job", deny: "No" }
+    },
+    options.signal
+  );
+  if (choice === "deny") return { ok: false, text: "No job was created." };
+  if (options.batchCapable === true) {
+    const batch = await options.approver.ask(
+      {
+        tool: "schedule",
+        target: { kind: "input", json: "{}" },
+        preview: [
+          "Half the token price. Each step waits for its batch: about 3 minutes in Garuda's first measurement, but some batches wait hours.",
+          `A step that waits more than ${DEFAULT_STEP_LIMIT_MINUTES} minutes runs on the normal API (full price); the next step tries the Batch API again.`,
+          `At ${switchTime(DEFAULT_FINISH_BY)} (15 minutes before the finish-by time ${DEFAULT_FINISH_BY}), a job that still runs goes on with the normal API. You can change "finishBy" and "stepLimitMinutes" in the job file.`
+        ].join("\n"),
+        isolation: options.executor.isolation,
+        title: "Use the Batch API for this job?",
+        question: "Use the Batch API?",
+        choices: ["once", "deny"],
+        labels: { once: "Yes, half price, slower", deny: "No, the normal API" }
+      },
+      options.signal
+    );
+    if (batch !== "deny") {
+      job.batch = true;
+      job.finishBy = DEFAULT_FINISH_BY;
+      job.stepLimitMinutes = DEFAULT_STEP_LIMIT_MINUTES;
+    }
+  }
+  await saveJob(job);
+  const lines = [
+    `Created job ${id}: ${jobPath(options.root, id)}`,
+    'You can edit its approval list ("allow") in that file before the run.'
+  ];
+  const platform = options.launchd?.platform ?? process.platform;
+  if (options.launchd !== void 0 && options.at !== void 0 && platform === "darwin") {
+    const agent = await offerAgent(job, options);
+    if (agent !== void 0) return { ok: true, job, text: [...lines, agent].join("\n") };
+  }
+  const at = options.at === void 0 ? "" : ` --at ${options.at}`;
+  lines.push(
+    `Run the night queue in a terminal in this folder: garuda night${at} (or this job alone: garuda run ${id}${at})`
+  );
+  if (options.at !== void 0) {
+    lines.push("The terminal waits until then; keep the Mac awake and on power.");
+  }
+  return { ok: true, job, text: lines.join("\n") };
+}
+async function offerAgent(job, options) {
+  const env = options.launchd?.env ?? defaultAgentEnv();
+  const at = job.at;
+  const when = nextTime(at, options.now);
+  const day = when.toDateString();
+  const earlier = nightAgentTime(job.root, env);
+  const choice = await options.approver.ask(
+    {
+      tool: "schedule",
+      target: { kind: "input", json: "{}" },
+      preview: [
+        `launchd starts the night queue (every queued job, up to 3 at a time, then one digest) at ${at} on ${day}, also when no terminal is open. Or only this job.`,
+        ...earlier === void 0 ? [] : [
+          `The queue's agent now starts at ${earlier.toTimeString().slice(0, 5)} on ${earlier.toDateString()}: it moves to ${at}.`
+        ],
+        `It runs through your login shell (${env.shell} -lic), so your shell setup gives it the API keys; no key is written to a file.`,
+        "caffeinate keeps the Mac from idle sleep while it runs. If the Mac sleeps at that time, it starts at the next wake.",
+        `Logs: ${JOBS_DIR}/night.log (the queue) or ${JOBS_DIR}/${job.id}.log (one job). /jobs cancel night (or ${job.id}) removes it; it removes itself after it runs.`
+      ].join("\n"),
+      isolation: options.executor.isolation,
+      title: `Start at ${at} with launchd?`,
+      question: "Add a launchd agent?",
+      choices: ["once", "session", "deny"],
+      labels: {
+        once: "Yes, the whole night queue",
+        session: "Only this job",
+        deny: "No, I will run it myself"
+      }
+    },
+    options.signal
+  );
+  if (choice === "deny") return void 0;
+  const executor = options.launchd?.executor ?? options.executor;
+  if (choice === "once") {
+    try {
+      await installSpec(executor, nightSpec(job.root), env, when);
+      return `launchd starts the night queue at ${at} on ${day}. Keep the Mac on power. Log: ${JOBS_DIR}/night.log. Cancel: /jobs cancel night.`;
+    } catch (error) {
+      return `The launchd agent failed (${error.message}). Run the queue in a terminal instead: garuda night --at ${at}`;
+    }
+  }
+  try {
+    const installed = await installAgent(executor, job, env, options.now);
+    job.launchd = {
+      label: agentLabel(job.id),
+      plist: installed.plist,
+      when: installed.when.toISOString()
+    };
+    await saveJob(job);
+    return `launchd starts it at ${at} on ${day}; it leaves the night queue. Keep the Mac on power. Log: ${JOBS_DIR}/${job.id}.log. Cancel: /jobs cancel ${job.id}.`;
+  } catch (error) {
+    return `The launchd agent failed (${error.message}). Run it in a terminal instead: garuda run ${job.id} --at ${at}`;
+  }
+}
+export {
+  DEFAULT_FINISH_BY,
+  DEFAULT_STEP_LIMIT_MINUTES,
+  SWITCH_BEFORE_MS,
+  createJob,
+  switchTime
+};
+//# sourceMappingURL=create-Y5SXJUXO.js.map

package/dist/deadline-F5RJJ2QW.js

@@ -0,0 +1,86 @@
+#!/usr/bin/env node
+
+// src/model/deadline.ts
+var DeadlineClient = class {
+  constructor(primary, fallback, switchAt, options = {}) {
+    this.primary = primary;
+    this.fallback = fallback;
+    this.switchAt = switchAt;
+    this.stepLimitMs = options.stepLimitMs ?? Number.POSITIVE_INFINITY;
+    this.now = options.now ?? Date.now;
+    if (primary.serverTools !== void 0) this.serverTools = primary.serverTools;
+  }
+  primary;
+  fallback;
+  switchAt;
+  serverTools;
+  /** Requests answered by each client, and when the switch happened. */
+  calls = {
+    primary: 0,
+    fallback: 0,
+    /** Requests that waited past the step limit and went to the fallback. */
+    slow: 0,
+    switchedAt: void 0
+  };
+  fallbackClient;
+  stepLimitMs;
+  now;
+  async *stream(request, options) {
+    const left = this.switchAt.getTime() - this.now();
+    if (this.calls.switchedAt !== void 0 || left <= 0) {
+      yield* this.viaFallback(request, options);
+      return;
+    }
+    const timer = new AbortController();
+    const stepOnly = this.stepLimitMs < left;
+    const handle = setTimeout(
+      () => timer.abort(stepOnly ? new StepTooSlow() : new DeadlineReached()),
+      Math.min(left, this.stepLimitMs)
+    );
+    const signals = [timer.signal, ...options?.signal === void 0 ? [] : [options.signal]];
+    try {
+      const events = [];
+      for await (const event of this.primary.stream(request, {
+        signal: AbortSignal.any(signals)
+      })) {
+        events.push(event);
+      }
+      this.calls.primary++;
+      yield* events;
+    } catch (error) {
+      if (options?.signal?.aborted === true || !timer.signal.aborted) throw error;
+      if (stepOnly) {
+        this.calls.slow++;
+        this.fallbackClient ??= await this.fallback();
+        this.calls.fallback++;
+        yield* this.fallbackClient.stream(request, options);
+      } else yield* this.viaFallback(request, options);
+    } finally {
+      clearTimeout(handle);
+    }
+  }
+  async *viaFallback(request, options) {
+    if (this.calls.switchedAt === void 0) this.calls.switchedAt = new Date(this.now());
+    this.fallbackClient ??= await this.fallback();
+    this.calls.fallback++;
+    yield* this.fallbackClient.stream(request, options);
+  }
+};
+var DeadlineReached = class extends Error {
+  constructor() {
+    super("The finish-by time is near: the request goes to the normal API.");
+    this.name = "DeadlineReached";
+  }
+};
+var StepTooSlow = class extends Error {
+  constructor() {
+    super("The batch took longer than the step limit: this request goes to the normal API.");
+    this.name = "StepTooSlow";
+  }
+};
+export {
+  DeadlineClient,
+  DeadlineReached,
+  StepTooSlow
+};
+//# sourceMappingURL=deadline-F5RJJ2QW.js.map

package/dist/detect-LARDSLLZ.js

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+import {
+  folderKind,
+  initTip
+} from "./chunk-42DSA4EA.js";
+export {
+  folderKind,
+  initTip
+};
+//# sourceMappingURL=detect-LARDSLLZ.js.map