Job 16ead56c-5073-48a5-8c76-487737781b67

{"command": "cd /project && ls -la && git log --oneline -10 && git branch -a"}

total 64
drwxr-xr-x  6 user user  4096 Aug 25 22:33 .
drwxr-xr-x  1 root root  4096 Aug 25 22:33 ..
drwxr-xr-x  7 user user  4096 Aug 25 22:33 .git
-rw-r--r--  1 user user    22 Aug 25 22:33 .gitignore
-rw-r--r--  1 user user  6387 Aug 25 22:33 README.md
drwxr-xr-x  3 user user  4096 Aug 25 22:33 cmd
drwxr-xr-x  2 user user  4096 Aug 25 22:33 docker
-rw-r--r--  1 user user  2628 Aug 25 22:33 go.mod
-rw-r--r--  1 user user 16578 Aug 25 22:33 go.sum
drwxr-xr-x 11 user user  4096 Aug 25 22:33 internal
-rw-r--r--  1 user user  3092 Aug 25 22:33 zoo.hcl.example
98298f6 Merge pull request 'Fix excessive vertical space in job view blocks (#53)' (#55) from issue-53-greg into main
b75b64d Fix excessive vertical space in job view blocks
10c3dce Better Docker/git inter.
315f993 Add docker image build.
5717258 Merge pull request 'forgejo: repository allowlist with wildcard patterns' (#40) from issue-39-greg into main
823ae62 fix(forgejo): resolve test helper collision after merging main
bccf930 Merge branch 'main' into issue-39-greg
1365ea8 Merge pull request 'Pass the agent's git credential to the sandbox, clone inside it' (#49) from issue-48-greg into main
7c60789 Remove the git tool and Context.Git per review
c3d3720 Pass the agent's git credential to the sandbox, clone inside it
* issue-56-greg
  main
  remotes/origin/main

{"path": ".", "recursive": false}

drwxr-xr-x  6 user user  4096 Aug 25 22:33 .
drwxr-xr-x  1 root root  4096 Aug 25 22:33 ..
drwxr-xr-x  7 user user  4096 Aug 25 22:33 .git
-rw-r--r--  1 user user    22 Aug 25 22:33 .gitignore
-rw-r--r--  1 user user  6387 Aug 25 22:33 README.md
drwxr-xr-x  3 user user  4096 Aug 25 22:33 cmd
drwxr-xr-x  2 user user  4096 Aug 25 22:33 docker
-rw-r--r--  1 user user  2628 Aug 25 22:33 go.mod
-rw-r--r--  1 user user 16578 Aug 25 22:33 go.sum
drwxr-xr-x 11 user user  4096 Aug 25 22:33 internal
-rw-r--r--  1 user user  3092 Aug 25 22:33 zoo.hcl.example

{"path": "internal", "recursive": true}

/project/internal/agentrun
/project/internal/agentrun/context.go
/project/internal/agentrun/docker.go
/project/internal/agentrun/docker_integration_test.go
/project/internal/agentrun/forgejo.go
/project/internal/agentrun/loop.go
/project/internal/agentrun/roster.go
/project/internal/agentrun/roster_test.go
/project/internal/agentrun/run.go
/project/internal/agentrun/sandboxgit.go
/project/internal/agentrun/sandboxgit_test.go
/project/internal/agentrun/seed_test.go
/project/internal/agentrun/system.md
/project/internal/config
/project/internal/config/config.go
/project/internal/config/config_test.go
/project/internal/forgejo
/project/internal/forgejo/client.go
/project/internal/forgejo/client_test.go
/project/internal/forgejo/event.go
/project/internal/forgejo/poll.go
/project/internal/forgejo/poll_test.go
/project/internal/forgejo/repo_filter.go
/project/internal/forgejo/repo_filter_test.go
/project/internal/forgejo/watcher.go
/project/internal/forgejo/watcher_test.go
/project/internal/forgejo/webhook.go
/project/internal/forgejo/webhook_test.go
/project/internal/livelog
/project/internal/livelog/hub.go
/project/internal/livelog/hub_test.go
/project/internal/llm
/project/internal/llm/client.go
/project/internal/llm/streamer.go
/project/internal/llm/streamer_test.go
/project/internal/llm/types.go
/project/internal/scheduler
/project/internal/scheduler/scheduler.go
/project/internal/scheduler/scheduler_test.go
/project/internal/store
/project/internal/store/schema.sql
/project/internal/store/store.go
/project/internal/store/store_test.go
/project/internal/tools
/project/internal/tools/bash.go
/project/internal/tools/context.go
/project/internal/tools/edit-file.go
/project/internal/tools/forgejo.go
/project/internal/tools/grep_search.go
/project/internal/tools/list_files.go
/project/internal/tools/move_file.go
/project/internal/tools/read_file.go
/project/internal/tools/registry.go
/project/internal/tools/remove_file.go
/project/internal/tools/shell.go
/project/internal/tools/tools_test.go
/project/internal/tools/write_file.go
/project/internal/web
/project/internal/web/templates.go
/project/internal/web/web.go
/project/internal/web/web_test.go

{"path": "README.md", "start_line": 1, "end_line": 200}

{"path":"README.md","content":"# 🐾 Zoo\n\n**Autonomous AI agents that work your Forgejo issues \u0026 pull requests.**\n\nZoo watches a [Forgejo](https://codeberg.org/forgejo/forgejo) instance for issue and pull request events, then dispatches them to configured AI agents running in isolated Docker containers. Each agent has its own role, LLM model, and personality — like a menagerie working together to keep your projects moving.\n\n---\n\n## ✨ Features\n\n- **Multi-agent orchestration** — Assign different tasks to specialized agents (reviewers, managers, developers).\n- **Event-driven routing** — Configure which agent handles `issue:new`, `pr:new`, `issue:comment`, `issue:assigned`, and more.\n- **LLM flexibility** — Plug in any OpenAI-compatible API; each agent gets its own model choice.\n- **Isolated execution** — Agents run in Docker containers with full filesystem access but no persistence between runs.\n- **Live dashboard** — Real-time web UI showing active agents, logs, and job history.\n- **Webhook \u0026 polling support** — React to events instantly via webhooks, or fall back to polling.\n\n---\n\n## 🚀 Quick Start\n\n### Prerequisites\n\n| Requirement | Version |\n|-------------|---------|\n| Go          | 1.26+   |\n| Docker      | Latest  |\n| Forgejo     | Any (self-hosted or codeberg.dk) |\n| LLM endpoint | OpenAI-compatible API |\n\n### Configuration\n\nCopy the example config and customize it:\n\n```bash\ncp zoo.hcl.example zoo.hcl\n```\n\nEdit `zoo.hcl` with your Forgejo credentials, LLM tokens, and agent definitions. See the [configuration reference](#-configuration-reference) below.\n\n### Running\n\n```bash\ngo build -o zoo ./cmd/zoo\n./zoo\n```\n\nThe daemon starts on port `:8080` by default. Open your browser to see the dashboard.\n\n---\n\n## 👥 Meet the Agents\n\nThe example configuration includes four agents, each with a distinct role:\n\n| Agent    | Role                  | Suggested LLM       | Handles                          |\n|----------|-----------------------|---------------------|----------------------------------|\n| **leon** | Engineering Manager   | Qwen 3.8            | New issues, comments             |\n| **greg** | Senior Developer      | Qwen 3.8            | Pull request reviews             |\n| **anna** | UI/UX Designer        | Qwen 3.6            | Design-related issues \u0026 PRs      |\n| **mika** | Junior Developer      | Qwen 3.6            | Assigned issues                  |\n\nYou can add, remove, or reassign agents freely in your `zoo.hcl`.\n\n---\n\n## ⚙️ Configuration Reference\n\nAll settings live in a single HCL file (`zoo.hcl`). Here's what each section controls:\n\n### LLM Definitions\n\nDefine one or more LLM endpoints. Agents reference these by name.\n\n```hcl\nllm \"Qwen 3.6\" {\n    openai = \"https://your-llm-endpoint\"\n    token  = \"YOUR_API_TOKEN\"\n    model  = \"model-name\"\n}\n```\n\n### Forgejo Connection\n\n```hcl\nforgejo {\n    url            = \"https://code.stdio.dk\"\n    token          = \"ZOO_SERVICE_TOKEN\"\n    webhook_secret = \"SHARED_SECRET\"  # optional if using polling\n}\n```\n\n### Environment\n\n```hcl\nenvironment {\n    docker_image    = \"golang:latest\"   # base image for agent containers\n    max_live_agents = 5                 # concurrent agent limit\n}\n```\n\n### Agent Definition\n\n```hcl\nagent \"anna\" {\n    llm   = \"Qwen 3.6\"\n    token = \"ANNA_FORGEJO_TOKEN\"\n}\n```\n\nThe optional `token` is the agent's own Forgejo token. When set, the\nagent acts as itself on Forgejo (comments, PRs, ...) and its sandbox's\ngit authenticates with it too — the initial clone and all remote git\noperations (pull, push, ...) run inside the container with that\ncredential. Without it, the shared `forgejo.token` is used.\n\n### Event Routing\n\nMap event types to agents with optional custom instructions:\n\n```hcl\nevent \"issue:new\" {\n    agent        = \"leon\"\n    instructions = \"Triage this issue.\"\n}\n\nevent \"issue:assigned\" {\n    // No `agent` — dynamically matches the assignee's username\n    instructions = \"Please handle this issue.\"\n}\n\nevent \"pr:new\" {\n    agent        = \"greg\"\n    instructions = \"Review this pull request.\"\n}\n```\n\n---\n\n## 🔧 Command-Line Flags\n\n| Flag              | Default         | Description                                  |\n|-------------------|-----------------|----------------------------------------------|\n| `-config`         | `zoo.hcl`       | Path to the configuration file               |\n| `-db`             | `zoo.db`        | SQLite database path                         |\n| `-listen`         | `:8080`         | HTTP listen address                          |\n| `-run-timeout`    | (see source)    | Max wall-clock time per agent run            |\n| `-keep-on-failure`| `false`         | Preserve container after failure for debugging |\n\n---\n\n## 📁 Project Structure\n\n```\n├── cmd/zoo/main.go           # Entry point\n├── internal/\n│   ├── agentrun/             # Docker-based agent execution\n│   ├── config/               # HCL config loader \u0026 validator\n│   ├── forgejo/              # Webhook receiver \u0026 event poller\n│   ├── livelog/              # Real-time log streaming hub\n│   ├── llm/                  # LLM client \u0026 streaming\n│   ├── scheduler/            # Event-to-agent dispatcher\n│   ├── store/                # SQLite state management\n│   ├── tools/                # Agent tool registry\n│   └── web/                  # Dashboard HTTP server\n└── zoo.hcl.example           # Configuration template\n```\n\n---\n\n## 🛠 Development\n\n### Running Tests\n\n```bash\ngo test ./...\n```\n\n### Adding a New Agent\n\n1. Define the agent in `zoo.hcl`:\n\n   ```hcl\n   agent \"newagent\" {\n       llm   = \"Qwen 3.6\"\n       token = \"NEW_AGENT_TOKEN\"\n   }\n   ```\n\n2. Add an event route:\n\n   ```hcl\n   event \"issue:new\" {\n       agent = \"newagent\"\n   }\n   ```\n\n3. Update your Forgejo profile with the agent's role description.\n\n### Adding a New Tool","start_line":1,"end_line":200,"total_lines":223,"truncated":true}

{"path": "internal/agentrun/sandboxgit.go", "start_line": 1, "end_line": 400}

{"path":"internal/agentrun/sandboxgit.go","content":"package agentrun\n\nimport (\n\t\"context\"\n\t\"encoding/base64\"\n\t\"fmt\"\n\t\"net/url\"\n\t\"strings\"\n)\n\n// This file makes git \"just work\" inside the agent's container: the\n// initial clone happens in the sandbox, and the sandbox's git\n// credential is written to the container's system gitconfig so every\n// subsequent remote operation (pull, fetch, push, ...) authenticates\n// without any per-invocation plumbing. Zoo itself never runs git\n// outside the sandbox.\n\n// shellQuote wraps s in single quotes for safe interpolation into a\n// `sh -c` command string, escaping any embedded single quotes.\nfunc shellQuote(s string) string {\n\treturn \"'\" + strings.ReplaceAll(s, \"'\", `'\\''`) + \"'\"\n}\n\n// shellGitCmd renders `git \u003cargs...\u003e` as one sh -c command line with\n// every argument quoted, for docker exec.\nfunc shellGitCmd(args ...string) string {\n\tparts := make([]string, 0, len(args)+1)\n\tparts = append(parts, \"git\")\n\n\tfor _, a := range args {\n\t\tparts = append(parts, shellQuote(a))\n\t}\n\n\treturn strings.Join(parts, \" \")\n}\n\n// runSandboxGit runs `git \u003cargs...\u003e` inside containerID (in its\n// working directory, /project) and returns its combined output. A\n// non-zero exit code is an error carrying the output.\nfunc runSandboxGit(ctx context.Context, rt *dockerRuntime, containerID string, args ...string) (string, error) {\n\tout, exitCode, err := rt.exec(ctx, containerID, shellGitCmd(args...))\n\tif err != nil {\n\t\treturn out, err\n\t}\n\n\tif exitCode != 0 {\n\t\treturn out, fmt.Errorf(\"git %s: exit %d: %s\", args[0], exitCode, out)\n\t}\n\n\treturn out, nil\n}\n\n// gitAuthHeader returns the value of an Authorization header that\n// authenticates git's smart-HTTP requests as user with token.\nfunc gitAuthHeader(user, token string) string {\n\tauth := base64.StdEncoding.EncodeToString([]byte(user + \":\" + token))\n\n\treturn \"Authorization: Basic \" + auth\n}\n\n// forgeHost returns the scheme+host prefix of cloneURL, e.g.\n// \"https://code.stdio.dk\" for \"https://code.stdio.dk/abrander/zoo.git\".\n// On a parse failure it falls back to the full URL, which is a valid\n// (narrower) prefix match too.\nfunc forgeHost(cloneURL string) string {\n\tu, err := url.Parse(cloneURL)\n\tif err != nil || u.Host == \"\" {\n\t\treturn cloneURL\n\t}\n\n\treturn u.Scheme + \"://\" + u.Host\n}\n\n// configureSandboxGit writes the container's system gitconfig so git\n// works inside the sandbox without further setup:\n//\n//   - safe.directory '*', so the bind-mounted /project is accepted\n//     regardless of which UID the container runs git as;\n//   - user.name / user.email, so commits are attributed to the agent;\n//   - http.\u003chost\u003e.extraHeader carrying the run's Forgejo credential,\n//     scoped to the forge host the repository lives on, so\n//     clone/fetch/pull/push all authenticate transparently — including\n//     for submodules and other repos on the same forge. The token is\n//     only valid on that forge anyway, so the host scope grants no\n//     extra access; git never sends it anywhere else;\n//   - push.autoSetupRemote, so a bare `git push` on the fresh working\n//     branch pushes it to origin and sets the upstream — after which\n//     a bare `git pull` works too.\n//\n// The credential lives in the container's own filesystem (ephemeral,\n// torn down with the container), never in the bind-mounted working\n// tree: the origin remote keeps the plain cloneURL, so the token can't\n// leak into the repo's .git/config, into a work dir zoo keeps on\n// failure, or anywhere the host can read it back.\nfunc configureSandboxGit(ctx context.Context, rt *dockerRuntime, containerID, cloneURL, user, token, name, email string) error {\n\tif _, err := runSandboxGit(ctx, rt, containerID, \"config\", \"--global\", \"--add\", \"safe.directory\", \"*\"); err != nil {\n\t\treturn fmt.Errorf(\"configure safe.directory: %w\", err)\n\t}\n\n\tif _, err := runSandboxGit(ctx, rt, containerID, \"config\", \"--global\", \"user.name\", name); err != nil {\n\t\treturn fmt.Errorf(\"configure user.name: %w\", err)\n\t}\n\n\tif _, err := runSandboxGit(ctx, rt, containerID, \"config\", \"--global\", \"user.email\", email); err != nil {\n\t\treturn fmt.Errorf(\"configure user.email: %w\", err)\n\t}\n\n\tif _, err := runSandboxGit(ctx, rt, containerID, \"config\", \"--global\", \"http.\"+forgeHost(cloneURL)+\".extraHeader\", gitAuthHeader(user, token)); err != nil {\n\t\treturn fmt.Errorf(\"configure git credential: %w\", err)\n\t}\n\n\tif _, err := runSandboxGit(ctx, rt, containerID, \"config\", \"--global\", \"push.autoSetupRemote\", \"true\"); err != nil {\n\t\treturn fmt.Errorf(\"configure push.autoSetupRemote: %w\", err)\n\t}\n\n\treturn nil\n}\n\n// cloneAndBranch clones cloneURL into /project inside the container\n// and checks out a fresh branch off defaultBranch. The clone\n// authenticates via the http.\u003chost\u003e.extraHeader configured by\n// configureSandboxGit, and the origin remote is left with the plain\n// cloneURL: no credential ends up in the working tree.\nfunc cloneAndBranch(ctx context.Context, rt *dockerRuntime, containerID, cloneURL, defaultBranch, branch string) error {\n\tif _, err := runSandboxGit(ctx, rt, containerID, \"clone\", \"--branch\", defaultBranch, \"--single-branch\", cloneURL, \"/project\"); err != nil {\n\t\treturn fmt.Errorf(\"clone: %w\", err)\n\t}\n\n\tif _, err := runSandboxGit(ctx, rt, containerID, \"checkout\", \"-b\", branch); err != nil {\n\t\treturn fmt.Errorf(\"checkout branch %q: %w\", branch, err)\n\t}\n\n\treturn nil\n}\n\n// clonePRHead clones cloneURL into /project inside the container and\n// checks out the pull request's head as a local branch named headRef,\n// so commits the agent makes push straight to the PR. The head is\n// fetched via the PR's refs/pull/\u003cn\u003e/head ref rather than by branch\n// name, which also works for PRs opened from a fork, where the head\n// branch doesn't exist in the base repo.\nfunc clonePRHead(ctx context.Context, rt *dockerRuntime, containerID, cloneURL, defaultBranch, headRef string, index int64) error {\n\tif _, err := runSandboxGit(ctx, rt, containerID, \"clone\", \"--branch\", defaultBranch, \"--single-branch\", cloneURL, \"/project\"); err != nil {\n\t\treturn fmt.Errorf(\"clone: %w\", err)\n\t}\n\n\tfetchRef := fmt.Sprintf(\"refs/pull/%d/head\", index)\n\n\tif _, err := runSandboxGit(ctx, rt, containerID, \"fetch\", \"--no-tags\", \"origin\", fetchRef); err != nil {\n\t\treturn fmt.Errorf(\"fetch PR %d head: %w\", index, err)\n\t}\n\n\tif _, err := runSandboxGit(ctx, rt, containerID, \"checkout\", \"-B\", headRef, \"FETCH_HEAD\"); err != nil {\n\t\treturn fmt.Errorf(\"checkout PR head %q: %w\", headRef, err)\n\t}\n\n\treturn nil\n}","start_line":1,"end_line":158,"total_lines":158,"truncated":false}

{"path": "internal/agentrun/docker.go", "start_line": 1, "end_line": 400}

{"path":"internal/agentrun/docker.go","content":"package agentrun\n\nimport (\n\t\"context\"\n\t\"fmt\"\n\t\"io\"\n\t\"time\"\n\n\t\"github.com/docker/docker/api/types/container\"\n\t\"github.com/docker/docker/client\"\n)\n\n// containerCPUs and containerMemory bound each agent container's\n// resource usage; there's no per-agent config knob for this yet (see\n// TODO.md), so every run gets the same sane default.\nconst (\n\tcontainerNanoCPUs = 2_000_000_000 // 2 CPUs\n\tcontainerMemory   = 2 \u003c\u003c 30       // 2 GiB\n)\n\ntype dockerRuntime struct {\n\tcli *client.Client\n}\n\nfunc newDockerRuntime() (*dockerRuntime, error) {\n\tcli, err := client.NewClientWithOpts(client.FromEnv, client.WithAPIVersionNegotiation())\n\tif err != nil {\n\t\treturn nil, fmt.Errorf(\"docker client: %w\", err)\n\t}\n\n\treturn \u0026dockerRuntime{cli: cli}, nil\n}\n\n// createContainer creates and starts a container from image with the\n// given bind mounts, kept alive with `sleep infinity` regardless of the\n// image's own entrypoint so it can be repeatedly `exec`'d into.\nfunc (d *dockerRuntime) createContainer(ctx context.Context, image string, binds []string, name string) (string, error) {\n\tresp, err := d.cli.ContainerCreate(ctx,\n\t\t\u0026container.Config{\n\t\t\tImage:      image,\n\t\t\tEntrypoint: []string{\"sleep\"},\n\t\t\tCmd:        []string{\"infinity\"},\n\t\t\tWorkingDir: \"/project\",\n\t\t},\n\t\t\u0026container.HostConfig{\n\t\t\tBinds: binds,\n\t\t\tResources: container.Resources{\n\t\t\t\tNanoCPUs: containerNanoCPUs,\n\t\t\t\tMemory:   containerMemory,\n\t\t\t},\n\t\t},\n\t\tnil, nil, name)\n\tif err != nil {\n\t\treturn \"\", fmt.Errorf(\"create container: %w\", err)\n\t}\n\n\tif err := d.cli.ContainerStart(ctx, resp.ID, container.StartOptions{}); err != nil {\n\t\treturn \"\", fmt.Errorf(\"start container: %w\", err)\n\t}\n\n\treturn resp.ID, nil\n}\n\n// exec runs command via `sh -c` inside containerID and returns its\n// combined stdout+stderr (a TTY is attached so the two streams merge\n// without needing to demultiplex Docker's stdcopy framing) plus its exit\n// code.\nfunc (d *dockerRuntime) exec(ctx context.Context, containerID, command string) (string, int, error) {\n\tcreated, err := d.cli.ContainerExecCreate(ctx, containerID, container.ExecOptions{\n\t\tCmd: []string{\"sh\", \"-c\", command},\n\t\t// A TTY is attached (see doc comment above), which makes git's\n\t\t// isatty-based color.ui=auto default to enabling ANSI color codes\n\t\t// that pollute the captured job log. NO_COLOR covers tools that\n\t\t// honor that convention; the GIT_CONFIG_* override forces git's\n\t\t// own color.ui to \"never\" regardless of tty detection, since git\n\t\t// does not honor NO_COLOR itself.\n\t\t//\n\t\t// The same isatty check makes git launch a pager for diff/log/show,\n\t\t// and the pager (waiting on a stdin nothing ever attaches or\n\t\t// closes) then blocks forever with no way to time it out — see\n\t\t// exec's read loop below. GIT_PAGER/PAGER=cat disable that.\n\t\t// GIT_TERMINAL_PROMPT=0 closes the same class of hang for\n\t\t// credential prompts on a private remote.\n\t\tEnv: []string{\n\t\t\t\"NO_COLOR=1\",\n\t\t\t\"GIT_CONFIG_COUNT=1\",\n\t\t\t\"GIT_CONFIG_KEY_0=color.ui\",\n\t\t\t\"GIT_CONFIG_VALUE_0=never\",\n\t\t\t\"GIT_PAGER=cat\",\n\t\t\t\"PAGER=cat\",\n\t\t\t\"GIT_TERMINAL_PROMPT=0\",\n\t\t},\n\t\tTty:          true,\n\t\tAttachStdout: true,\n\t\tAttachStderr: true,\n\t})\n\tif err != nil {\n\t\treturn \"\", 0, fmt.Errorf(\"exec create: %w\", err)\n\t}\n\n\tattached, err := d.cli.ContainerExecAttach(ctx, created.ID, container.ExecAttachOptions{Tty: true})\n\tif err != nil {\n\t\treturn \"\", 0, fmt.Errorf(\"exec attach: %w\", err)\n\t}\n\tdefer attached.Close()\n\n\t// Once hijacked, this stream is a raw connection that ctx cancellation\n\t// no longer reaches — a wedged child process (pager, credential\n\t// prompt, anything else reading a stdin nobody attaches) would\n\t// otherwise block this read forever, past the run's deadline, with no\n\t// way to recover the job. Race the read against ctx and force-remove\n\t// the container to sever the connection if it fires.\n\ttype readResult struct {\n\t\toutput []byte\n\t\terr    error\n\t}\n\n\treadDone := make(chan readResult, 1)\n\n\tgo func() {\n\t\toutput, err := io.ReadAll(attached.Reader)\n\t\treadDone \u003c- readResult{output, err}\n\t}()\n\n\tvar output []byte\n\n\tselect {\n\tcase res := \u003c-readDone:\n\t\tif res.err != nil {\n\t\t\treturn \"\", 0, fmt.Errorf(\"exec read output: %w\", res.err)\n\t\t}\n\n\t\toutput = res.output\n\n\tcase \u003c-ctx.Done():\n\t\tkillCtx, cancel := context.WithTimeout(context.Background(), 10*time.Second)\n\t\tdefer cancel()\n\n\t\t_ = d.cli.ContainerRemove(killCtx, containerID, container.RemoveOptions{Force: true})\n\t\t\u003c-readDone\n\n\t\treturn \"\", 0, ctx.Err()\n\t}\n\n\tinspect, err := d.cli.ContainerExecInspect(ctx, created.ID)\n\tif err != nil {\n\t\treturn string(output), 0, fmt.Errorf(\"exec inspect: %w\", err)\n\t}\n\n\treturn string(output), inspect.ExitCode, nil\n}\n\n// remove force-stops and removes containerID, ignoring \"already gone\"\n// errors so cleanup is safe to call unconditionally.\nfunc (d *dockerRuntime) remove(ctx context.Context, containerID string) error {\n\ttimeout := 5\n\t_ = d.cli.ContainerStop(ctx, containerID, container.StopOptions{Timeout: \u0026timeout})\n\n\tif err := d.cli.ContainerRemove(ctx, containerID, container.RemoveOptions{Force: true}); err != nil {\n\t\treturn fmt.Errorf(\"remove container: %w\", err)\n\t}\n\n\treturn nil\n}\n\nfunc (d *dockerRuntime) kill(ctx context.Context, containerID string) {\n\t_ = d.cli.ContainerKill(ctx, containerID, \"KILL\")\n}","start_line":1,"end_line":168,"total_lines":168,"truncated":false}

{"path": "internal/agentrun/run.go", "start_line": 1, "end_line": 400}

{"path":"internal/agentrun/run.go","content":"// Package agentrun creates the throwaway per-job environment an agent\n// runs in: a Docker container with the agent's git working tree cloned\n// inside it (authenticated with the agent's own Forgejo token), the\n// triggering event written to /event, and the tool-calling loop\n// (internal/llm + internal/tools) driven against it.\npackage agentrun\n\nimport (\n\t\"context\"\n\t_ \"embed\"\n\t\"encoding/json\"\n\t\"fmt\"\n\t\"log/slog\"\n\t\"os\"\n\t\"path/filepath\"\n\t\"strings\"\n\t\"sync\"\n\t\"time\"\n\n\t\"github.com/abrander/zoo/internal/config\"\n\t\"github.com/abrander/zoo/internal/forgejo\"\n\t\"github.com/abrander/zoo/internal/livelog\"\n\t\"github.com/abrander/zoo/internal/llm\"\n\t\"github.com/abrander/zoo/internal/store\"\n)\n\n//go:embed system.md\nvar defaultSystemPrompt string\n\n// DefaultTimeout bounds a single agent run's wall-clock time if the\n// caller doesn't override it.\nconst DefaultTimeout = 120 * time.Minute\n\ntype Runner struct {\n\tdocker        *dockerRuntime\n\tforgejo       *forgejo.Client\n\tstore         *store.Store\n\thub           *livelog.Hub\n\tcfg           *config.Config\n\tlogger        *slog.Logger\n\ttimeout       time.Duration\n\tkeepOnFailure bool\n\n\tagentClientsMu sync.Mutex\n\tagentClients   map[string]*forgejo.Client\n}\n\nfunc NewRunner(cfg *config.Config, fg *forgejo.Client, st *store.Store, hub *livelog.Hub, logger *slog.Logger, timeout time.Duration, keepOnFailure bool) (*Runner, error) {\n\tdocker, err := newDockerRuntime()\n\tif err != nil {\n\t\treturn nil, err\n\t}\n\n\tif timeout \u003c= 0 {\n\t\ttimeout = DefaultTimeout\n\t}\n\n\treturn \u0026Runner{\n\t\tdocker:        docker,\n\t\tforgejo:       fg,\n\t\tstore:         st,\n\t\thub:           hub,\n\t\tcfg:           cfg,\n\t\tlogger:        logger,\n\t\ttimeout:       timeout,\n\t\tkeepOnFailure: keepOnFailure,\n\t\tagentClients:  make(map[string]*forgejo.Client),\n\t}, nil\n}\n\n// forgejoAs returns a Forgejo client that authenticates as the given\n// agent (using the agent's own token from config). This lets each agent\n// act as themselves on Forgejo without needing a global token with sudo\n// privileges. Clients are built once per agent and cached, since\n// constructing one costs an extra API round trip.\n//\n// If the agent has no token configured, falls back to the shared zoo\n// identity so existing deployments without per-agent tokens still work.\nfunc (r *Runner) forgejoAs(agentName, token string) *forgejo.Client {\n\tr.agentClientsMu.Lock()\n\tdefer r.agentClientsMu.Unlock()\n\n\tif c, ok := r.agentClients[agentName]; ok {\n\t\treturn c\n\t}\n\n\tvar c *forgejo.Client\n\tif token != \"\" {\n\t\tc = r.forgejo.As(token)\n\t} else {\n\t\t// Fallback: use shared identity. Optionally log a warning\n\t\t// if we ever want to enforce per-agent tokens.\n\t\tc = r.forgejo\n\t}\n\n\tr.agentClients[agentName] = c\n\n\treturn c\n}\n\n// Run implements scheduler.Runner.\nfunc (r *Runner) Run(ctx context.Context, jobID string, agent config.AgentConfig, llmCfg config.LLM, dockerImage string, ev forgejo.Event) error {\n\tctx, cancel := context.WithTimeout(ctx, r.timeout)\n\tdefer cancel()\n\n\tlogger := r.logger.With(\"job\", jobID, \"agent\", agent.Name)\n\n\trepoInfo, err := r.forgejo.RepositoryInfo(ev.Owner, ev.Repo)\n\tif err != nil {\n\t\treturn fmt.Errorf(\"look up repository: %w\", err)\n\t}\n\n\tworkDir, err := os.MkdirTemp(\"\", \"zoo-run-*\")\n\tif err != nil {\n\t\treturn fmt.Errorf(\"create work dir: %w\", err)\n\t}\n\n\tsucceeded := false\n\n\tdefer func() {\n\t\tif succeeded || !r.keepOnFailure {\n\t\t\tos.RemoveAll(workDir)\n\t\t} else {\n\t\t\tlogger.Warn(\"keeping work dir after failure\", \"dir\", workDir)\n\t\t}\n\t}()\n\n\t// The container bind-mounts projectDir as /project and does the\n\t// initial clone into it, so the (empty) directory must exist on the\n\t// host before the container is created — otherwise Docker would\n\t// create it itself, root-owned.\n\tprojectDir := filepath.Join(workDir, \"project\")\n\n\tif err := os.MkdirAll(projectDir, 0o755); err != nil {\n\t\treturn fmt.Errorf(\"create project dir: %w\", err)\n\t}\n\n\t// A pr:review run works on the PR's own head branch, so the agent's\n\t// commits push straight to the PR. Every other event kind branches\n\t// off the default branch as usual.\n\tvar review *forgejo.ReviewDetail\n\tbranch := fmt.Sprintf(\"issue-%d-%s\", ev.Index, agent.Name)\n\n\tif ev.Kind == forgejo.EventPRReview {\n\t\t// Always fetch the current head ref, not just when the event\n\t\t// lacks one (the polling path doesn't carry it): the webhook's\n\t\t// copy could be stale if the PR's head branch was renamed since\n\t\t// the review, and the push target depends on it.\n\t\theadRef := ev.HeadRef\n\n\t\tif prInfo, err := r.forgejo.PullRequestInfo(ev.Owner, ev.Repo, ev.Index); err != nil {\n\t\t\tlogger.Warn(\"fetch pull request head failed; falling back to the event's head ref\", \"error\", err)\n\t\t} else if prInfo.HeadRef != \"\" {\n\t\t\theadRef = prInfo.HeadRef\n\t\t}\n\n\t\tif headRef == \"\" {\n\t\t\treturn fmt.Errorf(\"pr:review event has no pull request head branch to check out\")\n\t\t}\n\n\t\tbranch = headRef\n\n\t\t// Fetch the full review (verdict, body, inline comments) so the\n\t\t// agent sees all the feedback, not just the triggering event. A\n\t\t// failure degrades to no review detail rather than failing the\n\t\t// run: the agent can still do its job, just without the inline\n\t\t// comments.\n\t\treview, err = r.forgejo.ReviewDetail(ev.Owner, ev.Repo, ev.Index, ev.ReviewID)\n\t\tif err != nil {\n\t\t\tlogger.Warn(\"fetch review detail failed; agent will not see inline review comments\", \"error\", err)\n\t\t\treview = nil\n\t\t}\n\t}\n\n\troster := buildRoster(r.forgejo, r.cfg.Agents, logger)\n\tgitName, gitEmail := gitIdentity(agent.Name, roster)\n\n\t// The credential the sandbox's git uses for remote operations: the\n\t// agent's own Forgejo token when configured, so its git activity is\n\t// attributed to its own account, falling back to the shared zoo\n\t// identity for deployments without per-agent tokens (mirroring\n\t// forgejoAs).\n\tgitUser, gitToken := \"zoo\", r.forgejo.Token()\n\n\tif agent.Token != \"\" {\n\t\tgitUser, gitToken = agent.Name, agent.Token\n\t}\n\n\teventPath := filepath.Join(workDir, \"event.json\")\n\tif err := os.WriteFile(eventPath, ev.Raw, 0o644); err != nil {\n\t\treturn fmt.Errorf(\"write event file: %w\", err)\n\t}\n\n\tcontainerID, err := r.docker.createContainer(ctx, dockerImage, []string{\n\t\tprojectDir + \":/project\",\n\t\teventPath + \":/event:ro\",\n\t}, fmt.Sprintf(\"zoo-issue-%d-%s\", ev.Index, agent.Name))\n\tif err != nil {\n\t\treturn fmt.Errorf(\"start container: %w\", err)\n\t}\n\n\tdefer func() {\n\t\tcleanupCtx, cleanupCancel := context.WithTimeout(context.Background(), 30*time.Second)\n\t\tdefer cleanupCancel()\n\t\tif err := r.docker.remove(cleanupCtx, containerID); err != nil {\n\t\t\tlogger.Warn(\"failed to remove container\", \"container\", containerID, \"error\", err)\n\t\t}\n\t}()\n\n\t// Git must simply work inside the sandbox: safe.directory, commit\n\t// identity, and the remote credential all go into the container's\n\t// system gitconfig (see configureSandboxGit).\n\tif err := configureSandboxGit(ctx, r.docker, containerID, repoInfo.CloneURL, gitUser, gitToken, gitName, gitEmail); err != nil {\n\t\treturn fmt.Errorf(\"configure git in container: %w\", err)\n\t}\n\n\t// The initial clone happens inside the sandbox, so the working tree\n\t// is owned by the container's user and git never runs on the host.\n\tif ev.Kind == forgejo.EventPRReview {\n\t\tif err := clonePRHead(ctx, r.docker, containerID, repoInfo.CloneURL, repoInfo.DefaultBranch, branch, ev.Index); err != nil {\n\t\t\treturn fmt.Errorf(\"prepare git working tree: %w\", err)\n\t\t}\n\t} else {\n\t\tif err := cloneAndBranch(ctx, r.docker, containerID, repoInfo.CloneURL, repoInfo.DefaultBranch, branch); err != nil {\n\t\t\treturn fmt.Errorf(\"prepare git working tree: %w\", err)\n\t\t}\n\t}\n\n\tlogAppend := func(stream, line string) {\n\t\tif err := r.store.AppendLog(context.Background(), jobID, stream, line); err != nil {\n\t\t\tlogger.Warn(\"failed to append log\", \"error\", err)\n\t\t}\n\t}\n\n\trunCtx := \u0026runContext{\n\t\tdocker:      r.docker,\n\t\tcontainerID: containerID,\n\t\tforgejo: \u0026runForgejoActions{\n\t\t\tclient: r.forgejoAs(agent.Name, agent.Token),\n\t\t\towner:  ev.Owner,\n\t\t\trepo:   ev.Repo,\n\t\t\tindex:  ev.Index,\n\t\t\tlogger: logger,\n\t\t},\n\t}\n\n\tllmClient := llm.NewClient(llmCfg)\n\n\tsystemPrompt := defaultSystemPrompt + identitySection(agent.Name, roster)\n\n\tinstructions := r.cfg.EventInstructions(ev.Kind)\n\n\t// Fetch the full comment thread so the agent sees everything that's\n\t// been said on the issue/PR, not just the triggering event (which\n\t// only carries the latest comment, if any). A failure degrades to\n\t// no comments rather than failing the run: the agent can still do\n\t// its job, just without prior context.\n\tcomments, err := r.forgejo.ListIssueComments(ev.Owner, ev.Repo, ev.Index)\n\tif err != nil {\n\t\tlogger.Warn(\"fetch issue comments failed; agent will not see prior comments\", \"error\", err)\n\t\tcomments = nil\n\t}\n\n\tmessages := []llm.Message{\n\t\t{Role: \"system\", Content: systemPrompt},\n\t\t{Role: \"user\", Content: seedMessage(ev, branch, repoInfo.DefaultBranch, instructions, comments, review)},\n\t}\n\n\thooks := r.streamHooks(jobID, logAppend)\n\n\t_, err = runLoop(ctx, llmClient, runCtx, messages, hooks)\n\tif err != nil {\n\t\treturn fmt.Errorf(\"agent loop: %w\", err)\n\t}\n\n\tsucceeded = true\n\n\treturn nil\n}\n\n// streamHooks builds the Hooks a single Run passes to runLoop: every\n// delta is published live to the hub for connected dashboard viewers,\n// and once a reasoning/content block or tool call is complete, it's\n// persisted to the store as one row and the hub's replay buffer for\n// jobID is checkpointed — so a viewer connecting from this point on\n// sees it via the persisted history instead of a live replay, and is\n// never shown it twice.\nfunc (r *Runner) streamHooks(jobID string, logAppend func(stream, line string)) Hooks {\n\tvar reasoningBuf, contentBuf strings.Builder\n\n\treasoningOpen, contentOpen := false, false\n\n\treturn Hooks{\n\t\tOnReasoningDelta: func(delta string) {\n\t\t\tif !reasoningOpen {\n\t\t\t\treasoningOpen = true\n\t\t\t\treasoningBuf.Reset()\n\t\t\t\tr.hub.Publish(jobID, livelog.Event{Type: livelog.ReasoningStart})\n\t\t\t}\n\n\t\t\treasoningBuf.WriteString(delta)\n\t\t\tr.hub.Publish(jobID, livelog.Event{Type: livelog.ReasoningDelta, Text: delta})\n\t\t},\n\t\tOnContentDelta: func(delta string) {\n\t\t\tif !contentOpen {\n\t\t\t\tcontentOpen = true\n\t\t\t\tcontentBuf.Reset()\n\t\t\t\tr.hub.Publish(jobID, livelog.Event{Type: livelog.ContentStart})\n\t\t\t}\n\n\t\t\tcontentBuf.WriteString(delta)\n\t\t\tr.hub.Publish(jobID, livelog.Event{Type: livelog.ContentDelta, Text: delta})\n\t\t},\n\t\tOnTurnEnd: func() {\n\t\t\tif reasoningOpen {\n\t\t\t\tr.hub.Publish(jobID, livelog.Event{Type: livelog.ReasoningEnd})\n\t\t\t\tlogAppend(\"reasoning\", reasoningBuf.String())\n\t\t\t\tr.hub.Checkpoint(jobID)\n\t\t\t\treasoningOpen = false\n\t\t\t}\n\n\t\t\tif contentOpen {\n\t\t\t\tr.hub.Publish(jobID, livelog.Event{Type: livelog.ContentEnd})\n\t\t\t\tlogAppend(\"content\", contentBuf.String())\n\t\t\t\tr.hub.Checkpoint(jobID)\n\t\t\t\tcontentOpen = false\n\t\t\t}\n\t\t},\n\t\tOnTool: func(name, arguments, result string, toolErr bool) {\n\t\t\tr.hub.Publish(jobID, livelog.Event{\n\t\t\t\tType:      livelog.Tool,\n\t\t\t\tName:      name,\n\t\t\t\tArguments: arguments,\n\t\t\t\tResult:    result,\n\t\t\t\tError:     toolErr,\n\t\t\t})\n\n\t\t\tline, err := json.Marshal(store.ToolLogEntry{Name: name, Arguments: arguments, Result: result, Error: toolErr})\n\t\t\tif err != nil {\n\t\t\t\tr.logger.Warn(\"failed to marshal tool log entry\", \"job\", jobID, \"error\", err)\n\t\t\t} else {\n\t\t\t\tlogAppend(\"tool\", string(line))\n\t\t\t}\n\n\t\t\tr.hub.Checkpoint(jobID)\n\t\t},\n\t}\n}\n\nfunc seedMessage(ev forgejo.Event, branch, defaultBranch, instructions string, comments []forgejo.IssueComment, review *forgejo.ReviewDetail) string {\n\traw, _ := json.MarshalIndent(json.RawMessage(ev.Raw), \"\", \"  \")\n\n\tvar instructionsSection string\n\tif instructions != \"\" {\n\t\tinstructionsSection = fmt.Sprintf(\"Instructions for this event, from zoo.hcl:\\n%s\\n\\n\", instructions)\n\t}\n\n\t// A pr:review run works on the PR's own head branch, not a fresh\n\t// branch off the default branch.\n\tbranchLine := fmt.Sprintf(\"Your working branch is %q, checked out from the default branch %q.\\n\\n\", branch, defaultBranch)\n\tif ev.Kind == forgejo.EventPRReview {\n\t\tbranchLine = fmt.Sprintf(\"Your working branch is %q, the pull request's head branch — commits you push here update the pull request directly.\\n\\n\", branch)\n\t}\n\n\tvar reviewSection string\n\tif review != nil {\n\t\treviewSection = renderReviewSection(review)\n\t}\n\n\tvar commentsSection string\n\tif len(comments) \u003e 0 {\n\t\tvar b strings.Builder\n\t\tfmt.Fprintf(\u0026b, \"Comments (%d):\\n\\n\", len(comments))\n\n\t\tfor i, c := range comments {\n\t\t\tfmt.Fprintf(\u0026b, \"%d. %s (%s):\\n%s\\n\\n\", i+1, c.Author, c.Created.Format(time.RFC3339), c.Body)\n\t\t}\n\n\t\tcommentsSection = b.String()\n\t}\n\n\treturn fmt.Sprintf(\n\t\t\"You were triggered by a %q event on %s/%s.\\n\\n\"+\n\t\t\t\"%s%s\"+\n\t\t\t\"%sTitle: %s\\n\\nBody:\\n%s\\n\\n%sFull event payload:\\n```json\\n%s\\n```\",\n\t\tev.Kind, ev.Owner, ev.Repo, instructionsSection, branchLine, reviewSection, ev.Title, ev.Body, commentsSection, raw)\n}\n\n// renderReviewSection renders the submitted review as a briefing\n// section: the verdict, the review body, and each inline comment with\n// its location and id (the id lets the agent refer to a specific\n// comment in its reply).\nfunc renderReviewSection(review *forgejo.ReviewDetail) string {\n\tvar b strings.Builder\n\n\tfmt.Fprintf(\u0026b, \"Review submitted by %s:\\n\", review.Reviewer)\n\tfmt.Fprintf(\u0026b, \"  Verdict: %s\\n\", humanReviewState(review.State))\n\n\tif review.Body != \"\" {\n\t\tb.WriteString(\"  Review body:\\n\")","start_line":1,"end_line":400,"total_lines":437,"truncated":true}

{"path": "internal/agentrun/context.go", "start_line": 1, "end_line": 300}

{"path":"internal/agentrun/context.go","content":"package agentrun\n\nimport (\n\t\"context\"\n\t\"fmt\"\n\n\t\"github.com/abrander/zoo/internal/tools\"\n)\n\n// runContext implements tools.Context for a single agent run, executing\n// shell commands via docker exec against the run's container, and\n// binding Forgejo actions to the triggering issue/PR.\ntype runContext struct {\n\tdocker      *dockerRuntime\n\tcontainerID string\n\tforgejo     tools.ForgejoActions\n}\n\nfunc (c *runContext) Exec(ctx context.Context, command string) (string, error) {\n\toutput, exitCode, err := c.docker.exec(ctx, c.containerID, command)\n\n\tif err != nil {\n\t\treturn output, err\n\t}\n\n\tif exitCode != 0 {\n\t\treturn output, fmt.Errorf(\"command exited with status %d\", exitCode)\n\t}\n\n\treturn output, nil\n}\n\nfunc (c *runContext) Forgejo() tools.ForgejoActions {\n\treturn c.forgejo\n}","start_line":1,"end_line":35,"total_lines":35,"truncated":false}

{"path": "internal/forgejo/client.go", "start_line": 1, "end_line": 200}

{"path":"internal/forgejo/client.go","content":"// Package forgejo wraps the Forgejo SDK and turns webhook deliveries and\n// polling results into a common Event stream for the scheduler.\npackage forgejo\n\nimport (\n\t\"fmt\"\n\t\"time\"\n\n\tsdk \"codeberg.org/mvdkleijn/forgejo-sdk/forgejo/v2\"\n\n\t\"github.com/abrander/zoo/internal/config\"\n)\n\n// Client is zoo's single shared Forgejo identity, used both for the\n// event sources (webhook/poll) and for actions agents/scheduler take\n// (comments, labels, PRs).\ntype Client struct {\n\tsdk *sdk.Client\n\n\tbaseURL string\n\ttoken   string\n}\n\nfunc NewClient(cfg config.Forgejo) (*Client, error) {\n\tc, err := sdk.NewClient(cfg.URL, sdk.SetToken(cfg.Token))\n\tif err != nil {\n\t\treturn nil, fmt.Errorf(\"forgejo client: %w\", err)\n\t}\n\n\treturn \u0026Client{sdk: c, baseURL: cfg.URL, token: cfg.Token}, nil\n}\n\n// Token returns the shared zoo Forgejo identity's token, e.g. for\n// authenticating a host-side git clone/push against Forgejo (see\n// internal/agentrun) without ever writing the credential into a working\n// tree an agent's container can read.\nfunc (c *Client) Token() string {\n\treturn c.token\n}\n\n// As returns a new Client that authenticates as the given token.\n// This is used to create per-agent clients so each agent acts as\n// themselves on Forgejo, without needing a global token with sudo\n// privileges.\nfunc (c *Client) As(token string) *Client {\n\tclient, _ := sdk.NewClient(c.baseURL, sdk.SetToken(token))\n\treturn \u0026Client{sdk: client, baseURL: c.baseURL, token: token}\n}\n\n// Sudo returns a new Client that impersonates username (via Forgejo's\n// \"Sudo:\" header) on every API call it makes, using the same underlying\n// token. Actions an agent takes through it — comments, labels, PRs,\n// assignment — are attributed to that agent's own Forgejo account\n// instead of the shared zoo identity. The token must belong to a user\n// with sudo scope/admin rights for this to work; Forgejo rejects the\n// header otherwise.\n//\n// Deprecated: use As(token) with a per-agent token instead. Kept for\n// backward compatibility during migration.\nfunc (c *Client) Sudo(username string) (*Client, error) {\n\tsudoClient, err := sdk.NewClient(c.baseURL, sdk.SetToken(c.token), sdk.SetSudo(username))\n\tif err != nil {\n\t\treturn nil, fmt.Errorf(\"forgejo client sudo %q: %w\", username, err)\n\t}\n\n\treturn \u0026Client{sdk: sudoClient, baseURL: c.baseURL, token: c.token}, nil\n}\n\n// CreateIssueComment posts a comment on the given issue or pull request\n// (Forgejo/Gitea treat PRs as issues for commenting purposes).\nfunc (c *Client) CreateIssueComment(owner, repo string, index int64, body string) error {\n\t_, _, err := c.sdk.CreateIssueComment(owner, repo, index, sdk.CreateIssueCommentOption{Body: body})\n\tif err != nil {\n\t\treturn fmt.Errorf(\"comment on %s/%s#%d: %w\", owner, repo, index, err)\n\t}\n\n\treturn nil\n}\n\n// IssueComment is one comment on an issue or pull request, in the\n// shape zoo needs when briefing an agent: who said what, and when.\ntype IssueComment struct {\n\tAuthor  string\n\tBody    string\n\tCreated time.Time\n}\n\n// ListIssueComments fetches every comment on the given issue or pull\n// request, oldest first. PRs are issues under the hood in Forgejo, so\n// the same endpoint serves both. Pages are walked until exhausted so\n// the result isn't capped by the server's default page size.\nfunc (c *Client) ListIssueComments(owner, repo string, index int64) ([]IssueComment, error) {\n\tconst pageSize = 50\n\n\tvar all []*sdk.Comment\n\n\tfor page := 1; ; page++ {\n\t\tbatch, _, err := c.sdk.ListIssueComments(owner, repo, index, sdk.ListIssueCommentOptions{\n\t\t\tListOptions: sdk.ListOptions{Page: page, PageSize: pageSize},\n\t\t})\n\t\tif err != nil {\n\t\t\treturn nil, fmt.Errorf(\"list comments on %s/%s#%d (page %d): %w\", owner, repo, index, page, err)\n\t\t}\n\n\t\tall = append(all, batch...)\n\n\t\tif len(batch) \u003c pageSize {\n\t\t\tbreak\n\t\t}\n\t}\n\n\tout := make([]IssueComment, 0, len(all))\n\tfor _, cm := range all {\n\t\tauthor := \"\"\n\t\tif cm.Poster != nil {\n\t\t\tauthor = cm.Poster.UserName\n\t\t}\n\n\t\tout = append(out, IssueComment{Author: author, Body: cm.Body, Created: cm.Created})\n\t}\n\n\treturn out, nil\n}\n\n// AddLabel attaches the label with the given name to an issue/PR,\n// creating the label (with a default color) on the repo first if it\n// doesn't already exist.\nfunc (c *Client) AddLabel(owner, repo string, index int64, name string) error {\n\tid, err := c.labelID(owner, repo, name)\n\tif err != nil {\n\t\treturn err\n\t}\n\n\t_, _, err = c.sdk.AddIssueLabels(owner, repo, index, sdk.IssueLabelsOption{Labels: []int64{id}})\n\tif err != nil {\n\t\treturn fmt.Errorf(\"add label %q to %s/%s#%d: %w\", name, owner, repo, index, err)\n\t}\n\n\treturn nil\n}\n\n// RemoveLabel detaches the label with the given name from an issue/PR, if\n// both the label and the attachment exist.\nfunc (c *Client) RemoveLabel(owner, repo string, index int64, name string) error {\n\tlabels, _, err := c.sdk.GetIssueLabels(owner, repo, index, sdk.ListLabelsOptions{})\n\tif err != nil {\n\t\treturn fmt.Errorf(\"list labels on %s/%s#%d: %w\", owner, repo, index, err)\n\t}\n\n\tfor _, l := range labels {\n\t\tif l.Name == name {\n\t\t\t_, err := c.sdk.DeleteIssueLabel(owner, repo, index, l.ID)\n\t\t\tif err != nil {\n\t\t\t\treturn fmt.Errorf(\"remove label %q from %s/%s#%d: %w\", name, owner, repo, index, err)\n\t\t\t}\n\t\t\treturn nil\n\t\t}\n\t}\n\n\treturn nil\n}\n\nfunc (c *Client) labelID(owner, repo, name string) (int64, error) {\n\tlabels, _, err := c.sdk.ListRepoLabels(owner, repo, sdk.ListLabelsOptions{})\n\tif err != nil {\n\t\treturn 0, fmt.Errorf(\"list labels on %s/%s: %w\", owner, repo, err)\n\t}\n\n\tfor _, l := range labels {\n\t\tif l.Name == name {\n\t\t\treturn l.ID, nil\n\t\t}\n\t}\n\n\tcreated, _, err := c.sdk.CreateLabel(owner, repo, sdk.CreateLabelOption{\n\t\tName:  name,\n\t\tColor: \"#ee0000\",\n\t})\n\tif err != nil {\n\t\treturn 0, fmt.Errorf(\"create label %q on %s/%s: %w\", name, owner, repo, err)\n\t}\n\n\treturn created.ID, nil\n}\n\n// CreatePullRequest opens a PR from head into base.\nfunc (c *Client) CreatePullRequest(owner, repo, head, base, title, body string) error {\n\t_, _, err := c.sdk.CreatePullRequest(owner, repo, sdk.CreatePullRequestOption{\n\t\tHead:  head,\n\t\tBase:  base,\n\t\tTitle: title,\n\t\tBody:  body,\n\t})\n\tif err != nil {\n\t\treturn fmt.Errorf(\"create pull request %s/%s %s-\u003e%s: %w\", owner, repo, head, base, err)\n\t}\n\n\treturn nil\n}\n","start_line":1,"end_line":200,"total_lines":432,"truncated":true}

{"path": "internal/agentrun/run.go", "start_line": 400, "end_line": 437}

{"path":"internal/agentrun/run.go","content":"\t\tb.WriteString(\"  Review body:\\n\")\n\t\tfor _, line := range strings.Split(review.Body, \"\\n\") {\n\t\t\tfmt.Fprintf(\u0026b, \"  %s\\n\", line)\n\t\t}\n\t}\n\n\tif len(review.Comments) \u003e 0 {\n\t\tfmt.Fprintf(\u0026b, \"  Inline comments (%d):\\n\", len(review.Comments))\n\n\t\tfor i, c := range review.Comments {\n\t\t\twhere := c.Path\n\t\t\tif c.Line \u003e 0 {\n\t\t\t\twhere = fmt.Sprintf(\"%s:%d\", c.Path, c.Line)\n\t\t\t}\n\n\t\t\tfmt.Fprintf(\u0026b, \"  %d. [%s] %s (comment id %d):\\n\", i+1, where, c.Author, c.ID)\n\t\t\tfor _, line := range strings.Split(c.Body, \"\\n\") {\n\t\t\t\tfmt.Fprintf(\u0026b, \"     %s\\n\", line)\n\t\t\t}\n\t\t}\n\t}\n\n\treturn b.String() + \"\\n\"\n}\n\n// humanReviewState maps a Forgejo review state to a readable verdict.\nfunc humanReviewState(state string) string {\n\tswitch state {\n\tcase \"APPROVED\":\n\t\treturn \"approved\"\n\tcase \"REQUEST_CHANGES\":\n\t\treturn \"changes requested\"\n\tcase \"COMMENT\":\n\t\treturn \"comment\"\n\tdefault:\n\t\treturn state\n\t}\n}","start_line":400,"end_line":437,"total_lines":437,"truncated":false}

{"path": "internal/forgejo/client.go", "start_line": 200, "end_line": 432}

{"path":"internal/forgejo/client.go","content":"\n// RequestReview asks the given users to review the pull request.\nfunc (c *Client) RequestReview(owner, repo string, index int64, reviewers []string) error {\n\t_, err := c.sdk.CreateReviewRequests(owner, repo, index, sdk.PullReviewRequestOptions{Reviewers: reviewers})\n\tif err != nil {\n\t\treturn fmt.Errorf(\"request review on %s/%s#%d: %w\", owner, repo, index, err)\n\t}\n\n\treturn nil\n}\n\n// Review states an agent can submit, in the friendly names the tools\n// expose. SubmitReview maps them onto the SDK's ReviewStateType.\nconst (\n\tReviewStateApproved       = \"approved\"\n\tReviewStateChangesRequest = \"changes_requested\"\n\tReviewStateComment        = \"comment\"\n)\n\n// SubmitReview submits a review on the pull request with the given\n// verdict and body. state is one of ReviewStateApproved,\n// ReviewStateChangesRequest, or ReviewStateComment. A body is required\n// for anything other than an approval (Forgejo enforces this too).\nfunc (c *Client) SubmitReview(owner, repo string, index int64, state, body string) error {\n\tvar sdkState sdk.ReviewStateType\n\n\tswitch state {\n\tcase ReviewStateApproved:\n\t\tsdkState = sdk.ReviewStateApproved\n\tcase ReviewStateChangesRequest:\n\t\tsdkState = sdk.ReviewStateRequestChanges\n\tcase ReviewStateComment:\n\t\tsdkState = sdk.ReviewStateComment\n\tdefault:\n\t\treturn fmt.Errorf(\"submit review on %s/%s#%d: unknown review state %q\", owner, repo, index, state)\n\t}\n\n\tif _, _, err := c.sdk.CreatePullReview(owner, repo, index, sdk.CreatePullReviewOptions{State: sdkState, Body: body}); err != nil {\n\t\treturn fmt.Errorf(\"submit review on %s/%s#%d: %w\", owner, repo, index, err)\n\t}\n\n\treturn nil\n}\n\n// ReviewCommentDetail is one inline comment on a pull request review,\n// in the shape zoo needs when briefing an agent: where it points, what\n// it says, and its id (so the agent can refer to it in its reply).\ntype ReviewCommentDetail struct {\n\tID     int64\n\tPath   string\n\tLine   int\n\tBody   string\n\tAuthor string\n}\n\n// ReviewDetail is the review context zoo briefs an agent with when a\n// pr:review event fires: the review's verdict and body, plus its inline\n// comments.\ntype ReviewDetail struct {\n\tID       int64\n\tState    string\n\tBody     string\n\tReviewer string\n\tComments []ReviewCommentDetail\n}\n\n// ReviewDetail fetches a pull request review and its inline comments.\n// The webhook payload carries the review but not its inline comments,\n// so this is how a reacting agent gets the full feedback.\nfunc (c *Client) ReviewDetail(owner, repo string, index, reviewID int64) (*ReviewDetail, error) {\n\treview, _, err := c.sdk.GetPullReview(owner, repo, index, reviewID)\n\tif err != nil {\n\t\treturn nil, fmt.Errorf(\"get review %d on %s/%s#%d: %w\", reviewID, owner, repo, index, err)\n\t}\n\n\tcomments, _, err := c.sdk.ListPullReviewComments(owner, repo, index, reviewID)\n\tif err != nil {\n\t\treturn nil, fmt.Errorf(\"list comments on review %d of %s/%s#%d: %w\", reviewID, owner, repo, index, err)\n\t}\n\n\tdetail := \u0026ReviewDetail{\n\t\tID:    review.ID,\n\t\tState: string(review.State),\n\t\tBody:  review.Body,\n\t}\n\n\tif review.Reviewer != nil {\n\t\tdetail.Reviewer = review.Reviewer.UserName\n\t}\n\n\tfor _, cm := range comments {\n\t\tauthor := \"\"\n\t\tif cm.Reviewer != nil {\n\t\t\tauthor = cm.Reviewer.UserName\n\t\t}\n\n\t\tline := int(cm.LineNum)\n\t\tif cm.OldLineNum != 0 \u0026\u0026 cm.LineNum == 0 {\n\t\t\tline = int(cm.OldLineNum)\n\t\t}\n\n\t\tdetail.Comments = append(detail.Comments, ReviewCommentDetail{\n\t\t\tID:     cm.ID,\n\t\t\tPath:   cm.Path,\n\t\t\tLine:   line,\n\t\t\tBody:   cm.Body,\n\t\t\tAuthor: author,\n\t\t})\n\t}\n\n\treturn detail, nil\n}\n\n// PullRequestInfo is the branch metadata agentrun needs to check out a\n// pull request's head.\ntype PullRequestInfo struct {\n\tHeadRef string\n\tBaseRef string\n}\n\n// PullRequestInfo returns the pull request's head and base branch refs.\nfunc (c *Client) PullRequestInfo(owner, repo string, index int64) (PullRequestInfo, error) {\n\tpr, _, err := c.sdk.GetPullRequest(owner, repo, index)\n\tif err != nil {\n\t\treturn PullRequestInfo{}, fmt.Errorf(\"get pull request %s/%s#%d: %w\", owner, repo, index, err)\n\t}\n\n\tinfo := PullRequestInfo{}\n\tif pr.Head != nil {\n\t\tinfo.HeadRef = pr.Head.Ref\n\t}\n\tif pr.Base != nil {\n\t\tinfo.BaseRef = pr.Base.Ref\n\t}\n\n\treturn info, nil\n}\n\n// CloseIssue closes the given issue or pull request.\nfunc (c *Client) CloseIssue(owner, repo string, index int64) error {\n\treturn c.setIssueState(owner, repo, index, sdk.StateClosed)\n}\n\n// ReopenIssue reopens the given issue or pull request.\nfunc (c *Client) ReopenIssue(owner, repo string, index int64) error {\n\treturn c.setIssueState(owner, repo, index, sdk.StateOpen)\n}\n\n// RepositoryInfo returns the pieces of repo metadata agentrun needs to\n// clone and branch off of the right place.\ntype RepositoryInfo struct {\n\tDefaultBranch string\n\tCloneURL      string\n}\n\nfunc (c *Client) RepositoryInfo(owner, repo string) (RepositoryInfo, error) {\n\tr, _, err := c.sdk.GetRepo(owner, repo)\n\tif err != nil {\n\t\treturn RepositoryInfo{}, fmt.Errorf(\"get repo %s/%s: %w\", owner, repo, err)\n\t}\n\n\treturn RepositoryInfo{DefaultBranch: r.DefaultBranch, CloneURL: r.CloneURL}, nil\n}\n\nfunc (c *Client) setIssueState(owner, repo string, index int64, state sdk.StateType) error {\n\t_, _, err := c.sdk.EditIssue(owner, repo, index, sdk.EditIssueOption{State: \u0026state})\n\tif err != nil {\n\t\treturn fmt.Errorf(\"set state %q on %s/%s#%d: %w\", state, owner, repo, index, err)\n\t}\n\n\treturn nil\n}\n\n// AgentProfile is what zoo reads off an agent's Forgejo account: its bio\n// (surfaced in the system prompt), the name/email used to set git commit\n// authorship inside that agent's container, and its avatar URL (surfaced\n// on the dashboard).\ntype AgentProfile struct {\n\tDescription string\n\tFullName    string\n\tEmail       string\n\tAvatarURL   string\n}\n\n// AgentProfile fetches the Forgejo profile of the user account named\n// username. Agent config labels double as their Forgejo usernames (see\n// issue:assigned resolution), so this is how an agent's \"what it does\"\n// text, and its commit identity, are authored: by editing that account's\n// profile on Forgejo, not in zoo.hcl.\nfunc (c *Client) AgentProfile(username string) (AgentProfile, error) {\n\tu, _, err := c.sdk.GetUserInfo(username)\n\tif err != nil {\n\t\treturn AgentProfile{}, fmt.Errorf(\"get user %q: %w\", username, err)\n\t}\n\n\tp := AgentProfile{\n\t\tDescription: u.Description,\n\t\tFullName:    u.FullName,\n\t\tEmail:       u.Email,\n\t\tAvatarURL:   u.AvatarURL,\n\t}\n\n\treturn p, nil\n}\n\n// AssignIssue sets the sole assignee of an issue/PR to username. Used by\n// the assign_issue tool so agents can hand work off to each other: the\n// resulting issue:assigned event (webhook or poll) triggers whichever\n// agent's config label matches username.\nfunc (c *Client) AssignIssue(owner, repo string, index int64, username string) error {\n\t_, _, err := c.sdk.EditIssue(owner, repo, index, sdk.EditIssueOption{Assignees: []string{username}})\n\tif err != nil {\n\t\treturn fmt.Errorf(\"assign %s/%s#%d to %q: %w\", owner, repo, index, username, err)\n\t}\n\n\treturn nil\n}\n\n// IssueTitle fetches the title of an issue or pull request from Forgejo.\n// Returns an empty string (not an error) if the client is nil or the\n// issue cannot be fetched — the caller should degrade gracefully.\nfunc (c *Client) IssueTitle(owner, repo string, index int64) string {\n\tif c == nil || c.sdk == nil {\n\t\treturn \"\"\n\t}\n\n\tissue, _, err := c.sdk.GetIssue(owner, repo, index)\n\tif err != nil {\n\t\treturn \"\"\n\t}\n\n\treturn issue.Title\n}","start_line":200,"end_line":432,"total_lines":432,"truncated":false}

{"path": "internal/agentrun/sandboxgit_test.go", "start_line": 1, "end_line": 200}

{"path":"internal/agentrun/sandboxgit_test.go","content":"package agentrun\n\nimport (\n\t\"encoding/base64\"\n\t\"strings\"\n\t\"testing\"\n)\n\nfunc TestSandboxShellQuote(t *testing.T) {\n\tcases := map[string]string{\n\t\t\"simple\":            \"'simple'\",\n\t\t\"it's a branch\":     `'it'\\''s a branch'`,\n\t\t\"with space\":        \"'with space'\",\n\t\t\"$(rm -rf /)\":       \"'$(rm -rf /)'\",\n\t\t\"a\\\"b\\\\c\":           \"'a\\\"b\\\\c'\",\n\t\t\"\":                  \"''\",\n\t\t\"HEAD~1\":            \"'HEAD~1'\",\n\t\t\"https://h/a/b.git\": \"'https://h/a/b.git'\",\n\t}\n\n\tfor in, want := range cases {\n\t\tif got := shellQuote(in); got != want {\n\t\t\tt.Errorf(\"shellQuote(%q) = %q, want %q\", in, got, want)\n\t\t}\n\t}\n}\n\nfunc TestShellGitCmdQuotesEveryArg(t *testing.T) {\n\tgot := shellGitCmd(\"clone\", \"--branch\", \"main\", \"--single-branch\", \"https://h/a/b.git\", \"/project\")\n\n\twant := \"git 'clone' '--branch' 'main' '--single-branch' 'https://h/a/b.git' '/project'\"\n\n\tif got != want {\n\t\tt.Fatalf(\"shellGitCmd = %q, want %q\", got, want)\n\t}\n}\n\nfunc TestShellGitCmdSubcommandWithArgs(t *testing.T) {\n\tgot := shellGitCmd(\"commit\", \"-m\", \"fix: handle it's edge case\")\n\n\tif !strings.HasPrefix(got, \"git 'commit' '-m' \") {\n\t\tt.Fatalf(\"shellGitCmd = %q, want prefix git 'commit' '-m' \", got)\n\t}\n\n\t// The message must be one quoted word with the embedded quote\n\t// escaped, so sh passes it through verbatim.\n\tif want := `'fix: handle it'\\''s edge case'`; !strings.HasSuffix(got, want) {\n\t\tt.Fatalf(\"shellGitCmd = %q, want suffix %q\", got, want)\n\t}\n}\n\nfunc TestForgeHost(t *testing.T) {\n\tcases := map[string]string{\n\t\t\"https://code.stdio.dk/abrander/zoo.git\": \"https://code.stdio.dk\",\n\t\t\"http://forgejo.local:3000/acme/widgets\": \"http://forgejo.local:3000\",\n\t\t\"https://h/a/b.git?x=1\":                  \"https://h\",\n\t\t// Not a URL with a host: fall back to the full string, which is\n\t\t// still a valid (narrower) prefix match.\n\t\t\"/bare\":     \"/bare\",\n\t\t\"not a url\": \"not a url\",\n\t}\n\n\tfor in, want := range cases {\n\t\tif got := forgeHost(in); got != want {\n\t\t\tt.Errorf(\"forgeHost(%q) = %q, want %q\", in, got, want)\n\t\t}\n\t}\n}\n\nfunc TestGitAuthHeader(t *testing.T) {\n\tgot := gitAuthHeader(\"greg\", \"s3cr3t\")\n\n\twant := \"Authorization: Basic \" + base64.StdEncoding.EncodeToString([]byte(\"greg:s3cr3t\"))\n\n\tif got != want {\n\t\tt.Fatalf(\"gitAuthHeader = %q, want %q\", got, want)\n\t}\n}","start_line":1,"end_line":78,"total_lines":78,"truncated":false}

{"path": "internal/agentrun/docker_integration_test.go", "start_line": 1, "end_line": 250}

{"path":"internal/agentrun/docker_integration_test.go","content":"//go:build docker\n\n// Run with: go test -tags docker ./internal/agentrun/...\n// Requires a reachable Docker daemon (DOCKER_HOST or the default socket).\npackage agentrun\n\nimport (\n\t\"context\"\n\t\"os\"\n\t\"os/exec\"\n\t\"path/filepath\"\n\t\"strings\"\n\t\"testing\"\n\t\"time\"\n)\n\nfunc TestDockerRuntimeExecRoundTrip(t *testing.T) {\n\trt, err := newDockerRuntime()\n\tif err != nil {\n\t\tt.Fatalf(\"docker client: %v\", err)\n\t}\n\n\tctx, cancel := context.WithTimeout(context.Background(), 60*time.Second)\n\tdefer cancel()\n\n\tcontainerID, err := rt.createContainer(ctx, \"debian:unstable\", nil, \"zoo-test-run\")\n\tif err != nil {\n\t\tt.Fatalf(\"create container: %v\", err)\n\t}\n\tdefer rt.remove(context.Background(), containerID)\n\n\toutput, exitCode, err := rt.exec(ctx, containerID, \"echo hello-from-zoo\")\n\tif err != nil {\n\t\tt.Fatalf(\"exec: %v\", err)\n\t}\n\tif exitCode != 0 {\n\t\tt.Fatalf(\"expected exit code 0, got %d\", exitCode)\n\t}\n\tif !strings.Contains(output, \"hello-from-zoo\") {\n\t\tt.Fatalf(\"unexpected output: %q\", output)\n\t}\n\n\t_, exitCode, err = rt.exec(ctx, containerID, \"exit 3\")\n\tif err != nil {\n\t\tt.Fatalf(\"exec: %v\", err)\n\t}\n\tif exitCode != 3 {\n\t\tt.Fatalf(\"expected exit code 3, got %d\", exitCode)\n\t}\n}\n\n// TestDockerRuntimeGitSafeDirectory reproduces the \"detected dubious\n// ownership\" error git raises against a bind-mounted repo owned by a\n// different UID than the container runs as, and confirms the `git\n// config --system --add safe.directory '*'` fix Run() applies (see\n// run.go) actually clears it, against the same golang:latest image\n// zoo.hcl now defaults to.\nfunc TestDockerRuntimeGitSafeDirectory(t *testing.T) {\n\tprojectDir := t.TempDir()\n\n\tfor _, args := range [][]string{\n\t\t{\"init\", \"-q\", projectDir},\n\t\t{\"-C\", projectDir, \"commit\", \"-q\", \"--allow-empty\", \"-m\", \"init\"},\n\t} {\n\t\tif out, err := exec.Command(\"git\", args...).CombinedOutput(); err != nil {\n\t\t\tt.Fatalf(\"git %v: %v: %s\", args, err, out)\n\t\t}\n\t}\n\n\trt, err := newDockerRuntime()\n\tif err != nil {\n\t\tt.Fatalf(\"docker client: %v\", err)\n\t}\n\n\tctx, cancel := context.WithTimeout(context.Background(), 60*time.Second)\n\tdefer cancel()\n\n\tcontainerID, err := rt.createContainer(ctx, \"golang:latest\", []string{projectDir + \":/project\"}, \"zoo-test-git\")\n\tif err != nil {\n\t\tt.Fatalf(\"create container: %v\", err)\n\t}\n\tdefer rt.remove(context.Background(), containerID)\n\n\toutput, _, err := rt.exec(ctx, containerID, \"git status\")\n\tif err != nil {\n\t\tt.Fatalf(\"exec: %v\", err)\n\t}\n\tif !strings.Contains(output, \"dubious ownership\") {\n\t\tt.Fatalf(\"expected the bind mount to reproduce dubious ownership before the fix, got: %s\", output)\n\t}\n\n\toutput, exitCode, err := rt.exec(ctx, containerID, \"git config --system --add safe.directory '*'\")\n\tif err != nil || exitCode != 0 {\n\t\tt.Fatalf(\"configure safe.directory: err=%v exit=%d: %s\", err, exitCode, output)\n\t}\n\n\toutput, exitCode, err = rt.exec(ctx, containerID, \"git status\")\n\tif err != nil {\n\t\tt.Fatalf(\"exec: %v\", err)\n\t}\n\tif exitCode != 0 || strings.Contains(output, \"dubious ownership\") {\n\t\tt.Fatalf(\"expected git status to succeed after the fix, got exit=%d: %s\", exitCode, output)\n\t}\n}\n\n// TestDockerRuntimeSandboxGit exercises the in-sandbox git setup\n// Run() performs (see sandboxgit.go): the system gitconfig round-trip\n// (including the http.\u003curl\u003e.extraHeader key whose subsection is a URL\n// full of dots and colons), the initial clone + branch done inside the\n// container, the commit identity taken from the system gitconfig, and\n// that the credential never lands in the bind-mounted working tree.\n// The clone uses a local path remote (no http involved), so the test\n// needs no reachable Forgejo; the header mechanism itself is core git\n// behavior.\nfunc TestDockerRuntimeSandboxGit(t *testing.T) {\n\ttmp := t.TempDir()\n\n\t// A bare \"remote\" on the host, plus the empty directory the\n\t// container will clone into (Run() creates it before the container\n\t// exists, for the same reason).\n\tseedDir := filepath.Join(tmp, \"seed\")\n\tbareDir := filepath.Join(tmp, \"remote.git\")\n\tprojectDir := filepath.Join(tmp, \"project\")\n\n\trun := func(dir string, args ...string) {\n\t\tcmd := exec.Command(\"git\", args...)\n\t\tcmd.Dir = dir\n\n\t\tif out, err := cmd.CombinedOutput(); err != nil {\n\t\t\tt.Fatalf(\"git %v: %v: %s\", args, err, out)\n\t\t}\n\t}\n\n\trun(\"\", \"init\", \"-q\", \"-b\", \"main\", seedDir)\n\trun(seedDir, \"config\", \"user.name\", \"zoo-test\")\n\trun(seedDir, \"config\", \"user.email\", \"zoo@test\")\n\n\tif err := os.WriteFile(filepath.Join(seedDir, \"file.txt\"), []byte(\"hello\\n\"), 0o644); err != nil {\n\t\tt.Fatalf(\"write seed file: %v\", err)\n\t}\n\n\trun(seedDir, \"add\", \".\")\n\trun(seedDir, \"commit\", \"-q\", \"-m\", \"init\")\n\trun(\"\", \"clone\", \"-q\", \"--bare\", seedDir, bareDir)\n\n\tif err := os.MkdirAll(projectDir, 0o755); err != nil {\n\t\tt.Fatalf(\"create project dir: %v\", err)\n\t}\n\n\trt, err := newDockerRuntime()\n\tif err != nil {\n\t\tt.Fatalf(\"docker client: %v\", err)\n\t}\n\n\tctx, cancel := context.WithTimeout(context.Background(), 120*time.Second)\n\tdefer cancel()\n\n\tcontainerID, err := rt.createContainer(ctx, \"golang:latest\", []string{\n\t\tbareDir + \":/bare\",\n\t\tprojectDir + \":/project\",\n\t}, \"zoo-test-sandbox-git\")\n\tif err != nil {\n\t\tt.Fatalf(\"create container: %v\", err)\n\t}\n\tdefer rt.remove(context.Background(), containerID)\n\n\tconst (\n\t\tcloneURL = \"https://forgejo.example/acme/widgets.git\"\n\t\tuser     = \"greg\"\n\t\ttoken    = \"super-secret-token\"\n\t)\n\n\tif err := configureSandboxGit(ctx, rt, containerID, cloneURL, user, token, \"Greg Coolio\", \"greg@noreply.localhost\"); err != nil {\n\t\tt.Fatalf(\"configureSandboxGit: %v\", err)\n\t}\n\n\t// The credential must round-trip through the system gitconfig,\n\t// which is what makes plain `git pull`/`git push` authenticate.\n\twantHeader := gitAuthHeader(user, token)\n\n\tout, err := runSandboxGit(ctx, rt, containerID, \"config\", \"--system\", \"--get\", \"http.\"+forgeHost(cloneURL)+\".extraHeader\")\n\tif err != nil {\n\t\tt.Fatalf(\"read back credential: %v\", err)\n\t}\n\tif got := strings.TrimSpace(out); got != wantHeader {\n\t\tt.Fatalf(\"credential round-trip = %q, want %q\", got, wantHeader)\n\t}\n\n\tif err := cloneAndBranch(ctx, rt, containerID, \"/bare\", \"main\", \"issue-1-greg\"); err != nil {\n\t\tt.Fatalf(\"cloneAndBranch: %v\", err)\n\t}\n\n\t// The clone happened inside the container: the fresh branch is\n\t// checked out in /project.\n\tout, err = runSandboxGit(ctx, rt, containerID, \"branch\", \"--show-current\")\n\tif err != nil {\n\t\tt.Fatalf(\"branch --show-current: %v\", err)\n\t}\n\tif got := strings.TrimSpace(out); got != \"issue-1-greg\" {\n\t\tt.Fatalf(\"branch = %q, want issue-1-greg\", got)\n\t}\n\n\t// Commits must pick up the identity from the system gitconfig.\n\tif _, exitCode, err := rt.exec(ctx, containerID, \"echo more \u003e\u003e file.txt \u0026\u0026 git add file.txt \u0026\u0026 git commit -qm 'from sandbox'\"); err != nil || exitCode != 0 {\n\t\tt.Fatalf(\"commit in sandbox: err=%v exit=%d\", err, exitCode)\n\t}\n\n\tout, err = runSandboxGit(ctx, rt, containerID, \"log\", \"-1\", \"--format=%an %ae\")\n\tif err != nil {\n\t\tt.Fatalf(\"log: %v\", err)\n\t}\n\tif got := strings.TrimSpace(out); got != \"Greg Coolio greg@noreply.localhost\" {\n\t\tt.Fatalf(\"commit author = %q, want %q\", got, \"Greg Coolio greg@noreply.localhost\")\n\t}\n\n\t// The token must not leak into the bind-mounted working tree.\n\tout, _, err = rt.exec(ctx, containerID, \"grep -r super-secret-token /project || true\")\n\tif err != nil {\n\t\tt.Fatalf(\"grep: %v\", err)\n\t}\n\tif strings.Contains(out, \"super-secret-token\") {\n\t\tt.Fatalf(\"token leaked into the working tree: %s\", out)\n\t}\n}","start_line":1,"end_line":224,"total_lines":224,"truncated":false}

{"path": "zoo.hcl.example", "start_line": 1, "end_line": 100}

{"path":"zoo.hcl.example","content":"# zoo.hcl - Configuration for the zoo daemon.\n#\n# Copy this file to zoo.hcl (gitignored) and fill in real values.\n\nllm \"Qwen 3.6\" {\n    openai = \"https://code.stdio.dk\"\n    token  = \"TOKEN\"\n    model  = \"Qwen3.6\"\n}\n\nllm \"Qwen 3.8\" {\n    openai = \"https://code.stdio.dk\"\n    token  = \"TOKEN\"\n    model  = \"Qwen3.8\"\n}\n\nforgejo {\n    url            = \"https://code.stdio.dk\"\n    token          = \"ZOO_SERVICE_TOKEN\"\n    # Shared secret configured on the Forgejo webhook. Required to accept\n    # webhook deliveries; polling works without it.\n    webhook_secret = \"EXAMPLE_WEBHOOK_SECRET\"\n\n    # Which repositories to watch. Events from every other repository\n    # are ignored. Each entry is an \"owner/repo\" pair with glob\n    # wildcards:\n    #\n    #   repos = [\"acme/*\"]          # everything in the acme org\n    #   repos = [\"acme/widgets\"]    # just that one repository\n    #   repos = [\"acme/web*\"]       # repos in acme whose name starts with \"web\"\n    #   repos = [\"acme\", \"bob\"]     # bare names mean \"everything in that org\"\n    #   repos = [\"*\"]               # everything on the instance\n    #\n    # Owner names match case-insensitively (like Forgejo usernames);\n    # repository names match case-sensitively. Leave the list out (or\n    # empty) to watch everything the token can see.\n    # repos = [\"abrander/*\", \"acme/widgets\"]\n}\n\nenvironment {\n    docker_image   = \"golang:latest\"\n    max_live_agents = 5\n}\n\nagent \"anna\" {\n    llm   = \"Qwen 3.6\"\n    token = \"ANNA_FORGEJO_TOKEN\"\n}\n\nagent \"greg\" {\n    llm   = \"Qwen 3.8\"\n    token = \"GREG_FORGEJO_TOKEN\"\n}\n\n# \"leon\" doubles as the expected Forgejo assignee username for\n# issue:assigned events - see the event block below.\nagent \"leon\" {\n    llm   = \"Qwen 3.8\"\n    token = \"LEON_FORGEJO_TOKEN\"\n}\n\nagent \"mika\" {\n    llm   = \"Qwen 3.6\"\n    token = \"MIKA_FORGEJO_TOKEN\"\n}\n\nevent \"issue:new\" {\n    agent = \"leon\"\n}\n\nevent \"issue:assigned\" {\n    // No `agent` here: the agent whose name matches the Forgejo\n    // assignee's username is triggered.\n    instructions = \"Please handle this issue.\"\n}\n\nevent \"issue:comment\" {\n    agent        = \"leon\"\n    instructions = \"Please review what this comment says and respond appropriately.\"\n}\n\nevent \"pr:new\" {\n    agent        = \"greg\"\n    instructions = \"Please review this pull request and respond appropriately.\"\n}\n\n# A review was submitted on a pull request (approved, changes requested,\n# or comment). The agent that opened the PR is triggered to handle it,\n# like issue:assigned: its working tree is checked out on the PR's head\n# branch, so changes it pushes update the PR directly. It should address\n# the feedback and reply to the review with a summary of what it\n# addressed. (Forgejo has no API to mark review comments resolved, so\n# that stays with the reviewer.)\nevent \"pr:review\" {\n    // No `agent` here: the agent whose name matches the pull request\n    // author's username is triggered.\n    instructions = \"A review was submitted on this pull request. Address the feedback, push your changes to the PR branch, and reply to the review with a summary of what you addressed.\"\n}","start_line":1,"end_line":98,"total_lines":98,"truncated":false}

{"path": "internal/agentrun/system.md", "start_line": 1, "end_line": 120}

{"path":"internal/agentrun/system.md","content":"You are an autonomous coding agent working inside `zoo`, a system that\ntriggers you from Forgejo (a Gitea-family forge) issue/PR events.\n\n**Your environment**\n\n- Your working tree is at `/project`, checked out on the working branch\n  named in your briefing below. For most events that's a fresh branch\n  off the repository's default branch; for a PR review event it's the\n  pull request's own head branch, so commits you push update the PR\n  directly. Only `/project` persists; nothing outside it survives\n  between tool calls.\n- The event that triggered you (issue or pull request JSON) is available\n  at `/event` inside the container, and is also included below.\n- You have a real git remote configured with push access. When you're\n  done, `git add`/`git commit`/`git push` your branch — that's how your\n  work gets saved. Nothing is persisted automatically.\n\n**Tools**\n\n- `bash`, `read_file`, `write_file`, `list_files`, `grep_search`,\n  `move_file`, `remove_file` operate on the project container.\n- `comment`, `open_pull_request`, `request_review`, `submit_review`,\n  `add_label`, `remove_label`, `close_issue`, `reopen_issue`,\n  `assign_issue` act directly on the Forgejo issue/PR that triggered\n  this run — use `comment` to report back to the person who filed it,\n  `open_pull_request` once you've pushed a branch with your changes,\n  and `submit_review` to leave a review verdict.\n\nBelow, in \"Your identity\" and \"Other agents\", you'll find your own role\n(from your Forgejo profile) and a roster of the other agents zoo runs,\neach with their own role. If a task in front of you clearly belongs to\nsomeone else's role, use `assign_issue` to hand it off rather than\ndoing it yourself.\n\n**Git**\n\nYou may use normal git commands in `bash` to manage your working tree.\nRemote (pull, fetch, push, etc.) git operations are authenticated for\nyou and simply work.\n\n**Guidelines**\n\n- Make surgical changes: modify only what's necessary for the task in\n  the triggering event.\n- Before finishing, verify your changes (re-read the file, run tests or\n  a build if the project has them).\n- Always leave a `comment` summarizing what you did (or why you couldn't\n  finish), and use `open_pull_request` when you have a change ready for\n  review. Don't leave the issue without a response.","start_line":1,"end_line":49,"total_lines":49,"truncated":false}

{"path": "cmd/zoo/main.go", "start_line": 1, "end_line": 150}

{"path":"cmd/zoo/main.go","content":"// Command zoo runs the daemon: it watches a Forgejo instance for\n// issue/PR events, dispatches them to configured AI agents running in\n// Docker containers, and serves a small dashboard over the result.\npackage main\n\nimport (\n\t\"context\"\n\t\"flag\"\n\t\"fmt\"\n\t\"log/slog\"\n\t\"net/http\"\n\t\"os\"\n\t\"os/signal\"\n\t\"syscall\"\n\t\"time\"\n\n\t\"github.com/abrander/zoo/internal/agentrun\"\n\t\"github.com/abrander/zoo/internal/config\"\n\t\"github.com/abrander/zoo/internal/forgejo\"\n\t\"github.com/abrander/zoo/internal/livelog\"\n\t\"github.com/abrander/zoo/internal/scheduler\"\n\t\"github.com/abrander/zoo/internal/store\"\n\t\"github.com/abrander/zoo/internal/web\"\n)\n\nfunc main() {\n\tif err := run(); err != nil {\n\t\tfmt.Fprintln(os.Stderr, \"zoo:\", err)\n\n\t\tos.Exit(1)\n\t}\n}\n\nfunc run() error {\n\tvar (\n\t\tconfigPath    = flag.String(\"config\", \"zoo.hcl\", \"path to the zoo.hcl config file\")\n\t\tdbPath        = flag.String(\"db\", \"zoo.db\", \"path to the sqlite state database\")\n\t\tlisten        = flag.String(\"listen\", \":8080\", \"address to serve webhooks and the dashboard on\")\n\t\trunTimeout    = flag.Duration(\"run-timeout\", agentrun.DefaultTimeout, \"wall-clock timeout for a single agent run\")\n\t\tkeepOnFailure = flag.Bool(\"keep-on-failure\", false, \"keep the container and clone around after a failed run, for debugging\")\n\t)\n\n\tflag.Parse()\n\n\tlogger := slog.New(slog.NewTextHandler(os.Stderr, nil))\n\n\tcfg, err := config.Load(*configPath)\n\tif err != nil {\n\t\treturn fmt.Errorf(\"load config: %w\", err)\n\t}\n\n\tst, err := store.Open(*dbPath)\n\tif err != nil {\n\t\treturn fmt.Errorf(\"open store: %w\", err)\n\t}\n\tdefer st.Close()\n\n\tif n, err := st.ReapOrphanedJobs(context.Background()); err != nil {\n\t\tlogger.Warn(\"failed to reap orphaned jobs\", \"error\", err)\n\t} else if n \u003e 0 {\n\t\tlogger.Warn(\"reaped jobs left running by a previous process instance\", \"count\", n)\n\t}\n\n\tfgClient, err := forgejo.NewClient(cfg.Forgejo)\n\tif err != nil {\n\t\treturn fmt.Errorf(\"forgejo client: %w\", err)\n\t}\n\n\trepoFilter, err := forgejo.NewRepoFilter(cfg.Forgejo.Repos)\n\tif err != nil {\n\t\treturn fmt.Errorf(\"forgejo repos: %w\", err)\n\t}\n\n\twatcher := forgejo.NewWatcher(fgClient, st, cfg.Forgejo.WebhookSecret, repoFilter, logger.With(\"component\", \"forgejo\"))\n\n\thub := livelog.NewHub()\n\n\trunner, err := agentrun.NewRunner(cfg, fgClient, st, hub, logger.With(\"component\", \"agentrun\"), *runTimeout, *keepOnFailure)\n\tif err != nil {\n\t\treturn fmt.Errorf(\"agent runner: %w\", err)\n\t}\n\n\tsched := scheduler.New(cfg, st, fgClient, runner, hub, logger.With(\"component\", \"scheduler\"))\n\tdashboard := web.New(cfg, st, hub, fgClient)\n\n\tmux := http.NewServeMux()\n\n\tmux.Handle(\"/webhooks/forgejo\", watcher.Handler())\n\n\tmux.HandleFunc(\"/healthz\", func(w http.ResponseWriter, r *http.Request) {\n\t\tw.WriteHeader(http.StatusOK)\n\t\tw.Write([]byte(\"ok\"))\n\t})\n\n\tmux.Handle(\"/\", dashboard.Handler())\n\n\tserver := \u0026http.Server{Addr: *listen, Handler: mux}\n\n\tctx, stop := signal.NotifyContext(context.Background(), os.Interrupt, syscall.SIGTERM)\n\tdefer stop()\n\n\tgo watcher.Run(ctx)\n\tgo sched.Run(ctx, watcher.Events())\n\n\tserveErr := make(chan error, 1)\n\n\tgo func() {\n\t\tlogger.Info(\"listening\", \"addr\", *listen)\n\t\tif err := server.ListenAndServe(); err != nil \u0026\u0026 err != http.ErrServerClosed {\n\t\t\tserveErr \u003c- err\n\t\t}\n\t}()\n\n\tselect {\n\tcase \u003c-ctx.Done():\n\t\tlogger.Info(\"shutting down\")\n\n\tcase err := \u003c-serveErr:\n\t\tstop()\n\n\t\tlogger.Error(\"http server failed\", \"error\", err)\n\t}\n\n\tshutdownCtx, cancel := context.WithTimeout(context.Background(), 30*time.Second)\n\tdefer cancel()\n\n\tif err := server.Shutdown(shutdownCtx); err != nil {\n\t\tlogger.Warn(\"http server shutdown\", \"error\", err)\n\t}\n\n\tif err := sched.Shutdown(shutdownCtx); err != nil {\n\t\tlogger.Warn(\"scheduler did not drain in time\", \"error\", err)\n\t}\n\n\treturn nil\n}","start_line":1,"end_line":136,"total_lines":136,"truncated":false}

{"query": "token|Token", "glob": "internal/agentrun/*.go", "context_after": 2, "context_before": 1}

No matches found.

{"path": "internal/agentrun/roster.go", "start_line": 1, "end_line": 120}

{"path":"internal/agentrun/roster.go","content":"package agentrun\n\nimport (\n\t\"fmt\"\n\t\"log/slog\"\n\t\"strings\"\n\n\t\"github.com/abrander/zoo/internal/config\"\n\t\"github.com/abrander/zoo/internal/forgejo\"\n)\n\n// agentInfo pairs a configured agent with its Forgejo profile: the bio\n// (what its account says it does) and the name/email used to set git\n// commit authorship inside its container.\ntype agentInfo struct {\n\tName        string\n\tDescription string\n\tFullName    string\n\tEmail       string\n}\n\n// buildRoster fetches every configured agent's Forgejo profile (agent\n// config labels double as Forgejo usernames). A per-agent lookup failure\n// is logged and that agent is included with an empty profile rather than\n// failing the whole run — one missing/unreachable profile shouldn't\n// block someone else's job.\nfunc buildRoster(fg *forgejo.Client, agents []config.Agent, logger *slog.Logger) []agentInfo {\n\troster := make([]agentInfo, 0, len(agents))\n\n\tfor _, a := range agents {\n\t\tprofile, err := fg.AgentProfile(a.Name)\n\t\tif err != nil {\n\t\t\tlogger.Warn(\"failed to fetch agent profile from forgejo\", \"agent\", a.Name, \"error\", err)\n\t\t}\n\n\t\troster = append(roster, agentInfo{Name: a.Name, Description: profile.Description, FullName: profile.FullName, Email: profile.Email})\n\t}\n\n\treturn roster\n}\n\n// gitIdentity returns the git commit author name/email to configure\n// inside self's container, from its Forgejo profile, falling back to\n// its agent name and a synthetic zoo.local address for whichever fields\n// its profile doesn't set.\nfunc gitIdentity(self string, roster []agentInfo) (name, email string) {\n\tfor _, a := range roster {\n\t\tif a.Name == self {\n\t\t\tname, email = a.FullName, a.Email\n\t\t\tbreak\n\t\t}\n\t}\n\n\tif name == \"\" {\n\t\tname = self\n\t}\n\n\tif email == \"\" {\n\t\temail = self + \"@zoo.local\"\n\t}\n\n\treturn name, email\n}\n\n// identitySection renders the \"who am I / who else is there\" prompt\n// section injected after the static system prompt: the agent's own\n// Forgejo profile description, and everyone else's, so it can decide\n// when a task is better handed off via the assign_issue tool.\nfunc identitySection(self string, roster []agentInfo) string {\n\tvar b strings.Builder\n\n\tvar selfDesc string\n\tvar others []agentInfo\n\n\tfor _, a := range roster {\n\t\tif a.Name == self {\n\t\t\tselfDesc = a.Description\n\t\t} else {\n\t\t\tothers = append(others, a)\n\t\t}\n\t}\n\n\tfmt.Fprintf(\u0026b, \"\\n\\n## Your identity\\n\\nYou are the agent %q.\", self)\n\n\tif selfDesc != \"\" {\n\t\tfmt.Fprintf(\u0026b, \" Your role, from your Forgejo profile description: %s\", selfDesc)\n\t} else {\n\t\tb.WriteString(\" Your Forgejo profile has no description set.\")\n\t}\n\n\tif len(others) \u003e 0 {\n\t\tb.WriteString(\"\\n\\n## Other agents\\n\\nIf this task is a better fit for another agent's role, use the assign_issue tool with their name to hand it off (this reassigns the issue/PR on Forgejo, which triggers their run):\\n\")\n\n\t\tfor _, a := range others {\n\t\t\tdesc := a.Description\n\t\t\tif desc == \"\" {\n\t\t\t\tdesc = \"(no description set)\"\n\t\t\t}\n\n\t\t\tfmt.Fprintf(\u0026b, \"### %s\\n\\n%s\\n\\n\", a.Name, desc)\n\t\t}\n\t}\n\n\treturn b.String()\n}","start_line":1,"end_line":105,"total_lines":105,"truncated":false}

{"query": "Token", "glob": "**/*.go", "max_results": 80}

No matches found.

{"command": "cd /project && grep -rn \"Token\" --include=\"*.go\" internal/ | head -50 && echo --- && grep -rn \"extraHeader\\|insteadOf\\|host.docker\" --include=\"*.go\" internal/ | head -20"}

internal/config/config.go:43:	Token string `hcl:"token,optional"`
internal/config/config.go:49:	Token  string `hcl:"token"`
internal/config/config.go:55:	Token         string `hcl:"token"`
internal/config/config.go:74:	Token string `hcl:"token,optional"`
internal/config/config.go:103:		if l.OpenAI == "" || l.Token == "" || l.Model == "" {
internal/config/config.go:109:	if c.Forgejo.URL == "" || c.Forgejo.Token == "" {
internal/config/config.go:194:	Token string
internal/config/config.go:204:				Token: a.Token,
internal/web/web_test.go:161:	cfg := &config.Config{Web: &config.Web{Token: "secret"}}
internal/web/web_test.go:210:	fg, err := forgejo.NewClient(config.Forgejo{URL: api.URL, Token: "test"})
internal/web/web.go:67:	if s.cfg.Web == nil || s.cfg.Web.Token == "" {
internal/web/web.go:71:	token := s.cfg.Web.Token
internal/llm/client.go:24:		token:      cfg.Token,
internal/llm/types.go:218:	PromptPerTokenMs    float64 `json:"prompt_per_token_ms"`
internal/llm/types.go:222:	PredictedPerTokenMs float64 `json:"predicted_per_token_ms"`
internal/forgejo/client.go:25:	c, err := sdk.NewClient(cfg.URL, sdk.SetToken(cfg.Token))
internal/forgejo/client.go:30:	return &Client{sdk: c, baseURL: cfg.URL, token: cfg.Token}, nil
internal/forgejo/client.go:33:// Token returns the shared zoo Forgejo identity's token, e.g. for
internal/forgejo/client.go:37:func (c *Client) Token() string {
internal/forgejo/client.go:46:	client, _ := sdk.NewClient(c.baseURL, sdk.SetToken(token))
internal/forgejo/client.go:61:	sudoClient, err := sdk.NewClient(c.baseURL, sdk.SetToken(c.token), sdk.SetSudo(username))
internal/forgejo/poll_test.go:38:	client, err := NewClient(config.Forgejo{URL: serverURL, Token: "test"})
internal/forgejo/client_test.go:76:	client, err := NewClient(config.Forgejo{URL: server.URL, Token: "test"})
internal/forgejo/client_test.go:110:	client, err := NewClient(config.Forgejo{URL: server.URL, Token: "test"})
internal/forgejo/client_test.go:147:	client, err := NewClient(config.Forgejo{URL: server.URL, Token: "test"})
internal/forgejo/client_test.go:188:	client, err := NewClient(config.Forgejo{URL: server.URL, Token: "test"})
internal/forgejo/client_test.go:226:	client, err := NewClient(config.Forgejo{URL: server.URL, Token: "test"})
internal/forgejo/client_test.go:246:	client, err := NewClient(config.Forgejo{URL: server.URL, Token: "test"})
internal/agentrun/run.go:183:	gitUser, gitToken := "zoo", r.forgejo.Token()
internal/agentrun/run.go:185:	if agent.Token != "" {
internal/agentrun/run.go:186:		gitUser, gitToken = agent.Name, agent.Token
internal/agentrun/run.go:213:	if err := configureSandboxGit(ctx, r.docker, containerID, repoInfo.CloneURL, gitUser, gitToken, gitName, gitEmail); err != nil {
internal/agentrun/run.go:239:			client: r.forgejoAs(agent.Name, agent.Token),
internal/scheduler/scheduler_test.go:20:		LLMs:        []config.LLM{{Name: "qwen", OpenAI: "https://example.com", Token: "tok", Model: "qwen3"}},
internal/scheduler/scheduler_test.go:21:		Forgejo:     config.Forgejo{URL: "https://example.com", Token: "tok"},
---
internal/agentrun/sandboxgit.go:80://   - http.<host>.extraHeader carrying the run's Forgejo credential,
internal/agentrun/sandboxgit.go:108:	if _, err := runSandboxGit(ctx, rt, containerID, "config", "--global", "http."+forgeHost(cloneURL)+".extraHeader", gitAuthHeader(user, token)); err != nil {
internal/agentrun/sandboxgit.go:121:// authenticates via the http.<host>.extraHeader configured by
internal/agentrun/docker_integration_test.go:108:// (including the http.<url>.extraHeader key whose subsection is a URL
internal/agentrun/docker_integration_test.go:181:	out, err := runSandboxGit(ctx, rt, containerID, "config", "--system", "--get", "http."+forgeHost(cloneURL)+".extraHeader")

{"path": "internal/config/config.go", "start_line": 1, "end_line": 120}

{"path":"internal/config/config.go","content":"// Package config loads and validates zoo's HCL configuration file.\npackage config\n\nimport (\n\t\"fmt\"\n\t\"strings\"\n\n\t\"github.com/hashicorp/hcl/v2/hclsimple\"\n)\n\n// Known event kinds. issue:assigned and pr:review are resolved\n// dynamically (agent name must match the Forgejo assignee's username,\n// or the pull request author's username, respectively) so they never\n// carry an `agent` attribute; the rest map statically to one\n// configured agent.\nconst (\n\tEventIssueNew      = \"issue:new\"\n\tEventIssueComment  = \"issue:comment\"\n\tEventIssueAssigned = \"issue:assigned\"\n\tEventPRNew         = \"pr:new\"\n\tEventPRReview      = \"pr:review\"\n)\n\nvar staticEventKinds = map[string]bool{\n\tEventIssueNew:     true,\n\tEventIssueComment: true,\n\tEventPRNew:        true,\n}\n\ntype Config struct {\n\tLLMs        []LLM       `hcl:\"llm,block\"`\n\tForgejo     Forgejo     `hcl:\"forgejo,block\"`\n\tEnvironment Environment `hcl:\"environment,block\"`\n\tAgents      []Agent     `hcl:\"agent,block\"`\n\tEvents      []Event     `hcl:\"event,block\"`\n\tWeb         *Web        `hcl:\"web,block\"`\n}\n\n// Web configures the dashboard's optional bearer-token gate. Leave the\n// block out of zoo.hcl entirely to run without one (fine on localhost;\n// put a real gate or a proxy in front for anything else).\ntype Web struct {\n\tToken string `hcl:\"token,optional\"`\n}\n\ntype LLM struct {\n\tName   string `hcl:\"name,label\"`\n\tOpenAI string `hcl:\"openai\"`\n\tToken  string `hcl:\"token\"`\n\tModel  string `hcl:\"model\"`\n}\n\ntype Forgejo struct {\n\tURL           string `hcl:\"url\"`\n\tToken         string `hcl:\"token\"`\n\tWebhookSecret string `hcl:\"webhook_secret,optional\"`\n\n\t// Repos is the allowlist of repository patterns to watch, e.g.\n\t// [\"acme/*\", \"acme/widgets\"]. Patterns are \"owner/repo\" pairs with\n\t// glob wildcards; \"*\" watches everything on the instance. An empty\n\t// list keeps the historical behavior of watching every repository\n\t// the token can see.\n\tRepos []string `hcl:\"repos,optional\"`\n}\n\ntype Environment struct {\n\tDockerImage string `hcl:\"docker_image\"`\n\tMaxLive     int    `hcl:\"max_live_agents\"`\n}\n\ntype Agent struct {\n\tName  string `hcl:\"name,label\"`\n\tLLM   string `hcl:\"llm\"`\n\tToken string `hcl:\"token,optional\"`\n}\n\ntype Event struct {\n\tKind         string `hcl:\"name,label\"`\n\tAgent        string `hcl:\"agent,optional\"`\n\tInstructions string `hcl:\"instructions,optional\"`\n}\n\n// Load reads and validates the config file at path.\nfunc Load(path string) (*Config, error) {\n\tvar cfg Config\n\n\tif err := hclsimple.DecodeFile(path, nil, \u0026cfg); err != nil {\n\t\treturn nil, fmt.Errorf(\"parse config: %w\", err)\n\t}\n\n\tif err := cfg.Validate(); err != nil {\n\t\treturn nil, fmt.Errorf(\"invalid config: %w\", err)\n\t}\n\n\treturn \u0026cfg, nil\n}\n\n// Validate checks that the config is internally consistent: every\n// reference between blocks resolves, and required values are set.\nfunc (c *Config) Validate() error {\n\tllmNames := make(map[string]bool, len(c.LLMs))\n\tfor _, l := range c.LLMs {\n\t\tif l.OpenAI == \"\" || l.Token == \"\" || l.Model == \"\" {\n\t\t\treturn fmt.Errorf(\"llm %q: openai, token, and model are required\", l.Name)\n\t\t}\n\t\tllmNames[l.Name] = true\n\t}\n\n\tif c.Forgejo.URL == \"\" || c.Forgejo.Token == \"\" {\n\t\treturn fmt.Errorf(\"forgejo: url and token are required\")\n\t}\n\n\tfor _, p := range c.Forgejo.Repos {\n\t\tif err := validRepoPattern(p); err != nil {\n\t\t\treturn fmt.Errorf(\"forgejo: %w\", err)\n\t\t}\n\t}\n\n\tif c.Environment.MaxLive \u003c 1 {\n\t\treturn fmt.Errorf(\"environment: max_live_agents must be \u003e= 1, got %d\", c.Environment.MaxLive)","start_line":1,"end_line":120,"total_lines":246,"truncated":true}

{"command": "cd /project && ls docker/ && cat docker/* 2>/dev/null | head -50 && go version"}

Dockerfile
group
passwd
shadow
uid1000-sudo
FROM debian:unstable

RUN apt-get update && \
    apt-get install -y --no-install-recommends \
        ca-certificates \
        clang \
        cpp \
        curl \
        forgejo-cli \
        g++ \
        gcc \
        git \
        gnupg \
        golang-go \
        libc6-dev \
        make \
        mercurial \
        netbase \
        openssh-client \
        pkg-config \
        procps \
        sq \
        subversion \
        sudo \
        wget \
    && \
    rm -rf /var/lib/apt/lists/*

ADD --chmod=0644 passwd /etc/passwd
ADD --chmod=0644 group /etc/group
ADD --chmod=0640 shadow /etc/shadow
ADD --chmod=0644 uid1000-sudo /etc/sudoers.d/uid1000

RUN mkdir -p /home/user && \
    chown 1000:1000 /home/user

USER 1000:1000
root:x:0:
user:x:1000:
nogroup:x:65534:
root:x:0:0:root:/root:/bin/bash
user:x:1000:1000:user,,,:/home/user:/bin/bash
nobody:x:65534:65534::
root:$y$j9T$ElEG3FgmW16OtVys3v4FL0$tunDvgySurBjIXi5UzXdVToBSZ1VE2zm/PG/oc2yeE/:19136:0:99999:7:::
user:$y$j9T$ElEG3FgmW16OtVys3v4FL0$tunDvgySurBjIXi5UzXdVToBSZ1VE2zm/PG/oc2yeE/:19136:0:99999:7:::
user ALL=(ALL) NOPASSWD: ALL
go version go1.26.7 linux/amd64

{"command": "cd /project && grep -E \"docker|sdk\" go.mod && git --version && go doc github.com/docker/docker/api/types/network 2>/dev/null | head -30"}

	codeberg.org/mvdkleijn/forgejo-sdk/forgejo/v2 v2.2.0
	github.com/docker/docker v28.5.2+incompatible
	github.com/docker/go-connections v0.8.1 // indirect
	github.com/docker/go-units v0.5.0 // indirect
	github.com/moby/docker-image-spec v1.3.1 // indirect
	go.opentelemetry.io/auto/sdk v1.2.1 // indirect
git version 2.55.0

{"command": "cd /project && go doc github.com/docker/docker/api/types/container.InspectResponse 2>/dev/null | head -20; go doc github.com/docker/docker/api/types/network.Settings 2>/dev/null | head -30; go doc github.com/docker/docker/api/types/network.NetworkSettings 2>/dev/null | head -40"}

{"command": "cd /project && go env GOMODCACHE && find $(go env GOMODCACHE)/github.com/docker -maxdepth 2 -name \"*.go\" -path \"*api/types*\" 2>/dev/null | head -5"}

/home/user/go/pkg/mod

{"command": "cd /project && go build ./... 2>&1 | head -20 && echo BUILD_OK", "timeout": 300}

go: downloading github.com/docker/docker v28.5.2+incompatible
go: downloading github.com/hashicorp/hcl/v2 v2.24.0
go: downloading codeberg.org/mvdkleijn/forgejo-sdk/forgejo/v2 v2.2.0
go: downloading github.com/google/uuid v1.6.0
go: downloading modernc.org/sqlite v1.56.0
go: downloading github.com/docker/go-connections v0.8.1
go: downloading github.com/docker/go-units v0.5.0
go: downloading github.com/moby/docker-image-spec v1.3.1
go: downloading github.com/opencontainers/image-spec v1.1.1
go: downloading github.com/containerd/errdefs v1.0.0
go: downloading github.com/containerd/errdefs/pkg v0.3.0
go: downloading github.com/distribution/reference v0.6.0
go: downloading github.com/opencontainers/go-digest v1.0.0
go: downloading github.com/pkg/errors v0.9.1
go: downloading go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.70.0
go: downloading go.opentelemetry.io/otel/trace v1.45.0
go: downloading go.opentelemetry.io/otel v1.45.0
go: downloading github.com/42wim/httpsig v1.2.3
go: downloading github.com/go-fed/httpsig v1.1.0
go: downloading github.com/hashicorp/go-version v1.7.0
BUILD_OK

{"command": "cd /project && grep -n \"Networks \" /home/user/go/pkg/mod/github.com/docker/docker@v28.5.2+incompatible/api/types/types.go | head -5 && grep -n \"GatewayIP\" /home/user/go/pkg/mod/github.com/docker/docker@v28.5.2+incompatible/api/types/types.go | head -5"}

{"command": "cd /project && grep -rn \"Networks map\" /home/user/go/pkg/mod/github.com/docker/docker@v28.5.2+incompatible/api/types/ | head -5; grep -rn \"GatewayIP\" /home/user/go/pkg/mod/github.com/docker/docker@v28.5.2+incompatible/api/types/network/*.go 2>/dev/null | head -5"}

/home/user/go/pkg/mod/github.com/docker/docker@v28.5.2+incompatible/api/types/container/network_settings.go:12:	Networks map[string]*network.EndpointSettings
/home/user/go/pkg/mod/github.com/docker/docker@v28.5.2+incompatible/api/types/container/network_settings.go:84:	Networks map[string]*network.EndpointSettings
/home/user/go/pkg/mod/github.com/docker/docker@v28.5.2+incompatible/api/types/network/ipam_test.go:24:					AuxAddress: map[string]string{"DefaultGatewayIPv4": "2001:db8::1"},
/home/user/go/pkg/mod/github.com/docker/docker@v28.5.2+incompatible/api/types/network/ipam_test.go:30:				"invalid auxiliary address DefaultGatewayIPv4: parent subnet is an IPv4 block",
/home/user/go/pkg/mod/github.com/docker/docker@v28.5.2+incompatible/api/types/network/ipam_test.go:53:					AuxAddress: map[string]string{"DefaultGatewayIPv4": "dummy"},
/home/user/go/pkg/mod/github.com/docker/docker@v28.5.2+incompatible/api/types/network/ipam_test.go:59:				"invalid auxiliary address DefaultGatewayIPv4: invalid address",
/home/user/go/pkg/mod/github.com/docker/docker@v28.5.2+incompatible/api/types/network/ipam_test.go:80:					AuxAddress: map[string]string{"DefaultGatewayIPv4": "192.168.0.1"},

{"command": "cd /project && grep -rn \"GatewayIP\" /home/user/go/pkg/mod/github.com/docker/docker@v28.5.2+incompatible/api/types/network/*.go | grep -v _test | head -5 && grep -rn \"type EndpointSettings\" /home/user/go/pkg/mod/github.com/docker/docker@v28.5.2+incompatible/api/types/network/*.go"}

/home/user/go/pkg/mod/github.com/docker/docker@v28.5.2+incompatible/api/types/network/endpoint.go:10:type EndpointSettings struct {

{"command": "cd /project && sed -n '1,60p' /home/user/go/pkg/mod/github.com/docker/docker@v28.5.2+incompatible/api/types/network/endpoint.go"}

package network

import (
	"errors"
	"fmt"
	"net"
)

// EndpointSettings stores the network endpoint details
type EndpointSettings struct {
	// Configurations
	IPAMConfig *EndpointIPAMConfig
	Links      []string
	Aliases    []string // Aliases holds the list of extra, user-specified DNS names for this endpoint.
	// MacAddress may be used to specify a MAC address when the container is created.
	// Once the container is running, it becomes operational data (it may contain a
	// generated address).
	MacAddress string
	DriverOpts map[string]string

	// GwPriority determines which endpoint will provide the default gateway
	// for the container. The endpoint with the highest priority will be used.
	// If multiple endpoints have the same priority, they are lexicographically
	// sorted based on their network name, and the one that sorts first is picked.
	GwPriority int
	// Operational data
	NetworkID           string
	EndpointID          string
	Gateway             string
	IPAddress           string
	IPPrefixLen         int
	IPv6Gateway         string
	GlobalIPv6Address   string
	GlobalIPv6PrefixLen int
	// DNSNames holds all the (non fully qualified) DNS names associated to this endpoint. First entry is used to
	// generate PTR records.
	DNSNames []string
}

// Copy makes a deep copy of `EndpointSettings`
func (es *EndpointSettings) Copy() *EndpointSettings {
	epCopy := *es
	if es.IPAMConfig != nil {
		epCopy.IPAMConfig = es.IPAMConfig.Copy()
	}

	if es.Links != nil {
		links := make([]string, 0, len(es.Links))
		epCopy.Links = append(links, es.Links...)
	}

	if es.Aliases != nil {
		aliases := make([]string, 0, len(es.Aliases))
		epCopy.Aliases = append(aliases, es.Aliases...)
	}

	if len(es.DNSNames) > 0 {
		epCopy.DNSNames = make([]string, len(es.DNSNames))
		copy(epCopy.DNSNames, es.DNSNames)
	}

{"command": "cd /project && git log --oneline -8 -- internal/agentrun/sandboxgit.go && git show c3d3720:internal/agentrun/sandboxgit.go 2>/dev/null | grep -n \"global\\|system\" | head"}

10c3dce Better Docker/git inter.
c3d3720 Pass the agent's git credential to the sandbox, clone inside it
13:// credential is written to the container's system gitconfig so every
74:// configureSandboxGit writes the container's system gitconfig so git
90:// The credential lives in the container's own filesystem (ephemeral,
96:	if _, err := runSandboxGit(ctx, rt, containerID, "config", "--system", "--add", "safe.directory", "*"); err != nil {
100:	if _, err := runSandboxGit(ctx, rt, containerID, "config", "--system", "user.name", name); err != nil {
104:	if _, err := runSandboxGit(ctx, rt, containerID, "config", "--system", "user.email", email); err != nil {
108:	if _, err := runSandboxGit(ctx, rt, containerID, "config", "--system", "http."+forgeHost(cloneURL)+".extraHeader", gitAuthHeader(user, token)); err != nil {
112:	if _, err := runSandboxGit(ctx, rt, containerID, "config", "--system", "push.autoSetupRemote", "true"); err != nil {

{"command": "git upload-pack --help 2>&1 | grep -A2 \"http-backend\" | head -8; echo ---; git receive-pack --help 2>&1 | grep -A2 \"http-backend\" | head -8"}

---

{"command": "git upload-pack -h 2>&1 | head -40; echo ===; git receive-pack -h 2>&1 | head -40"}

usage: git-upload-pack [--[no-]strict] [--timeout=<n>] [--stateless-rpc]
                       [--advertise-refs] <directory>

    --[no-]stateless-rpc  quit after a single request/response exchange
    --[no-]strict         do not try <directory>/.git/ if <directory> is no Git directory
    --[no-]timeout <n>    interrupt transfer after <n> seconds of inactivity

===
usage: git receive-pack <git-dir>

    -q, --[no-]quiet      quiet