@openape/apes 1.25.1 → 1.26.0

package/dist/chunk-VHZEVW2N.js

@@ -0,0 +1,998 @@
+#!/usr/bin/env node
+
+// src/errors.ts
+var CliError = class extends Error {
+  constructor(message, exitCode = 1) {
+    super(message);
+    this.exitCode = exitCode;
+    this.name = "CliError";
+  }
+  exitCode;
+};
+var CliExit = class extends Error {
+  constructor(exitCode = 0) {
+    super("");
+    this.exitCode = exitCode;
+    this.name = "CliExit";
+  }
+  exitCode;
+};
+
+// src/duration.ts
+function parseDuration(value) {
+  const match = value.match(/^(\d+)\s*([smhd])$/);
+  if (!match) {
+    throw new Error(`Invalid duration format: "${value}". Use e.g. 30m, 1h, 7d`);
+  }
+  const amount = Number.parseInt(match[1], 10);
+  switch (match[2]) {
+    case "s":
+      return amount;
+    case "m":
+      return amount * 60;
+    case "h":
+      return amount * 3600;
+    case "d":
+      return amount * 86400;
+    default:
+      throw new Error(`Unknown duration unit: ${match[2]}`);
+  }
+}
+
+// src/lib/agent-tools/ape-shell-exec.ts
+import { spawn } from "child_process";
+var DEFAULT_TIMEOUT_MS = 5 * 60 * 1e3;
+var MAX_STDIO_BYTES = 64 * 1024;
+var BIN = "ape-shell";
+function capStdio(s) {
+  const buf = Buffer.from(s, "utf8");
+  if (buf.byteLength <= MAX_STDIO_BYTES) return s;
+  return `${buf.subarray(0, MAX_STDIO_BYTES).toString("utf8")}
+[truncated to ${MAX_STDIO_BYTES} bytes]`;
+}
+function runApeShell(cmd, timeoutMs = DEFAULT_TIMEOUT_MS) {
+  return new Promise((resolveResult) => {
+    const child = spawn(BIN, ["-c", cmd], {
+      env: { ...process.env, APE_WAIT: "1" },
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    let stdout = "";
+    let stderr = "";
+    let timedOut = false;
+    let spawnError = null;
+    child.stdout.on("data", (chunk) => {
+      stdout += chunk.toString("utf8");
+    });
+    child.stderr.on("data", (chunk) => {
+      stderr += chunk.toString("utf8");
+    });
+    child.on("error", (err) => {
+      spawnError = err;
+    });
+    const timer = setTimeout(() => {
+      timedOut = true;
+      child.kill("SIGTERM");
+      setTimeout(() => {
+        try {
+          child.kill("SIGKILL");
+        } catch {
+        }
+      }, 5e3);
+    }, timeoutMs);
+    child.on("close", (code) => {
+      clearTimeout(timer);
+      if (spawnError) {
+        resolveResult({
+          stdout: "",
+          stderr: "",
+          exit_code: -1,
+          error: spawnError.message,
+          hint: `Could not exec '${BIN}'. The agent host needs @openape/apes installed globally so ape-shell is on PATH.`
+        });
+        return;
+      }
+      resolveResult({
+        stdout: capStdio(stdout),
+        stderr: capStdio(stderr),
+        exit_code: code ?? -1,
+        ...timedOut ? { timed_out: true } : {}
+      });
+    });
+  });
+}
+var DEFAULTS = { DEFAULT_TIMEOUT_MS };
+
+// src/lib/agent-tools/bash.ts
+var bashTools = [
+  {
+    name: "bash",
+    description: "Run a shell command on the agent host. Every invocation goes through the OpenApe DDISA grant cycle \u2014 auto-approved if the owner has a matching YOLO scope, otherwise the owner gets a push notification to approve. Runs as the agent's macOS user, so file/network access is limited to what that user can see. Returns stdout, stderr, and exit code. For repeated command patterns ask the owner to set up a YOLO scope so approvals don't pile up.",
+    parameters: {
+      type: "object",
+      properties: {
+        cmd: {
+          type: "string",
+          description: "Shell command to run, e.g. `ls -la ~/Documents`, `git status`, `curl -fsSL https://example.com`. The whole string is passed to `bash -c`; quote internally as needed."
+        },
+        timeout_ms: {
+          type: "number",
+          description: "Wall-clock cap for the whole approval-and-run cycle in milliseconds. Default 300000 (5 min). Approval waits count against this budget."
+        }
+      },
+      required: ["cmd"]
+    },
+    execute: async (args) => {
+      const a = args;
+      if (typeof a.cmd !== "string" || a.cmd.trim() === "") {
+        throw new Error("cmd must be a non-empty string");
+      }
+      const timeout = typeof a.timeout_ms === "number" && a.timeout_ms > 0 ? a.timeout_ms : DEFAULTS.DEFAULT_TIMEOUT_MS;
+      return await runApeShell(a.cmd, timeout);
+    }
+  }
+];
+
+// src/lib/agent-tools/file.ts
+import { mkdirSync, readFileSync, writeFileSync } from "fs";
+import { homedir } from "os";
+import { dirname, normalize, resolve } from "path";
+var MAX_BYTES = 1024 * 1024;
+function jailPath(input) {
+  if (typeof input !== "string" || input === "") {
+    throw new Error("path must be a non-empty string");
+  }
+  const home = homedir();
+  const candidate = input.startsWith("~/") ? resolve(home, input.slice(2)) : input.startsWith("/") ? normalize(input) : resolve(home, input);
+  if (candidate !== home && !candidate.startsWith(`${home}/`)) {
+    throw new Error(`path "${input}" resolves outside the agent's home`);
+  }
+  return candidate;
+}
+var fileTools = [
+  {
+    name: "file.read",
+    description: "Read a UTF-8 file from the agent's home directory ($HOME). Capped at 1MB. Path traversal blocked.",
+    parameters: {
+      type: "object",
+      properties: {
+        path: { type: "string", description: "Path relative to $HOME (or absolute under $HOME). `..` segments are rejected." }
+      },
+      required: ["path"]
+    },
+    execute: async (args) => {
+      const a = args;
+      const p = jailPath(a.path);
+      const content = readFileSync(p, "utf8");
+      if (Buffer.byteLength(content, "utf8") > MAX_BYTES) {
+        return { path: p, truncated: true, content: content.slice(0, MAX_BYTES) };
+      }
+      return { path: p, truncated: false, content };
+    }
+  },
+  {
+    name: "file.write",
+    description: "Write a UTF-8 file under the agent's home directory. Creates parent dirs as needed. 1MB max.",
+    parameters: {
+      type: "object",
+      properties: {
+        path: { type: "string", description: "Path relative to $HOME (or absolute under $HOME)." },
+        content: { type: "string", description: "File body. Existing files are overwritten." }
+      },
+      required: ["path", "content"]
+    },
+    execute: async (args) => {
+      const a = args;
+      if (typeof a.content !== "string") throw new Error("content must be a string");
+      if (Buffer.byteLength(a.content, "utf8") > MAX_BYTES) {
+        throw new Error(`content exceeds ${MAX_BYTES} byte cap`);
+      }
+      const p = jailPath(a.path);
+      mkdirSync(dirname(p), { recursive: true });
+      writeFileSync(p, a.content, { encoding: "utf8" });
+      return { path: p, bytes: Buffer.byteLength(a.content, "utf8") };
+    }
+  },
+  {
+    name: "file.edit",
+    description: "Replace an exact substring in a file under the agent's home directory. Prefer this over file.write for edits \u2014 it touches only the changed region instead of rewriting the whole file. `old_string` must appear exactly once unless `replace_all` is true. Path traversal blocked, 1MB max.",
+    parameters: {
+      type: "object",
+      properties: {
+        path: { type: "string", description: "Path relative to $HOME (or absolute under $HOME)." },
+        old_string: { type: "string", description: "Exact text to replace. Include enough surrounding context to be unique unless replace_all is set." },
+        new_string: { type: "string", description: "Replacement text. Must differ from old_string." },
+        replace_all: { type: "boolean", description: "Replace every occurrence instead of requiring a unique match. Default false." }
+      },
+      required: ["path", "old_string", "new_string"]
+    },
+    execute: async (args) => {
+      const a = args;
+      if (typeof a.old_string !== "string" || a.old_string === "") {
+        throw new Error("old_string must be a non-empty string");
+      }
+      if (typeof a.new_string !== "string") {
+        throw new TypeError("new_string must be a string");
+      }
+      if (a.old_string === a.new_string) {
+        throw new Error("old_string and new_string are identical \u2014 nothing to change");
+      }
+      const replaceAll = a.replace_all === true;
+      const p = jailPath(a.path);
+      const before = readFileSync(p, "utf8");
+      const occurrences = before.split(a.old_string).length - 1;
+      if (occurrences === 0) {
+        throw new Error("old_string not found in file");
+      }
+      if (occurrences > 1 && !replaceAll) {
+        throw new Error(`old_string occurs ${occurrences} times \u2014 pass replace_all:true or add surrounding context to make it unique`);
+      }
+      const after = replaceAll ? before.split(a.old_string).join(a.new_string) : before.replace(a.old_string, a.new_string);
+      if (Buffer.byteLength(after, "utf8") > MAX_BYTES) {
+        throw new Error(`result exceeds ${MAX_BYTES} byte cap`);
+      }
+      writeFileSync(p, after, { encoding: "utf8" });
+      return { path: p, replacements: replaceAll ? occurrences : 1 };
+    }
+  }
+];
+
+// src/lib/coding/forge.ts
+var BRANCH_RE = /^[\w./-]{1,200}$/;
+var ID_RE = /^\d{1,12}$/;
+function shq(s) {
+  return `'${String(s).replace(/'/g, "'\\''")}'`;
+}
+function assertBranch(v) {
+  if (typeof v !== "string" || !BRANCH_RE.test(v)) {
+    throw new Error("branch must match ^[A-Za-z0-9._/-]{1,200}$");
+  }
+  return v;
+}
+function assertId(v) {
+  if (typeof v !== "string" && typeof v !== "number") throw new Error("id required");
+  const s = String(v);
+  if (!ID_RE.test(s)) throw new Error("id must be a number");
+  return s;
+}
+var githubAdapter = {
+  id: "github",
+  matchesRemote: (url) => /github\.com/i.test(url),
+  prCreate: (i) => {
+    const head = assertBranch(i.head);
+    const parts = ["gh", "pr", "create", "--title", shq(i.title), "--body", shq(i.body), "--head", shq(head)];
+    if (i.base !== void 0) parts.push("--base", shq(assertBranch(i.base)));
+    return parts.join(" ");
+  },
+  prMerge: (i) => {
+    const ref = String(i.ref);
+    const refTok = ID_RE.test(ref) ? ref : assertBranch(ref);
+    const parts = ["gh", "pr", "merge", shq(refTok)];
+    if (i.squash === true) parts.push("--squash");
+    if (i.auto) parts.push("--auto");
+    if (i.deleteBranch) parts.push("--delete-branch");
+    return parts.join(" ");
+  },
+  prStatus: (ref) => {
+    const r = String(ref);
+    const refTok = ID_RE.test(r) ? r : assertBranch(r);
+    return `gh pr view ${shq(refTok)} --json state,mergeStateStatus,statusCheckRollup,reviewDecision`;
+  },
+  issueGet: (ref) => `gh issue view ${assertId(ref)} --json number,title,body,labels`
+};
+var azureAdapter = {
+  id: "azure",
+  matchesRemote: (url) => /dev\.azure\.com|visualstudio\.com/i.test(url),
+  prCreate: (i) => {
+    const head = assertBranch(i.head);
+    const parts = ["az", "repos", "pr", "create", "--title", shq(i.title), "--description", shq(i.body), "--source-branch", shq(head)];
+    if (i.base !== void 0) parts.push("--target-branch", shq(assertBranch(i.base)));
+    return parts.join(" ");
+  },
+  prMerge: (i) => {
+    const id = assertId(i.ref);
+    const parts = ["az", "repos", "pr", "update", "--id", id];
+    if (i.auto) parts.push("--auto-complete", "true");
+    else parts.push("--status", "completed");
+    if (i.squash === true) parts.push("--merge-commit-message-style", "squash");
+    if (i.deleteBranch) parts.push("--delete-source-branch", "true");
+    return parts.join(" ");
+  },
+  prStatus: (ref) => `az repos pr show --id ${assertId(ref)}`,
+  issueGet: (ref) => `az boards work-item show --id ${assertId(ref)}`
+};
+var registry = /* @__PURE__ */ new Map([
+  [githubAdapter.id, githubAdapter],
+  [azureAdapter.id, azureAdapter]
+]);
+function listForges() {
+  return [...registry.keys()];
+}
+function getForge(id) {
+  const a = registry.get(id);
+  if (!a) {
+    throw new Error(`unknown forge '${id}'. Registered: ${listForges().join(", ")}. Add one with registerForge().`);
+  }
+  return a;
+}
+function detectForge(remoteUrl) {
+  if (typeof remoteUrl !== "string" || remoteUrl === "") {
+    throw new Error("remote URL required to detect forge");
+  }
+  for (const a of registry.values()) {
+    if (a.matchesRemote(remoteUrl)) return a.id;
+  }
+  throw new Error(`no forge adapter matches remote: ${remoteUrl}. Registered: ${listForges().join(", ")}. Register one with registerForge() (e.g. GitLab/Bitbucket/Gitea).`);
+}
+function buildPrCreate(input) {
+  return getForge(input.forge).prCreate(input);
+}
+function buildPrMerge(input) {
+  return getForge(input.forge).prMerge(input);
+}
+function buildPrStatus(forge, ref) {
+  return getForge(forge).prStatus(ref);
+}
+function buildIssueGet(forge, ref) {
+  return getForge(forge).issueGet(ref);
+}
+
+// src/lib/agent-tools/forge.ts
+function resolveForge(a) {
+  if (typeof a.forge === "string" && a.forge !== "") return a.forge;
+  if (typeof a.remote === "string") return detectForge(a.remote);
+  throw new Error("provide a forge id (e.g. github, azure, or a registered adapter) or a remote URL to detect it");
+}
+var forgeParam = { type: "string", description: "Target forge id (github, azure, or a registered adapter). Omit to auto-detect from `remote`." };
+var remoteParam = { type: "string", description: "git remote URL \u2014 used to auto-detect the forge when `forge` is omitted." };
+var forgeTools = [
+  {
+    name: "forge.pr.create",
+    description: "Open a pull request on GitHub (gh) or Azure DevOps (az). Gated via the DDISA grant cycle. Provider chosen by `forge` or auto-detected from `remote`.",
+    parameters: {
+      type: "object",
+      properties: {
+        forge: forgeParam,
+        remote: remoteParam,
+        title: { type: "string", description: "PR title." },
+        body: { type: "string", description: "PR description / body." },
+        head: { type: "string", description: "Source branch." },
+        base: { type: "string", description: "Target branch. Omit for the repo default." }
+      },
+      required: ["title", "body", "head"]
+    },
+    execute: async (args) => {
+      const a = args;
+      const cmd = buildPrCreate({ forge: resolveForge(a), title: a.title, body: a.body, head: a.head, base: a.base });
+      return await runApeShell(cmd);
+    }
+  },
+  {
+    name: "forge.pr.merge",
+    description: 'Merge a PR \u2014 or with auto=true, arm "merge when checks pass" (gh --auto / az auto-complete) so the platform merges only on green CI. Gated. Never bypasses required checks (branch protection is the server-side gate).',
+    parameters: {
+      type: "object",
+      properties: {
+        forge: forgeParam,
+        remote: remoteParam,
+        ref: { type: "string", description: "GitHub: PR number or branch. Azure: PR id." },
+        auto: { type: "boolean", description: "Arm merge-when-green instead of immediate merge. Recommended." },
+        squash: { type: "boolean", description: "Squash-merge. Default true." },
+        delete_branch: { type: "boolean", description: "Delete the source branch after merge." }
+      },
+      required: ["ref"]
+    },
+    execute: async (args) => {
+      const a = args;
+      const cmd = buildPrMerge({ forge: resolveForge(a), ref: a.ref, auto: a.auto, squash: a.squash, deleteBranch: a.delete_branch });
+      return await runApeShell(cmd);
+    }
+  },
+  {
+    name: "forge.pr.status",
+    description: "Fetch a PR's state + checks + review decision. Gated (read).",
+    parameters: {
+      type: "object",
+      properties: { forge: forgeParam, remote: remoteParam, ref: { type: "string", description: "PR number/branch (GitHub) or id (Azure)." } },
+      required: ["ref"]
+    },
+    execute: async (args) => {
+      const a = args;
+      return await runApeShell(buildPrStatus(resolveForge(a), a.ref));
+    }
+  },
+  {
+    name: "forge.issue.get",
+    description: "Fetch an issue (GitHub) or work-item (Azure) \u2014 title, body, labels. Gated (read). Use to turn an assigned task into a coding run.",
+    parameters: {
+      type: "object",
+      properties: { forge: forgeParam, remote: remoteParam, ref: { type: "string", description: "Issue number (GitHub) or work-item id (Azure)." } },
+      required: ["ref"]
+    },
+    execute: async (args) => {
+      const a = args;
+      return await runApeShell(buildIssueGet(resolveForge(a), a.ref));
+    }
+  }
+];
+
+// src/lib/agent-tools/git-worktree.ts
+import { homedir as homedir2 } from "os";
+import { resolve as resolve2 } from "path";
+import process2 from "process";
+function jailedRoot(envVar, fallbackName) {
+  const home = homedir2();
+  const raw = process2.env[envVar];
+  const dir = raw ? resolve2(raw) : resolve2(home, fallbackName);
+  if (dir !== home && !dir.startsWith(`${home}/`)) {
+    throw new Error(`${envVar} (${dir}) must resolve inside the agent's home`);
+  }
+  return dir;
+}
+function workRoot() {
+  return jailedRoot("OPENAPE_CODING_WORK_DIR", "work");
+}
+function reposRoot() {
+  return jailedRoot("OPENAPE_CODING_REPOS_DIR", "repos");
+}
+var TASK_ID_RE = /^[\w.-]{1,64}$/;
+var BRANCH_RE2 = /^[\w./-]{1,128}$/;
+var URL_RE = /^(?:https:\/\/|git@)[\w@:/.-]{3,256}$/;
+function assertTaskId(v) {
+  if (typeof v !== "string" || !TASK_ID_RE.test(v)) {
+    throw new Error("task_id must match ^[a-zA-Z0-9._-]{1,64}$");
+  }
+  return v;
+}
+function assertBranch2(v) {
+  if (typeof v !== "string" || !BRANCH_RE2.test(v)) {
+    throw new Error("branch must match ^[A-Za-z0-9._/-]{1,128}$");
+  }
+  return v;
+}
+function resolveRepo(repo) {
+  if (typeof repo !== "string" || repo === "") {
+    throw new Error("repo must be a non-empty string (URL or path under $HOME)");
+  }
+  const home = homedir2();
+  if (URL_RE.test(repo)) {
+    const tail = repo.replace(/\.git$/, "").replace(/[/:]+$/, "");
+    const parts = tail.split(/[/:]/).filter(Boolean).slice(-2);
+    const base = parts.join("-").replace(/[^\w.-]/g, "");
+    if (!base) throw new Error("could not derive a clone name from repo URL");
+    return { source: repo, baseDir: resolve2(reposRoot(), base), isUrl: true };
+  }
+  const candidate = repo.startsWith("~/") ? resolve2(home, repo.slice(2)) : resolve2(home, repo);
+  if (candidate !== home && !candidate.startsWith(`${home}/`)) {
+    throw new Error(`repo path "${repo}" resolves outside the agent's home`);
+  }
+  return { source: candidate, baseDir: candidate, isUrl: false };
+}
+function worktreePathFor(taskId) {
+  return resolve2(workRoot(), assertTaskId(taskId));
+}
+var q = (s) => `'${s}'`;
+function buildCreateCommand(repo, taskId, branch) {
+  const id = assertTaskId(taskId);
+  const br = assertBranch2(branch);
+  const { source, baseDir, isUrl } = resolveRepo(repo);
+  const wt = worktreePathFor(id);
+  const clone = isUrl ? `if [ ! -d ${q(baseDir)}/.git ]; then git clone ${q(source)} ${q(baseDir)}; fi` : `test -d ${q(baseDir)}/.git`;
+  return [
+    `mkdir -p ${q(reposRoot())} ${q(workRoot())}`,
+    clone,
+    `git -C ${q(baseDir)} fetch --quiet || true`,
+    `git -C ${q(baseDir)} worktree add -b ${q(br)} ${q(wt)}`,
+    `echo ${q(wt)}`
+  ].join(" && ");
+}
+function buildRemoveCommand(repo, taskId) {
+  const id = assertTaskId(taskId);
+  const { baseDir } = resolveRepo(repo);
+  const wt = worktreePathFor(id);
+  return `git -C ${q(baseDir)} worktree remove --force ${q(wt)} && git -C ${q(baseDir)} worktree prune`;
+}
+function buildListCommand() {
+  return `ls -1 ${q(workRoot())} 2>/dev/null || true`;
+}
+var gitWorktreeTools = [
+  {
+    name: "git.worktree",
+    description: "Manage isolated git worktrees for coding tasks. action=create clones the repo (cached under ~/repos) and adds a fresh worktree under ~/work/<task_id> on a new branch. action=remove tears it down. action=list shows current task worktrees. Git operations go through the DDISA grant cycle (git-shape).",
+    parameters: {
+      type: "object",
+      properties: {
+        action: { type: "string", enum: ["create", "remove", "list"], description: "create | remove | list" },
+        repo: { type: "string", description: "For create/remove: git remote URL (https/git@) or a path under $HOME to an existing clone." },
+        task_id: { type: "string", description: "For create/remove: identifier for the worktree, ^[a-zA-Z0-9._-]{1,64}$. The worktree lands at ~/work/<task_id>." },
+        branch: { type: "string", description: "For create: new branch name, ^[A-Za-z0-9._/-]{1,128}$." }
+      },
+      required: ["action"]
+    },
+    execute: async (args) => {
+      const a = args;
+      let cmd;
+      if (a.action === "create") {
+        if (typeof a.branch !== "string") throw new Error("branch is required for action=create");
+        cmd = buildCreateCommand(a.repo, assertTaskId(a.task_id), a.branch);
+      } else if (a.action === "remove") {
+        cmd = buildRemoveCommand(a.repo, assertTaskId(a.task_id));
+      } else if (a.action === "list") {
+        cmd = buildListCommand();
+      } else {
+        throw new Error("action must be one of: create, remove, list");
+      }
+      const res = await runApeShell(cmd);
+      return {
+        action: a.action,
+        ...a.action !== "list" ? { worktree: worktreePathFor(assertTaskId(a.task_id)) } : {},
+        stdout: res.stdout,
+        stderr: res.stderr,
+        exit_code: res.exit_code,
+        ...res.error ? { error: res.error, hint: res.hint } : {}
+      };
+    }
+  }
+];
+
+// src/lib/agent-tools/http.ts
+var MAX_BYTES2 = 1024 * 1024;
+var FORBIDDEN_HEADERS = /* @__PURE__ */ new Set([
+  "host",
+  "authorization",
+  "cookie",
+  "connection",
+  "transfer-encoding",
+  "upgrade",
+  "proxy-authorization"
+]);
+function sanitizeHeaders(input) {
+  if (!input || typeof input !== "object") return {};
+  const out = {};
+  for (const [k, v] of Object.entries(input)) {
+    if (typeof v !== "string") continue;
+    if (FORBIDDEN_HEADERS.has(k.toLowerCase())) continue;
+    out[k] = v;
+  }
+  return out;
+}
+async function readCappedBody(res) {
+  const buf = new Uint8Array(MAX_BYTES2 + 1);
+  let written = 0;
+  const reader = res.body?.getReader();
+  if (!reader) return await res.text();
+  while (true) {
+    const { value, done } = await reader.read();
+    if (done) break;
+    if (written + value.byteLength > MAX_BYTES2) {
+      buf.set(value.subarray(0, MAX_BYTES2 - written), written);
+      written = MAX_BYTES2;
+      try {
+        await reader.cancel();
+      } catch {
+      }
+      break;
+    }
+    buf.set(value, written);
+    written += value.byteLength;
+  }
+  return new TextDecoder().decode(buf.subarray(0, written));
+}
+var httpTools = [
+  {
+    name: "http.get",
+    description: "GET an HTTPS URL and return the response body (capped at 1MB). Useful for reading public APIs, RSS feeds, web pages.",
+    parameters: {
+      type: "object",
+      properties: {
+        url: { type: "string", description: "Absolute HTTPS URL." },
+        headers: { type: "object", description: "Optional headers (Host, Authorization, Cookie are stripped)." }
+      },
+      required: ["url"]
+    },
+    execute: async (args) => {
+      const a = args;
+      if (typeof a.url !== "string" || !a.url.startsWith("http")) {
+        throw new Error("url must be an http(s) URL");
+      }
+      const res = await fetch(a.url, { method: "GET", headers: sanitizeHeaders(a.headers) });
+      const body = await readCappedBody(res);
+      return { status: res.status, headers: Object.fromEntries(res.headers), body };
+    }
+  },
+  {
+    name: "http.post",
+    description: "POST JSON to an HTTPS URL and return the response body (capped at 1MB).",
+    parameters: {
+      type: "object",
+      properties: {
+        url: { type: "string", description: "Absolute HTTPS URL." },
+        body: { description: "JSON-serialisable payload." },
+        headers: { type: "object", description: "Optional headers (Host, Authorization, Cookie are stripped)." }
+      },
+      required: ["url", "body"]
+    },
+    execute: async (args) => {
+      const a = args;
+      if (typeof a.url !== "string" || !a.url.startsWith("http")) {
+        throw new Error("url must be an http(s) URL");
+      }
+      const res = await fetch(a.url, {
+        method: "POST",
+        headers: { "content-type": "application/json", ...sanitizeHeaders(a.headers) },
+        body: JSON.stringify(a.body)
+      });
+      const body = await readCappedBody(res);
+      return { status: res.status, headers: Object.fromEntries(res.headers), body };
+    }
+  }
+];
+
+// src/lib/agent-tools/mail.ts
+import { execFileSync } from "child_process";
+function o365(args) {
+  try {
+    return execFileSync("o365-cli", args, { encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] });
+  } catch (err) {
+    const e = err;
+    if (e.code === "ENOENT") {
+      throw new Error("o365-cli is not installed on this agent host");
+    }
+    const stderr = typeof e.stderr === "string" ? e.stderr : e.stderr?.toString("utf8");
+    throw new Error(`o365-cli failed: ${stderr ?? e.message ?? err}`);
+  }
+}
+var mailTools = [
+  {
+    name: "mail.list",
+    description: "List recent inbox messages via o365-cli. Optional `unread_only` and `limit`.",
+    parameters: {
+      type: "object",
+      properties: {
+        limit: { type: "integer", minimum: 1, maximum: 100, default: 20 },
+        unread_only: { type: "boolean", default: false }
+      },
+      required: []
+    },
+    execute: async (args) => {
+      const a = args ?? {};
+      const argv = ["mail", "list", "--json", "--limit", String(a.limit ?? 20)];
+      if (a.unread_only) argv.push("--unread");
+      const out = o365(argv);
+      try {
+        return JSON.parse(out);
+      } catch {
+        return { raw: out };
+      }
+    }
+  },
+  {
+    name: "mail.search",
+    description: "Search the inbox via o365-cli using a free-form query string.",
+    parameters: {
+      type: "object",
+      properties: {
+        q: { type: "string" },
+        limit: { type: "integer", minimum: 1, maximum: 100, default: 20 }
+      },
+      required: ["q"]
+    },
+    execute: async (args) => {
+      const a = args;
+      if (typeof a.q !== "string" || a.q.length === 0) throw new Error("q is required");
+      const argv = ["mail", "search", a.q, "--json", "--limit", String(a.limit ?? 20)];
+      const out = o365(argv);
+      try {
+        return JSON.parse(out);
+      } catch {
+        return { raw: out };
+      }
+    }
+  }
+];
+
+// src/lib/agent-tools/tasks.ts
+import { execFileSync as execFileSync2 } from "child_process";
+function ape(args) {
+  try {
+    return execFileSync2("ape-tasks", args, { encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] });
+  } catch (err) {
+    const e = err;
+    const stderr = typeof e.stderr === "string" ? e.stderr : e.stderr?.toString("utf8");
+    throw new Error(`ape-tasks failed: ${stderr ?? e.message ?? err}`);
+  }
+}
+var tasksTools = [
+  {
+    name: "tasks.list",
+    description: "List the owner's open ape-tasks (the user's personal task list at tasks.openape.ai).",
+    parameters: {
+      type: "object",
+      properties: {
+        status: { type: "string", enum: ["open", "doing", "done", "archived"] },
+        team_id: { type: "string" }
+      },
+      required: []
+    },
+    execute: async (args) => {
+      const a = args ?? {};
+      const argv = ["list", "--json"];
+      if (a.status) argv.push("--status", a.status);
+      if (a.team_id) argv.push("--team", a.team_id);
+      const out = ape(argv);
+      try {
+        return JSON.parse(out);
+      } catch {
+        return { raw: out };
+      }
+    }
+  },
+  {
+    name: "tasks.create",
+    description: "Create a new ape-task on the owner's task list at tasks.openape.ai.",
+    parameters: {
+      type: "object",
+      properties: {
+        title: { type: "string" },
+        notes: { type: "string" },
+        priority: { type: "string", enum: ["low", "med", "high"] },
+        due_at: { type: "string", description: "ISO date or +Nh/+Nd shorthand." }
+      },
+      required: ["title"]
+    },
+    execute: async (args) => {
+      const a = args;
+      const argv = ["new", "--title", a.title, "--json"];
+      if (a.notes) argv.push("--notes", a.notes);
+      if (a.priority) argv.push("--priority", a.priority);
+      if (a.due_at) argv.push("--due", a.due_at);
+      const out = ape(argv);
+      try {
+        return JSON.parse(out);
+      } catch {
+        return { raw: out };
+      }
+    }
+  }
+];
+
+// src/lib/agent-tools/time.ts
+var timeTools = [
+  {
+    name: "time.now",
+    description: "Returns the current UTC date and time as ISO 8601 plus epoch seconds. No inputs.",
+    parameters: { type: "object", properties: {}, required: [] },
+    execute: async () => {
+      const now = /* @__PURE__ */ new Date();
+      return {
+        iso: now.toISOString(),
+        epoch_seconds: Math.floor(now.getTime() / 1e3),
+        timezone_offset_minutes: -now.getTimezoneOffset()
+      };
+    }
+  }
+];
+
+// src/lib/coding/verify.ts
+var CWD_RE = /^[\w./-]{1,256}$/;
+async function runVerify(cwd, command, timeoutMs) {
+  if (typeof cwd !== "string" || !CWD_RE.test(cwd)) {
+    throw new Error("cwd must match ^[A-Za-z0-9._/-]{1,256}$");
+  }
+  if (typeof command !== "string" || command.trim() === "") {
+    throw new Error("verify command must be a non-empty string");
+  }
+  const res = await runApeShell(`cd '${cwd}' && ${command}`, timeoutMs);
+  return {
+    passed: res.exit_code === 0,
+    exit_code: res.exit_code,
+    stdout: res.stdout,
+    stderr: res.stderr,
+    ...res.timed_out ? { timed_out: true } : {}
+  };
+}
+
+// src/lib/agent-tools/verify.ts
+var verifyTools = [
+  {
+    name: "verify",
+    description: "Run the verification command (tests/build/lint) in a worktree and report pass/fail. The coding loop must NOT open or merge a PR when this fails. Runs through the DDISA grant cycle (same as bash). Returns { passed, exit_code, stdout, stderr }.",
+    parameters: {
+      type: "object",
+      properties: {
+        cwd: { type: "string", description: "Worktree path to run in (e.g. ~/work/issue-42)." },
+        command: { type: "string", description: "Verification command, e.g. `pnpm test` or `npm run build && npm test`." },
+        timeout_ms: { type: "number", description: "Wall-clock cap incl. approval wait. Default 300000." }
+      },
+      required: ["cwd", "command"]
+    },
+    execute: async (args) => {
+      const a = args;
+      const timeout = typeof a.timeout_ms === "number" && a.timeout_ms > 0 ? a.timeout_ms : void 0;
+      return await runVerify(a.cwd, a.command, timeout);
+    }
+  }
+];
+
+// src/lib/agent-tools/index.ts
+var ALL_TOOLS = [
+  ...timeTools,
+  ...httpTools,
+  ...fileTools,
+  ...tasksTools,
+  ...mailTools,
+  ...bashTools,
+  ...gitWorktreeTools,
+  ...verifyTools,
+  ...forgeTools
+];
+var TOOLS = Object.fromEntries(
+  ALL_TOOLS.map((t) => [t.name, t])
+);
+function taskTools(names) {
+  const out = [];
+  const missing = [];
+  for (const name of names) {
+    const tool = TOOLS[name];
+    if (!tool) missing.push(name);
+    else out.push(tool);
+  }
+  if (missing.length > 0) {
+    throw new Error(`unknown tool(s): ${missing.join(", ")}`);
+  }
+  return out;
+}
+function asOpenAiTools(tools) {
+  return tools.map((t) => ({
+    type: "function",
+    function: { name: wireToolName(t.name), description: t.description, parameters: t.parameters }
+  }));
+}
+function wireToolName(local) {
+  return local.replace(/\./g, "_");
+}
+function localToolName(wire) {
+  for (const t of Object.values(TOOLS)) {
+    if (wireToolName(t.name) === wire) return t.name;
+  }
+  return wire;
+}
+
+// src/lib/agent-runtime.ts
+function previewJson(value, max = 500) {
+  let s;
+  try {
+    s = JSON.stringify(value);
+  } catch {
+    s = String(value);
+  }
+  return s.length > max ? `${s.slice(0, max)}\u2026` : s;
+}
+async function runLoop(opts) {
+  const fetchFn = opts.fetchImpl ?? fetch;
+  const trace = [];
+  const messages = [
+    { role: "system", content: opts.systemPrompt },
+    ...opts.history ?? [],
+    { role: "user", content: opts.userMessage }
+  ];
+  const tools = asOpenAiTools(opts.tools);
+  for (let step = 1; step <= opts.maxSteps; step++) {
+    const res = await fetchFn(`${opts.config.apiBase}/chat/completions`, {
+      method: "POST",
+      headers: {
+        "authorization": `Bearer ${opts.config.apiKey}`,
+        "content-type": "application/json"
+      },
+      body: JSON.stringify({
+        model: opts.config.model,
+        messages,
+        ...tools.length > 0 ? { tools, tool_choice: "auto" } : {}
+      })
+    });
+    if (!res.ok) {
+      const text = await res.text().catch(() => "");
+      throw new Error(`LiteLLM ${res.status}: ${text.slice(0, 500)}`);
+    }
+    const data = await res.json();
+    const choice = data.choices?.[0];
+    if (!choice) throw new Error("LiteLLM response had no choices");
+    const assistant = choice.message;
+    messages.push(assistant);
+    if (assistant.content) opts.handlers?.onTextDelta?.(assistant.content);
+    trace.push({
+      step,
+      type: "assistant",
+      preview: previewJson({ content: assistant.content, tool_calls: assistant.tool_calls?.length ?? 0 })
+    });
+    if (!assistant.tool_calls || assistant.tool_calls.length === 0) {
+      const result2 = {
+        status: "ok",
+        finalMessage: assistant.content,
+        stepCount: step,
+        trace
+      };
+      opts.handlers?.onDone?.(result2);
+      return result2;
+    }
+    for (const call of assistant.tool_calls) {
+      const wireName = call.function.name;
+      const localName = localToolName(wireName);
+      const tool = opts.tools.find((t) => t.name === localName);
+      let parsedArgs;
+      try {
+        parsedArgs = JSON.parse(call.function.arguments);
+      } catch {
+        parsedArgs = {};
+      }
+      opts.handlers?.onToolCall?.({ name: localName, args: parsedArgs });
+      trace.push({ step, type: "tool_call", tool: localName, preview: previewJson(parsedArgs) });
+      let result2;
+      let isError = false;
+      if (!tool) {
+        result2 = `unknown tool: ${localName}`;
+        isError = true;
+      } else {
+        try {
+          result2 = await tool.execute(parsedArgs);
+        } catch (err) {
+          result2 = err?.message ?? String(err);
+          isError = true;
+        }
+      }
+      if (isError) {
+        opts.handlers?.onToolError?.({ name: localName, error: String(result2) });
+        trace.push({ step, type: "tool_error", tool: localName, preview: previewJson(result2) });
+      } else {
+        opts.handlers?.onToolResult?.({ name: localName, result: result2 });
+        trace.push({ step, type: "tool_result", tool: localName, preview: previewJson(result2) });
+      }
+      messages.push({
+        role: "tool",
+        tool_call_id: call.id,
+        name: wireToolName(localName),
+        content: typeof result2 === "string" ? result2 : JSON.stringify(result2)
+      });
+    }
+  }
+  const result = {
+    status: "error",
+    finalMessage: `max_steps (${opts.maxSteps}) reached without completion`,
+    stepCount: opts.maxSteps,
+    trace
+  };
+  opts.handlers?.onDone?.(result);
+  return result;
+}
+var RPC_SESSION_TTL_MS = 60 * 60 * 1e3;
+var RpcSessionMap = class {
+  sessions = /* @__PURE__ */ new Map();
+  get(id) {
+    const s = this.sessions.get(id);
+    if (s) s.lastTouched = Date.now();
+    return s;
+  }
+  put(id, s) {
+    s.lastTouched = Date.now();
+    this.sessions.set(id, s);
+  }
+  evictStale() {
+    const cutoff = Date.now() - RPC_SESSION_TTL_MS;
+    for (const [k, v] of this.sessions) {
+      if (v.lastTouched < cutoff) this.sessions.delete(k);
+    }
+  }
+  size() {
+    return this.sessions.size;
+  }
+};
+
+export {
+  CliError,
+  CliExit,
+  parseDuration,
+  TOOLS,
+  taskTools,
+  runLoop,
+  RpcSessionMap
+};
+//# sourceMappingURL=chunk-VHZEVW2N.js.map