@bunny-agent/runner-cli 0.9.57 → 0.9.58

package/README.md

@@ -18,12 +18,13 @@ runner-cli → runner-* (direct, NO dependencies on manager or sandbox)
              ├─ runner-claude ✅
              ├─ runner-codex ✅
              ├─ runner-gemini ✅
-             └─ runner-copilot 🚧
+             └─ runner-copilot ✅
 
 Dependencies:
 ✅ @bunny-agent/runner-claude (runtime)
 ✅ @bunny-agent/runner-codex (runtime)
 ✅ @bunny-agent/runner-gemini (runtime)
+✅ @bunny-agent/runner-copilot (runtime)
 ❌ NO @bunny-agent/manager
 ❌ NO @bunny-agent/sandbox-*
 ```
@@ -69,7 +70,7 @@ bunny-agent run --runner codex -- "Build a REST API with Express"
 # Using Gemini
 bunny-agent run --runner gemini -- "Build a REST API with Express"
 
-# Using GitHub Copilot (when implemented)
+# Using GitHub Copilot
 bunny-agent run --runner copilot -- "Refactor this code"
 
 # With custom system prompt
@@ -86,7 +87,9 @@ bunny-agent run --runner claude --system-prompt "You are a coding assistant" --
 | `--system-prompt <prompt>` | `-s` | Custom system prompt | - |
 | `--max-turns <n>` | `-t` | Maximum conversation turns | - |
 | `--allowed-tools <tools>` | `-a` | Comma-separated list of allowed tools | - |
-| `--resume <session-id>` | `-r` | Resume a previous session | - |
+| `--yolo` | - | Automatically approve tool permission requests | `false` |
+| `--effort <level>` | - | Reasoning effort or thinking level, depending on runner | - |
+| `--resume <session-id>` | - | Resume a previous session | - |
 | `--help` | `-h` | Show help message | - |
 
 `--allowed-tools` limits built-in runner tools. Custom tools are provided
@@ -114,6 +117,7 @@ data: [DONE]
 | `ANTHROPIC_API_KEY` | Anthropic API key (Claude runner) | No |
 | `OPENAI_API_KEY` or `CODEX_API_KEY` | OpenAI API key (Codex runner) | No |
 | `GEMINI_API_KEY` | Gemini API key (Gemini runner) | No |
+| `GITHUB_TOKEN` or `GH_TOKEN` | GitHub token (Copilot runner); falls back to the logged-in Copilot user | No |
 | `BUNNY_AGENT_WORKSPACE` | Default workspace path | No |
 | `BUNNY_AGENT_LOG_LEVEL` | Logging level (debug, info, warn, error) | No |
 

package/dist/apply-patch-bin.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Bundle entry for the standalone `apply_patch` shell command. esbuild
+ * builds this into the self-contained `dist/apply-patch-bin.js` that the
+ * sandbox image wires up as /usr/local/bin/apply_patch and that the pi
+ * runner's PATH shim execs (see @bunny-agent/runner-pi's
+ * apply-patch-shim.ts). The imported module runs the CLI on import.
+ */
+import "@bunny-agent/apply-patch/bin";
+//# sourceMappingURL=apply-patch-bin.d.ts.map

package/dist/apply-patch-bin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"apply-patch-bin.d.ts","sourceRoot":"","sources":["../src/apply-patch-bin.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,OAAO,8BAA8B,CAAC"}

package/dist/apply-patch-bin.js

@@ -0,0 +1,237 @@
+// ../../packages/apply-patch/dist/bin.js
+import { readFileSync as readFileSync2 } from "node:fs";
+
+// ../../packages/apply-patch/dist/core.js
+import { existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+var BEGIN_PATCH = "*** Begin Patch";
+var END_PATCH = "*** End Patch";
+var UPDATE_FILE = "*** Update File: ";
+var ADD_FILE = "*** Add File: ";
+var DELETE_FILE = "*** Delete File: ";
+var MOVE_TO = "*** Move to: ";
+var HUNK_MARKER = "@@";
+var EOF_MARKER = "*** End of File";
+var PatchParseError = class extends Error {
+};
+function isSectionMarker(line) {
+  return line.startsWith(UPDATE_FILE) || line.startsWith(ADD_FILE) || line.startsWith(DELETE_FILE) || line.trim() === END_PATCH;
+}
+function parseUpdateHunks(lines, start) {
+  const hunks = [];
+  let i = start;
+  let current = null;
+  const flush = () => {
+    if (current && (current.before.length > 0 || current.after.length > 0)) {
+      hunks.push(current);
+    }
+    current = null;
+  };
+  while (i < lines.length && !isSectionMarker(lines[i])) {
+    const line = lines[i];
+    if (line.startsWith(HUNK_MARKER)) {
+      flush();
+      current = { before: [], after: [] };
+      i++;
+      continue;
+    }
+    if (line.trim() === EOF_MARKER) {
+      i++;
+      continue;
+    }
+    if (current === null)
+      current = { before: [], after: [] };
+    if (line.startsWith("+")) {
+      current.after.push(line.slice(1));
+    } else if (line.startsWith("-")) {
+      current.before.push(line.slice(1));
+    } else if (line.startsWith(" ")) {
+      const content = line.slice(1);
+      current.before.push(content);
+      current.after.push(content);
+    } else if (line.trim() === "") {
+      current.before.push("");
+      current.after.push("");
+    } else {
+      throw new PatchParseError(`Malformed hunk line: ${line}`);
+    }
+    i++;
+  }
+  flush();
+  return { hunks, next: i };
+}
+function parsePatch(patchText) {
+  const lines = patchText.split("\n");
+  let i = 0;
+  while (i < lines.length && lines[i].trim() === "")
+    i++;
+  if (i < lines.length && lines[i].trim() === BEGIN_PATCH)
+    i++;
+  const ops = [];
+  while (i < lines.length) {
+    const line = lines[i];
+    if (line.trim() === END_PATCH || line.trim() === "") {
+      i++;
+      continue;
+    }
+    if (line.startsWith(UPDATE_FILE)) {
+      const path = line.slice(UPDATE_FILE.length).trim();
+      i++;
+      let moveTo;
+      if (lines[i]?.startsWith(MOVE_TO)) {
+        moveTo = lines[i].slice(MOVE_TO.length).trim();
+        i++;
+      }
+      const { hunks, next } = parseUpdateHunks(lines, i);
+      ops.push({ kind: "update", path, moveTo, hunks, addLines: [] });
+      i = next;
+      continue;
+    }
+    if (line.startsWith(ADD_FILE)) {
+      const path = line.slice(ADD_FILE.length).trim();
+      i++;
+      const addLines = [];
+      while (i < lines.length && !isSectionMarker(lines[i])) {
+        if (lines[i].startsWith("+"))
+          addLines.push(lines[i].slice(1));
+        else if (lines[i].trim() !== "") {
+          throw new PatchParseError(`Add File "${path}": expected "+"-prefixed content, got: ${lines[i]}`);
+        }
+        i++;
+      }
+      ops.push({ kind: "add", path, hunks: [], addLines });
+      continue;
+    }
+    if (line.startsWith(DELETE_FILE)) {
+      const path = line.slice(DELETE_FILE.length).trim();
+      i++;
+      ops.push({ kind: "delete", path, hunks: [], addLines: [] });
+      continue;
+    }
+    throw new PatchParseError(`Unexpected line in patch: ${line}`);
+  }
+  if (ops.length === 0) {
+    throw new PatchParseError("Patch contains no file operations (Update File / Add File / Delete File).");
+  }
+  return ops;
+}
+function findHunkStart(haystack, needle, from) {
+  if (needle.length === 0)
+    return from;
+  const canonicalizers = [
+    (s) => s,
+    (s) => s.replace(/\s+$/, ""),
+    (s) => s.trim()
+  ];
+  for (const canon of canonicalizers) {
+    const canonNeedle = needle.map(canon);
+    for (let start = from; start <= haystack.length - needle.length; start++) {
+      let matched = true;
+      for (let j = 0; j < needle.length; j++) {
+        if (canon(haystack[start + j]) !== canonNeedle[j]) {
+          matched = false;
+          break;
+        }
+      }
+      if (matched)
+        return start;
+    }
+  }
+  return -1;
+}
+function applyHunks(originalContent, hunks) {
+  const trailingNewline = originalContent.endsWith("\n");
+  const lines = originalContent.length === 0 ? [] : originalContent.split("\n");
+  if (trailingNewline)
+    lines.pop();
+  let cursor = 0;
+  const resultLines = [];
+  for (const hunk of hunks) {
+    const start = findHunkStart(lines, hunk.before, cursor);
+    if (start === -1) {
+      throw new PatchParseError(`Could not locate context for hunk:
+${hunk.before.join("\n")}`);
+    }
+    resultLines.push(...lines.slice(cursor, start));
+    resultLines.push(...hunk.after);
+    cursor = start + hunk.before.length;
+  }
+  resultLines.push(...lines.slice(cursor));
+  return resultLines.join("\n") + (trailingNewline ? "\n" : "");
+}
+function applyPatch(cwd, patchText) {
+  const ops = parsePatch(patchText);
+  const changedFiles = [];
+  const addedFiles = [];
+  const deletedFiles = [];
+  for (const op of ops) {
+    const target = resolve(cwd, op.path);
+    if (op.kind === "add") {
+      if (existsSync(target)) {
+        throw new PatchParseError(`Add File "${op.path}": file already exists.`);
+      }
+      mkdirSync(dirname(target), { recursive: true });
+      writeFileSync(target, `${op.addLines.join("\n")}
+`);
+      addedFiles.push(op.path);
+      continue;
+    }
+    if (op.kind === "delete") {
+      if (!existsSync(target)) {
+        throw new PatchParseError(`Delete File "${op.path}": file not found.`);
+      }
+      unlinkSync(target);
+      deletedFiles.push(op.path);
+      continue;
+    }
+    if (!existsSync(target)) {
+      throw new PatchParseError(`Update File "${op.path}": file not found.`);
+    }
+    const original = readFileSync(target, "utf8");
+    const updated = applyHunks(original, op.hunks);
+    if (op.moveTo) {
+      const destination = resolve(cwd, op.moveTo);
+      mkdirSync(dirname(destination), { recursive: true });
+      writeFileSync(destination, updated);
+      unlinkSync(target);
+    } else {
+      writeFileSync(target, updated);
+    }
+    changedFiles.push(op.moveTo ?? op.path);
+  }
+  return { changedFiles, addedFiles, deletedFiles };
+}
+function formatPatchResult(result) {
+  return [
+    ...result.addedFiles.map((f) => `A ${f}`),
+    ...result.changedFiles.map((f) => `M ${f}`),
+    ...result.deletedFiles.map((f) => `D ${f}`)
+  ].join("\n");
+}
+
+// ../../packages/apply-patch/dist/bin.js
+function readPatchText() {
+  const arg = process.argv[2];
+  if (arg !== void 0 && arg.trim() !== "")
+    return arg;
+  if (process.stdin.isTTY) {
+    process.stderr.write("usage: apply_patch '<patch>'  (or pipe the patch via stdin/heredoc)\n");
+    process.exit(2);
+  }
+  return readFileSync2(0, "utf8");
+}
+try {
+  const patchText = readPatchText();
+  if (patchText.trim() === "") {
+    throw new PatchParseError("Empty patch input.");
+  }
+  const result = applyPatch(process.cwd(), patchText);
+  const summary = formatPatchResult(result);
+  process.stdout.write(`${summary || "Patch applied."}
+`);
+} catch (e) {
+  const msg = e instanceof Error ? e.message : String(e);
+  process.stderr.write(`apply_patch: ${msg}
+`);
+  process.exit(1);
+}

package/dist/apply-patch-bin.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"apply-patch-bin.js","sourceRoot":"","sources":["../src/apply-patch-bin.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,OAAO,8BAA8B,CAAC"}