2032 commits

Author	SHA1	Message	Date
Scott Werner	ce404cddef	Interpolation foundation (InterpString v2) (#472) ... # Interpolation foundation (InterpString v2) First step of unifying config-string interpolation across Fabro. This PR is the **behavior-neutral foundation** only — it introduces the type machinery and a clippy gate, but changes no field's interpolation behavior. The actual field work follows as separate stacked PRs, sequenced **reduce-first**: narrowing changes (demote fields that shouldn't interpolate, de-template DOT attrs) land before capability additions (resolve env in MCP / prepare / hooks). ## Why Config strings interpolate `{{ ... }}` inconsistently today — some fields resolve `{{ env.X }}`, others are typed as if they do but silently pass the literal template text downstream. We're converging on three field types (`String`, `InterpString`, and later an importable template for prompts/goals) with four namespaces (`env`, `vars`, `secrets`, `inputs`). This PR lays the `InterpString` foundation; it does not migrate any field. ## What's in it - Segments generalize to `Token { namespace, name }` with a `Namespace` enum (`env`/`vars`/`secrets`/`inputs`). `secrets`/`inputs` are **reserved** — parsed as tokens ahead of their resolvers. - `ResolveCtx` with per-namespace lookups. `resolve_with()` fails loudly (`Unavailable`) for a token whose namespace isn't provided in context; `substitute_with()` substitutes provided namespaces and preserves the rest. `resolve()` / `substitute_variables()` are thin wrappers over one core path. - `ResolveEnvError` → `ResolveError { namespace, name, kind: Missing | Unavailable }` (message text unchanged for env/vars; the kind no longer bakes the namespace in, so it scales to four namespaces without an enum explosion). - `Provenance` tracks secret-sourced names alongside env-sourced, for uniform redaction later. - **`as_source()` is clippy-gated** (`disallowed-methods`). It keeps its name; every call site carries an `#[expect(..., reason)]` classifying it (serialization, error display, known-leak-pending-fix, demotion-pending, test). The lint turns the leak surface into a greppable, reasoned work-list and the method stays for its permanent uses (serde round-trip of the unresolved template + diagnostics). - fabro-server: five duplicate `process_env_var` facades and two duplicate `resolve_interp` helpers consolidated into one `crate::interp` module. ## Behavior changes (honest list) - **`{{ secrets.* }}` / `{{ inputs.* }}` are now reserved.** On main they weren't recognized as tokens → silent literal passthrough. Now, at `resolve()` consumers they **fail loud** (`Unavailable`) instead of passing the literal string through (nobody wants the literal characters as a value — strictly better, but technically a change). At `as_source` sites they round-trip unchanged. Actual resolution lands in later enhancing PRs. - Some fabro-server resolution errors gain a `"failed to resolve <source>"` context line. Otherwise behavior-neutral: every field resolves exactly as it did on main. ## What's deferred to follow-up PRs (reduce-first order) - **Reducing / cleanup (next):** demote leak fields to `String` (`run.model.*`, `cli.exec.model.*`, `run.git.author.*`, `run.scm.owner/repository`); de-template `condition`/`label`/`model`/ `provider`/`speed` and `output_schema`. - **Enhancing (after):** resolve `{{ env.* }}` in MCP transports, prepare steps, and hooks; wire `secrets`/`inputs`. ## Verification - `cargo build --workspace` - `cargo nextest run --workspace` → 6449 passed, 181 skipped - `cargo +nightly fmt --check --all` - `cargo +nightly clippy --workspace --all-targets -- -D warnings` → clean ## Reviewer notes - The reserved-namespace `Unavailable` error for `secrets`/`inputs` is **intentional**, not a missing case — they're parsed ahead of their resolvers so misuse fails loud instead of leaking. - `as_source` is clippy-gated but keeps its name deliberately — the gate is the enforcement; renaming was avoided as unnecessary churn. Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com>	2026-06-10 12:51:08 -04:00
Scott Werner	3985eaf1d7	refactor(llm): introduce Codec trait seam + extract openai_compatible (#481) ... ## What Introduces the `Codec` / `StreamDecoder` trait seam in `fabro-llm` and extracts the OpenAI Chat Completions wire logic behind it as the first conforming codec. Two commits: 1. **`codec/mod.rs`** — the pure translation contract (`encode` / `decode_response` / `stream_decoder`, plus defaulted `encode_count_tokens` / `decode_count_tokens` / `decode_error`) and its data types (`CodecCtx`, `CodecParams`, `EncodedRequest`, `RawEvent`). A codec knows *what the bytes say*; it owns no HTTP, auth, or base URL. 2. **`codec/openai_compatible/`** — the Chat Completions codec split into `wire` / `translate` / `request` / `response` / `stream`. `providers/openai_compatible.rs` shrinks from 1,608 → ~330 lines: a thin transport shell that keeps the public struct/builders/auth/`validate_request`, owns the streaming byte loop + SSE `data:` framing, and delegates all translation to the codec. The two hand-rolled stream unfolds collapse into one. This is the first step of a gateway refactor that separates codec (wire dialect) from transport/auth/route, so later work (Bedrock, OpenRouter) becomes mostly config rather than parallel adapters. ## Behavior No behavior change. The public adapter API (`OpenAiCompatibleAdapter::new` / `with_name` / `with_catalog` / …) is unchanged, and **all 126 wire snapshots pass without edits** — the parity proof that the extracted codec produces byte-identical output. The 29 in-module unit tests move into the codec submodules alongside the code they exercise. ## On the trait `openai_compatible` is the simplest dialect, so its `impl Codec` is just three methods — count-tokens and error mapping inherit the defaults. The contract is defined in full now (a scoped `dead_code` allow on `codec/mod.rs` covers the seams the anthropic/openai/gemini codecs will exercise in follow-up PRs) so those extractions only *override* methods, never extend the trait. Extracting a real codec refined two trait signatures vs. the initial sketch: the canonical `Request` lives in `CodecCtx` (decoders need it for tool-argument parsing and the stream model fallback), and the header-parsed `rate_limit` threads into `decode_response` / `stream_decoder`. `on_event` returns `Result` so dialect error events propagate as stream errors. ## Tests - `cargo nextest run -p fabro-llm` — 515 passed (incl. 126 wire snapshots, unmodified) - `cargo nextest run --workspace` — green - fabro-agent `parity_matrix` (the frozen `OpenAiCompatibleAdapter` contract) — green - `cargo +nightly fmt --check` / `clippy --all-targets -- -D warnings` — clean 🤖 Generated with [Claude Code](https://claude.com/claude-code) --------- Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com>	2026-06-10 12:50:19 -04:00
Scott Werner	9e30804ae0	test(llm): refresh wire snapshots for omitted null Message fields (#480) ... ## Summary Fixes the 33 `fabro-llm::it wire::*` snapshot failures currently red on `main`. These are a **semantic merge conflict** between two PRs that landed in parallel, not a behavior regression: - **#450** made the canonical `fabro_types::Message` omit absent optional fields (`name`, `tool_call_id`) via `#[serde(skip_serializing_if = "Option::is_none")]`, to match the OpenAPI completions wire contract. - **#471** added the per-dialect wire snapshots in parallel, authored against the older shape that emitted explicit `"name": null` / `"tool_call_id": null`. Each PR was green on its own branch (#450 never contained #471's snapshots; #471 predated #450's serde change). They only collided once both sat on `main` together — and because the serde attribute and the snapshots live in different files, there was no textual git conflict to flag it at merge time. ## What changed Regenerated the 33 affected snapshots (anthropic / gemini / openai_compatible / openai_responses) via `cargo insta accept`. The **only** change in every snapshot is the removal of the two trailing null fields: ```diff - ], - "name": null, - "tool_call_id": null + ] ``` No decode/stream behavior changed; the new shape is the intended canonical serialization. ## Test plan - [x] `cargo nextest run -p fabro-llm` — 515 passed, 0 failed - [x] Verified the diff across all 33 snapshots is uniformly the null-field omission (plus the `],`→`]` reflow), nothing else 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com>	2026-06-09 12:45:42 -04:00
Scott Werner	d590122531	feat: chat-driven workflow builder at /playground (#450) ... ## Summary Adds a new `/playground` route where users build a Fabro workflow by chatting with Ask Fabro on the right while watching a live canvas re-render on the left. The workflow can be downloaded as a `.fabro.zip` or — eventually — launched as a real Fabro run; today the "Run for real" button POSTs to `/api/v1/runs` and redirects to the resulting `/runs/{id}` page, with a placeholder project/repo/folder picker. The feature is built as a standalone component subtree under `apps/fabro-web/app/components/playground/` with no `AppShell` or `react-router` dependencies, so it can be re-embedded in other contexts later by passing `chatEndpoint`, `authMode`, and an optional `realRunRedirect` prop. ## What changed **Frontend (`apps/fabro-web/`)** - New `/playground` route + `<Playground>` component tree. - Live SVG canvas via `@viz-js/viz` with click-to-inspect (read-only node detail panel), pan, zoom, fit-to-window, and a simulated walk through the graph driven by a Play button. - Docked chat sidebar (assistant-ui) wired to the new `/api/v1/playground/chat` endpoint, with auto-retry on parse failure and a playground-specific tool-call summary that reads `Wrote workflow.fabro (N nodes, M edges)`. - File tabs (`workflow.fabro` / `workflow.toml` / `README.md`), `.fabro.zip` download via `fflate`, and a "Run for real" toolbar button that POSTs an inline `RunManifest` to `/api/v1/runs`. - Draft persists across page refreshes via `localStorage`. **Backend (`lib/crates/fabro-server/`)** - New `POST /api/v1/playground/chat` SSE endpoint. Server is stateless across turns: each request carries the full draft, the server runs the LLM with a single `write_workflow_file` tool, streams `StreamEvent` frames back, and lets the client own diffing/animating the result into the canvas. - Request-size caps before the LLM call (50 messages, 100 nodes, 200 edges) so a misbehaving or malicious client can't drag multi-MB transcripts through token billing. **Spec / wire contract** - OpenAPI: new `playground/chat` operation + four new schemas (`CreatePlaygroundChatRequest`, `PlaygroundWorkflowDraft`, `PlaygroundWorkflowNode`, `PlaygroundWorkflowEdge`). - `lib/packages/fabro-api-client` not regenerated yet (the playground uses raw `fetch`); reviewers who want the TS client to pick up the new types can run `bun run generate` in that package. ## Key design decisions 1. **Single `write_workflow_file` tool, not six per-op tools.** The first cut exposed `add_node`/`update_node`/`connect`/etc. as discrete tool calls. The model would routinely add nodes without wiring them up, leaving the canvas in a broken half-state. Pivoted to a single tool that takes the full new `workflow.fabro` content; the browser parses the DOT, diffs it against the local draft, and animates the resulting reducer ops in. The model only has to "get the file right", and the canvas still paints node-by-node thanks to the client-side animator. 2. **Stateless server.** Each chat turn POSTs the full current draft; nothing is persisted server-side. Keeps the endpoint cheap, makes refresh-resumption trivial (browser owns the truth), and means the same endpoint can later sit behind a rate-limited anonymous variant without growing per-session state. 3. **Standalone component subtree.** `<Playground>` has no `AppShell`/router/store dependencies. All cross-cutting concerns flow in as props (`chatEndpoint`, `authMode`, `realRunRedirect`). This is the structural hook that makes future re-embedding possible without a refactor. 4. **Chat is the only mutation path.** Click-to-inspect on the canvas is read-only. Bi-directional canvas editing was explicitly cut from scope to keep one source of truth for "how the workflow changed." 5. **Inline `RunManifest` instead of temp-dir-then-clone.** The playground has no project to run against, so the `Run for real` modal builds a `RunManifest` that carries the full DOT and `workflow.toml` source inline (`workflows[key].{source, config}`). `cwd` is pinned to a fixed `/tmp/fabro-playground` constant — no LLM-controlled segment in a filesystem-looking field. 6. **React effects policy compliance.** All `useEffect` calls in playground component code go through the existing primitives in `app/hooks/effects.ts` (`useDocumentEvent`, `useInterval`) or a purpose-named hook (`useCanvasRender`). ## Still outstanding (planned follow-ups) - [ ] **Actually kicking off the ad-hoc run.** "Run for real" today POSTs a manifest with a placeholder project/repo/folder fieldset. The intent is to reuse the project-picker pattern being introduced on the in-flight automations branch — once that pattern lands, the disabled inputs in `run-for-real-modal.tsx` become the live surface. - [ ] **Header link to `/playground`.** No nav entry yet; users have to type the URL directly. - [ ] **Live SSE-driven canvas overlay** via `GET /api/v1/runs/{id}/attach` — currently the modal redirects to the standard run-view page; the "watch it build on the playground canvas" experience comes when the `stage.*` events are wired through. - [ ] **Regenerate `lib/packages/fabro-api-client`** so the new types ship to TS consumers. - [ ] **Smoke test:** end-to-end download → unzip → `fabro run <name>` round-trip. - [ ] **`scripts/build.ts` dist-symlink bug:** `pruneOldBuilds` can delete the directory `apps/fabro-web/dist` points at, which pins the dev server in 503 "build in progress" forever. Workaround documented; the real fix is a separate PR. ## Test plan - [ ] `cd apps/fabro-web && bun run test app/components/playground/` — 111 tests pass - [ ] `cd apps/fabro-web && bun run typecheck` — clean - [ ] `cargo test -p fabro-server playground` — 6 tests pass - [ ] Visit `/playground`; the canvas renders the welcome `start → ??? → exit` ghost. - [ ] Type "build me a release-notes workflow" in chat; nodes/edges animate in; ack reads `Wrote workflow.fabro (N nodes, M edges)`. - [ ] Click a node → inspector panel populates; click empty canvas → deselects. - [ ] Click `Simulate`; nodes light up `start → ... → exit` along the resolved path. - [ ] Click `Download .fabro`; unzip; `cd <unzipped> && fabro run <name>` runs locally. - [ ] Click `Run for real` → modal opens → confirm → POST succeeds → redirected to `/runs/{id}` → run executes. - [ ] Refresh the page; the draft persists from localStorage. - [ ] Click `Start over` → `Yes`; canvas resets to welcome state. --------- Co-authored-by: Claude Opus 4.7 (1M context) <noreply@anthropic.com>	2026-06-09 11:24:56 -04:00
Scott Werner	eb5d8c53f9	fix(llm): stamp configured provider name into responses and error details (#479) ... ## What Threads the configured provider name through the response and error paths so custom-named providers report their real identity. Previously several sites used hardcoded literals: - streamed `Response.provider` always said `"anthropic"` / `"openai"` / `"gemini"` regardless of the configured name; - OpenAI's **non-stream** `Response.provider` ignored `with_name` entirely; - `ProviderErrorDetail.provider` in error paths (stream error events, HTTP/gRPC status mapping, request error contexts) carried the same literals. Now the name flows through anthropic's `StreamAccumulator`, openai's `SseStreamState` / error-json mapper / complete + error paths, and gemini's stream state and error helpers. ## Why One adapter code path already serves multiple providers — e.g. Kimi runs through the anthropic adapter via `with_name`, and the seven compat providers share one adapter. The "this file == this provider" assumption baked into the literals is wrong for those routes: a Kimi request that 429s reported `"Server error from anthropic"`, and its usage/error records were misattributed. The fix was also inconsistent before this change — some paths already used `provider_name` while the stream paths didn't, so the same request could be attributed differently depending on whether it streamed. This is foundational for an upcoming gateway refactor that makes codec/transport/provider orthogonal, where identity must travel with the route as data rather than being hardcoded per adapter. ## Behavior change The one intentional, behavior-visible delta: **custom-named providers** now report their configured name in `Response.provider` and `ProviderErrorDetail.provider`. Built-in default-named providers are byte-identical — the wire snapshot suite from #471 passes unmodified. Failover/retry policy keys on `ProviderErrorKind` and the `retryable()` / `failover_eligible()` flags, never on the provider string, so the error-detail change is display/log/signature-only (confirmed by a consumer sweep). ## Tests New per-dialect `custom_named_*` wire tests pin the intentional deltas, including a capture of the Kimi-over-anthropic route shape (bearer auth, no `anthropic-version` header) — useful as a pin for the route-config work later in the refactor. - `cargo nextest run -p fabro-llm` — 515 passed - `cargo +nightly fmt --check` / `clippy --all-targets -- -D warnings` — clean 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com>	2026-06-09 11:02:31 -04:00
Scott Werner	4ba2c11926	test(llm): pin provider wire behavior with per-dialect snapshot tests (#471) ... ## What Adds wire snapshot tests pinning the exact encode/decode/stream behavior of all four provider adapters — **109 tests / 117 insta snapshots** in `fabro-llm/tests/it/wire/{anthropic,openai_compatible,openai_responses,gemini}.rs`, driven by a shared canonical request corpus in `tests/it/support.rs`. Tests only; no `src/` changes. Each test points a real adapter at a local httpmock server, side-channels the full received request (method, path, headers, body) out of an `is_true` matcher closure, responds with a canned provider body or scripted SSE transcript, and snapshots both the captured wire request and the decoded canonical `Response` / `Vec<StreamEvent>`. ## Why This is the behavior-pinning net for an upcoming refactor series that separates fabro-llm's wire translation (codec) from transport/auth concerns. The refactor must be behavior-preserving; these snapshots make that checkable per PR instead of asserted. The anthropic and gemini dialects have no twin coverage, so these tests are the only net for those paths. httpmock matcher-capture is used for all four dialects (rather than twin request-logs for the OpenAI ones): the corpus deliberately exercises shapes a strict twin would reject (provider_options merges, response_format variants, bad-file-path attachment parts), one mechanism is cheaper to maintain than two, and the twin already validates the OpenAI dialects via `parity_matrix` and the server scenario tests. ## Coverage Per dialect: - **Encode** — multi-turn/system mapping, `tool_choice` ×4, tool round-trips (incl. error results), thinking round-trips, attachments (inline data, URL passthrough, silent bad-file-path drop, audio fallback), `response_format` (json + json_schema), sampling params, per-dialect `provider_options` merges (incl. the adapter-name-keyed compat case), catalog-driven reasoning effort and prompt cache (beta header), and the count-tokens wire route. - **Decode** — finish-reason mappings, each dialect's distinct usage arithmetic (anthropic direct cache reads with `reasoning_tokens: 0`; openai-responses cached/reasoning subtraction; gemini `(prompt − cached) + tool_use_prompt`; compat prompt/completion only), thinking/tool/opaque items, dual-id (`fc_…`/`call_…`) preservation. - **Stream** — tool-call and reasoning deltas, error events (pinning `retryable`/`failover_eligible`), and each dialect's stream-end contract: anthropic emits no `Finish` without `message_stop`; openai_compatible synthesizes one only if content started (both halves of the minimax tolerance pinned); gemini synthesizes unconditionally. Notable current behaviors pinned as-is (documented divergences, not changed here): `ToolResult.image_data` is dropped by every encoder; `ToolChoice::None` drops the whole `tools` array on anthropic only; canonical `Thinking` parts are dropped by openai-responses/gemini; `Request.metadata` is dropped by compat/gemini; gemini ignores `reasoning_effort` and mints synthetic UUID tool-call/response ids (normalized to `[UUID]` in snapshots). ## Test plan - `cargo nextest run -p fabro-llm` — 498 passed (new `it` target run twice to verify snapshot determinism incl. UUID normalization) - `cargo +nightly fmt --check --all` / `cargo +nightly clippy -p fabro-llm --all-targets -- -D warnings` — clean - `fabro-llm/tests/integration.rs` and `fabro-agent/tests/it/parity_matrix.rs` untouched 🤖 Generated with [Claude Code](https://claude.com/claude-code) --------- Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com>	2026-06-08 16:11:27 -04:00
Scott Werner	911e080f3c	Limit DOT templates to prompt + goal (#474) ... # Limit DOT templates to prompt + goal Part of unifying config interpolation in Fabro. Per the field taxonomy, full MiniJinja templates (`ImportableTemplate`) should be limited to **`prompt` (node) and `goal` (graph)** — the content fields that legitimately need `{{ inputs.* }}` / `{{ goal }}`. Every other graph/node/edge attribute should be a plain value, not a Turing-complete template. This is a **behavior-reducing** slice and is **independent of the InterpString foundation PR** (it touches the MiniJinja/template-engine path, not the `InterpString` config path), so it branches off `main` and can be reviewed on its own. ## What changes - `TemplateTransform::render_attrs` still renders node `prompt` (unchanged) and the graph `goal` (rendered separately, as before), but **no longer renders** `label`, `model`, `provider`, `speed`, edge `label`, or `condition`. Those are left as literal text. - When a now-demoted attribute still contains `{{ … }}` / `{% … %}`, a `detemplated_attribute` **warning** is emitted so authors can migrate (the syntax is now literal, not rendered). - `condition` keeps its dedicated routing-expression evaluator (`evaluate_condition` / `parse_condition_expr`); only the Jinja pre-render is removed, so routing still works exactly as before. - `output_schema` becomes a string-or-`@file` value, not a template: `FileInliningTransform` still resolves an `@file` reference but loads its contents **verbatim**, and neither the inline value nor the loaded file is MiniJinja-rendered. `prompt` and `goal` are unaffected — both inline and `@file` forms are still MiniJinja-rendered (the `@` only selects whether the template is in-band or loaded from a file). ## Behavior change `{{ … }}` in a demoted attribute (`label`/`model`/`provider`/`speed`/ `condition`/`output_schema`) is now **literal text** instead of being rendered. A parse-time `detemplated_attribute` warning flags any remaining occurrences so they're not silently dropped. This was rarely a sensible thing to do anyway (e.g. `label = "{{ goal }}"` would splat the entire goal into a short display label). ## Verification - `cargo build --workspace` - `cargo nextest run -p fabro-workflow` → 1164 passed - `cargo +nightly fmt --check --all` - `cargo +nightly clippy --workspace --all-targets -- -D warnings` → clean - No pending `insta` snapshots ## Tests - `template_transform_renders_prompt_and_leaves_other_attrs_literal` — `prompt` still renders; node/graph/edge `label` stay literal; one migration warning per demoted label. - `file_inlining_transform_does_not_render_templates_in_output_schema` and `file_inlining_transform_loads_output_schema_file_verbatim` — `output_schema` inline and `@file` contents are used verbatim, no Jinja. Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com>	2026-06-05 11:22:38 -04:00
Bryan Helmkamp	ccbc62ea5d	fix(ci): restore Rust checks	2026-06-02 19:05:08 -04:00
Bryan Helmkamp	e952bb4c7f	fix(config): disable Slack unless configured ... Require an explicit server.integrations.slack table before Slack reports enabled or starts from vault tokens.	2026-06-02 18:41:36 -04:00
Bryan Helmkamp	160f587a1d	feat(install): enable only allowed sandbox providers ... Add an "Allow local sandboxes" checkbox (checked by default) below the Docker/Daytona choice in the web installer, and stop unconditionally enabling all three providers when generating settings.toml. The wizard now enables only the selected runtime plus local when allowed; the unselected runtime is written as `enabled = false` so the config resolver does not default it back on. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>	2026-06-02 18:39:31 -04:00
Bryan Helmkamp	efbd2d02e0	chore(server): switch CSP to report-only while tuning ... Emit the policy via Content-Security-Policy-Report-Only instead of the enforcing header so browsers log violations without blocking resources while we debug remaining CSP issues. The policy string is unchanged. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>	2026-06-01 19:42:39 -04:00
Bryan Helmkamp	b3528a982e	chore: update CSP	2026-06-01 19:42:39 -04:00
Bryan Helmkamp	3e881e9938	fix(server): allow required CSP handoffs ... Permit GitHub App manifest form posts and signed HTTPS VNC preview iframes while keeping the rest of the SPA CSP locked down. Mirror the policy in the split-web Caddy config.	2026-06-01 18:24:45 -04:00
Bryan Helmkamp	b5de404354	ci: lock Cargo resolution and fix cancellation flake (#461) ... ## Summary Enforce Cargo lockfile use across CI and release automation so jobs fail on stale `Cargo.lock` state instead of resolving dependencies implicitly. This adds `--locked` to Rust CI, release builds/tests, nightly release tagging, the TypeScript workflow's embedded Rust build, and helper-owned Cargo calls in `fabro-dev`. This also fixes the Linux CI flake exposed by the PR: canceling a durably blocked in-process run could take the abort path while the workflow was still unwinding a human-input gate, causing `run.failed(cancelled)` to be followed by `run.unblocked`. That invalid event order broke projection rebuilds and made `GET /runs/{id}` return 404. Cancellation now uses the durable lifecycle status when selecting the in-process blocked-run path, so the pending interview is cancelled before the terminal event is emitted. The release command's intentional `cargo update --workspace` step is unchanged, because that step updates `Cargo.lock` after bumping the workspace version. ## Testing - `cargo nextest run --locked -p fabro-dev --features dev -E 'test(dry_run_computes_stable_version_from_date) | test(dry_run_prints_equivalent_build_commands)'` - `cargo --locked dev release --dry-run --skip-tests --release-date 2026-01-01` - `cargo --locked dev docs check` - `cargo nextest run --locked -p fabro-server --features test-support cancel_durably_blocked_in_process_run_cancels_pending_interview_without_abort_signal --status-level fail --final-status-level fail --show-progress none` - `cargo nextest run --locked -p fabro-server --features test-support --test it scenario::lifecycle --profile ci --status-level fail --final-status-level fail --show-progress none --no-fail-fast` - Linux Docker stress reproduction: `cargo nextest run --locked -p fabro-server --features test-support --test it scenario::lifecycle::full_http_lifecycle_cancel --profile ci --stress-count 200 --status-level fail --final-status-level fail --show-progress none` - `cargo +nightly-2026-04-14 fmt --check --all` - `cargo +nightly-2026-04-14 clippy --locked -p fabro-dev --features dev --all-targets -- -D warnings` - `cargo +nightly-2026-04-14 clippy --locked -p fabro-server --features test-support --all-targets -- -D warnings` - `git diff --check` Full `cargo nextest run --locked -p fabro-dev --features dev` currently has two unrelated policy-test failures: `policy::catalog_builtin_references_stay_in_allowlist` and `policy::workflow_template_rendering_call_sites_stay_in_allowlist`. --- [](https://github.com/EveryInc/compound-engineering-plugin) 🤖 Generated with GPT-5 via [Codex](https://openai.com/codex) --------- Co-authored-by: Release Repro <release-repro@example.com>	2026-05-30 15:07:41 -04:00
Bryan Helmkamp	d7a00d52d0	fix(automation): honor schedule trigger enabled state ... Remove the stale top-level automation enabled gate from schedule filtering now that automations only carry trigger-level enabled flags.	2026-05-30 02:19:52 -04:00
fabro-sh-0530[bot]	17cae07e5a	Add scheduled automation executor with in-memory cron planner (#457) ... ## Summary Automation schedule triggers now fire automatically at their UTC cron times. A new long-lived server task (`spawn_automation_scheduler`) owns an in-memory planner that tracks one cursor per enabled schedule trigger and creates/starts a normal Fabro run whenever a cursor comes due — reusing the same materialization and run-creation path as API-triggered runs. ### Plan Summary - **Planner** (`AutomationSchedulePlanner`) — pure in-memory, no persistent state. Reconciles cursors from the live automation list on every tick; advances each due cursor _before_ spawning the fire task so a failed materialization never hot-loops. - **Executor loop** (`spawn_automation_scheduler`) — wakes on the nearest cursor due time (capped at 30 s), on automation store mutations (via `Notify`), or on shutdown. Spawns one Tokio task per due trigger so slow materializations don't block other triggers. - **Run firing** (`fire_scheduled_automation_run`) — materializes, calls `create_run_from_manifest` with `Principal::System { Engine }`, then calls `queue_run_start`. Warnings on any failure; next attempt waits for the next cron occurrence. - **Wiring** — `automation_scheduler_notify: Notify` added to `AppState`; `create_automation`, `replace_automation`, and `delete_automation` handlers call `notify_automation_scheduler()` so the planner reacts immediately to changes. - **Visibility widening** — `handler/lifecycle.rs` (`queue_run_start`) and `handler/mod.rs` (`lifecycle`) promoted from `pub(super)` to `pub(in crate::server)` so the scheduler (a sibling of `handler`) can call the same start path. - **Shared cron parser** — `parse_schedule_expression` extracted to `fabro-automation` and re-exported so both validation and the scheduler use the same parser configuration (no seconds, no year). ### Key design decisions | Decision | Rationale | |---|---| | Cursor advances before fire task spawns | Guarantees at-most-one attempt per occurrence even if materialization panics | | No backfill on startup | Matches locked spec; `next_occurrence(expr, now)` always starts from the current time | | `Principal::System { Engine }` for actor | Avoids adding new public enum variants or OpenAPI surface | | `automation_temp_root()` extracted to `AppState` | Removes duplicated `Storage::new(…).scratch_dir().join("automations")` from the automations handler | | Tests use `run_due_schedules_once` helper | Drives the planner directly with fixed `DateTime<Utc>` values; no wall-clock sleeps in tests | ### Fabro Details <details> <summary>Ran 9 stages in 60m 12s for $22.11</summary> | Stage | Duration | Cost | Retries | |---|---|---|---| | start | 0s | – | 0 | | toolchain | 1s | – | 0 | | preflight_compile | 2m 9s | – | 0 | | preflight_lint | 2m 26s | – | 0 | | implement | 20m 14s | $12.44 | 0 | | simplify_opus | 12m 29s | $6.34 | 0 | | simplify_gpt | 3m 53s | $2.79 | 0 | | verify | 11m 5s | – | 0 | | fixup | 6m 46s | $0.54 | 0 | | **Total** | **60m 12s** | **$22.11** | **0** | </details> <details> <summary>Ran <code>ImplementPlan.fabro</code> (11 nodes and 14 edges)</summary> ```dot digraph ImplementPlan { graph [ goal="Implement and simplify", model_stylesheet=" * { model: claude-opus-4-7; } " ] rankdir=LR start [shape=Mdiamond, label="Start"] exit [shape=Msquare, label="Exit"] toolchain [label="Toolchain", shape=parallelogram, script="command -v cargo >/dev/null || { curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y && sudo ln -sf $HOME/.cargo/bin/* /usr/local/bin/; }; cargo --version 2>&1", max_retries=0] preflight_compile [label="Preflight Compile", shape=parallelogram, script="cargo check -q --workspace 2>&1", max_retries=0] preflight_lint [label="Preflight Lint", shape=parallelogram, script="cargo +nightly-2026-04-14 clippy -q --workspace --all-targets -- -D warnings 2>&1", max_retries=0] fix_lints [label="Fix Lints", prompt="The preflight lint step failed. Read the build output from context and fix all clippy lint warnings.", max_visits=3] implement [label="Implement", prompt="Read the plan file referenced in the goal and implement every step. Make all the code changes described in the plan. Use red/green TDD.", model="gpt-55", reasoning_effort="xhigh"] simplify_opus [label="Simplify (Opus)", prompt="@prompts/simplify.md"] simplify_gpt [label="Simplify (GPT-55)", prompt="@prompts/simplify.md", model="gpt-55"] verify [label="Verify", shape=parallelogram, script="git fetch origin main 2>&1 && git merge --no-edit --no-stat origin/main 2>&1 && cargo +nightly-2026-04-14 fmt --all 2>&1 && cargo dev docs refresh 2>&1 && cargo +nightly-2026-04-14 fmt --check --all 2>&1 && { command -v rg >/dev/null 2>&1 || { echo 'rg is required for verify'; exit 127; }; } && ! rg -n 'AuthMode::Disabled|RunAuthMethod|RunSubjectProvenance|\bActorRef\b|\bActorKind\b|AuthenticatedSubject|AuthenticatedService|AuthorizeRunScoped|AuthorizeRunBlob|AuthorizeStageArtifact|AuthorizeCommandLog|auth_method\s*==\s*\"disabled\"' lib/crates apps lib/packages docs/public/api-reference/fabro-api.yaml 2>&1 && cargo +nightly-2026-04-14 clippy --workspace --all-targets -- -D warnings 2>&1 && cargo nextest run --workspace --status-level slow --profile ci 2>&1 && cargo dev docs check 2>&1 && bun install --frozen-lockfile 2>&1 && (cd apps/fabro-web && bun run typecheck) 2>&1 && (cd apps/fabro-web && bun run test) 2>&1 && (cd lib/packages/fabro-api-client && bun run typecheck) 2>&1 && cargo dev build -- -p fabro-cli --release 2>&1", goal_gate=true, retry_target="fixup"] fixup [label="Fixup", prompt="The verify step failed. Read the build output from context and fix all format, clippy, Rust test, docs, TypeScript typecheck/test, and build failures.", max_visits=3] start -> toolchain toolchain -> preflight_compile [condition="outcome=succeeded"] toolchain -> exit preflight_compile -> preflight_lint [condition="outcome=succeeded"] preflight_compile -> exit preflight_lint -> implement [condition="outcome=succeeded"] preflight_lint -> fix_lints fix_lints -> preflight_lint implement -> simplify_opus -> simplify_gpt -> verify verify -> exit [condition="outcome=succeeded"] verify -> fixup fixup -> verify } ``` </details> ⚒️ Generated with [Fabro](https://fabro.sh) --------- Co-authored-by: Fabro <noreply@fabro.sh>	2026-05-29 22:19:47 -04:00
fabro-sh-0530[bot]	fe1d33c041	Remove top-level automation enabled master gate (#456) ... The top-level `enabled` flag on automations created a confusing two-level activation model (automation-level + trigger-level). Since automations are brand new with no existing data to migrate, the master gate is removed entirely — trigger-level `enabled` is now the sole activation control. ## What changed **Domain model (`fabro-automation`):** `enabled` removed from `Automation`, `AutomationDraft`, `AutomationReplace`, and `PersistedAutomation`. `enabled_api_trigger()` no longer short-circuits on the automation flag. The `default_true()` helper is gone. A new test asserts that TOML with a top-level `enabled` key is rejected (no silent compatibility path). **Server handler:** Conflict detail updated from `"automation is disabled or has no enabled API trigger"` → `"automation has no enabled API trigger"`. The `disabled_automation_run_endpoint_returns_conflict_code` test is deleted; the trigger-disabled and missing-trigger tests remain as the authoritative inactive-run coverage. **OpenAPI + generated clients:** `enabled` removed from `Automation`, `CreateAutomationRequest`, and `ReplaceAutomationRequest` schemas and from the generated TypeScript interfaces. Trigger-level `enabled` on `AutomationApiTrigger` and `AutomationScheduleTrigger` is untouched. **Web UI:** `AutomationFormValues.enabled` and the "Enabled" toggle row are gone. `isFormValid` no longer requires at least one enabled trigger. `canRun` in the detail view is now just `apiTrigger?.enabled === true`. The `StatusChip` component is removed. The automations list uses a new `apiEnabled` field (derived from `hasEnabledApiTrigger`) to drive run-button state and tooltip copy. A shared `lib/automation.ts` helper centralises `findApiTrigger`, `findScheduleTrigger`, and `hasEnabledApiTrigger` to avoid repeated inline `.find()` calls across routes. ### Fabro Details <details> <summary>Ran 8 stages in 41m 34s for $17.84</summary> | Stage | Duration | Cost | Retries | |---|---|---|---| | start | 0s | – | 0 | | toolchain | 1s | – | 0 | | preflight_compile | 2m 15s | – | 0 | | preflight_lint | 2m 25s | – | 0 | | implement | 13m 0s | $9.25 | 0 | | simplify_opus | 9m 43s | $6.18 | 0 | | simplify_gpt | 3m 56s | $2.41 | 0 | | verify | 9m 17s | – | 0 | | **Total** | **41m 34s** | **$17.84** | **0** | </details> <details> <summary>Ran <code>ImplementPlan.fabro</code> (11 nodes and 14 edges)</summary> ```dot digraph ImplementPlan { graph [ goal="Implement and simplify", model_stylesheet=" * { model: claude-opus-4-7; } " ] rankdir=LR start [shape=Mdiamond, label="Start"] exit [shape=Msquare, label="Exit"] toolchain [label="Toolchain", shape=parallelogram, script="command -v cargo >/dev/null || { curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y && sudo ln -sf $HOME/.cargo/bin/* /usr/local/bin/; }; cargo --version 2>&1", max_retries=0] preflight_compile [label="Preflight Compile", shape=parallelogram, script="cargo check -q --workspace 2>&1", max_retries=0] preflight_lint [label="Preflight Lint", shape=parallelogram, script="cargo +nightly-2026-04-14 clippy -q --workspace --all-targets -- -D warnings 2>&1", max_retries=0] fix_lints [label="Fix Lints", prompt="The preflight lint step failed. Read the build output from context and fix all clippy lint warnings.", max_visits=3] implement [label="Implement", prompt="Read the plan file referenced in the goal and implement every step. Make all the code changes described in the plan. Use red/green TDD.", model="gpt-55", reasoning_effort="xhigh"] simplify_opus [label="Simplify (Opus)", prompt="@prompts/simplify.md"] simplify_gpt [label="Simplify (GPT-55)", prompt="@prompts/simplify.md", model="gpt-55"] verify [label="Verify", shape=parallelogram, script="git fetch origin main 2>&1 && git merge --no-edit --no-stat origin/main 2>&1 && cargo +nightly-2026-04-14 fmt --all 2>&1 && cargo dev docs refresh 2>&1 && cargo +nightly-2026-04-14 fmt --check --all 2>&1 && { command -v rg >/dev/null 2>&1 || { echo 'rg is required for verify'; exit 127; }; } && ! rg -n 'AuthMode::Disabled|RunAuthMethod|RunSubjectProvenance|\bActorRef\b|\bActorKind\b|AuthenticatedSubject|AuthenticatedService|AuthorizeRunScoped|AuthorizeRunBlob|AuthorizeStageArtifact|AuthorizeCommandLog|auth_method\s*==\s*\"disabled\"' lib/crates apps lib/packages docs/public/api-reference/fabro-api.yaml 2>&1 && cargo +nightly-2026-04-14 clippy --workspace --all-targets -- -D warnings 2>&1 && cargo nextest run --workspace --status-level slow --profile ci 2>&1 && cargo dev docs check 2>&1 && bun install --frozen-lockfile 2>&1 && (cd apps/fabro-web && bun run typecheck) 2>&1 && (cd apps/fabro-web && bun run test) 2>&1 && (cd lib/packages/fabro-api-client && bun run typecheck) 2>&1 && cargo dev build -- -p fabro-cli --release 2>&1", goal_gate=true, retry_target="fixup"] fixup [label="Fixup", prompt="The verify step failed. Read the build output from context and fix all format, clippy, Rust test, docs, TypeScript typecheck/test, and build failures.", max_visits=3] start -> toolchain toolchain -> preflight_compile [condition="outcome=succeeded"] toolchain -> exit preflight_compile -> preflight_lint [condition="outcome=succeeded"] preflight_compile -> exit preflight_lint -> implement [condition="outcome=succeeded"] preflight_lint -> fix_lints fix_lints -> preflight_lint implement -> simplify_opus -> simplify_gpt -> verify verify -> exit [condition="outcome=succeeded"] verify -> fixup fixup -> verify } ``` </details> ⚒️ Generated with [Fabro](https://fabro.sh) --------- Co-authored-by: Fabro <noreply@fabro.sh>	2026-05-29 22:18:14 -04:00
fabro-sh-0530[bot]	037073d2b2	feat: Add Environment REST CRUD API under /api/v1/environments (#453) ... ## Summary Adds a server-managed Environment CRUD API at `/api/v1/environments`, modeled after the existing Automations API and backed by `EnvironmentStore`. The API manages only server-side environment definitions in `environments/*.toml`; client-side catalogs (workflow, project TOML, run inputs) are unaffected. ### Plan Summary - **OpenAPI contract**: new `Environments` tag, `EnvironmentId` path parameter, five CRUD paths, list envelope, and REST-specific inline-only image schema (`EnvironmentApiImageSettings`) - **Server handler** (`environments.rs`): mirrors `automations.rs` — auth guard, ETag/If-Match, and `EnvironmentStoreError → ApiError` mapping - **Shared handler utilities**: `parse_required_if_match` and `json_with_etag_response` extracted from `automations.rs` into `handler/mod.rs` so both modules share them - **Inline-only Dockerfile enforcement**: `ApiDockerfileSource::Path` is parsed and immediately rejected with `422`; the file is never read - **Manifest refresh**: `refresh_manifest_run_settings_from_environment_catalog()` called after create, replace, and delete so `/system/info` and default run settings stay consistent - **Client regeneration**: TypeScript Axios client regenerated with `EnvironmentsApi` and new model files; Rust `fabro-api` type aliases updated - **Tests**: integration suite in `tests/it/api/environments.rs` covering all CRUD paths, error cases, and the manifest-refresh invariant; OpenAPI conformance test verifies generated surfaces ## Key Design Decisions **Inline-only Dockerfile at the REST boundary.** Allowing `path` sources over REST would let callers silently read arbitrary server-local files into the environment catalog. The handler recognizes the `path` discriminant so it can return a descriptive `422` rather than a generic parse error, but the payload is discarded via `IgnoredAny` — no disk access occurs. **Shared ETag utilities instead of per-handler helpers.** The original `parse_required_if_match` and ETag header builder in `automations.rs` were duplicated for environments. They're now generic over any `FromStr` revision type in `handler/mod.rs`, making future resource handlers cheaper to add. **`Environment` response type aliased to domain type.** The OpenAPI-generated `Environment` response struct is replaced with `fabro_environment::Environment` via `build.rs` `with_replacement`. A compile-time function-cast witness in `fabro-api/tests/environment_round_trip.rs` confirms the alias holds. Request types (`CreateEnvironmentRequest`, `ReplaceEnvironmentRequest`) stay API-specific because their image schema differs from the workflow/settings schema. **Stale revision → `409`.** Consistent with Automations; `428` is reserved for missing `If-Match` only. ### Fabro Details <details> <summary>Ran 8 stages in 59m 23s for $30.41</summary> | Stage | Duration | Cost | Retries | |---|---|---|---| | start | 0s | – | 0 | | toolchain | 1s | – | 0 | | preflight_compile | 2m 9s | – | 0 | | preflight_lint | 2m 25s | – | 0 | | implement | 25m 43s | $19.79 | 0 | | simplify_opus | 14m 34s | $6.98 | 0 | | simplify_gpt | 4m 39s | $3.64 | 0 | | verify | 9m 14s | – | 0 | | **Total** | **59m 23s** | **$30.41** | **0** | </details> <details> <summary>Ran <code>ImplementPlan.fabro</code> (11 nodes and 14 edges)</summary> ```dot digraph ImplementPlan { graph [ goal="Implement and simplify", model_stylesheet=" * { model: claude-opus-4-7; } " ] rankdir=LR start [shape=Mdiamond, label="Start"] exit [shape=Msquare, label="Exit"] toolchain [label="Toolchain", shape=parallelogram, script="command -v cargo >/dev/null || { curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y && sudo ln -sf $HOME/.cargo/bin/* /usr/local/bin/; }; cargo --version 2>&1", max_retries=0] preflight_compile [label="Preflight Compile", shape=parallelogram, script="cargo check -q --workspace 2>&1", max_retries=0] preflight_lint [label="Preflight Lint", shape=parallelogram, script="cargo +nightly-2026-04-14 clippy -q --workspace --all-targets -- -D warnings 2>&1", max_retries=0] fix_lints [label="Fix Lints", prompt="The preflight lint step failed. Read the build output from context and fix all clippy lint warnings.", max_visits=3] implement [label="Implement", prompt="Read the plan file referenced in the goal and implement every step. Make all the code changes described in the plan. Use red/green TDD.", model="gpt-55", reasoning_effort="xhigh"] simplify_opus [label="Simplify (Opus)", prompt="@prompts/simplify.md"] simplify_gpt [label="Simplify (GPT-55)", prompt="@prompts/simplify.md", model="gpt-55"] verify [label="Verify", shape=parallelogram, script="git fetch origin main 2>&1 && git merge --no-edit --no-stat origin/main 2>&1 && cargo +nightly-2026-04-14 fmt --all 2>&1 && cargo dev docs refresh 2>&1 && cargo +nightly-2026-04-14 fmt --check --all 2>&1 && { command -v rg >/dev/null 2>&1 || { echo 'rg is required for verify'; exit 127; }; } && ! rg -n 'AuthMode::Disabled|RunAuthMethod|RunSubjectProvenance|\bActorRef\b|\bActorKind\b|AuthenticatedSubject|AuthenticatedService|AuthorizeRunScoped|AuthorizeRunBlob|AuthorizeStageArtifact|AuthorizeCommandLog|auth_method\s*==\s*\"disabled\"' lib/crates apps lib/packages docs/public/api-reference/fabro-api.yaml 2>&1 && cargo +nightly-2026-04-14 clippy --workspace --all-targets -- -D warnings 2>&1 && cargo nextest run --workspace --status-level slow --profile ci 2>&1 && cargo dev docs check 2>&1 && bun install --frozen-lockfile 2>&1 && (cd apps/fabro-web && bun run typecheck) 2>&1 && (cd apps/fabro-web && bun run test) 2>&1 && (cd lib/packages/fabro-api-client && bun run typecheck) 2>&1 && cargo dev build -- -p fabro-cli --release 2>&1", goal_gate=true, retry_target="fixup"] fixup [label="Fixup", prompt="The verify step failed. Read the build output from context and fix all format, clippy, Rust test, docs, TypeScript typecheck/test, and build failures.", max_visits=3] start -> toolchain toolchain -> preflight_compile [condition="outcome=succeeded"] toolchain -> exit preflight_compile -> preflight_lint [condition="outcome=succeeded"] preflight_compile -> exit preflight_lint -> implement [condition="outcome=succeeded"] preflight_lint -> fix_lints fix_lints -> preflight_lint implement -> simplify_opus -> simplify_gpt -> verify verify -> exit [condition="outcome=succeeded"] verify -> fixup fixup -> verify } ``` </details> ⚒️ Generated with [Fabro](https://fabro.sh) --------- Co-authored-by: Fabro <noreply@fabro.sh>	2026-05-29 17:30:57 -04:00
Bryan Helmkamp	7c73f7ac02	fix(server): inline dockerfiles defined in the [environments.*] catalog ... The manifest bundler collects Dockerfile path references from both the named-environment catalog and [run.environment], but the server-side resolver only inlined [run.environment.image]. A Dockerfile declared under [environments.<slug>.image] therefore reached the Daytona provider as an un-inlined Path and tripped its guard ("dockerfile path should have been resolved to inline content before sandbox creation"), so no run could use a catalog-defined Dockerfile environment. Walk layer.environments alongside run.environment when resolving manifest dockerfiles, mirroring the bundler. Add a regression test proving a catalog dockerfile path is inlined. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>	2026-05-29 11:38:10 -04:00
Bryan Helmkamp	ac66f6c1d6	Merge remote-tracking branch 'origin/main' into fix-center-size-column ... # Conflicts: # lib/crates/fabro-server/src/automation_materializer.rs # lib/crates/fabro-server/src/server.rs	2026-05-29 08:51:57 -04:00
Bryan Helmkamp	fee245d788	fix(web): make plural /automations/:id the canonical detail route ... The list card linked to the singular /automation/:id, which mismatched the rest of the new automations CRUD surface (/automations, /automations/new, /automations/:id/edit). Switch the card link and the slug-preview text on the create form to the plural form, and mount /automations/:id in the router alongside the existing singular route (kept as a back-compat alias for any older bookmarks). Drive-by: fold two adjacent `use super::*` imports into one and reflow a long `if let` line in the automations handler (linter cleanup; no behavior change). Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>	2026-05-29 08:47:31 -04:00
Bryan Helmkamp	7f9b31074c	perf(server): cache bare GitHub clones for automation materialization ... Materializing an automation run cloned the full repo fresh into a tempdir on every click — 5–15s of git activity on the HTTP request thread, paid in full for every run, then thrown away. Add a per-`(owner, repo)` bare-clone cache under `<Storage::cache_dir>/automation-repos/<owner>/<repo>.git`, and replace the per-call clone+fetch+checkout dance with: 1. `KeyedMutex` lock on `(owner, repo)` so concurrent calls serialize per repo and parallelize across repos. 2. If the bare clone is missing, `git clone --bare --depth 1`. Otherwise `git worktree prune` to clean up any admin entries leaked by previous `TempDir` drops. 3. `git fetch --depth 1 origin <ref>` against the bare clone. 4. `git rev-parse FETCH_HEAD` for the SHA. 5. `git worktree add --detach --force <temp>/repo FETCH_HEAD` into the per-call scratch dir, then build the manifest as today. First run for a repo still pays the clone cost. Every subsequent run for any ref or automation against that repo pays only the fetch delta plus a near-free worktree add (~100–500ms). Corruption recovery: if the bare clone's `HEAD` file is missing or zero-length after a failure, the cache wipes the directory and retries once before surfacing `CloneFailed` as before. Auth and network errors do not trigger a wipe. Promote `fabro_store::KeyedMutex` and its guard to `pub` so the server can reuse the existing primitive instead of duplicating it. Tests: - `bare_clone_reused_across_calls` seeds a local upstream, runs `prepare_worktree` twice, and asserts the bare clone's `objects/` tree is identical before and after the second call (i.e., no re-clone). - `bare_clone_recovers_from_corruption` truncates `HEAD` between calls and asserts the cache rebuilds and succeeds. - The existing plan-builder argv/timeout assertions are updated to cover the new bare-clone, bare-fetch, worktree-add, worktree-prune, and rev-parse FETCH_HEAD plans. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>	2026-05-29 08:29:58 -04:00
Bryan Helmkamp	87516c25ce	feat(automations): wire UI to API and auto-start runs from API trigger ... Make the Automations area in the web UI functional end-to-end against the real Automation API, and fix the backend so runs created by an automation's API trigger actually start instead of sitting in Submitted forever. Web: - Reveal the Automations nav tab outside demo mode; drop the now-empty demoOnly mechanism. - List page: render via listAutomations (was workflows mock data); wire ellipsis menu to Edit and Delete, with ConfirmDialog + If-Match revision. Move Create Automation into the toolbar, switch the trigger select to a shared FilterButton, hide the redundant page-header title via a new hideTitle handle flag. - Play button on each card fires createAutomationRun with spinner + toast and navigates to the new run. - New automation form: drop the dead Goal panel and hardcoded repository list, post to createAutomation with real triggers. - Edit automation: new /automations/:id/edit route reusing a shared AutomationFormFields component, PUT via replaceAutomation with If-Match. - Show page: rebuild like a run detail page — breadcrumb, title, chips (enabled status, repo+ref, workflow, schedule), Edit + Run actions (Run hits createAutomationRun), and a Runs panel using RunsListView with URL-driven search/sort/pagination/column-picker like the Children sub-tab. Drop the obsolete Definition/Diagram/Runs child routes. Backend (fabro-server): - create_automation_run now calls lifecycle::queue_run_start after the run is persisted, so the run transitions Submitted → Runnable and the scheduler picks it up. Logs a warn and returns the created response if start fails (no worse than the prior always-stuck behavior). - queue_run_start in lifecycle.rs is promoted to pub(super) so sibling handlers can reuse it. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>	2026-05-28 20:24:09 -04:00
Bryan Helmkamp	8272d8239b	feat(model): add Claude Opus 4.8 (#451) ... ## Summary - Add `claude-opus-4-8` to the built-in Anthropic model catalog with pricing, limits, features, and fast-mode costs. - Move the floating `opus` and `claude-opus` aliases from Opus 4.7 to Opus 4.8 and update the public model table. - Remove/generalize Rust tests that were pinned to specific built-in Opus catalog data. ## Verification - `cargo nextest run -p fabro-model` - `cargo +nightly-2026-04-14 fmt --check --all` - `git diff --check` - `target/debug/fabro --json model test --model opus` (live Anthropic smoke; resolved to `claude-opus-4-8`)	2026-05-28 19:58:00 -04:00
fabro-sh-0530[bot]	4cff07373c	feat: add server-owned environment store (Task 1 & 2 foundation) (#446) ... ## Summary Moves environment definitions out of project/workflow TOML config and into server-owned files, introducing the `fabro-environment` crate and enforcing source-aware validation so project/workflow/user configs can no longer define environment catalogs. ### What changed **New `fabro-environment` crate** — workspace crate wired into `fabro-cli` and `fabro-server`. Exposes a `seeded_catalog_layer()` that CLI commands inject at the call site to fill the environment catalog that settings resolution requires. **Config environments are now migration-only** — `defaults.toml` no longer ships a built-in `[environments.*]` catalog. Instead: - `SettingsSource` enum tags every parsed layer (ActiveSettings, Project, Workflow, DirectRun, User). - `validate_settings_source` rejects `[environments.<id>]` in any source except `ActiveSettings` with a targeted message: `[environments.<id>] is now server-managed; move this definition to the server environments directory`. - TOML-provided `run.environment.{image,resources,network,lifecycle,labels,volumes,env}` overrides are also rejected; only `run.environment.id` survives. **New migration** (`2026052801_settings_environments_to_server_files`) — chains after the existing legacy-sandbox migration. Extracts `[environments.*]` entries from `settings.toml` into sibling `environments/<id>.toml` files, writes a `.settings-environments-migration.bak` backup, and fails without modifying any file if a target already exists. **Builder API additions** — `RunSettingsBuilder::load_from_with_catalog`, `load_default_with_catalog`, `from_toml_with_catalog` let callers inject a server-side catalog; the bare `from_toml` path now errors if no catalog is present and a named environment is selected. `WorkflowSettingsBuilder` test helpers in `src/tests/mod.rs` centralise catalog injection across all config tests. **`.fabro/project.toml`** — removed the inline `[environments.fabro-dev]` block (environment definition now lives server-side). ### Key design decisions - CLI offline commands (graph, preflight, validate) use `seeded_catalog_layer()` as a local stand-in until a running server is available — matches the pre-existing behaviour without regressing offline workflows. - `load_settings_path` no longer runs migrations for non-ActiveSettings sources, preventing project/workflow files from accidentally triggering file-system writes. - The `MigrationReport` type is now the new migration's `SettingsEnvironmentsMigrationReport` (exposes `contents: String` instead of a parsed layer), keeping `load.rs` simpler and decoupled from layer parsing. ### Fabro Details <details> <summary>Ran 9 stages in 143m 23s for $105.27</summary> | Stage | Duration | Cost | Retries | |---|---|---|---| | start | 0s | – | 0 | | toolchain | 1s | – | 0 | | preflight_compile | 2m 11s | – | 0 | | preflight_lint | 2m 23s | – | 0 | | implement | 28m 27s | – | 0 | | simplify_opus | 37m 27s | $53.28 | 0 | | simplify_gpt | 20m 50s | $12.14 | 0 | | verify | 6m 3s | – | 0 | | fixup | 45m 15s | $39.84 | 0 | | **Total** | **143m 23s** | **$105.27** | **0** | </details> <details> <summary>Ran <code>ImplementPlan.fabro</code> (11 nodes and 14 edges)</summary> ```dot digraph ImplementPlan { graph [ goal="Implement and simplify", model_stylesheet=" * { model: claude-opus-4-7; } " ] rankdir=LR start [shape=Mdiamond, label="Start"] exit [shape=Msquare, label="Exit"] toolchain [label="Toolchain", shape=parallelogram, script="command -v cargo >/dev/null || { curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y && sudo ln -sf $HOME/.cargo/bin/* /usr/local/bin/; }; cargo --version 2>&1", max_retries=0] preflight_compile [label="Preflight Compile", shape=parallelogram, script="cargo check -q --workspace 2>&1", max_retries=0] preflight_lint [label="Preflight Lint", shape=parallelogram, script="cargo +nightly-2026-04-14 clippy -q --workspace --all-targets -- -D warnings 2>&1", max_retries=0] fix_lints [label="Fix Lints", prompt="The preflight lint step failed. Read the build output from context and fix all clippy lint warnings.", max_visits=3] implement [label="Implement", prompt="Read the plan file referenced in the goal and implement every step. Make all the code changes described in the plan. Use red/green TDD.", model="gpt-55", reasoning_effort="xhigh"] simplify_opus [label="Simplify (Opus)", prompt="@prompts/simplify.md"] simplify_gpt [label="Simplify (GPT-55)", prompt="@prompts/simplify.md", model="gpt-55"] verify [label="Verify", shape=parallelogram, script="git fetch origin main 2>&1 && git merge --no-edit --no-stat origin/main 2>&1 && cargo +nightly-2026-04-14 fmt --all 2>&1 && cargo dev docs refresh 2>&1 && cargo +nightly-2026-04-14 fmt --check --all 2>&1 && { command -v rg >/dev/null 2>&1 || { echo 'rg is required for verify'; exit 127; }; } && ! rg -n 'AuthMode::Disabled|RunAuthMethod|RunSubjectProvenance|\bActorRef\b|\bActorKind\b|AuthenticatedSubject|AuthenticatedService|AuthorizeRunScoped|AuthorizeRunBlob|AuthorizeStageArtifact|AuthorizeCommandLog|auth_method\s*==\s*\"disabled\"' lib/crates apps lib/packages docs/public/api-reference/fabro-api.yaml 2>&1 && cargo +nightly-2026-04-14 clippy --workspace --all-targets -- -D warnings 2>&1 && cargo nextest run --workspace --status-level slow --profile ci 2>&1 && cargo dev docs check 2>&1 && bun install --frozen-lockfile 2>&1 && (cd apps/fabro-web && bun run typecheck) 2>&1 && (cd apps/fabro-web && bun run test) 2>&1 && (cd lib/packages/fabro-api-client && bun run typecheck) 2>&1 && cargo dev build -- -p fabro-cli --release 2>&1", goal_gate=true, retry_target="fixup"] fixup [label="Fixup", prompt="The verify step failed. Read the build output from context and fix all format, clippy, Rust test, docs, TypeScript typecheck/test, and build failures.", max_visits=3] start -> toolchain toolchain -> preflight_compile [condition="outcome=succeeded"] toolchain -> exit preflight_compile -> preflight_lint [condition="outcome=succeeded"] preflight_compile -> exit preflight_lint -> implement [condition="outcome=succeeded"] preflight_lint -> fix_lints fix_lints -> preflight_lint implement -> simplify_opus -> simplify_gpt -> verify verify -> exit [condition="outcome=succeeded"] verify -> fixup fixup -> verify } ``` </details> ⚒️ Generated with [Fabro](https://fabro.sh) --------- Co-authored-by: Fabro <noreply@fabro.sh> Co-authored-by: Bryan Helmkamp <bryan@brynary.com>	2026-05-28 17:10:59 -04:00
Bryan Helmkamp	0106711170	test: cover automation trigger API behavior	2026-05-28 12:56:14 -04:00
Bryan Helmkamp	91d11eb04d	fix(llm): preserve raw compatible tool arguments (#448) ... ## Summary Fixes #435. Preserve raw non-JSON tool-call arguments for custom/freeform tools when using the OpenAI-compatible Chat Completions adapter. This keeps `apply_patch` receiving the raw patch text instead of `{}` when LiteLLM/openai-compatible providers emit Codex-style freeform patch calls. Also extends the OpenAI twin so black-box tests can exercise the Chat Completions path with raw tool-call arguments. ## Test Plan - `cargo +nightly-2026-04-14 fmt --check --all` - `cargo nextest run -p fabro-agent --test it openai_compatible_twin_preserves_raw_apply_patch_arguments --run-ignored only` - `cargo nextest run -p fabro-llm` - `cargo nextest run -p fabro-test`	2026-05-28 11:52:36 -04:00
Bryan Helmkamp	2e39dfc70e	fix(agent): align compaction preserve boundary (#449) ... ## Summary Follow-up to fabro-sh/fabro#447. This keeps context compaction's effective preserve boundary consistent between summary generation, history mutation, and emitted telemetry so tool-call/result pairs that remain in raw history are not also summarized. The branch also tightens the OpenAI twin support added for this regression: scripted usage is modeled as a single `TokenUsage`, SSE completion payloads reuse the canonical Responses JSON shape, and request validation now treats custom tool-call outputs as tool outputs instead of spreading raw item-type string checks. ## Verification - `cargo +nightly-2026-04-14 fmt --check --all` - `cargo nextest run -p fabro-agent compaction` - `cargo nextest run -p twin-openai` - `FABRO_TEST_MODE=twin cargo nextest run -p fabro-agent --profile e2e --run-ignored only --test it openai_twin_compaction_preserves_tool_call_pairs` - `git diff --check origin/main...HEAD` --- [](https://github.com/EveryInc/compound-engineering-plugin) 🤖 Generated with GPT-5 via [Codex](https://openai.com/codex)	2026-05-28 11:26:52 -04:00
Bryan Helmkamp	81554581ca	fix(agent): preserve tool-call pairs during compaction (#447) ... ## Summary Fixes OpenAI Responses requests after context compaction by ensuring preserved tool results are not separated from the assistant tool calls that produced them. The previous fixed-size preserved tail could retain a `function_call_output` while dropping the matching `function_call`, which OpenAI rejects as an orphaned tool result. ## Changes - Extends `History::compact` so the preserved range moves backward until every kept tool result has its matching assistant tool call. - Adds a unit invariant test for compacted histories that serialize tool results. - Adds an OpenAI twin integration regression that forces compaction during a tool-use loop. - Teaches the OpenAI twin to validate orphaned `function_call_output` items and script response usage counts for deterministic compaction tests. ## Test Plan - `cargo +nightly-2026-04-14 fmt --check --all` - `git diff --check` - `FABRO_TEST_MODE=twin cargo nextest run -p fabro-agent --test it openai_twin_compaction_preserves_tool_call_pairs --run-ignored all` - `cargo nextest run -p fabro-agent` - `cargo nextest run -p twin-openai` - `cargo nextest run -p fabro-test` - `cargo +nightly-2026-04-14 clippy -p fabro-agent -p fabro-test -p twin-openai --all-targets --no-deps -- -D warnings` --- [](https://github.com/EveryInc/compound-engineering-plugin) 🤖 Generated with GPT-5 via [Codex](https://openai.com/codex)	2026-05-28 10:37:30 -04:00
fabro-sh-0530[bot]	9ee576690b	refactor: remove in-process IP allowlist and introduce WorkerRuntime (#444) ... ## Summary This PR does two things: it removes the in-process inbound source-IP allowlist entirely, and it lays the foundation for pluggable worker compute backends by introducing a `WorkerRuntime` abstraction. ## IP allowlist removal The `[server.ip_allowlist]` setting and its GitHub webhook overlay (`[server.integrations.github.webhooks.ip_allowlist]`) have been removed from config parsing, the settings API, and the OpenAPI spec. The `ip_allowlist.rs` module (~600 lines including the `GitHubMetaResolver`, middleware, and cache logic) is deleted. **Migration:** Existing `settings.toml` files containing those keys will now fail to parse as unknown fields. Source-IP restrictions should be moved to a reverse proxy, firewall, VPN, Tailscale ACL, or cloud ingress — as documented in the new security guidance. `build_router_with_options` loses the `ip_allowlist_config: Arc<IpAllowlistConfig>` parameter and `RouterOptions` loses `github_webhook_ip_allowlist`. Call sites in tests and the auth harness are updated accordingly. TCP serving no longer uses `make_service_with_connect_info` since `ConnectInfo` was only needed for IP extraction. ## WorkerRuntime abstraction A new `worker_runtime.rs` module introduces: - **`WorkerRuntime` trait** — `start`, `request_stop`, `force_stop`, `is_alive` - **`WorkerLaunchSpec`** — all inputs needed to describe a worker process, replacing the former `worker_command` helper - **`WorkerRef::Local { pid, process_group_id }`** — replaces the `worker_pid` / `worker_pgid` pair on `ManagedRun` - **`StartedWorker`** — carries the ref, optional stderr stream, and a `wait` future - **`LocalWorkerRuntime`** — the only implementation for now; wraps the existing subprocess spawn logic `AppState` stores an `Arc<dyn WorkerRuntime>` and `AppStateConfig` accepts an optional override in `#[cfg(test)]` for injection. Stop/kill paths in `server.rs` and `lifecycle.rs` now call `worker_runtime.request_stop` / `force_stop` / `is_alive` instead of issuing signals directly. ### Plan Summary - **Task 1:** New `worker_runtime.rs` with trait, types, and `LocalWorkerRuntime` impl - **Task 2:** Wire `Arc<dyn WorkerRuntime>` into `AppState` / `AppStateConfig` / `TestAppStateBuilder` - **Task 3:** Replace `worker_pid` / `worker_pgid` on `ManagedRun` with `worker_ref: Option<WorkerRef>`; build `WorkerLaunchSpec` in `execute_run_subprocess` - **Task 4:** Route all stop/kill calls through the runtime (`terminate_worker_for_deletion`, `shutdown_active_workers`, `cancel_run` fallback) - **Task 5:** Fake `RecordingWorkerRuntime` for unit tests; new cancel-fallback and shutdown tests ### Fabro Details <details> <summary>Ran 8 stages in 107m 33s for $21.66</summary> | Stage | Duration | Cost | Retries | |---|---|---|---| | start | 0s | – | 0 | | toolchain | 1s | – | 0 | | preflight_compile | 2m 10s | – | 0 | | preflight_lint | 2m 21s | – | 0 | | implement | 29m 0s | $11.86 | 0 | | simplify_opus | 11m 9s | $5.94 | 0 | | simplify_gpt | 53m 13s | $3.85 | 0 | | verify | 9m 23s | – | 0 | | **Total** | **107m 33s** | **$21.66** | **0** | </details> <details> <summary>Ran <code>ImplementPlan.fabro</code> (11 nodes and 14 edges)</summary> ```dot digraph ImplementPlan { graph [ goal="Implement and simplify", model_stylesheet=" * { model: claude-opus-4-7; } " ] rankdir=LR start [shape=Mdiamond, label="Start"] exit [shape=Msquare, label="Exit"] toolchain [label="Toolchain", shape=parallelogram, script="command -v cargo >/dev/null || { curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y && sudo ln -sf $HOME/.cargo/bin/* /usr/local/bin/; }; cargo --version 2>&1", max_retries=0] preflight_compile [label="Preflight Compile", shape=parallelogram, script="cargo check -q --workspace 2>&1", max_retries=0] preflight_lint [label="Preflight Lint", shape=parallelogram, script="cargo +nightly-2026-04-14 clippy -q --workspace --all-targets -- -D warnings 2>&1", max_retries=0] fix_lints [label="Fix Lints", prompt="The preflight lint step failed. Read the build output from context and fix all clippy lint warnings.", max_visits=3] implement [label="Implement", prompt="Read the plan file referenced in the goal and implement every step. Make all the code changes described in the plan. Use red/green TDD.", model="gpt-55", reasoning_effort="xhigh"] simplify_opus [label="Simplify (Opus)", prompt="@prompts/simplify.md"] simplify_gpt [label="Simplify (GPT-55)", prompt="@prompts/simplify.md", model="gpt-55"] verify [label="Verify", shape=parallelogram, script="git fetch origin main 2>&1 && git merge --no-edit --no-stat origin/main 2>&1 && cargo +nightly-2026-04-14 fmt --all 2>&1 && cargo dev docs refresh 2>&1 && cargo +nightly-2026-04-14 fmt --check --all 2>&1 && { command -v rg >/dev/null 2>&1 || { echo 'rg is required for verify'; exit 127; }; } && ! rg -n 'AuthMode::Disabled|RunAuthMethod|RunSubjectProvenance|\bActorRef\b|\bActorKind\b|AuthenticatedSubject|AuthenticatedService|AuthorizeRunScoped|AuthorizeRunBlob|AuthorizeStageArtifact|AuthorizeCommandLog|auth_method\s*==\s*\"disabled\"' lib/crates apps lib/packages docs/public/api-reference/fabro-api.yaml 2>&1 && cargo +nightly-2026-04-14 clippy --workspace --all-targets -- -D warnings 2>&1 && cargo nextest run --workspace --status-level slow --profile ci 2>&1 && cargo dev docs check 2>&1 && bun install --frozen-lockfile 2>&1 && (cd apps/fabro-web && bun run typecheck) 2>&1 && (cd apps/fabro-web && bun run test) 2>&1 && (cd lib/packages/fabro-api-client && bun run typecheck) 2>&1 && cargo dev build -- -p fabro-cli --release 2>&1", goal_gate=true, retry_target="fixup"] fixup [label="Fixup", prompt="The verify step failed. Read the build output from context and fix all format, clippy, Rust test, docs, TypeScript typecheck/test, and build failures.", max_visits=3] start -> toolchain toolchain -> preflight_compile [condition="outcome=succeeded"] toolchain -> exit preflight_compile -> preflight_lint [condition="outcome=succeeded"] preflight_compile -> exit preflight_lint -> implement [condition="outcome=succeeded"] preflight_lint -> fix_lints fix_lints -> preflight_lint implement -> simplify_opus -> simplify_gpt -> verify verify -> exit [condition="outcome=succeeded"] verify -> fixup fixup -> verify } ``` </details> ⚒️ Generated with [Fabro](https://fabro.sh) --------- Co-authored-by: Fabro <noreply@fabro.sh>	2026-05-27 23:17:23 -04:00
fabro-sh-0530[bot]	e3bbe91053	Add GET/POST /automations/{id}/runs endpoints (#442) ... ## Summary Implements the two automation run endpoints from issue #399, backed by a significant refactor of the worker control channel from stdin JSONL to a WebSocket-based pub/sub bus. ## What changed ### New API endpoints (`automations.rs`) - `GET /automations/{id}/runs` — lists cached runs filtered to those linked to the given automation ID, sorted newest-first, with `page[limit]`/`page[offset]` pagination and the standard `{ data, meta }` envelope. - `POST /automations/{id}/runs` — requires `RequiredRunToolActor` auth, checks that the automation exists and has an enabled API trigger (returning 409 with `automation_api_trigger_disabled` otherwise), materializes the run manifest, and delegates to the shared `create_run_from_manifest` helper with a fully-populated `AutomationRef`. ### `enabled_api_trigger()` helper (`fabro-automation`) A new method on `Automation` encapsulates the "automation is enabled **and** has an enabled API trigger" check, keeping the handler clean. ### Worker control channel: stdin JSONL → WebSocket bus The most significant structural change is how the server delivers control messages (answers, cancel, pause/unpause, steer, pair events) to running workers: | Before | After | |---|---| | Server pipes JSONL lines to worker stdin | Server publishes to `WorkerControlBus`; worker connects via WebSocket | | Worker reads stdin on a blocking OS thread | Worker manages a reconnecting WebSocket with ping/pong liveness | | No delivery deduplication | `AppliedWorkerControlDeliveryIds` deduplicates replayed frames | | No reconnect / resume | Worker reconnects with exponential backoff; replays from last applied cursor | The `LocalWorkerControlBus` replaces the old `mpsc` channel and stdin pipe. `RunAnswerTransport::Subprocess` is renamed `Worker` and holds a `run_id` + `Arc<dyn WorkerControlBus>` instead of a channel sender. Worker stdin is now `Stdio::null()`. New control messages `RunPause` / `RunUnpause` are added to the protocol, wired through to `RunControlState`. ### Plan Summary - Add `enabled_api_trigger()` to `Automation`. - Implement `list_automation_runs` and `create_automation_run` handlers; route them under `/automations/{id}/runs`. - Expose `create_run_from_manifest` from the runs handler for reuse. - Add `RequiredRunToolActor` extractor. - Replace stdin JSONL worker control with `WorkerControlBus` + WebSocket reconnect loop in the CLI worker. - Add integration tests for all 409/201 cases, run persistence, listing filters, pagination, and sorting. ### Fabro Details <details> <summary>Ran 8 stages in 51m 5s for $21.34</summary> | Stage | Duration | Cost | Retries | |---|---|---|---| | start | 0s | – | 0 | | toolchain | 1s | – | 0 | | preflight_compile | 2m 8s | – | 0 | | preflight_lint | 2m 23s | – | 0 | | implement | 20m 52s | $13.05 | 0 | | simplify_opus | 11m 5s | $5.70 | 0 | | simplify_gpt | 5m 0s | $2.60 | 0 | | verify | 9m 4s | – | 0 | | **Total** | **51m 5s** | **$21.34** | **0** | </details> <details> <summary>Ran <code>ImplementPlan.fabro</code> (11 nodes and 14 edges)</summary> ```dot digraph ImplementPlan { graph [ goal="Implement and simplify", model_stylesheet=" * { model: claude-opus-4-7; } " ] rankdir=LR start [shape=Mdiamond, label="Start"] exit [shape=Msquare, label="Exit"] toolchain [label="Toolchain", shape=parallelogram, script="command -v cargo >/dev/null || { curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y && sudo ln -sf $HOME/.cargo/bin/* /usr/local/bin/; }; cargo --version 2>&1", max_retries=0] preflight_compile [label="Preflight Compile", shape=parallelogram, script="cargo check -q --workspace 2>&1", max_retries=0] preflight_lint [label="Preflight Lint", shape=parallelogram, script="cargo +nightly-2026-04-14 clippy -q --workspace --all-targets -- -D warnings 2>&1", max_retries=0] fix_lints [label="Fix Lints", prompt="The preflight lint step failed. Read the build output from context and fix all clippy lint warnings.", max_visits=3] implement [label="Implement", prompt="Read the plan file referenced in the goal and implement every step. Make all the code changes described in the plan. Use red/green TDD.", model="gpt-55", reasoning_effort="xhigh"] simplify_opus [label="Simplify (Opus)", prompt="@prompts/simplify.md"] simplify_gpt [label="Simplify (GPT-55)", prompt="@prompts/simplify.md", model="gpt-55"] verify [label="Verify", shape=parallelogram, script="git fetch origin main 2>&1 && git merge --no-edit --no-stat origin/main 2>&1 && cargo +nightly-2026-04-14 fmt --all 2>&1 && cargo dev docs refresh 2>&1 && cargo +nightly-2026-04-14 fmt --check --all 2>&1 && { command -v rg >/dev/null 2>&1 || { echo 'rg is required for verify'; exit 127; }; } && ! rg -n 'AuthMode::Disabled|RunAuthMethod|RunSubjectProvenance|\bActorRef\b|\bActorKind\b|AuthenticatedSubject|AuthenticatedService|AuthorizeRunScoped|AuthorizeRunBlob|AuthorizeStageArtifact|AuthorizeCommandLog|auth_method\s*==\s*\"disabled\"' lib/crates apps lib/packages docs/public/api-reference/fabro-api.yaml 2>&1 && cargo +nightly-2026-04-14 clippy --workspace --all-targets -- -D warnings 2>&1 && cargo nextest run --workspace --status-level slow --profile ci 2>&1 && cargo dev docs check 2>&1 && bun install --frozen-lockfile 2>&1 && (cd apps/fabro-web && bun run typecheck) 2>&1 && (cd apps/fabro-web && bun run test) 2>&1 && (cd lib/packages/fabro-api-client && bun run typecheck) 2>&1 && cargo dev build -- -p fabro-cli --release 2>&1", goal_gate=true, retry_target="fixup"] fixup [label="Fixup", prompt="The verify step failed. Read the build output from context and fix all format, clippy, Rust test, docs, TypeScript typecheck/test, and build failures.", max_visits=3] start -> toolchain toolchain -> preflight_compile [condition="outcome=succeeded"] toolchain -> exit preflight_compile -> preflight_lint [condition="outcome=succeeded"] preflight_compile -> exit preflight_lint -> implement [condition="outcome=succeeded"] preflight_lint -> fix_lints fix_lints -> preflight_lint implement -> simplify_opus -> simplify_gpt -> verify verify -> exit [condition="outcome=succeeded"] verify -> fixup fixup -> verify } ``` </details> ⚒️ Generated with [Fabro](https://fabro.sh) --------- Co-authored-by: Fabro <noreply@fabro.sh>	2026-05-27 22:29:29 -04:00
fabro-sh-0530[bot]	29a9a3f7d6	refactor: Remove inbound IP allowlisting (#443) ... ## Summary Removes Fabro's in-process inbound source-IP allowlist entirely. `[server.ip_allowlist]` and `[server.integrations.github.webhooks.ip_allowlist]` are gone from config parsing, resolved settings types, the OpenAPI spec, generated API clients, and the Settings > Security UI. Existing `settings.toml` files containing those keys now fail as unknown fields — this is a hard removal with no migration path. Network source restrictions should be enforced upstream via a reverse proxy, firewall, VPN, Tailscale ACLs, Kubernetes ingress, or platform policy. ### What changed - **Config/types** (`fabro-config`, `fabro-types`): Removed `ServerIpAllowlistLayer`, `ServerIpAllowlistOverrideLayer`, `ServerIpAllowlistSettings`, `ServerIpAllowlistOverrideSettings`, `IpAllowEntry`, associated resolver functions, GitHub `/meta` hook-range parsing, and Unix socket trusted-proxy validation. `ipnet` dropped from `fabro-types`; kept in `fabro-config` for sandbox CIDR validation. - **Server runtime** (`fabro-server`): Deleted `ip_allowlist.rs`, removed `IpAllowlistConfig` parameter from `build_router_with_options` and `RouterOptions`, removed the global allowlist middleware layer, and removed `GitHubMetaResolver` startup logic. GitHub webhook HMAC verification is unchanged. - **OpenAPI + generated clients**: Removed `ServerIpAllowlistSettings`, `ServerIpAllowlistOverrideSettings`, `IpAllowEntry`, `LiteralIpAllowEntry`, `GitHubMetaHooksEntry` schemas; removed `ip_allowlist` from `ServerNamespace` and `IntegrationWebhooksSettings`; dropped `IpAllowEntry` re-exports from `fabro-api`. - **Web UI**: Removed IP allowlist row from Settings > Security; updated nav description and page copy. - **Docs/changelog**: Security docs explicitly state Fabro provides no source-IP filtering and direct operators upstream. Changelog entry dated 2026-05-27 documents the breaking removal and annotates the 2026-04-19 entry where the feature was introduced. ### Also in this diff (unrelated to IP allowlisting) The worker control stream was migrated from reading newline-delimited JSON on stdin to a reconnecting WebSocket (`/api/v1/runs/{id}/worker/control-stream`). This adds `tokio-tungstenite` to `fabro-cli`/`fabro-server`, introduces `WorkerControlManagerHandle` with backoff reconnection and deduplication of replayed delivery IDs, and adds `RunPause`/`RunUnpause` message handling. A new integration test (`detached_run_cancel_reaches_worker_over_control_websocket`) exercises the full cancel path over the WebSocket. ### Key decisions - **Hard removal via `deny_unknown_fields`**: stale config is immediately visible as a startup error rather than silently ignored. - **No stub or default pass-through**: `IpAllowlistConfig::default()` is gone, not left as a no-op wrapper, to avoid keeping the feature shape alive. - **Webhook HMAC boundary unchanged**: source-IP filtering on webhook routes is removed; cryptographic signature verification remains the security boundary. ### Fabro Details <details> <summary>Ran 9 stages in 59m 53s for $27.24</summary> | Stage | Duration | Cost | Retries | |---|---|---|---| | start | 0s | – | 0 | | toolchain | 1s | – | 0 | | preflight_compile | 2m 15s | – | 0 | | preflight_lint | 2m 22s | – | 0 | | implement | 33m 54s | $22.81 | 0 | | simplify_opus | 5m 55s | $0.75 | 0 | | simplify_gpt | 3m 35s | $2.81 | 0 | | verify | 8m 34s | – | 0 | | fixup | 2m 24s | $0.87 | 0 | | **Total** | **59m 53s** | **$27.24** | **0** | </details> <details> <summary>Ran <code>ImplementPlan.fabro</code> (11 nodes and 14 edges)</summary> ```dot digraph ImplementPlan { graph [ goal="Implement and simplify", model_stylesheet=" * { model: claude-opus-4-7; } " ] rankdir=LR start [shape=Mdiamond, label="Start"] exit [shape=Msquare, label="Exit"] toolchain [label="Toolchain", shape=parallelogram, script="command -v cargo >/dev/null || { curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y && sudo ln -sf $HOME/.cargo/bin/* /usr/local/bin/; }; cargo --version 2>&1", max_retries=0] preflight_compile [label="Preflight Compile", shape=parallelogram, script="cargo check -q --workspace 2>&1", max_retries=0] preflight_lint [label="Preflight Lint", shape=parallelogram, script="cargo +nightly-2026-04-14 clippy -q --workspace --all-targets -- -D warnings 2>&1", max_retries=0] fix_lints [label="Fix Lints", prompt="The preflight lint step failed. Read the build output from context and fix all clippy lint warnings.", max_visits=3] implement [label="Implement", prompt="Read the plan file referenced in the goal and implement every step. Make all the code changes described in the plan. Use red/green TDD.", model="gpt-55", reasoning_effort="xhigh"] simplify_opus [label="Simplify (Opus)", prompt="@prompts/simplify.md"] simplify_gpt [label="Simplify (GPT-55)", prompt="@prompts/simplify.md", model="gpt-55"] verify [label="Verify", shape=parallelogram, script="git fetch origin main 2>&1 && git merge --no-edit --no-stat origin/main 2>&1 && cargo +nightly-2026-04-14 fmt --all 2>&1 && cargo dev docs refresh 2>&1 && cargo +nightly-2026-04-14 fmt --check --all 2>&1 && { command -v rg >/dev/null 2>&1 || { echo 'rg is required for verify'; exit 127; }; } && ! rg -n 'AuthMode::Disabled|RunAuthMethod|RunSubjectProvenance|\bActorRef\b|\bActorKind\b|AuthenticatedSubject|AuthenticatedService|AuthorizeRunScoped|AuthorizeRunBlob|AuthorizeStageArtifact|AuthorizeCommandLog|auth_method\s*==\s*\"disabled\"' lib/crates apps lib/packages docs/public/api-reference/fabro-api.yaml 2>&1 && cargo +nightly-2026-04-14 clippy --workspace --all-targets -- -D warnings 2>&1 && cargo nextest run --workspace --status-level slow --profile ci 2>&1 && cargo dev docs check 2>&1 && bun install --frozen-lockfile 2>&1 && (cd apps/fabro-web && bun run typecheck) 2>&1 && (cd apps/fabro-web && bun run test) 2>&1 && (cd lib/packages/fabro-api-client && bun run typecheck) 2>&1 && cargo dev build -- -p fabro-cli --release 2>&1", goal_gate=true, retry_target="fixup"] fixup [label="Fixup", prompt="The verify step failed. Read the build output from context and fix all format, clippy, Rust test, docs, TypeScript typecheck/test, and build failures.", max_visits=3] start -> toolchain toolchain -> preflight_compile [condition="outcome=succeeded"] toolchain -> exit preflight_compile -> preflight_lint [condition="outcome=succeeded"] preflight_compile -> exit preflight_lint -> implement [condition="outcome=succeeded"] preflight_lint -> fix_lints fix_lints -> preflight_lint implement -> simplify_opus -> simplify_gpt -> verify verify -> exit [condition="outcome=succeeded"] verify -> fixup fixup -> verify } ``` </details> ⚒️ Generated with [Fabro](https://fabro.sh) --------- Co-authored-by: Fabro <noreply@fabro.sh>	2026-05-27 22:29:08 -04:00
fabro-sh-0530[bot]	475b4ab650	Replace stdin JSONL control pipe with WebSocket worker control bus (#440) ... ## Summary Workers no longer receive control messages over stdin JSONL. A new `WorkerControlBus` abstraction (backed by `LocalWorkerControlBus` for local/single-node deployments) publishes `WorkerControlEnvelope` messages server-side; a worker-initiated WebSocket at `GET /runs/{id}/worker/control-stream` delivers them with ordered, replayable delivery frames. The bus API is designed so a Redis Streams backend can slot in later without touching API handlers or worker message handling. ### Plan Summary - **Task 1 – Bus contract:** `WorkerControlBus` trait, `WorkerControlDelivery`, `WorkerControlCursor` (`Start` / `After(id)`), bus errors. - **Task 2 – Local backend:** `LocalWorkerControlBus` — in-memory per-run stream, replay from `Start`, reconnect via `After(id)`, 1 024-message trim bound, cleanup on terminal runs. - **Task 3 – Server state:** `Arc<dyn WorkerControlBus>` added to `AppState`; `LocalWorkerControlBus` constructed at startup. - **Task 4 – Protocol extension:** `WorkerControlMessage::RunPause` / `RunUnpause`, `WorkerControlDeliveryFrame`, WebSocket liveness constants (`WORKER_CONTROL_WS_PING_INTERVAL = 15s`, `WORKER_CONTROL_WS_LIVENESS_TIMEOUT = 45s`), close-reason strings. - **Task 5 – Worker message handler:** `apply_worker_control_message` split out; pause/unpause routing; delivery-id dedupe (`AppliedWorkerControlDeliveryIds`, capacity 2 048). - **Task 6 – Worker WebSocket client:** `spawn_worker_control_manager` — HTTP→ws/wss and Unix-socket connection, backoff 100ms→5s, first-connection gate before `operations::start/resume`, ping/pong watchdog, fatal loss wired back to `execute`. - **Task 7 – Server route:** `GET /runs/{id}/worker/control-stream`, worker-only auth via new `RequireWorkerRunScoped` extractor, `Start`/`After` cursor dispatch, 410 on invalid cursor, server-side ping/pong. - **Task 8 – Stdin removal:** `RunAnswerTransport::Subprocess` renamed to `Worker { run_id, bus }`; `pump_worker_control_jsonl` deleted; worker launched with `stdin(Stdio::null())`; pause/unpause transport methods added. - **Tasks 9–10 – E2E & verification:** reconnect, invalid-cursor, cancel-over-WebSocket, and human-interview regression tests; no Redis dependency added. ### Key design decisions **`RunAnswerTransport::Subprocess` → `Worker { run_id, bus }`** — all existing transport methods (`submit`, `cancel_run`, `steer`, `interrupt`, `pair_*`) now call `bus.publish(run_id, envelope)` instead of writing to a channel that fed stdin. The match arms are symmetric, so the diff is mechanical but large. **First-connection gate** — `execute()` calls `control_manager.wait_for_first_connection().await?` before `operations::start` or `operations::resume`. Temporary failures spin with backoff; a fatal invalid-cursor or request-build failure propagates as an error before the workflow starts. **Fatal vs. reconnectable** — HTTP 410 or a WebSocket close with reason `"invalid_cursor"` is fatal (infrastructure failure, not user cancellation). Any other close/error triggers the reconnect loop while the run is non-terminal. **`AutomationStore::load` made synchronous** — startup load now uses `std::fs` under a `clippy::disallowed_methods` exception; async `tokio::fs` is no longer needed for the one-shot directory scan. Invalid automation files now fail loudly instead of being silently skipped. **`canRetry` extended to succeeded runs** — `status.kind === "succeeded"` is now retryable (non-archived). Tests and API docs updated to match. **Default model bumps** — OpenAI default: `gpt-5.4` → `gpt-5.5`; Gemini default: `gemini-3.1-pro-preview` → `gemini-3.5-flash`. ### Fabro Details <details> <summary>Ran 9 stages in 129m 19s for $58.27</summary> | Stage | Duration | Cost | Retries | |---|---|---|---| | start | 0s | – | 0 | | toolchain | 1s | – | 0 | | preflight_compile | 2m 10s | – | 0 | | preflight_lint | 2m 23s | – | 0 | | implement | 73m 48s | $41.53 | 0 | | simplify_opus | 22m 55s | $11.75 | 0 | | simplify_gpt | 7m 19s | $2.74 | 0 | | verify | 8m 51s | – | 0 | | fixup | 10m 59s | $2.24 | 0 | | **Total** | **129m 19s** | **$58.27** | **0** | </details> <details> <summary>Ran <code>ImplementPlan.fabro</code> (11 nodes and 14 edges)</summary> ```dot digraph ImplementPlan { graph [ goal="Implement and simplify", model_stylesheet=" * { model: claude-opus-4-7; } " ] rankdir=LR start [shape=Mdiamond, label="Start"] exit [shape=Msquare, label="Exit"] toolchain [label="Toolchain", shape=parallelogram, script="command -v cargo >/dev/null || { curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y && sudo ln -sf $HOME/.cargo/bin/* /usr/local/bin/; }; cargo --version 2>&1", max_retries=0] preflight_compile [label="Preflight Compile", shape=parallelogram, script="cargo check -q --workspace 2>&1", max_retries=0] preflight_lint [label="Preflight Lint", shape=parallelogram, script="cargo +nightly-2026-04-14 clippy -q --workspace --all-targets -- -D warnings 2>&1", max_retries=0] fix_lints [label="Fix Lints", prompt="The preflight lint step failed. Read the build output from context and fix all clippy lint warnings.", max_visits=3] implement [label="Implement", prompt="Read the plan file referenced in the goal and implement every step. Make all the code changes described in the plan. Use red/green TDD.", model="gpt-55", reasoning_effort="xhigh"] simplify_opus [label="Simplify (Opus)", prompt="@prompts/simplify.md"] simplify_gpt [label="Simplify (GPT-55)", prompt="@prompts/simplify.md", model="gpt-55"] verify [label="Verify", shape=parallelogram, script="git fetch origin main 2>&1 && git merge --no-edit --no-stat origin/main 2>&1 && cargo +nightly-2026-04-14 fmt --all 2>&1 && cargo dev docs refresh 2>&1 && cargo +nightly-2026-04-14 fmt --check --all 2>&1 && { command -v rg >/dev/null 2>&1 || { echo 'rg is required for verify'; exit 127; }; } && ! rg -n 'AuthMode::Disabled|RunAuthMethod|RunSubjectProvenance|\bActorRef\b|\bActorKind\b|AuthenticatedSubject|AuthenticatedService|AuthorizeRunScoped|AuthorizeRunBlob|AuthorizeStageArtifact|AuthorizeCommandLog|auth_method\s*==\s*\"disabled\"' lib/crates apps lib/packages docs/public/api-reference/fabro-api.yaml 2>&1 && cargo +nightly-2026-04-14 clippy --workspace --all-targets -- -D warnings 2>&1 && cargo nextest run --workspace --status-level slow --profile ci 2>&1 && cargo dev docs check 2>&1 && bun install --frozen-lockfile 2>&1 && (cd apps/fabro-web && bun run typecheck) 2>&1 && (cd apps/fabro-web && bun run test) 2>&1 && (cd lib/packages/fabro-api-client && bun run typecheck) 2>&1 && cargo dev build -- -p fabro-cli --release 2>&1", goal_gate=true, retry_target="fixup"] fixup [label="Fixup", prompt="The verify step failed. Read the build output from context and fix all format, clippy, Rust test, docs, TypeScript typecheck/test, and build failures.", max_visits=3] start -> toolchain toolchain -> preflight_compile [condition="outcome=succeeded"] toolchain -> exit preflight_compile -> preflight_lint [condition="outcome=succeeded"] preflight_compile -> exit preflight_lint -> implement [condition="outcome=succeeded"] preflight_lint -> fix_lints fix_lints -> preflight_lint implement -> simplify_opus -> simplify_gpt -> verify verify -> exit [condition="outcome=succeeded"] verify -> fixup fixup -> verify } ``` </details> ⚒️ Generated with [Fabro](https://fabro.sh) --------- Co-authored-by: Fabro <noreply@fabro.sh> Co-authored-by: Bryan Helmkamp <bryan@brynary.com>	2026-05-27 20:24:25 -04:00
fabro-sh-0530[bot]	ee1502f793	Add automation run materialization core and shared run creation helper (#441) ... ## Summary Automation-triggered runs need to share the same run creation pipeline as `POST /runs`. This PR lays the core infrastructure: a `create_run_from_manifest` helper that the HTTP handler and the upcoming automation scheduler can both call, plus a `AutomationRunMaterializer` trait with a production implementation that clones a GitHub repo and builds a `RunManifest` from it. ### Plan Summary - Extract the body of `handler/runs.rs::create_run` into a crate-private `create_run_from_manifest(state, CreateRunFromManifestRequest)` helper; `POST /runs` calls it with `automation: None`, preserving existing behavior. - Add `AutomationRunMaterializeInput/Materialized/Error` types and the `AutomationRunMaterializer` trait (`automation_materializer.rs`). - Implement `ProductionAutomationRunMaterializer`: validates `owner/repo` slug, shallow-clones via `tokio::process::Command` argv (never shell strings), sets `GIT_TERMINAL_PROMPT=0`, enforces per-operation timeouts, redacts credentials from error text, resolves the workflow with `fabro_config::project::WorkflowLocation::resolve`, and builds a `RunManifest` via `fabro_manifest::build_run_manifest`. - Add `TestAutomationRunMaterializer` (gated on `test` or `test-support`) for fake injection in route tests without network access. - Wire the materializer override into `AppState` and `AppStateConfig` behind `#[cfg(any(test, feature = "test-support"))]`; expose via `TestAppStateBuilder::automation_materializer`. - Move `async-trait` from `[dev-dependencies]` to `[dependencies]` in `fabro-server` since the trait is now in production code. ## What changed and why **`automation_materializer.rs` (new)** — Core of this PR. The `GitCommandPlan` builder keeps all git invocations as argv slices so there is no shell injection surface. Credentials are injected exclusively via `GIT_CONFIG_VALUE_0` (the `extraheader` mechanism), never embedded in the clone URL, so they cannot appear in run metadata or error messages. The `redact_git_output` function scrubs the raw token, the Base64-encoded form, and the full `AUTHORIZATION` header value from any error string before it surfaces. **`create_run_from_manifest`** — The extracted helper accepts an optional `AutomationRef` which is forwarded into `create_input.automation` so the store can persist automation provenance on the run. The `POST /runs` code path passes `None`, leaving existing API behavior identical. **Test injection** — `TestAutomationRunMaterializer` captures every `AutomationRunMaterializeInput` it receives and returns a caller-controlled `Result`, letting route tests assert what inputs the scheduler would pass without touching GitHub. ```mermaid flowchart TB A["POST /runs\n(HTTP handler)"] -->|automation: None| H["create_run_from_manifest"] S["Automation scheduler\n(future issue)"] -->|automation: Some(ref)| H H --> DB[(Run store)] M["AutomationRunMaterializer\n(trait)"] -->|produces RunManifest| S M -- production --> P["ProductionAutomationRunMaterializer\n(git clone → manifest build)"] M -- test --> T["TestAutomationRunMaterializer\n(captures input, returns fixture)"] ``` ### Fabro Details <details> <summary>Ran 8 stages in 72m 56s for $36.55</summary> | Stage | Duration | Cost | Retries | |---|---|---|---| | start | 0s | – | 0 | | toolchain | 2s | – | 0 | | preflight_compile | 2m 12s | – | 0 | | preflight_lint | 2m 27s | – | 0 | | implement | 30m 41s | $23.10 | 0 | | simplify_opus | 19m 19s | $9.12 | 0 | | simplify_gpt | 7m 53s | $4.33 | 0 | | verify | 9m 20s | – | 0 | | **Total** | **72m 56s** | **$36.55** | **0** | </details> <details> <summary>Ran <code>ImplementPlan.fabro</code> (11 nodes and 14 edges)</summary> ```dot digraph ImplementPlan { graph [ goal="Implement and simplify", model_stylesheet=" * { model: claude-opus-4-7; } " ] rankdir=LR start [shape=Mdiamond, label="Start"] exit [shape=Msquare, label="Exit"] toolchain [label="Toolchain", shape=parallelogram, script="command -v cargo >/dev/null || { curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y && sudo ln -sf $HOME/.cargo/bin/* /usr/local/bin/; }; cargo --version 2>&1", max_retries=0] preflight_compile [label="Preflight Compile", shape=parallelogram, script="cargo check -q --workspace 2>&1", max_retries=0] preflight_lint [label="Preflight Lint", shape=parallelogram, script="cargo +nightly-2026-04-14 clippy -q --workspace --all-targets -- -D warnings 2>&1", max_retries=0] fix_lints [label="Fix Lints", prompt="The preflight lint step failed. Read the build output from context and fix all clippy lint warnings.", max_visits=3] implement [label="Implement", prompt="Read the plan file referenced in the goal and implement every step. Make all the code changes described in the plan. Use red/green TDD.", model="gpt-55", reasoning_effort="xhigh"] simplify_opus [label="Simplify (Opus)", prompt="@prompts/simplify.md"] simplify_gpt [label="Simplify (GPT-55)", prompt="@prompts/simplify.md", model="gpt-55"] verify [label="Verify", shape=parallelogram, script="git fetch origin main 2>&1 && git merge --no-edit --no-stat origin/main 2>&1 && cargo +nightly-2026-04-14 fmt --all 2>&1 && cargo dev docs refresh 2>&1 && cargo +nightly-2026-04-14 fmt --check --all 2>&1 && { command -v rg >/dev/null 2>&1 || { echo 'rg is required for verify'; exit 127; }; } && ! rg -n 'AuthMode::Disabled|RunAuthMethod|RunSubjectProvenance|\bActorRef\b|\bActorKind\b|AuthenticatedSubject|AuthenticatedService|AuthorizeRunScoped|AuthorizeRunBlob|AuthorizeStageArtifact|AuthorizeCommandLog|auth_method\s*==\s*\"disabled\"' lib/crates apps lib/packages docs/public/api-reference/fabro-api.yaml 2>&1 && cargo +nightly-2026-04-14 clippy --workspace --all-targets -- -D warnings 2>&1 && cargo nextest run --workspace --status-level slow --profile ci 2>&1 && cargo dev docs check 2>&1 && bun install --frozen-lockfile 2>&1 && (cd apps/fabro-web && bun run typecheck) 2>&1 && (cd apps/fabro-web && bun run test) 2>&1 && (cd lib/packages/fabro-api-client && bun run typecheck) 2>&1 && cargo dev build -- -p fabro-cli --release 2>&1", goal_gate=true, retry_target="fixup"] fixup [label="Fixup", prompt="The verify step failed. Read the build output from context and fix all format, clippy, Rust test, docs, TypeScript typecheck/test, and build failures.", max_visits=3] start -> toolchain toolchain -> preflight_compile [condition="outcome=succeeded"] toolchain -> exit preflight_compile -> preflight_lint [condition="outcome=succeeded"] preflight_compile -> exit preflight_lint -> implement [condition="outcome=succeeded"] preflight_lint -> fix_lints fix_lints -> preflight_lint implement -> simplify_opus -> simplify_gpt -> verify verify -> exit [condition="outcome=succeeded"] verify -> fixup fixup -> verify } ``` </details> ⚒️ Generated with [Fabro](https://fabro.sh) --------- Co-authored-by: Fabro <noreply@fabro.sh>	2026-05-27 20:14:56 -04:00
Bryan Helmkamp	a992a7d76b	feat(runs): allow retrying succeeded runs ... Broaden manual retry eligibility to all unarchived terminal runs while preserving active and archived precondition failures.	2026-05-27 18:49:45 -04:00
fabro-sh-0530[bot]	2d78f96107	Wire automation store into AppState and expose CRUD REST API (#439) ... ## Summary Loads `AutomationStore` into `AppState` at server startup and exposes five authenticated REST endpoints (`GET/POST /automations`, `GET/PUT/DELETE /automations/{id}`) backed by the existing `fabro-automation` crate. ### Plan Summary - Add `fabro-automation` as a dependency of `fabro-server` and mount `Arc<AutomationStore>` on `AppState`, computed from a sibling `automations/` directory next to the active config file. - Change `AutomationStore::load` from `async` to synchronous (`std::fs`) so it can run before the Tokio runtime needs to make progress; malformed files now fail startup instead of being silently skipped. - Implement `src/server/handler/automations.rs` with shared helpers for path-ID parsing, `If-Match` (quoted/unquoted) parsing, ETag formatting, and `AutomationStoreError → ApiError` mapping. - HTTP semantics: 201 on create, 404 on missing, 409 on duplicate or stale revision, 422 on domain validation failure, 428 on missing `If-Match`. - Update `TestAppStateBuilder` to derive `active_config_path` from the vault path so each test gets an isolated sibling `automations/` directory; add `try_build()` to allow startup-failure assertions. - Update the OpenAPI spec and generated TypeScript client to include `AutomationListMeta` with a `total` field. ## Key design decisions **Sync load path.** `AutomationStore::load` is now `fn` (not `async fn`), using `std::fs`. A `#[expect(clippy::disallowed_methods)]` annotation explains the rationale: this runs once at startup before the runtime needs to yield, and avoids requiring a Tokio handle at the call site in `build_app_state`. **Fail-fast on malformed files.** Previously, corrupt TOML files were logged as warnings and skipped. Now any parse or validation error during load aborts server startup. The old `warn_load_failure` helper is deleted; tests that relied on skip behaviour are replaced with tests that assert `Err(AutomationStoreError::Parse { .. })` and `Err(AutomationStoreError::InvalidFilename { .. })`. **ETag / If-Match handling.** `parse_required_if_match` strips optional surrounding quotes before parsing the revision, so both `"<rev>"` and bare `<rev>` are accepted from clients. Missing `If-Match` on PUT/DELETE returns **428 Precondition Required**, not 400. **Test isolation.** `TestAppStateBuilder::build` now derives `active_config_path` from `vault_path.with_file_name("settings.toml")` instead of a random temp path, so the sibling `automations/` directory is predictable and cleaned up with the same temp dir. ### Fabro Details <details> <summary>Ran 10 stages in 85m 20s for $33.66</summary> | Stage | Duration | Cost | Retries | |---|---|---|---| | start | 0s | – | 0 | | toolchain | 1s | – | 0 | | preflight_compile | 2m 19s | – | 0 | | preflight_lint | 2m 5s | – | 0 | | fix_lints | 33s | $0.15 | 0 | | implement | 30m 33s | $17.35 | 0 | | simplify_opus | 20m 27s | $11.82 | 0 | | simplify_gpt | 6m 41s | $3.88 | 0 | | verify | 15m 44s | – | 0 | | fixup | 6m 8s | $0.46 | 0 | | **Total** | **85m 20s** | **$33.66** | **0** | </details> <details> <summary>Ran <code>ImplementPlan.fabro</code> (11 nodes and 14 edges)</summary> ```dot digraph ImplementPlan { graph [ goal="Implement and simplify", model_stylesheet=" * { model: claude-opus-4-7; } " ] rankdir=LR start [shape=Mdiamond, label="Start"] exit [shape=Msquare, label="Exit"] toolchain [label="Toolchain", shape=parallelogram, script="command -v cargo >/dev/null || { curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y && sudo ln -sf $HOME/.cargo/bin/* /usr/local/bin/; }; cargo --version 2>&1", max_retries=0] preflight_compile [label="Preflight Compile", shape=parallelogram, script="cargo check -q --workspace 2>&1", max_retries=0] preflight_lint [label="Preflight Lint", shape=parallelogram, script="cargo +nightly-2026-04-14 clippy -q --workspace --all-targets -- -D warnings 2>&1", max_retries=0] fix_lints [label="Fix Lints", prompt="The preflight lint step failed. Read the build output from context and fix all clippy lint warnings.", max_visits=3] implement [label="Implement", prompt="Read the plan file referenced in the goal and implement every step. Make all the code changes described in the plan. Use red/green TDD.", model="gpt-55", reasoning_effort="xhigh"] simplify_opus [label="Simplify (Opus)", prompt="@prompts/simplify.md"] simplify_gpt [label="Simplify (GPT-55)", prompt="@prompts/simplify.md", model="gpt-55"] verify [label="Verify", shape=parallelogram, script="git fetch origin main 2>&1 && git merge --no-edit --no-stat origin/main 2>&1 && cargo +nightly-2026-04-14 fmt --all 2>&1 && cargo dev docs refresh 2>&1 && cargo +nightly-2026-04-14 fmt --check --all 2>&1 && { command -v rg >/dev/null 2>&1 || { echo 'rg is required for verify'; exit 127; }; } && ! rg -n 'AuthMode::Disabled|RunAuthMethod|RunSubjectProvenance|\bActorRef\b|\bActorKind\b|AuthenticatedSubject|AuthenticatedService|AuthorizeRunScoped|AuthorizeRunBlob|AuthorizeStageArtifact|AuthorizeCommandLog|auth_method\s*==\s*\"disabled\"' lib/crates apps lib/packages docs/public/api-reference/fabro-api.yaml 2>&1 && cargo +nightly-2026-04-14 clippy --workspace --all-targets -- -D warnings 2>&1 && cargo nextest run --workspace --status-level slow --profile ci 2>&1 && cargo dev docs check 2>&1 && bun install --frozen-lockfile 2>&1 && (cd apps/fabro-web && bun run typecheck) 2>&1 && (cd apps/fabro-web && bun run test) 2>&1 && (cd lib/packages/fabro-api-client && bun run typecheck) 2>&1 && cargo dev build -- -p fabro-cli --release 2>&1", goal_gate=true, retry_target="fixup"] fixup [label="Fixup", prompt="The verify step failed. Read the build output from context and fix all format, clippy, Rust test, docs, TypeScript typecheck/test, and build failures.", max_visits=3] start -> toolchain toolchain -> preflight_compile [condition="outcome=succeeded"] toolchain -> exit preflight_compile -> preflight_lint [condition="outcome=succeeded"] preflight_compile -> exit preflight_lint -> implement [condition="outcome=succeeded"] preflight_lint -> fix_lints fix_lints -> preflight_lint implement -> simplify_opus -> simplify_gpt -> verify verify -> exit [condition="outcome=succeeded"] verify -> fixup fixup -> verify } ``` </details> ⚒️ Generated with [Fabro](https://fabro.sh) --------- Co-authored-by: Fabro <noreply@fabro.sh>	2026-05-27 18:45:59 -04:00
Bryan Helmkamp	fa565ceaae	chore(model): update provider default models (#437) ... Updates the built-in catalog so OpenAI default selection now resolves to `gpt-5.5` and Gemini default selection resolves to `gemini-3.5-flash`. The public model defaults table and catalog assertions were updated to pin the new behavior. Verified with `cargo nextest run -p fabro-model`. --- [](https://github.com/EveryInc/compound-engineering-plugin) 🤖 Generated with GPT-5 (Codex) via [Codex](https://openai.com/codex)	2026-05-27 18:45:51 -04:00
fabro-sh-0530[bot]	c767db897f	Add Automations API contract to OpenAPI spec and update generated clien… (#436) ... ## Summary Defines the public Automations REST API contract in the OpenAPI spec, updates the `RunSandbox` schema to reflect the new sandbox lifecycle model, adds `fabro-automation` as a dependency to `fabro-api` for type reuse, and removes the retired `fabro-devcontainer` crate and all references to it. ## What changed ### Automations API (`fabro-api.yaml`) Seven new paths under `/api/v1/automations` covering the full CRUD surface plus run sub-resources: ``` GET/POST /automations GET/PUT/DELETE /automations/{id} GET/POST /automations/{id}/runs ``` New schemas: `Automation`, `AutomationTarget`, `AutomationTrigger` (discriminated oneOf on `type`), `AutomationApiTrigger`, `AutomationScheduleTrigger`, `CreateAutomationRequest`, `ReplaceAutomationRequest`, `AutomationListResponse`. Key contract decisions: - `AutomationTrigger` uses an OpenAPI discriminator (`propertyName: type`); unknown discriminator values → HTTP 422, not 400. - `PUT` and `DELETE` require an `If-Match` header (428 if absent, 409 on mismatch); `GET` and `PUT` responses carry an `ETag`. - `POST /automations/{id}/runs` fires the automation's enabled API trigger; 409 if the automation is disabled or lacks one. - Run sub-resource responses reuse the existing `Run` and `PaginatedRunList` schemas. ### `RunSandbox` schema refactor The sandbox schema is restructured to express the full lifecycle rather than only the ready state: | Before | After | |---|---| | Flat object with `provider`, `image`, `snapshot`, `runtime` | Discriminated by `kind`: `planned`, `initializing`, `ready`, `failed` | | `runtime` was nullable | Moved into `RunSandboxInstance` (non-nullable); present only when `kind = ready` | | No failure detail | New `RunSandboxFailure` schema with `error`, `causes`, `duration_ms` | `SandboxDetails.sandbox` now references `RunSandboxInstance` (the ready state), which preserves the existing shape for the details endpoint while the richer `RunSandbox` type appears on run responses. ### Web UI (`run-sandbox-lifecycle.ts`) New helper module that bridges the old flat-object sandbox wire shape and the new lifecycle-keyed shape, with display metadata for each lifecycle state. Consumers (`RunSummaryPanel`, `TerminalView`, `RunSandbox` route, `run-detail` header/tabs) updated to route through these helpers so both old and new wire shapes are handled transparently. ### `fabro-devcontainer` removal The `fabro-devcontainer` crate is removed from `Cargo.lock`, `AGENTS.md`, nextest config, and all doc references. Public-facing changelog entries for devcontainer-specific features are removed or retitled. ### Plan Summary - Add Automations CRUD + run sub-resource paths and schemas to the OpenAPI spec - Restructure `RunSandbox` schema to model lifecycle states (`planned → initializing → ready | failed`) - Add `fabro-automation` dependency to `fabro-api` for domain-type reuse; add JSON parity round-trip tests - Regenerate Rust API types and TypeScript client - Remove `fabro-devcontainer` crate and all references - Add `run-sandbox-lifecycle.ts` helper module in the web UI and update all sandbox-state consumers ### Fabro Details <details> <summary>Ran 9 stages in 83m 29s for $35.47</summary> | Stage | Duration | Cost | Retries | |---|---|---|---| | start | 0s | – | 0 | | toolchain | 1s | – | 0 | | preflight_compile | 2m 22s | – | 0 | | preflight_lint | 2m 40s | – | 0 | | implement | 45m 36s | $28.67 | 0 | | simplify_opus | 7m 46s | $2.46 | 0 | | simplify_gpt | 6m 7s | $3.92 | 0 | | verify | 12m 8s | – | 0 | | fixup | 5m 52s | $0.43 | 0 | | **Total** | **83m 29s** | **$35.47** | **0** | </details> <details> <summary>Ran <code>ImplementPlan.fabro</code> (11 nodes and 14 edges)</summary> ```dot digraph ImplementPlan { graph [ goal="Implement and simplify", model_stylesheet=" * { model: claude-opus-4-7; } " ] rankdir=LR start [shape=Mdiamond, label="Start"] exit [shape=Msquare, label="Exit"] toolchain [label="Toolchain", shape=parallelogram, script="command -v cargo >/dev/null || { curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y && sudo ln -sf $HOME/.cargo/bin/* /usr/local/bin/; }; cargo --version 2>&1", max_retries=0] preflight_compile [label="Preflight Compile", shape=parallelogram, script="cargo check -q --workspace 2>&1", max_retries=0] preflight_lint [label="Preflight Lint", shape=parallelogram, script="cargo +nightly-2026-04-14 clippy -q --workspace --all-targets -- -D warnings 2>&1", max_retries=0] fix_lints [label="Fix Lints", prompt="The preflight lint step failed. Read the build output from context and fix all clippy lint warnings.", max_visits=3] implement [label="Implement", prompt="Read the plan file referenced in the goal and implement every step. Make all the code changes described in the plan. Use red/green TDD.", model="gpt-55", reasoning_effort="xhigh"] simplify_opus [label="Simplify (Opus)", prompt="@prompts/simplify.md"] simplify_gpt [label="Simplify (GPT-55)", prompt="@prompts/simplify.md", model="gpt-55"] verify [label="Verify", shape=parallelogram, script="git fetch origin main 2>&1 && git merge --no-edit --no-stat origin/main 2>&1 && cargo +nightly-2026-04-14 fmt --all 2>&1 && cargo dev docs refresh 2>&1 && cargo +nightly-2026-04-14 fmt --check --all 2>&1 && { command -v rg >/dev/null 2>&1 || { echo 'rg is required for verify'; exit 127; }; } && ! rg -n 'AuthMode::Disabled|RunAuthMethod|RunSubjectProvenance|\bActorRef\b|\bActorKind\b|AuthenticatedSubject|AuthenticatedService|AuthorizeRunScoped|AuthorizeRunBlob|AuthorizeStageArtifact|AuthorizeCommandLog|auth_method\s*==\s*\"disabled\"' lib/crates apps lib/packages docs/public/api-reference/fabro-api.yaml 2>&1 && cargo +nightly-2026-04-14 clippy --workspace --all-targets -- -D warnings 2>&1 && cargo nextest run --workspace --status-level slow --profile ci 2>&1 && cargo dev docs check 2>&1 && bun install --frozen-lockfile 2>&1 && (cd apps/fabro-web && bun run typecheck) 2>&1 && (cd apps/fabro-web && bun run test) 2>&1 && (cd lib/packages/fabro-api-client && bun run typecheck) 2>&1 && cargo dev build -- -p fabro-cli --release 2>&1", goal_gate=true, retry_target="fixup"] fixup [label="Fixup", prompt="The verify step failed. Read the build output from context and fix all format, clippy, Rust test, docs, TypeScript typecheck/test, and build failures.", max_visits=3] start -> toolchain toolchain -> preflight_compile [condition="outcome=succeeded"] toolchain -> exit preflight_compile -> preflight_lint [condition="outcome=succeeded"] preflight_compile -> exit preflight_lint -> implement [condition="outcome=succeeded"] preflight_lint -> fix_lints fix_lints -> preflight_lint implement -> simplify_opus -> simplify_gpt -> verify verify -> exit [condition="outcome=succeeded"] verify -> fixup fixup -> verify } ``` </details> ⚒️ Generated with [Fabro](https://fabro.sh) --------- Co-authored-by: Fabro <noreply@fabro.sh>	2026-05-27 14:07:01 -04:00
fabro-sh-0530[bot]	7b7a2c9044	Add fabro variable CLI namespace for server-managed variables (#434) ... ## Summary Exposes the existing variables API through a new `fabro variable` CLI namespace (`list`, `get`, `set`, `rm`), following the same patterns as `fabro secret`. Variables are intentionally readable — `list` and `get` show stored values — while `fabro secret` remains write-only. This PR also ships a significant set of accompanying changes: a refactored sandbox lifecycle model in the web UI, removal of the `fabro-devcontainer` crate, and a new `RunSandbox` OpenAPI schema that models the full planned → initializing → ready/failed lifecycle. ## What Changed ### CLI (`fabro variable`) - New `fabro variable` namespace with `list` (aliased `ls`), `get`, `set`, and `rm` subcommands, dispatched through the same `ServerTargetArgs` pattern as `fabro secret`. - `fabro-client` gains five new wrapper methods (`list_variables`, `get_variable`, `create_variable`, `update_variable`, `delete_variable`) over the generated OpenAPI client. - `set` is an upsert; `--value-stdin` accepts empty input after newline-trimming (unlike the secrets equivalent). - CLI reference docs (`docs/public/reference/cli.mdx`) regenerated; `docs/public/workflows/variables.mdx` gains a short section explaining `{{ vars.NAME }}` interpolation and the variables-vs-secrets security boundary. ### Sandbox lifecycle model (web) - New `RunSandbox` OpenAPI shape splits the old flat object into `kind` (planned/initializing/ready/failed) + `plan` + optional `instance` + optional `failure`. - `apps/fabro-web/app/lib/run-sandbox-lifecycle.ts` centralises lifecycle helpers (`sandboxLifecycleKind`, `sandboxInstance`, `sandboxRuntime`, `sandboxIsReady`, `sandboxTabVisible`, `SANDBOX_LIFECYCLE_DISPLAY`). - Run summary panel and sandbox route now show lifecycle state (Initializing / Failed with causes / Not created) before or instead of the fully-loaded `SandboxDetails`. - The sandbox details query is skipped entirely until `sandboxIsReady` returns true, preventing unnecessary 404 fetches for planned/failed sandboxes. - `runHasSandbox` in `tabs-shell.tsx` delegates to `sandboxTabVisible`, hiding the Sandbox tab for `planned` state and showing it for `initializing`/`ready`/`failed`. - Legacy flat sandbox shape (no `kind`) is handled via backwards-compatible shims in the new helpers. ### `fabro-devcontainer` removal - The `fabro-devcontainer` crate has been removed from `Cargo.lock` and all dependent crates. - References to devcontainer in internal plans, docs, changelog entries, and event schemas have been cleaned up or reworded to reflect that the feature is no longer present. ### Plan summary - **Unit 1:** `fabro-client` variable wrappers - **Unit 2:** CLI args, dispatch, and `commands/variable/mod.rs` - **Unit 3:** `list`, `get`, `set`, `rm` behavior modules - **Unit 4:** Test harness helpers and integration tests - **Unit 5:** Regenerated CLI docs + `variables.mdx` update ### Fabro Details <details> <summary>Ran 8 stages in 58m 50s for $23.81</summary> | Stage | Duration | Cost | Retries | |---|---|---|---| | start | 0s | – | 0 | | toolchain | 1s | – | 0 | | preflight_compile | 2m 9s | – | 0 | | preflight_lint | 2m 21s | – | 0 | | implement | 31m 34s | $18.44 | 0 | | simplify_opus | 8m 48s | $2.60 | 0 | | simplify_gpt | 4m 1s | $2.77 | 0 | | verify | 9m 17s | – | 0 | | **Total** | **58m 50s** | **$23.81** | **0** | </details> <details> <summary>Ran <code>ImplementPlan.fabro</code> (11 nodes and 14 edges)</summary> ```dot digraph ImplementPlan { graph [ goal="Implement and simplify", model_stylesheet=" * { model: claude-opus-4-7; } " ] rankdir=LR start [shape=Mdiamond, label="Start"] exit [shape=Msquare, label="Exit"] toolchain [label="Toolchain", shape=parallelogram, script="command -v cargo >/dev/null || { curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y && sudo ln -sf $HOME/.cargo/bin/* /usr/local/bin/; }; cargo --version 2>&1", max_retries=0] preflight_compile [label="Preflight Compile", shape=parallelogram, script="cargo check -q --workspace 2>&1", max_retries=0] preflight_lint [label="Preflight Lint", shape=parallelogram, script="cargo +nightly-2026-04-14 clippy -q --workspace --all-targets -- -D warnings 2>&1", max_retries=0] fix_lints [label="Fix Lints", prompt="The preflight lint step failed. Read the build output from context and fix all clippy lint warnings.", max_visits=3] implement [label="Implement", prompt="Read the plan file referenced in the goal and implement every step. Make all the code changes described in the plan. Use red/green TDD.", model="gpt-55", reasoning_effort="xhigh"] simplify_opus [label="Simplify (Opus)", prompt="@prompts/simplify.md"] simplify_gpt [label="Simplify (GPT-55)", prompt="@prompts/simplify.md", model="gpt-55"] verify [label="Verify", shape=parallelogram, script="git fetch origin main 2>&1 && git merge --no-edit --no-stat origin/main 2>&1 && cargo +nightly-2026-04-14 fmt --all 2>&1 && cargo dev docs refresh 2>&1 && cargo +nightly-2026-04-14 fmt --check --all 2>&1 && { command -v rg >/dev/null 2>&1 || { echo 'rg is required for verify'; exit 127; }; } && ! rg -n 'AuthMode::Disabled|RunAuthMethod|RunSubjectProvenance|\bActorRef\b|\bActorKind\b|AuthenticatedSubject|AuthenticatedService|AuthorizeRunScoped|AuthorizeRunBlob|AuthorizeStageArtifact|AuthorizeCommandLog|auth_method\s*==\s*\"disabled\"' lib/crates apps lib/packages docs/public/api-reference/fabro-api.yaml 2>&1 && cargo +nightly-2026-04-14 clippy --workspace --all-targets -- -D warnings 2>&1 && cargo nextest run --workspace --status-level slow --profile ci 2>&1 && cargo dev docs check 2>&1 && bun install --frozen-lockfile 2>&1 && (cd apps/fabro-web && bun run typecheck) 2>&1 && (cd apps/fabro-web && bun run test) 2>&1 && (cd lib/packages/fabro-api-client && bun run typecheck) 2>&1 && cargo dev build -- -p fabro-cli --release 2>&1", goal_gate=true, retry_target="fixup"] fixup [label="Fixup", prompt="The verify step failed. Read the build output from context and fix all format, clippy, Rust test, docs, TypeScript typecheck/test, and build failures.", max_visits=3] start -> toolchain toolchain -> preflight_compile [condition="outcome=succeeded"] toolchain -> exit preflight_compile -> preflight_lint [condition="outcome=succeeded"] preflight_compile -> exit preflight_lint -> implement [condition="outcome=succeeded"] preflight_lint -> fix_lints fix_lints -> preflight_lint implement -> simplify_opus -> simplify_gpt -> verify verify -> exit [condition="outcome=succeeded"] verify -> fixup fixup -> verify } ``` </details> ⚒️ Generated with [Fabro](https://fabro.sh) --------- Co-authored-by: Fabro <noreply@fabro.sh>	2026-05-27 13:57:25 -04:00
Bryan Helmkamp	e18772888e	Model run sandbox lifecycle explicitly (#431) ... ## Summary Fixes sandbox state reporting by separating a requested sandbox plan from an initialized sandbox instance. Runs now project sandbox lifecycle as `planned`, `initializing`, `ready`, or `failed`, and live sandbox operations only proceed once a real instance exists. ## Changes - Introduces `RunSandboxPlan`, `RunSandboxInstance`, and lifecycle-backed `RunSandbox` domain types, with serde validation that prevents `ready` sandboxes without an instance. - Updates store projection behavior so sandbox events transition through planned, initializing, ready, and failed states while preserving requested provider/image/snapshot separately from runtime metadata. - Tightens server sandbox handlers so details/files/services/terminal/VNC helpers require an initialized instance and return a clear 404 when the sandbox was never created. - Updates the OpenAPI contract and regenerated clients so `Run.sandbox` exposes lifecycle state while `SandboxDetails.sandbox` contains only initialized instance metadata. - Updates the web UI to render lifecycle state directly from run summaries, hide the Sandbox tab for pure planned sandboxes, and disable sandbox controls until the instance is ready. - Cleans up duplicated lifecycle display/type logic and duplicate server-side sandbox instance loading found during review. | Lifecycle state | Meaning | Live controls | | --- | --- | --- | | `planned` | Sandbox was requested but no provider instance exists | Hidden/disabled | | `initializing` | Provider setup has started | State view only | | `ready` | Runtime instance exists | Enabled | | `failed` | Provider setup failed with error details | State view only | ## Testing - `cargo check --workspace` - `cargo +nightly-2026-04-14 fmt --check --all` - `git diff --check` - `cd apps/fabro-web && bun run typecheck` - `cd apps/fabro-web && bun test app/routes/run-detail.test.ts app/routes/run-sandbox.test.tsx app/components/run-summary-panel.test.tsx` - `cargo nextest run -p fabro-types --test sandbox_model_serde` - `cargo nextest run -p fabro-store run_created_projects_planned_sandbox_lifecycle sandbox_lifecycle_events_update_projected_sandbox_state run_failed_before_sandbox_events_leaves_sandbox_planned` - `cargo nextest run -p fabro-server planned_sandbox_returns_404_from_details_endpoint planned_sandbox_rejects_live_operations failed_sandbox_rejects_live_operations local_sandbox_returns_provider_neutral_details` - `cargo nextest run -p fabro-api --test run_sandbox_round_trip` - `cargo nextest run -p fabro-api --test sandbox_details_round_trip` --- [](https://github.com/EveryInc/compound-engineering-plugin) 🤖 Generated with GPT-5 via [Codex](https://openai.com/codex)	2026-05-27 12:48:56 -04:00
Bryan Helmkamp	352b7c5de4	refactor: remove devcontainer support (#433) ... ## Summary Remove devcontainer support from the product surface and codebase: the parser crate, workflow bridge, lifecycle execution path, typed events, CLI progress rendering, generated client field, and public/internal documentation references are all gone. ## What Changed - Deleted the dedicated parser crate and removed its Cargo dependencies and lockfile entries. - Removed workflow initialization paths that resolved repository devcontainer metadata, applied Daytona snapshots from it, merged environment variables from it, or ran its lifecycle commands. - Removed the typed event variants and CLI progress handlers for the retired lifecycle events while leaving shared unknown-event handling intact. - Cleaned the generated TypeScript client and tracked docs so repository search has no remaining devcontainer references outside git history. ## Verification - `cargo +nightly-2026-04-14 fmt --all` - `cargo +nightly-2026-04-14 fmt --check --all` - `cargo build --workspace` - `cargo nextest run -p fabro-types` - `cargo nextest run -p fabro-workflow` - `cargo nextest run -p fabro-cli run_progress` - `cd lib/packages/fabro-api-client && bun run generate && bun run typecheck` - `cargo metadata --no-deps --format-version 1 | rg -i "fabro-devcontainer|devcontainer"` - `rg -n -i "devcontainer|dev container|dev-container|dev_container|fabro-devcontainer|\\.devcontainer" . --glob '!target/**' --glob '!.worktrees/**'` --- [](https://github.com/EveryInc/compound-engineering-plugin) 🤖 Generated with GPT-5 via [Codex](https://openai.com/codex)	2026-05-27 12:48:40 -04:00
Bryan Helmkamp	cf124be413	fix(types): finish image.ref → image.docker rename in env var substitution ... Commit ec1b3f2 (#429) renamed `EnvironmentImageSettings::reference` to `docker` but missed the variable-substitution call site in `substitute_environment` and its companion test, breaking the workspace build. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>	2026-05-27 12:15:14 -04:00
Bryan Helmkamp	e13de9faaf	feat(automation): persist automation refs on runs (#428) ... ## Summary Adds durable automation metadata to workflow runs so automation-triggered runs can carry their automation and trigger references through creation, stored events, projections, summaries, fork, retry, and API surfaces. This also introduces the new `fabro-automation` crate with typed automation IDs, TOML parsing/validation, revision hashing, and a file-backed automation store. The store avoids overwriting malformed existing TOML files on create and keeps read access from being blocked by mutation disk I/O. ## Changes - Add `AutomationRef` propagation through `RunSpec`, `run.created`, store projections, summaries, fork, retry, and related tests. - Add `fabro-automation` domain/store crate for automation TOML definitions, trigger validation, revisions, create/replace/delete, and load behavior. - Update OpenAPI and regenerated TypeScript client types for `RunSpec.automation` and `AutomationRef.trigger_id`. - Add API/type regression coverage for the new automation fields. - Harden automation store create semantics so skipped malformed files still reserve their path. ## Verification - `cargo nextest run -p fabro-automation` - `cargo +nightly-2026-04-14 clippy -p fabro-automation --all-targets -- -D warnings` - `cargo nextest run -p fabro-api` - `cargo nextest run -p fabro-types run_spec_round_trips_templated_settings run_created_props_round_trip_templated_settings` - `cd lib/packages/fabro-api-client && bun run typecheck` - `cargo +nightly-2026-04-14 fmt --check --all` - `git diff --check`	2026-05-27 11:52:57 -04:00
Bryan Helmkamp	ec1b3f2084	feat(sandbox): secure daytona snapshot names (#429) ... ## Summary Secures Daytona custom snapshot creation by removing user-controlled snapshot/image references and replacing them with deterministic names Fabro computes internally. Docker image selection now uses `image.docker`, while Daytona only accepts `image.dockerfile` for custom snapshots and continues to use `daytona-medium` when no Dockerfile is configured. ## Changes - Replaces public `image.ref` config/API shape with Docker-specific `image.docker` across Rust settings, OpenAPI, generated TypeScript client, docs, defaults, examples, and web samples. - Adds Daytona snapshot identity generation using HMAC-SHA256 over a canonical manifest keyed by the Daytona API key, producing `fabro-<uuid>` snapshot names without exposing Dockerfile text or key material. - Routes Daytona custom Dockerfiles, including devcontainer-generated Dockerfiles, through the same computed identity path before calling Daytona snapshot APIs. - Updates sandbox initialization events and store projections so initialized run state can show the resolved image and computed Daytona snapshot after startup. - Updates legacy config migration behavior so Docker image refs map to `image.docker`, while Daytona legacy snapshot names are not preserved. ## Breaking Changes - `image.ref` is no longer accepted in new environment config. - Docker environments should use `image.docker` for image selection. - Daytona environments reject `image.docker`; use `image.dockerfile` to request a custom computed snapshot. ## Verification - `cargo build -p fabro-api` - `cd lib/packages/fabro-api-client && bun run generate` - `cd lib/packages/fabro-api-client && bun run typecheck` - `cd apps/fabro-web && bun run typecheck` - `cargo +nightly-2026-04-14 fmt --check --all` - `cargo +nightly-2026-04-14 clippy --workspace --all-targets -- -D warnings` - `ulimit -n 4096 && cargo nextest run --no-fail-fast -p fabro-cli -p fabro-config -p fabro-sandbox -p fabro-workflow -p fabro-store -p fabro-server -p fabro-api` - `cargo insta pending-snapshots` --- [](https://github.com/EveryInc/compound-engineering-plugin) 🤖 Generated with GPT-5 via [Codex](https://openai.com/codex)	2026-05-27 11:52:35 -04:00
Bryan Helmkamp	b1bd2f522c	feat(server): add variables API (#430) ... ## Summary Adds a workflow-visible variables store and HTTP API for managing non-sensitive run variables, then wires those variables into run config interpolation before run creation, validation, and preflight. ## What Changed - Adds `/api/v1/variables` CRUD endpoints backed by a JSON variable store and generated Rust/TypeScript API types. - Supports `{{ vars.NAME }}` interpolation alongside existing `{{ env.NAME }}` handling for run-owned config fields, including environment, MCP, hook, artifact, checkpoint, SCM, and notification settings. - Reuses canonical `fabro-types` variable DTOs in `fabro-api` and adds OpenAPI name patterns so clients see the same env-style variable contract enforced by the server. - Keeps variable updates store-owned with `update_existing`, avoiding duplicated not-found/update semantics in the HTTP handler. - Shares env-style name validation between variables, interpolation parsing, and vault token names to avoid grammar drift. Variables are intentionally non-sensitive: list/get responses include values, unlike vault secrets. ## Validation - `cargo +nightly-2026-04-14 fmt --check --all` - `cargo test -p fabro-types` - `cargo test -p fabro-variable` - `cargo test -p fabro-api --test variable_round_trip` - `cargo test -p fabro-server --features test-support --test it api::variables` - `cargo +nightly-2026-04-14 clippy -p fabro-types -p fabro-variable -p fabro-vault --all-targets -- -D warnings` - `cargo +nightly-2026-04-14 clippy -p fabro-server --features test-support --all-targets -- -D warnings` --- [](https://github.com/EveryInc/compound-engineering-plugin) 🤖 Generated with GPT-5 via [Codex](https://openai.com/codex/)	2026-05-27 11:46:36 -04:00
fabro-sh-0530[bot]	5d6cd48e9e	Replace vague expect/panic messages with invariant-explaining messages (#422) ... Production code must not panic without a clear explanation of *why* the failure is impossible. This PR upgrades panic-adjacent messages across the codebase to meet that standard, and converts two genuine runtime panics into proper error handling. ## What changed **Invariant-explaining `expect` messages** — all existing `expect("short label")` calls that guarded hard-coded literals, just-inserted map entries, just-pushed Vec elements, or hard-coded regex/template strings now carry a sentence explaining *why* the None/Err path cannot be reached (e.g. `"node was just inserted by ensure_node, so get_mut cannot return None"`). No behavior changes. **`assert_eq!` → `panic!` with justification** in `strategy.rs` — the bare assert is replaced with an explicit `panic!` whose message names every existing call site that enforces the `CodexDevice ↔ OpenAI` invariant, making future regressions easier to diagnose. **Genuine runtime errors converted to `Result`** — `select_backend` / `select_backend_for_gh_command` in the upgrade command previously called `.expect()` on `http_client()`, which can fail due to TLS or environment issues. Both functions now return `Result<Backend>` and propagate the error to the CLI boundary. **Signal handler panics degraded to warnings** in `serve.rs` — `ctrl_c()` and `unix::signal()` failures no longer panic the server; instead they log a warning and park the future, allowing the server to keep running without graceful-shutdown support rather than crashing on startup. **Telemetry thread spawn failure** in `fabro-telemetry` — instead of panicking, a failure to spawn the background thread logs a debug message and silently disables telemetry, which is the correct degradation for an optional observability feature. **OS RNG `expect` messages** — three sites (`random_secret`, `random_auth_code`, `generate_dev_token`) now explain that a failure means the system RNG is broken and the security of the generated value would be compromised, justifying the panic boundary. ### Fabro Details <details> <summary>Ran 3 stages in 45m 16s for $11.65</summary> | Stage | Duration | Cost | Retries | |---|---|---|---| | start | 0s | – | 0 | | work | 34m 22s | $9.00 | 0 | | audit | 10m 35s | $2.65 | 0 | | **Total** | **45m 16s** | **$11.65** | **0** | </details> <details> <summary>Ran <code>Goal.fabro</code> (4 nodes and 5 edges)</summary> ```dot digraph Goal { graph [ goal="Complete the user-provided goal", rankdir=LR, max_node_visits=30 ] start [shape=Mdiamond, label="Start"] exit [shape=Msquare, label="Exit"] work [ label="Work", thread_id="goal", fidelity="full", max_visits=12, prompt="@prompts/continue.md" ] audit [ label="Completion Audit", thread_id="goal", fidelity="full", goal_gate=true, retry_target="work", output_schema="routing", output_retries=2, max_visits=12, prompt="@prompts/audit.md" ] start -> work -> audit audit -> exit [label="Done", condition="outcome=succeeded"] audit -> work [label="Continue", condition="outcome=failed || preferred_label=Continue"] audit -> work [label="No clear verdict"] } ``` </details> ⚒️ Generated with [Fabro](https://fabro.sh) --------- Co-authored-by: Fabro <noreply@fabro.sh> Co-authored-by: Bryan Helmkamp <bryan@brynary.com>	2026-05-27 10:38:20 -04:00
Bryan Helmkamp	5eb3eb1a23	fix(server): allow GitHub avatars in CSP img-src ... Recent CSP enforcement blocked avatars.githubusercontent.com images used by run cards in the web UI. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>	2026-05-26 22:39:52 -04:00
Bryan Helmkamp	ab68fc27d1	fix(workflow): preserve usage across session compaction (#420) ... ## Summary Fixes shared-thread workflow stages that compact their session before routing/audit bookkeeping finishes. The workflow backend now records token usage from each `Session::process_input` call as it happens, instead of slicing assistant turns out of the final session history after the session may have been compacted or replaced. ## Changes - Track per-input token usage inside `fabro-agent::Session` alongside the existing timing data. - Use the recorded per-input usage in the workflow LLM backend for initial prompts, retry-after-compaction prompts, and schema repair prompts. - Keep the invariant panic message for inconsistent session history explicit with `expect(...)`. - Add a black-box workflow integration test that drives a shared-thread audit through pre-routing compaction and asserts the audit still succeeds. ## Verification - `ulimit -n 4096 && cargo nextest run --workspace` - `cargo +nightly-2026-04-14 fmt --check --all` - `cargo +nightly-2026-04-14 clippy --workspace --all-targets -- -D warnings` - `cd apps/fabro-web && bun test --isolate` - `cd apps/fabro-web && bun run typecheck` - `cd lib/packages/fabro-api-client && bun run typecheck` - After rebasing onto current `origin/main`: `ulimit -n 4096 && cargo nextest run -p fabro-workflow --test it integration::shared_thread_compaction_before_routing_audit_succeeds` --- [](https://github.com/EveryInc/compound-engineering-plugin) 🤖 Generated with GPT-5 via [Codex](https://openai.com/codex)	2026-05-26 21:19:53 -04:00
Bryan Helmkamp	535cbda355	fix(server): enforce content security policy (#421) ... ## Summary Enforces Fabro's CSP by switching from `Content-Security-Policy-Report-Only` to `Content-Security-Policy` while preserving the SPA sources we know are required. The policy now hashes the install-mode inline bootstrap and allows `ws:`/`wss:` connections so terminal WebSockets do not regress under enforcement. The security headers integration test now asserts enforced CSP behavior, and the public security docs now describe the default headers Fabro emits. ## Verification - `cargo +nightly-2026-04-14 fmt --check --all` - `cargo test -p fabro-server csp::tests --lib` - `cargo test -p fabro-server security_headers::tests --lib` - `cargo test -p fabro-server --features test-support --test it security_headers_are_applied_to_all_responses` - Browser QA against an enforced local server: login, runs list, settings, and automation diagram rendered with no CSP console violations or page errors. - Live listener on `127.0.0.1:32276` restarted and verified to emit `content-security-policy` with no report-only header. --- [](https://github.com/EveryInc/compound-engineering-plugin) 🤖 Generated with GPT-5 via [Codex](https://openai.com/codex)	2026-05-26 21:19:36 -04:00
Bryan Helmkamp	38695d7e89	fix(server): normalize default ports in terminal origin check (#417) ... ## Summary The terminal WebSocket origin check (`origin_allowed` in `handler/sandbox.rs`) rejected browser requests when the `Host` header omitted the default port for the scheme. Result: clicking the **Terminal** tab on `/runs/<id>/sandbox` returned **403 Forbidden** and the UI showed "Terminal WebSocket connection failed." Other tabs (Services, Filesystem, VNC) worked because their WebSockets either don't traverse the server (VNC connects directly to Daytona's signed preview URL) or aren't WebSocket upgrades. ## Root cause Browsers send `Origin: https://example.com` and `Host: example.com` (no `:443`) on default HTTPS. The previous logic always constructed the origin authority *with* the default port, then string-compared against the raw `Host` header: ```rust let origin_authority = match origin_url.port_or_known_default() { Some(port) => format!("{origin_host}:{port}"), None => origin_host.to_string(), }; origin_authority.eq_ignore_ascii_case(host) ``` So `"example.com:443"` got compared against `"example.com"` and never matched. Every browser-driven WS upgrade to a default-port HTTPS deployment failed. ## Fix Parse the `Host` header through the origin's scheme into another `Url`, then compare `host_str()` and `port_or_known_default()` on both sides. This normalizes default ports symmetrically. ```rust let Ok(host_url) = url::Url::parse(&format!("{}://{host}", origin_url.scheme())) else { return false; }; origin_url.host_str() == host_url.host_str() && origin_url.port_or_known_default() == host_url.port_or_known_default() ``` Reproduced in a production deployment of the nightly image behind Caddy doing TLS termination on a public IP. Before the fix the terminal WS handshake returned 403 every time; with the fix the handshake completes and the terminal session attaches. ## Tests Added four new cases alongside the existing two: - `origin_validation_allows_default_https_port_omitted_from_host` — the bug case (browser-style `Origin: https://host` + `Host: host`). - `origin_validation_allows_default_http_port_omitted_from_host` — same for plain HTTP. - `origin_validation_allows_explicit_default_port_in_host` — `Host: example.com:443` still matches `Origin: https://example.com`. - `origin_validation_rejects_scheme_mismatch_on_default_port` — `Origin: http://example.com` + `Host: example.com:443` is still rejected (different effective ports). All six `origin_validation_*` tests pass; the full `fabro-server` suite stays green (679/679). ## Test plan - [x] `cargo nextest run -p fabro-server origin_validation` — 6 passed - [x] `cargo nextest run -p fabro-server` — 679 passed - [x] `cargo +nightly-2026-04-14 fmt --check --all` - [x] `cargo +nightly-2026-04-14 clippy -p fabro-server --all-targets -- -D warnings` - [x] Manual: terminal tab in the SPA against a TLS-terminated default-port deployment 🤖 Generated with [Claude Code](https://claude.com/claude-code)	2026-05-26 19:30:24 -04:00