From 13cde3772247230d3244d25dae2529a6c6a91cec Mon Sep 17 00:00:00 2001 From: Nick Pismenkov Date: Mon, 9 Mar 2026 16:33:49 -0700 Subject: [PATCH] fix [skip-regression-check] --- .claude/commands/pr-shepherd.md | 303 ++++++++++++++++++ .claude/rules/database.md | 63 ++++ .claude/rules/review-discipline.md | 48 +++ .claude/rules/safety-and-sandbox.md | 34 ++ .claude/rules/skills.md | 56 ++++ .claude/rules/testing.md | 25 ++ .claude/rules/tools.md | 39 +++ .github/workflows/claude-review.yml | 99 ++++++ .github/workflows/e2e.yml | 1 + .github/workflows/staging-ci.yml | 473 ++++++++++++++++++++++++++++ .github/workflows/test.yml | 37 ++- CLAUDE.md | 2 +- rust_out | Bin 0 -> 439608 bytes src/cli/mcp.rs | 5 - src/cli/tool.rs | 4 - src/db/mod.rs | 45 ++- src/llm/CLAUDE.md | 13 + 17 files changed, 1205 insertions(+), 42 deletions(-) create mode 100644 .claude/commands/pr-shepherd.md create mode 100644 .claude/rules/database.md create mode 100644 .claude/rules/review-discipline.md create mode 100644 .claude/rules/safety-and-sandbox.md create mode 100644 .claude/rules/skills.md create mode 100644 .claude/rules/testing.md create mode 100644 .claude/rules/tools.md create mode 100644 .github/workflows/claude-review.yml create mode 100644 .github/workflows/staging-ci.yml create mode 100755 rust_out diff --git a/.claude/commands/pr-shepherd.md b/.claude/commands/pr-shepherd.md new file mode 100644 index 00000000..c6dc87a1 --- /dev/null +++ b/.claude/commands/pr-shepherd.md @@ -0,0 +1,303 @@ +--- +description: Full PR lifecycle — review, fix findings, address comments, quality gate, push, CI fix loop, merge +disable-model-invocation: true +allowed-tools: Bash(gh pr view:*), Bash(gh pr diff:*), Bash(gh pr comment:*), Bash(gh pr merge:*), Bash(gh pr checks:*), Bash(gh pr edit:*), Bash(gh pr list:*), Bash(gh pr checkout:*), Bash(gh api:*), Bash(gh repo view:*), Bash(gh run view:*), Bash(gh run watch:*), Bash(git diff:*), Bash(git log:*), Bash(git fetch:*), Bash(git checkout:*), Bash(git status:*), Bash(git branch:*), Bash(git add:*), Bash(git commit:*), Bash(git push:*), Bash(git merge:*), Bash(git rebase:*), Bash(cargo fmt:*), Bash(cargo clippy:*), Bash(cargo test:*), Bash(cargo check:*), Read, Edit, Write, Grep, Glob, Agent +argument-hint: " [--fix] [--merge] [--review-only]" +--- + +# PR Shepherd + +Full PR lifecycle: review → fix → quality gate → push → CI → merge. + +Parse `$ARGUMENTS`: +- Extract PR number from bare number or `https://github.com/owner/repo/pull/123` URL. +- Flags: `--fix` (auto-fix without asking), `--merge` (merge when CI green), `--review-only` (stop after review, don't fix). +- If no PR number, detect from current branch: `gh pr list --head $(git branch --show-current) --json number --jq '.[0].number'` +- If still nothing, stop and ask the user. + +--- + +## Phase 1: Situational Awareness + +Gather everything in parallel: + +**PR metadata:** +``` +gh pr view {number} --json number,title,body,author,baseRefName,headRefName,headRefOid,state,isDraft,mergeable,mergeStateStatus,files,additions,deletions,labels,reviewRequests +``` + +**Diff:** +``` +gh pr diff {number} +gh pr diff {number} --name-only +``` + +**CI status:** +``` +gh pr checks {number} --json name,status,conclusion,detailsUrl +``` + +**Review comments (human + bot):** +``` +gh api --paginate repos/{owner}/{repo}/pulls/{number}/comments +gh api --paginate repos/{owner}/{repo}/pulls/{number}/reviews +``` + +Resolve `{owner}/{repo}`: +``` +gh repo view --json owner,name --jq '"\(.owner.login)/\(.name)"' +``` + +Save `headRefOid` — needed for posting line comments later. + +**Assess the situation and print a status card:** + +``` +PR #{number}: {title} +Author: {author} Base: {base} ← {head} +Size: +{additions} -{deletions} across {file_count} files +CI: {PASS|FAIL|PENDING|NONE} Mergeable: {yes|no|conflict} +Reviews: {N approved, N changes_requested, N comments-only, N bot-only} +Unresolved comments: {N} +Draft: {yes|no} +``` + +**Decide the mode** based on situation: +- **Has unresolved review comments** → Phase 2a (address comments first, then review remaining) +- **No reviews yet / bot-only reviews** → Phase 2b (full deep review) +- **CI failing, no review issues** → Phase 4 (jump to CI fix) +- **Everything green + approved** → Phase 6 (ready to merge) + +--- + +## Phase 2a: Address Existing Review Comments + +For each unresolved review comment or review with CHANGES_REQUESTED: + +1. **Read the referenced code** at the file and line mentioned. Never assess without reading. +2. **Classify each comment:** + - ✅ **Valid & unresolved** — needs a code fix + - ✅ **Already fixed** — a later commit addressed it + - ❌ **False positive** — explain why the code is correct + - 🔧 **Nit** — optional improvement, not blocking + +3. **Deduplicate** — bots (Copilot, Gemini) often post the same finding. Group by actual issue. + +Present a table: + +| # | Source | File:Line | Issue | Status | Planned Fix | +|---|--------|-----------|-------|--------|-------------| + +Wait for user confirmation (unless `--fix` flag set), then proceed to Phase 3. + +--- + +## Phase 2b: Deep Review (6 Lenses) + +Read EVERY changed file in full (not just diff hunks). For PRs touching >20 files, prioritize: service logic > handlers > types > tests > docs. Batch reads in parallel via Agent tool. + +### IronClaw-specific checks (always) +- No `.unwrap()` or `.expect()` in production code +- Prefer `crate::` for cross-module imports (`super::` OK in tests/intra-module) +- Error types use `thiserror` +- If persistence touched, both backends updated (postgres.rs AND libsql/) +- New tools implement `Tool` trait correctly and registered +- External tool output passes through safety layer +- Tool parameters redacted before logging/SSE +- No byte-index slicing on external strings +- Case-insensitive comparisons where needed + +### Correctness +Off-by-one, wrong operators, inverted conditions, unreachable code, type confusion, error propagation, broken invariants, TOCTOU races. + +### Edge cases & failure handling +Empty/None/zero-length input, external service failures, integer boundaries, malformed/adversarial input, partial failure handling. + +### Security (assume adversarial actors) +Auth/authz bypass, IDOR, injection (SQL/command/log/header), data leakage in logs/errors/API responses, resource exhaustion, replay/race conditions. + +### Test coverage +New public functions tested? Error paths tested? Edge cases covered? Existing tests still valid? + +### Architecture +Follows existing patterns? Unnecessary abstractions? Duplicated logic? Clean module dependencies? + +**Present findings as a table:** + +| # | Severity | Category | File:Line | Finding | Suggested Fix | +|---|----------|----------|-----------|---------|---------------| + +Severity: Critical > High > Medium > Low > Nit + +If `--review-only` flag is set, post findings as GitHub comments (see Phase 2c) and STOP. + +Otherwise, ask which findings to fix (default: all Critical + High + Medium). Then proceed to Phase 3. + +--- + +## Phase 2c: Post Review Comments on GitHub + +For each finding the user approved (or all Critical/High/Medium if `--fix`): + +**Line-specific findings** — post as PR review comments: +``` +gh api repos/{owner}/{repo}/pulls/{number}/comments \ + -f body="**{Severity}**: {finding}\n\n{explanation}\n\n**Suggested fix:** {suggestion}" \ + -f path="{file}" \ + -f commit_id="{headRefOid}" \ + -F line={line} \ + -f side="RIGHT" +``` + +**Cross-cutting/architectural findings** — post as regular PR comment: +``` +gh pr comment {number} --body "..." +``` + +--- + +## Phase 3: Fix + +Checkout the PR branch if not already on it (handles fork PRs automatically): +``` +gh pr checkout {number} +``` + +**Implement fixes** for: +1. All approved review comment fixes (from Phase 2a) +2. All approved review findings (from Phase 2b) + +Follow IronClaw conventions: +- `thiserror` for errors +- `crate::` imports +- No `.unwrap()` in production +- Both DB backends if persistence touched +- Regression test for every bug fix (enforced by commit-msg hook; bypass only with `[skip-regression-check]` if genuinely not feasible) + +After all fixes implemented, proceed to Phase 4. + +--- + +## Phase 4: Quality Gate + +Run the full IronClaw shipping checklist: + +```bash +cargo fmt +``` + +```bash +cargo clippy --all --benches --tests --examples --all-features +``` + +```bash +cargo test --lib +``` + +If persistence changes are present, also verify feature isolation: +```bash +cargo check --no-default-features --features libsql +cargo check --all-features +``` + +**If any step fails:** fix the issue and re-run. Do NOT proceed past a failing step. Loop up to 3 times per step. If still failing after 3 attempts, report the failure and stop. + +--- + +## Phase 5: Commit & Push + +Stage changed files by name (never `git add -A` — it can include unintended files): +```bash +git add path/to/changed/file1 path/to/changed/file2 +git commit -m "{message}" +``` + +Commit message format: +- For review fixes: `fix: address review findings on PR #{number}` +- For comment responses: `fix: address review comments on PR #{number}` +- For CI fixes: `fix: resolve CI failures on PR #{number}` +- Include specifics in the body (which findings/comments were addressed) + +Push: +```bash +git push origin {headRefName} +``` + +**Reply to addressed review comments on GitHub.** For each comment that was fixed, reply with the commit SHA and a brief description of what was done. For false positives, reply explaining why no change was needed. + +--- + +## Phase 6: CI Monitor & Fix Loop + +Wait briefly for CI to start, then poll (do NOT use `--watch` as it can hang indefinitely): +``` +gh pr checks {number} --json name,status,conclusion +``` + +Re-check every 30 seconds, up to 10 minutes. If still pending after 10 minutes, report status and ask the user whether to keep waiting. + +**If CI passes** → proceed to Phase 7. + +**If CI fails** (up to 3 fix attempts): + +1. Identify the failing check: + ``` + gh run view {run_id} --log-failed + ``` + If `--log-failed` shows nothing useful: + ``` + gh run view {run_id} --log | tail -100 + ``` + +2. Diagnose and fix the failure. +3. Re-run Phase 4 (quality gate). +4. Commit and push (Phase 5). +5. Go back to top of Phase 6. + +**After 3 failed CI fix attempts:** Report what's failing and why, then stop. Don't keep looping. + +--- + +## Phase 7: Merge Decision + +Print final status: +``` +PR #{number}: {title} +CI: ✅ PASS +Reviews: {summary} +Findings fixed: {N} +Comments addressed: {N} +Commits added: {N} +``` + +**Auto-merge conditions** (if `--merge` flag or user confirms): +- CI is passing +- No unresolved CHANGES_REQUESTED reviews +- PR is not draft +- PR is mergeable (no conflicts) + +If all conditions met, ask the user for merge strategy: + +"CI is green. Merge this PR? [squash/rebase/merge/no]" + +Then execute: +``` +gh pr merge {number} --{strategy} --delete-branch +``` + +If any condition NOT met, report what's blocking and let the user decide. + +--- + +## Rules + +- **Read before judging.** Never comment on code you haven't read in full. Verify line numbers. +- **Be specific.** "Line 42 returns 404 but should return 400 because X" not "this might have issues." +- **Fix the pattern, not just the instance.** When fixing a bug, grep for the same pattern across `src/`. +- **Respect the commit-msg hook.** Bug fixes need regression tests. Use `[skip-regression-check]` only if genuinely not feasible. +- **Don't over-fix.** Only change what was flagged. Don't refactor surrounding code or add improvements beyond the review scope. +- **Credit original authors.** If taking over someone else's PR, credit them in commits and comments. +- **No secrets in comments.** Never include customer data, credentials, or PII in GitHub comments. +- **Distinguish certainty.** "This IS a bug" vs "This COULD be a bug if X." Be honest. +- **Round up severity when uncertain.** Cheaper to dismiss a false alarm than miss a real bug. +- **Parallel where possible.** Use Agent tool for parallel file reads on large PRs. Batch `gh api` calls. diff --git a/.claude/rules/database.md b/.claude/rules/database.md new file mode 100644 index 00000000..07accf07 --- /dev/null +++ b/.claude/rules/database.md @@ -0,0 +1,63 @@ +--- +paths: + - "src/db/**" + - "src/history/**" + - "migrations/**" +--- +# Database Rules + +Dual-backend persistence: PostgreSQL + libSQL/Turso. **All new persistence features must support both backends.** + +See `src/db/CLAUDE.md` for full schema, dialect differences, and libSQL limitations. + +## Adding a New Operation + +1. Decide which sub-trait it belongs to (`ConversationStore`, `JobStore`, `SandboxStore`, `RoutineStore`, `ToolFailureStore`, `SettingsStore`, `WorkspaceStore`) or create a new one +2. Add the async method signature to that sub-trait in `src/db/mod.rs` +3. Implement in `src/db/postgres.rs` (delegate to `Store`/`Repository`) +4. Implement in `src/db/libsql/.rs` (use `self.connect().await?` per operation) +5. Add migration if needed: + - PostgreSQL: new `migrations/VN__description.sql` + - libSQL: add `CREATE TABLE IF NOT EXISTS` to `libsql_migrations.rs` +6. Test feature isolation: + ```bash + cargo check # postgres (default) + cargo check --no-default-features --features libsql # libsql only + cargo check --all-features # both + ``` + +## SQL Dialect Translation Checklist + +When writing SQL for both backends, translate these types: + +| PostgreSQL | libSQL | +|-----------|--------| +| `UUID` | `TEXT` | +| `TIMESTAMPTZ` | `TEXT` (ISO-8601, write with `fmt_ts()`, read with `get_ts()`) | +| `JSONB` | `TEXT` (JSON string) | +| `BOOLEAN` | `INTEGER` (0/1 -- use `get_i64(row, idx) != 0` to read) | +| `NUMERIC` | `TEXT` (preserves `rust_decimal` precision) | +| `TEXT[]` | `TEXT` (JSON-encoded array) | +| `VECTOR` | `BLOB` (flexible dimensions; vector index dropped, brute-force search fallback) | +| `jsonb_set(col, '{key}', val)` | `json_patch(col, '{"key": val}')` -- replaces top-level keys entirely, cannot do partial nested updates | +| `DEFAULT NOW()` | `DEFAULT (datetime('now'))` | +| `tsvector` + `ts_rank_cd` | FTS5 virtual table + sync triggers | + +## Schema Translation Beyond DDL + +Don't just translate `CREATE TABLE`. Also check: +- **Indexes** -- diff `CREATE INDEX` statements between backends +- **Seed data** -- check for `INSERT INTO` in migrations (e.g., `leak_detection_patterns`) +- **Triggers** -- PostgreSQL functions vs SQLite triggers (no stored procs in SQLite) + +## Transaction Safety + +Multi-step operations (INSERT+INSERT, UPDATE+DELETE, read-modify-write) MUST be wrapped in a transaction. Ask: "If this crashes between step N and N+1, is the database consistent?" If not, wrap in a transaction. Applies to both backends. + +## libSQL Connection Model + +`LibSqlBackend::connect()` creates a fresh connection per operation with `PRAGMA busy_timeout = 5000`. This is intentional -- no pool exists. Never hold connections open across `await` points. Satellite stores (`LibSqlSecretsStore`, `LibSqlWasmToolStore`) receive `Arc` via `shared_db()` and call `.connect()` themselves -- never pass a live `Connection`. + +## Fix the Pattern, Not the Instance + +When fixing a bug in one backend's SQL, always grep for the same pattern in the other. A fix to `postgres.rs` that doesn't also fix `libsql/jobs.rs` is half a fix. Same applies to satellite stores. diff --git a/.claude/rules/review-discipline.md b/.claude/rules/review-discipline.md new file mode 100644 index 00000000..74ace30a --- /dev/null +++ b/.claude/rules/review-discipline.md @@ -0,0 +1,48 @@ +--- +paths: + - "src/**/*.rs" +--- +# Review & Fix Discipline + +Hard-won lessons from code review -- follow these when fixing bugs or addressing review feedback. + +**Fix the pattern, not just the instance:** When a reviewer flags a bug (e.g., TOCTOU race in INSERT + SELECT-back), search the entire codebase for all instances of that same pattern. A fix in `SecretsStore::create()` that doesn't also fix `WasmToolStore::store()` is half a fix. + +**Propagate architectural fixes to satellite types:** If a core type changes its concurrency model (e.g., `LibSqlBackend` switches to connection-per-operation), every type that was handed a resource from the old model must also be updated. Grep for the old type across the codebase. + +**Schema translation is more than DDL:** When translating a database schema between backends (PostgreSQL to libSQL, etc.), check for: +- **Indexes** -- diff `CREATE INDEX` statements between the two schemas +- **Seed data** -- check for `INSERT INTO` in migrations (e.g., `leak_detection_patterns`) +- **Semantic differences** -- document where SQL functions behave differently (e.g., `json_patch` vs `jsonb_set`) + +**Feature flag testing:** When adding feature-gated code, test compilation with each feature in isolation: +```bash +cargo check # default features +cargo check --no-default-features --features libsql # libsql only +cargo check --all-features # all features +``` + +**Regression test with every fix:** Every bug fix must include a test that would have caught the bug. Add a `#[test]` or `#[tokio::test]` that reproduces the original failure. Exempt: changes limited to `src/channels/web/static/` or `.md` files. Use `[skip-regression-check]` in commit message or PR label if genuinely not feasible. The `commit-msg` hook and CI workflow enforce this automatically. + +**Zero clippy warnings policy:** Fix ALL clippy warnings before committing, including pre-existing ones in files you didn't change. Never leave warnings behind. + +**Transaction safety:** Multi-step database operations (INSERT+INSERT, UPDATE+DELETE, read-then-write) MUST be wrapped in a transaction. Never assume sequential calls are atomic. This applies to both postgres and libsql backends. + +**UTF-8 string safety:** Never use byte-index slicing (`&s[..n]`) on user-supplied or external strings -- it panics on multi-byte characters. Use `is_char_boundary()` or `char_indices()`. Grep for `[..` in changed files. + +**Case-insensitive comparisons:** When comparing user-supplied strings (file paths, media types, extension names), normalize to lowercase with `.to_ascii_lowercase()`. Path comparisons must be case-insensitive on macOS/Windows. + +**Decorator/wrapper trait delegation:** When adding a new method to `LlmProvider` (or any trait with decorator wrappers), update ALL wrapper types to delegate. Grep for `impl LlmProvider for` to find all implementations. Test through the full provider chain. + +**Sensitive data in logs & events:** Tool parameters and outputs MUST be redacted before logging or broadcasting via SSE/WebSocket. Use `redact_params()` before any `tracing::info!`, `JobEvent`, or SSE emission that includes tool call data. + +**Test temporary files:** Use the `tempfile` crate. Never hardcode `/tmp/...` paths. + +**Trust boundaries in multi-process architecture:** Data from worker containers is untrusted. The orchestrator MUST validate: tool domain, nesting depth (server-side tracking), and parameter sensitivity. + +**Mechanical verification before committing:** +- `cargo clippy --all --benches --tests --examples --all-features` -- zero warnings +- `grep -rnE '\.unwrap\(|\.expect\(' ` -- no panics in production +- `grep -rn 'super::' ` -- prefer `crate::` for cross-module imports (`super::` OK in tests/intra-module) +- If you fixed a pattern bug, `grep` for other instances across `src/` +- Run `scripts/pre-commit-safety.sh` to catch UTF-8, case-sensitivity, hardcoded /tmp, and logging issues diff --git a/.claude/rules/safety-and-sandbox.md b/.claude/rules/safety-and-sandbox.md new file mode 100644 index 00000000..50e1135e --- /dev/null +++ b/.claude/rules/safety-and-sandbox.md @@ -0,0 +1,34 @@ +--- +paths: + - "src/safety/**" + - "src/sandbox/**" + - "src/secrets/**" + - "src/tools/wasm/**" +--- +# Safety Layer & Sandbox Rules + +## Safety Layer + +All external tool output passes through `SafetyLayer`: +1. **Sanitizer** - Detects injection patterns, escapes dangerous content +2. **Validator** - Checks length, encoding, forbidden patterns +3. **Policy** - Rules with severity (Critical/High/Medium/Low) and actions (Block/Warn/Review/Sanitize) +4. **Leak Detector** - Scans for 15+ secret patterns at two points: tool output before LLM, and LLM responses before user + +Tool outputs are wrapped in `` XML before reaching the LLM. + +## Shell Environment Scrubbing + +The shell tool scrubs sensitive env vars before executing commands. The sanitizer detects command injection patterns (chained commands, subshells, path traversal). + +## Sandbox Policies + +| Policy | Filesystem | Network | +|--------|-----------|---------| +| ReadOnly | Read-only workspace | Allowlisted domains | +| WorkspaceWrite | Read-write workspace | Allowlisted domains | +| FullAccess | Full filesystem | Unrestricted | + +## Zero-Exposure Credential Model + +Secrets are stored encrypted on the host and injected into HTTP requests by the proxy at transit time. Container processes never see raw credential values. diff --git a/.claude/rules/skills.md b/.claude/rules/skills.md new file mode 100644 index 00000000..ded26de9 --- /dev/null +++ b/.claude/rules/skills.md @@ -0,0 +1,56 @@ +--- +paths: + - "src/skills/**" + - "skills/**" +--- +# Skills System + +SKILL.md files extend the agent's prompt with domain-specific instructions. Each skill is a YAML frontmatter block (metadata, activation criteria, required tools) followed by a markdown body injected into the LLM context. + +## Trust Model + +| Trust Level | Source | Tool Access | +|-------------|--------|-------------| +| **Trusted** | User-placed in `~/.ironclaw/skills/` or workspace `skills/` | All tools available to the agent | +| **Installed** | Downloaded from ClawHub registry (`~/.ironclaw/installed_skills/`) | Read-only tools only (no shell, file write, HTTP) | + +## SKILL.md Format + +```yaml +--- +name: my-skill +version: 0.1.0 +description: Does something useful +activation: + patterns: + - "deploy to.*production" + keywords: + - "deployment" + exclude_keywords: + - "rollback" + tags: + - "devops" + max_context_tokens: 2000 +metadata: + openclaw: + requires: + bins: [docker, kubectl] + env: [KUBECONFIG] +--- + +# Skill instructions here... +``` + +## Selection Pipeline + +1. **Gating** -- Check binary/env/config requirements; skip skills whose prerequisites are missing +2. **Scoring** -- Deterministic scoring: keywords (10/5 pts, cap 30) + patterns (20 pts, cap 40) + tags (3 pts, cap 15). `exclude_keywords` veto (score = 0 if any present) +3. **Budget** -- Select top-scoring skills within `SKILLS_MAX_TOKENS` prompt budget +4. **Attenuation** -- Minimum trust across active skills determines tool ceiling; installed skills lose dangerous tools + +## Skill Tools + +- `skill_list` -- List all discovered skills with trust level and status +- `skill_search` -- Search ClawHub registry for available skills +- `skill_install` -- Download and install a skill from ClawHub +- `skill_remove` -- Remove an installed skill diff --git a/.claude/rules/testing.md b/.claude/rules/testing.md new file mode 100644 index 00000000..3d50b3ea --- /dev/null +++ b/.claude/rules/testing.md @@ -0,0 +1,25 @@ +--- +paths: + - "src/**/*.rs" + - "tests/**" +--- +# Testing Rules + +## Test Tiers + +| Tier | Command | External deps | +|------|---------|---------------| +| Unit | `cargo test` | None | +| Integration | `cargo test --features integration` | Running PostgreSQL | +| Live | `cargo test --features integration -- --ignored` | PostgreSQL + LLM API keys | + +Run `bash scripts/check-boundaries.sh` to verify test tier gating. + +## Key Patterns + +- Unit tests in `mod tests {}` at the bottom of each file +- Async tests with `#[tokio::test]` +- No mocks, prefer real implementations or stubs +- Use `tempfile` crate for test directories, never hardcode `/tmp/` +- Regression test with every bug fix (enforced by commit-msg hook) +- Integration tests (`--test workspace_integration`) require PostgreSQL; skipped if DB is unreachable diff --git a/.claude/rules/tools.md b/.claude/rules/tools.md new file mode 100644 index 00000000..a35d9e23 --- /dev/null +++ b/.claude/rules/tools.md @@ -0,0 +1,39 @@ +--- +paths: + - "src/tools/**" + - "tools-src/**" +--- +# Tool Architecture + +**Keep tool-specific logic out of the main agent codebase.** The main agent provides generic infrastructure; tools are self-contained units that declare requirements through `.capabilities.json` sidecar files (in dev mode: `tools-src//-tool.capabilities.json`). + +Tools can be WASM (sandboxed, credential-injected, single binary) or MCP servers (ecosystem, any language, no sandbox). Both are first-class via `ironclaw tool install`. + +See `src/tools/README.md` for full architecture, adding new tools, auth JSON examples, and WASM vs MCP decision guide. + +## Tool Implementation Pattern + +```rust +#[async_trait] +impl Tool for MyTool { + fn name(&self) -> &str { "my_tool" } + fn description(&self) -> &str { "Does something useful" } + fn parameters_schema(&self) -> serde_json::Value { + serde_json::json!({ + "type": "object", + "properties": { + "param": { "type": "string", "description": "A parameter" } + }, + "required": ["param"] + }) + } + async fn execute(&self, params: serde_json::Value, ctx: &JobContext) + -> Result + { + let start = std::time::Instant::now(); + // ... do work ... + Ok(ToolOutput::text("result", start.elapsed())) + } + fn requires_sanitization(&self) -> bool { true } // External data +} +``` diff --git a/.github/workflows/claude-review.yml b/.github/workflows/claude-review.yml new file mode 100644 index 00000000..86d1bb2f --- /dev/null +++ b/.github/workflows/claude-review.yml @@ -0,0 +1,99 @@ +name: Claude Code Review + +on: + pull_request: + types: [opened, labeled] + +permissions: + contents: read + pull-requests: write + issues: write + id-token: write + +concurrency: + group: claude-review-${{ github.event.pull_request.number || github.run_id }} + cancel-in-progress: true + +jobs: + review: + name: Claude Code Review + if: contains(github.event.pull_request.labels.*.name, 'staging-promotion') + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v6 + with: + fetch-depth: 0 + + - name: Run Claude Code review + uses: anthropics/claude-code-action@v1 + with: + anthropic_api_key: ${{ secrets.ANTHROPIC_API_KEY }} + claude_args: "--max-turns 50 --model claude-haiku-4-5-20251001 --allowedTools 'Bash(gh pr comment:*),Bash(gh pr diff:*),Bash(gh pr view:*),Bash(gh pr list:*),Bash(gh issue view:*),Bash(gh issue list:*),Bash(gh search:*),Bash(git blame:*),Bash(git log:*),Bash(git diff:*)'" + prompt: | + Code review this pull request. Follow these steps precisely: + + 1. Use a Haiku agent to find relevant CLAUDE.md files: the root CLAUDE.md + and any CLAUDE.md files in directories whose files this PR modifies. + + 2. Use a Haiku agent to summarize the PR change (use `gh pr diff`). + + 3. Launch 4 parallel agents to review the change independently. Each agent should + read the PR diff with `gh pr diff` and the full source files for changed + code, then return a list of issues found: + + Agent 1 — Security & Safety + Check for: command injection, path traversal, SSRF, XSS, auth bypass, + secrets in logs, .unwrap()/.expect() in production code (not tests), + race conditions, TOCTOU, unsafe blocks, panics in async, unbounded allocations. + + Agent 2 — Architecture & Patterns + Check for: extensible design (traits/enums over nested conditionals), + clean abstractions, proper error types (thiserror), CLAUDE.md compliance, + type-driven design over stringly-typed code, DRY violations. + + Agent 3 — Bug Scan + Shallow diff-only scan for obvious bugs: logic errors, off-by-one, + missing error handling, division by zero, incorrect return values. + Ignore nitpicks and likely false positives. Do NOT read extra context + beyond the diff — focus only on the changes. + + Agent 4 — Performance & Production + Check for: blocking in async, N+1 queries, unbounded loops, missing + timeouts, resource leaks (file handles, connections), large allocations + in hot paths. + + 4. For each issue found, launch a parallel Haiku agent to: + a. Assign a severity: + - CRITICAL: security vulns, panics in prod (.unwrap/.expect), data exfiltration, race conditions + - HIGH: logic bugs, missing error handling, breaking API/schema changes + - MEDIUM: missing tests, unnecessary complexity, performance issues + - LOW: documentation gaps, naming suggestions + b. Score confidence 0-100 (give this rubric verbatim): + 0: False positive, doesn't stand up to scrutiny, or pre-existing issue. + 25: Might be real, but may be false positive. Stylistic issues not in CLAUDE.md. + 50: Real issue but nitpick or rare in practice. Not very important. + 75: Verified real issue, will be hit in practice. Directly impacts functionality + or explicitly mentioned in CLAUDE.md. + 100: Certain, confirmed, will happen frequently. Evidence directly confirms. + + 5. Post a single comment on the PR using `gh pr comment` with this format. + If no issues were found, post "No issues found." instead: + + ### Code review + + Found N issues: + + 1. [SEVERITY:CONFIDENCE] + + + + Example: [CRITICAL:92] `.unwrap()` can panic in production when config is missing + + You MUST use the full git SHA in links (not HEAD or branch name). + Provide 1 line of context before and after each linked range. + + Notes: + - Use `gh` for all GitHub interactions, not web fetch + - Do NOT check build signal or attempt to build/test the code + - Ignore pre-existing issues not introduced by this PR + - Ignore issues a linter/compiler would catch (formatting, imports, types) diff --git a/.github/workflows/e2e.yml b/.github/workflows/e2e.yml index 3dc95a2d..fea70b87 100644 --- a/.github/workflows/e2e.yml +++ b/.github/workflows/e2e.yml @@ -1,5 +1,6 @@ name: E2E Tests on: + workflow_call: schedule: - cron: "0 6 * * 1" # Weekly Monday 6 AM UTC workflow_dispatch: diff --git a/.github/workflows/staging-ci.yml b/.github/workflows/staging-ci.yml new file mode 100644 index 00000000..9e887436 --- /dev/null +++ b/.github/workflows/staging-ci.yml @@ -0,0 +1,473 @@ +name: Staging CI (Batched) + +on: + schedule: + - cron: "0 * * * *" # Every 60 minutes + workflow_dispatch: + inputs: + force: + description: "Force run even if no new commits" + type: boolean + default: false + skip_claude_gate: + description: "Skip Claude review gate (bypass blocking findings)" + type: boolean + default: false + +permissions: + contents: write + issues: write + pull-requests: write + checks: read + +concurrency: + group: staging-ci + cancel-in-progress: false # Let running suites finish + +jobs: + # ── Check for new commits ────────────────────────────────────── + check-changes: + name: Check for new commits + runs-on: ubuntu-latest + outputs: + has_changes: ${{ steps.check.outputs.has_changes }} + current_head: ${{ steps.check.outputs.current_head }} + diff_range: ${{ steps.check.outputs.diff_range }} + steps: + - uses: actions/checkout@v6 + with: + ref: staging + fetch-depth: 0 + fetch-tags: true + + - name: Check for changes since last tested + id: check + env: + FORCE_RUN: ${{ inputs.force }} + run: | + CURRENT_HEAD=$(git rev-parse HEAD) + echo "current_head=${CURRENT_HEAD}" >> "$GITHUB_OUTPUT" + + if git rev-parse staging-tested >/dev/null 2>&1; then + LAST_TESTED=$(git rev-parse staging-tested) + else + LAST_TESTED="" + fi + + DIFF_RANGE="" + if [ -n "$LAST_TESTED" ] && [ "$LAST_TESTED" = "$CURRENT_HEAD" ]; then + echo "No new commits since last tested (${CURRENT_HEAD})" + HAS_CHANGES=false + else + HAS_CHANGES=true + if [ -n "$LAST_TESTED" ]; then + COMMIT_COUNT=$(git rev-list --count "${LAST_TESTED}..HEAD") + echo "Found ${COMMIT_COUNT} new commit(s) since last tested" + DIFF_RANGE="${LAST_TESTED}..${CURRENT_HEAD}" + else + git fetch origin main + MERGE_BASE=$(git merge-base origin/main HEAD) + echo "First run -- reviewing from merge-base ${MERGE_BASE}" + DIFF_RANGE="${MERGE_BASE}..${CURRENT_HEAD}" + fi + fi + + # Force override from workflow_dispatch + if [ "$FORCE_RUN" = "true" ]; then + echo "Force run requested" + HAS_CHANGES=true + if [ -z "$DIFF_RANGE" ]; then + DIFF_RANGE="${CURRENT_HEAD}..${CURRENT_HEAD}" + fi + fi + + echo "has_changes=${HAS_CHANGES}" >> "$GITHUB_OUTPUT" + echo "diff_range=${DIFF_RANGE}" >> "$GITHUB_OUTPUT" + + # ── Run full test suite ────────────────────────────────────────── + tests: + name: Test Suite + needs: check-changes + if: needs.check-changes.outputs.has_changes == 'true' + uses: ./.github/workflows/test.yml + + # ── Run E2E browser tests ──────────────────────────────────────── + e2e: + name: E2E Browser Tests + needs: check-changes + if: needs.check-changes.outputs.has_changes == 'true' + uses: ./.github/workflows/e2e.yml + + # ── Create promotion PR (triggers claude-review.yml on the PR) ── + create-promotion-pr: + name: Create Promotion PR + needs: check-changes + if: needs.check-changes.outputs.has_changes == 'true' + runs-on: ubuntu-latest + outputs: + pr_number: ${{ steps.create-pr.outputs.pr_number }} + promotion_branch: ${{ steps.branch.outputs.branch }} + steps: + - uses: actions/checkout@v6 + with: + ref: staging + fetch-depth: 0 + + - name: Generate GitHub App token + id: app-token + if: ${{ secrets.GH_RELEASES_MANAGER_APP_ID != '' }} + uses: actions/create-github-app-token@v2 + with: + app-id: ${{ secrets.GH_RELEASES_MANAGER_APP_ID }} + private-key: ${{ secrets.GH_RELEASES_MANAGER_APP_PRIVATE_KEY }} + + - name: Set token + id: token + run: | + if [ -n "${{ steps.app-token.outputs.token }}" ]; then + echo "token=${{ steps.app-token.outputs.token }}" >> "$GITHUB_OUTPUT" + else + echo "token=${{ github.token }}" >> "$GITHUB_OUTPUT" + fi + + - name: Check if staging is ahead of main + id: ahead-check + env: + GH_TOKEN: ${{ steps.token.outputs.token }} + run: | + git fetch origin main + AHEAD=$(git rev-list --count origin/main..origin/staging) + echo "commits_ahead=${AHEAD}" >> "$GITHUB_OUTPUT" + if [ "$AHEAD" -eq 0 ]; then + echo "Staging is not ahead of main. Nothing to promote." + else + echo "Staging is ${AHEAD} commits ahead of main." + fi + + - name: Create promotion branch + id: branch + if: steps.ahead-check.outputs.commits_ahead != '0' + run: | + SHORT_SHA=$(echo "${{ needs.check-changes.outputs.current_head }}" | cut -c1-8) + BRANCH="staging-promote/${SHORT_SHA}-${{ github.run_id }}" + git checkout -b "$BRANCH" + git push origin "$BRANCH" + echo "branch=${BRANCH}" >> "$GITHUB_OUTPUT" + echo "Created promotion branch: ${BRANCH}" + + - name: Find base branch + id: find-base + if: steps.ahead-check.outputs.commits_ahead != '0' + env: + GH_TOKEN: ${{ steps.token.outputs.token }} + run: | + # Find the newest open promotion PR with a staging-promote/* head branch + LATEST=$(gh pr list --label staging-promotion --state open \ + --json headRefName,createdAt \ + --jq '[.[] | select(.headRefName | startswith("staging-promote/"))] | sort_by(.createdAt) | last | .headRefName // empty') + if [ -n "$LATEST" ]; then + echo "base=${LATEST}" >> "$GITHUB_OUTPUT" + echo "Chaining onto existing promotion branch: ${LATEST}" + else + echo "base=main" >> "$GITHUB_OUTPUT" + echo "No existing promotion PR — targeting main" + fi + + - name: Create promotion PR + id: create-pr + if: steps.ahead-check.outputs.commits_ahead != '0' + env: + GH_TOKEN: ${{ steps.token.outputs.token }} + run: | + RANGE="${{ needs.check-changes.outputs.diff_range }}" + TIMESTAMP=$(date -u +"%Y-%m-%d %H:%M UTC") + BRANCH="${{ steps.branch.outputs.branch }}" + BASE="${{ steps.find-base.outputs.base }}" + + PR_URL=$(gh pr create \ + --base "$BASE" \ + --head "$BRANCH" \ + --title "chore: promote staging to main (${TIMESTAMP})" \ + --body "## Auto-promotion from staging CI + + **Batch range:** \`${RANGE}\` + **Promotion branch:** \`${BRANCH}\` + **Base:** \`${BASE}\` + **Triggered by:** Staging CI batch at ${TIMESTAMP} + + Waiting for gates: + - Tests: pending + - E2E: pending + - Claude Code review: pending (will post comments on this PR) + + --- + *Auto-created by staging-ci workflow*" \ + --label "staging-promotion") + + PR_NUM=$(echo "$PR_URL" | grep -oE '[0-9]+$') + echo "pr_number=${PR_NUM}" >> "$GITHUB_OUTPUT" + echo "Created promotion PR #${PR_NUM}" + + # ── Gate: wait for review, process findings, merge or block ───── + gate: + name: Staging Gate + needs: [check-changes, tests, e2e, create-promotion-pr] + if: > + always() && + needs.check-changes.outputs.has_changes == 'true' && + needs.tests.result == 'success' && + needs.e2e.result == 'success' && + needs.create-promotion-pr.result == 'success' + runs-on: ubuntu-latest + timeout-minutes: 25 + outputs: + gate_passed: ${{ steps.evaluate.outputs.passed }} + steps: + - uses: actions/checkout@v6 + with: + ref: staging + fetch-depth: 1 + + - name: Generate GitHub App token + id: app-token + if: ${{ secrets.GH_RELEASES_MANAGER_APP_ID != '' }} + uses: actions/create-github-app-token@v2 + with: + app-id: ${{ secrets.GH_RELEASES_MANAGER_APP_ID }} + private-key: ${{ secrets.GH_RELEASES_MANAGER_APP_PRIVATE_KEY }} + + - name: Set token + id: token + run: | + if [ -n "${{ steps.app-token.outputs.token }}" ]; then + echo "token=${{ steps.app-token.outputs.token }}" >> "$GITHUB_OUTPUT" + else + echo "token=${{ github.token }}" >> "$GITHUB_OUTPUT" + fi + + - name: Wait for Claude review job + env: + GH_TOKEN: ${{ steps.token.outputs.token }} + PR_NUMBER: ${{ needs.create-promotion-pr.outputs.pr_number }} + REPO: ${{ github.repository }} + run: | + if [ -z "$PR_NUMBER" ]; then + echo "No PR number — skipping wait" + exit 0 + fi + + PR_SHA=$(gh pr view "$PR_NUMBER" --json headRefOid --jq '.headRefOid' || echo "") + if [ -z "$PR_SHA" ]; then + echo "::warning::Could not get PR head SHA" + exit 0 + fi + + echo "Polling for Claude Code Review job on PR #${PR_NUMBER} (SHA: ${PR_SHA})..." + TIMEOUT=1200 # 20 minutes + ELAPSED=0 + INTERVAL=30 + + while [ "$ELAPSED" -lt "$TIMEOUT" ]; do + STATUS=$(gh api "repos/${REPO}/commits/${PR_SHA}/check-runs" \ + --jq '[.check_runs[] | select(.name == "Claude Code Review") | .conclusion // .status] | first // "pending"' 2>/dev/null || echo "pending") + + if [ "$STATUS" = "success" ] || [ "$STATUS" = "failure" ] || [ "$STATUS" = "cancelled" ]; then + echo "Claude review job completed with status: ${STATUS} (${ELAPSED}s)" + exit 0 + fi + + echo "Claude review status: ${STATUS} (${ELAPSED}s elapsed)" + sleep "$INTERVAL" + ELAPSED=$((ELAPSED + INTERVAL)) + done + + echo "::warning::Claude review job not completed after ${TIMEOUT}s" + + - name: Process Claude review comments and create issues + id: process-findings + env: + GH_TOKEN: ${{ steps.token.outputs.token }} + PR_NUMBER: ${{ needs.create-promotion-pr.outputs.pr_number }} + REPO: ${{ github.repository }} + run: | + HAS_BLOCKING=false + ISSUES_CREATED=0 + + if [ -z "$PR_NUMBER" ]; then + echo "No PR — skipping finding processing" + echo "has_blocking=false" >> "$GITHUB_OUTPUT" + exit 0 + fi + + # Check for "No issues found" first (clean pass) + NO_ISSUES=$(gh api "repos/${REPO}/issues/${PR_NUMBER}/comments" \ + --jq '[.[] | select(.user.login == "claude[bot]") | select(.body | test("No issues found"))] | length' 2>/dev/null || echo "0") + if [ "$NO_ISSUES" -gt 0 ]; then + echo "Claude review found no issues — gate passes" + echo "has_blocking=false" >> "$GITHUB_OUTPUT" + exit 0 + fi + + # Get the last Claude comment that contains findings + JQ_FILTER='[.[] | select(.user.login == "claude[bot]") | select(.body | test("Found [0-9]+ issue"))] | last' + BODY=$(gh api "repos/${REPO}/issues/${PR_NUMBER}/comments" \ + --jq "${JQ_FILTER} | .body // empty" 2>/dev/null || echo "") + COMMENT_URL=$(gh api "repos/${REPO}/issues/${PR_NUMBER}/comments" \ + --jq "${JQ_FILTER} | .html_url // empty" 2>/dev/null || echo "") + + if [ -z "$BODY" ]; then + echo "::warning::No Claude review comment found for PR #${PR_NUMBER} — treating as blocking" + echo "has_blocking=true" >> "$GITHUB_OUTPUT" + exit 0 + fi + + # Parse [SEVERITY:CONFIDENCE] tags from each numbered finding + # Matrix: CRITICAL always→issue, ≥80→block. HIGH ≥50→issue. MEDIUM ≥80→issue. LOW ≥80→issue. + # Use process substitution so variables propagate to parent shell + while read -r line; do + TAG=$(echo "$line" | grep -oE '^\[(CRITICAL|HIGH|MEDIUM|LOW):[0-9]+\]') + SEVERITY=$(echo "$TAG" | sed 's/\[\(.*\):\(.*\)\]/\1/') + CONFIDENCE=$(echo "$TAG" | sed 's/\[\(.*\):\(.*\)\]/\2/') + DESC=$(echo "$line" | sed "s/\[${SEVERITY}:${CONFIDENCE}\] *//" | head -1) + + echo "Found: [${SEVERITY}:${CONFIDENCE}] ${DESC}" + + # Check if blocking (CRITICAL ≥80) + if [ "$SEVERITY" = "CRITICAL" ] && [ "$CONFIDENCE" -ge 80 ]; then + HAS_BLOCKING=true + fi + + # Determine if this should create an issue + CREATE_ISSUE=false + case "$SEVERITY" in + CRITICAL) CREATE_ISSUE=true ;; + HIGH) [ "$CONFIDENCE" -ge 50 ] && CREATE_ISSUE=true ;; + MEDIUM) [ "$CONFIDENCE" -ge 80 ] && CREATE_ISSUE=true ;; + LOW) [ "$CONFIDENCE" -ge 80 ] && CREATE_ISSUE=true ;; + esac + + if [ "$CREATE_ISSUE" = "true" ]; then + case "$SEVERITY" in + CRITICAL) LABELS="bug,risk: high,staging-ci-review" ;; + HIGH) LABELS="bug,risk: medium,staging-ci-review" ;; + MEDIUM) LABELS="risk: medium,staging-ci-review" ;; + LOW) LABELS="risk: low,staging-ci-review" ;; + esac + + TITLE=$(echo "$DESC" | cut -c1-80) + { + echo "## [${SEVERITY}:${CONFIDENCE}] Issue Found by Staging CI Review" + echo "" + echo "**Severity:** ${SEVERITY}" + echo "**Confidence:** ${CONFIDENCE}/100" + echo "**PR comment:** ${COMMENT_URL}" + echo "" + echo "### Description" + echo "$DESC" + echo "" + echo "---" + echo "*Auto-created by staging-ci Claude Code review*" + } > /tmp/issue-body.md + + if gh issue create \ + --title "[${SEVERITY}] ${TITLE}" \ + --body-file /tmp/issue-body.md \ + --label "${LABELS}"; then + ISSUES_CREATED=$((ISSUES_CREATED + 1)) + else + echo "::warning::Failed to create issue for ${SEVERITY} finding" + fi + fi + done < <(echo "$BODY" | grep -oE '\[(CRITICAL|HIGH|MEDIUM|LOW):[0-9]+\].*') + + echo "Created ${ISSUES_CREATED} issues" + echo "has_blocking=${HAS_BLOCKING}" >> "$GITHUB_OUTPUT" + + - name: Evaluate gate + id: evaluate + env: + PR_NUMBER: ${{ needs.create-promotion-pr.outputs.pr_number }} + SKIP_GATE: ${{ inputs.skip_claude_gate }} + HAS_BLOCKING: ${{ steps.process-findings.outputs.has_blocking }} + run: | + SKIP_INPUT="$SKIP_GATE" + + if [ "$HAS_BLOCKING" = "true" ]; then + echo "::warning::Claude review found blocking issues (CRITICAL ≥80 confidence)" + if [ "$SKIP_INPUT" = "true" ]; then + echo "::warning::Gate overridden by skip_claude_gate workflow input" + echo "passed=true" >> "$GITHUB_OUTPUT" + else + echo "::error::Blocking promotion due to CRITICAL findings (≥80 confidence)" + echo "::error::PR #${PR_NUMBER} left open with review comments" + echo "passed=false" >> "$GITHUB_OUTPUT" + exit 1 + fi + else + echo "No blocking findings. Gate passed." + echo "passed=true" >> "$GITHUB_OUTPUT" + fi + + - name: Merge promotion PR + id: merge + if: steps.evaluate.outputs.passed == 'true' + env: + GH_TOKEN: ${{ steps.token.outputs.token }} + PR_NUMBER: ${{ needs.create-promotion-pr.outputs.pr_number }} + run: | + if [ -n "$PR_NUMBER" ]; then + echo "Merging promotion PR #${PR_NUMBER}" + # Do NOT use --delete-branch: deleting a promotion branch closes + # any chained PRs that use it as their base (verified in ironclaw-ci-test). + # Stale promotion branches are cleaned up separately. + gh pr merge "$PR_NUMBER" --merge + echo "merged=true" >> "$GITHUB_OUTPUT" + fi + + # ── Update tested tag (always, so next batch covers only new commits) ── + update-tag: + name: Update staging-tested tag + needs: [check-changes, tests, e2e, create-promotion-pr, gate] + if: > + always() && + needs.check-changes.outputs.has_changes == 'true' && + needs.tests.result == 'success' && + needs.e2e.result == 'success' && + needs.create-promotion-pr.result == 'success' + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v6 + with: + ref: staging + fetch-depth: 1 + + - name: Update staging-tested tag + run: | + git tag -f staging-tested "${{ needs.check-changes.outputs.current_head }}" + git push origin staging-tested --force + echo "Updated staging-tested tag to ${{ needs.check-changes.outputs.current_head }}" + + # ── Report ─────────────────────────────────────────────────────── + report: + name: Staging CI Summary + needs: [check-changes, tests, e2e, create-promotion-pr, gate, update-tag] + if: always() && needs.check-changes.outputs.has_changes == 'true' + runs-on: ubuntu-latest + steps: + - name: Summary + run: | + echo "## Staging CI Batch Results" >> "$GITHUB_STEP_SUMMARY" + echo "" >> "$GITHUB_STEP_SUMMARY" + echo "| Check | Result |" >> "$GITHUB_STEP_SUMMARY" + echo "|-------|--------|" >> "$GITHUB_STEP_SUMMARY" + echo "| Tests | ${{ needs.tests.result }} |" >> "$GITHUB_STEP_SUMMARY" + echo "| E2E | ${{ needs.e2e.result }} |" >> "$GITHUB_STEP_SUMMARY" + echo "| Promotion PR | ${{ needs.create-promotion-pr.result }} |" >> "$GITHUB_STEP_SUMMARY" + echo "| Gate | ${{ needs.gate.result }} |" >> "$GITHUB_STEP_SUMMARY" + echo "| Tag Updated | ${{ needs.update-tag.result }} |" >> "$GITHUB_STEP_SUMMARY" + echo "" >> "$GITHUB_STEP_SUMMARY" + echo "Range: ${{ needs.check-changes.outputs.diff_range }}" >> "$GITHUB_STEP_SUMMARY" + PR_NUM="${{ needs.create-promotion-pr.outputs.pr_number }}" + if [ -n "$PR_NUM" ]; then + echo "Promotion PR: #${PR_NUM}" >> "$GITHUB_STEP_SUMMARY" + fi diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml index 8f0fd2bb..efa28648 100644 --- a/.github/workflows/test.yml +++ b/.github/workflows/test.yml @@ -1,5 +1,6 @@ name: Run Tests on: + workflow_call: pull_request: push: branches: @@ -38,6 +39,9 @@ jobs: telegram-tests: name: Telegram Channel Tests + if: > + github.event_name == 'push' || + (github.event_name == 'pull_request' && github.base_ref != 'staging') runs-on: ubuntu-latest steps: - name: Checkout repository @@ -50,6 +54,9 @@ jobs: windows-build: name: Windows Build (${{ matrix.name }}) + if: > + github.event_name == 'push' || + (github.event_name == 'pull_request' && github.base_ref != 'staging') runs-on: windows-latest strategy: fail-fast: false @@ -74,6 +81,9 @@ jobs: wasm-wit-compat: name: WASM WIT Compatibility + if: > + github.event_name == 'push' || + (github.event_name == 'pull_request' && github.base_ref != 'staging') runs-on: ubuntu-latest steps: - name: Checkout repository @@ -94,6 +104,9 @@ jobs: docker-build: name: Docker Build + if: > + github.event_name == 'push' || + (github.event_name == 'pull_request' && github.base_ref != 'staging') runs-on: ubuntu-latest steps: - name: Checkout repository @@ -123,12 +136,22 @@ jobs: needs: [tests, telegram-tests, wasm-wit-compat, docker-build, windows-build, version-check] steps: - run: | - if [[ "${{ needs.tests.result }}" != "success" || "${{ needs.telegram-tests.result }}" != "success" || "${{ needs.wasm-wit-compat.result }}" != "success" || "${{ needs.docker-build.result }}" != "success" || "${{ needs.windows-build.result }}" != "success" ]]; then - echo "One or more jobs failed" - exit 1 - fi - # version-check only runs on PRs, so skip/success are both acceptable - if [[ "${{ needs.version-check.result }}" == "failure" ]]; then - echo "Version bump check failed" + # Unit tests must always pass + if [[ "${{ needs.tests.result }}" != "success" ]]; then + echo "Unit tests failed" exit 1 fi + # Gated jobs: must pass on promotion PRs / push, skipped on developer PRs + for job in telegram-tests wasm-wit-compat docker-build windows-build version-check; do + case "$job" in + telegram-tests) result="${{ needs.telegram-tests.result }}" ;; + wasm-wit-compat) result="${{ needs.wasm-wit-compat.result }}" ;; + docker-build) result="${{ needs.docker-build.result }}" ;; + windows-build) result="${{ needs.windows-build.result }}" ;; + version-check) result="${{ needs.version-check.result }}" ;; + esac + if [[ "$result" == "failure" || "$result" == "cancelled" ]]; then + echo "$job failed" + exit 1 + fi + done diff --git a/CLAUDE.md b/CLAUDE.md index a77575ea..411af57a 100644 --- a/CLAUDE.md +++ b/CLAUDE.md @@ -647,7 +647,7 @@ Key test patterns: ## Current Limitations / TODOs -1. **libSQL CLI connection crash** - `ironclaw tool setup` and `ironclaw secret set` crash with "invalid connection string" error on libSQL deployments. Blocks all interactive setup flows. Workaround: manually encrypt secrets via Python. See `src/db/mod.rs` `create_secrets_store()` doc comment. Related: #655 (libSQL backend gaps). +1. ~~**libSQL CLI connection crash**~~ - **Fixed in commit d8dcc34.** Root cause was inline compile-time `#[cfg]` blocks in CLI subcommands always choosing postgres when both features were compiled. The fix moved backend dispatch to `db::create_secrets_store()` with explicit pattern matching. Defensively improved `connect_from_config()` and `create_secrets_store()` to use explicit `Postgres =>` patterns instead of wildcards, catching misconfiguration in postgres-only builds more clearly. 2. **Domain-specific tools** - `marketplace.rs`, `restaurant.rs`, `taskrabbit.rs`, `ecommerce.rs` return placeholder responses; need real API integrations 3. **Integration tests** - Need testcontainers setup for PostgreSQL 4. **MCP stdio transport** - Only HTTP transport implemented diff --git a/rust_out b/rust_out new file mode 100755 index 0000000000000000000000000000000000000000..2e504bca69c51d859385c4a4f2012a52d284f34d GIT binary patch literal 439608 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 literal 0 HcmV?d00001 diff --git a/src/cli/mcp.rs b/src/cli/mcp.rs index 7e32b470..bc89e617 100644 --- a/src/cli/mcp.rs +++ b/src/cli/mcp.rs @@ -626,12 +626,7 @@ async fn save_servers( } } -/// Initialize and return the secrets store. /// Get the secrets store for MCP authentication operations. -/// -/// **Known Issue:** This function crashes with "invalid connection string" on libSQL deployments -/// when called from `mcp auth` subcommands. See `src/db/mod.rs` `create_secrets_store()` -/// documentation for details and workaround. async fn get_secrets_store() -> anyhow::Result> { let config = Config::from_env().await?; diff --git a/src/cli/tool.rs b/src/cli/tool.rs index 19f8f4d3..752f4263 100644 --- a/src/cli/tool.rs +++ b/src/cli/tool.rs @@ -551,10 +551,6 @@ fn validate_tool_name(name: &str) -> anyhow::Result<()> { } /// Initialize the secrets store from environment config. -/// -/// **Known Issue:** This function crashes with "invalid connection string" on libSQL deployments -/// when called from `tool setup` or `secret set` subcommands. See `src/db/mod.rs` `create_secrets_store()` -/// documentation for details and workaround. async fn init_secrets_store() -> anyhow::Result> { let config = Config::from_env().await?; let master_key = config.secrets.master_key().ok_or_else(|| { diff --git a/src/db/mod.rs b/src/db/mod.rs index 08475d1b..0462361a 100644 --- a/src/db/mod.rs +++ b/src/db/mod.rs @@ -77,7 +77,7 @@ pub async fn connect_from_config( Ok(Arc::new(backend)) } #[cfg(feature = "postgres")] - _ => { + crate::config::DatabaseBackend::Postgres => { let pg = postgres::PgBackend::new(config) .await .map_err(|e| DatabaseError::Pool(e.to_string()))?; @@ -85,9 +85,16 @@ pub async fn connect_from_config( Ok(Arc::new(pg)) } #[cfg(not(feature = "postgres"))] - _ => Err(DatabaseError::Pool( - "No database backend available. Enable 'postgres' or 'libsql' feature.".to_string(), + crate::config::DatabaseBackend::Postgres => Err(DatabaseError::Pool( + "No postgres backend available. Rebuild with --features postgres.".to_string(), )), + // Catches LibSql in postgres-only builds (libsql arm compiled out) + #[allow(unreachable_patterns)] + _ => Err(DatabaseError::Pool(format!( + "Database backend {:?} not available in this build. \ + Set DATABASE_BACKEND to a compiled-in backend, or rebuild with the matching feature flag.", + config.backend + ))), } } @@ -96,24 +103,6 @@ pub async fn connect_from_config( /// This is the shared factory for CLI commands and other call sites that need /// a `SecretsStore` without going through the full `AppBuilder`. Mirrors the /// pattern of [`connect_from_config`] but returns a secrets-specific store. -/// -/// ## Known Issue: libSQL CLI Connection Crash -/// -/// Running `ironclaw tool setup` or `ironclaw secret set` crashes with an -/// "invalid connection string" error when DATABASE_BACKEND=libsql. This blocks -/// all interactive setup flows on libSQL deployments (the default for hosted agents). -/// -/// **Workaround:** Manually read the master key from `/proc/PID/environ`, encrypt -/// secrets with AES-256-GCM via Python ctypes, and write directly to the secrets table. -/// -/// **Related Issue:** #655 (libSQL backend gaps) -/// -/// **Root Cause:** Unclear; the local libSQL database opens fine for the main process, -/// but CLI subcommands fail when calling `LibSqlBackend::new_local(path)`. Likely -/// relates to path resolution, file permissions, or WAL mode conflicts in concurrent -/// connection scenarios. -/// -/// **TODO:** Debug why libSQL connection fails in CLI context while working in main.rs. pub async fn create_secrets_store( config: &crate::config::DatabaseConfig, crypto: Arc, @@ -148,7 +137,7 @@ pub async fn create_secrets_store( ))) } #[cfg(feature = "postgres")] - _ => { + crate::config::DatabaseBackend::Postgres => { let pg = postgres::PgBackend::new(config) .await .map_err(|e| DatabaseError::Pool(e.to_string()))?; @@ -160,10 +149,16 @@ pub async fn create_secrets_store( ))) } #[cfg(not(feature = "postgres"))] - _ => Err(DatabaseError::Pool( - "No database backend available for secrets. Enable 'postgres' or 'libsql' feature." - .to_string(), + crate::config::DatabaseBackend::Postgres => Err(DatabaseError::Pool( + "No postgres backend available. Rebuild with --features postgres.".to_string(), )), + // Catches LibSql in postgres-only builds (libsql arm compiled out) + #[allow(unreachable_patterns)] + _ => Err(DatabaseError::Pool(format!( + "Database backend {:?} not available in this build. \ + Set DATABASE_BACKEND to a compiled-in backend, or rebuild with the matching feature flag.", + config.backend + ))), } } diff --git a/src/llm/CLAUDE.md b/src/llm/CLAUDE.md index a1eb72be..d1b9eea2 100644 --- a/src/llm/CLAUDE.md +++ b/src/llm/CLAUDE.md @@ -19,6 +19,7 @@ Multi-provider LLM integration with circuit breaker, retry, failover, and respon | `rig_adapter.rs` | Adapter bridging rig-core `CompletionModel` → `LlmProvider`; used by OpenAI, Anthropic, Ollama, Tinfoil | | `smart_routing.rs` | `SmartRoutingProvider` — 13-dimension complexity scorer routes cheap vs primary model | | `recording.rs` | `RecordingLlm` — trace capture for E2E replay testing (`IRONCLAW_RECORD_TRACE`) | +| `bedrock.rs` | AWS Bedrock provider via native Converse API (feature-gated: `--features bedrock`) | ## Provider Selection @@ -32,6 +33,18 @@ Set via `LLM_BACKEND` env var: | `ollama` | Ollama local | `OLLAMA_BASE_URL` | | `openai_compatible` | Any OpenAI-compatible endpoint | `LLM_BASE_URL`, `LLM_API_KEY`, `LLM_MODEL` | | `tinfoil` | Tinfoil TEE inference | `TINFOIL_API_KEY`, `TINFOIL_MODEL` | +| `bedrock` | AWS Bedrock (requires `--features bedrock`) | `BEDROCK_REGION`, `BEDROCK_MODEL`, `AWS_PROFILE` | + +## AWS Bedrock Provider + +Uses the native Converse API via `aws-sdk-bedrockruntime` (`bedrock.rs`). Requires `--features bedrock` at build time — not in default features due to heavy AWS SDK dependencies. + +**Auth:** Standard AWS credential chain — IAM credentials (`AWS_ACCESS_KEY_ID`/`AWS_SECRET_ACCESS_KEY`), SSO profiles (`AWS_PROFILE`), or instance roles. The SDK resolves auth automatically from the environment. + +**Config:** +- `BEDROCK_REGION` — AWS region (default: `us-east-1`) +- `BEDROCK_MODEL` — Required model ID (e.g., `anthropic.claude-opus-4-6-v1`) +- `BEDROCK_CROSS_REGION` — Optional cross-region inference prefix (`us`, `eu`, `apac`, `global`) ## NEAR AI Provider Gotchas