Compare commits

...
12 Commits
Author SHA1 Message Date
sam 56044476fc chore(release): v1.59.0
Quality / check (push) Successful in 3m53s
deploy / gate (push) Successful in 4m21s
deploy / archied-image (push) Successful in 2m45s
deploy / agent-image (push) Successful in 3m15s
deploy / dist-zip (push) Successful in 2m35s
2026-11-03 06:15:09 +11:00
sam 796bfd0045 docs(changelog): forge extensions gain CreateIssue
Quality / check (push) Successful in 7m12s
deploy / gate (push) Successful in 5m16s
deploy / archied-image (push) Successful in 3m2s
deploy / agent-image (push) Successful in 11s
deploy / dist-zip (push) Skipped
2026-11-03 02:43:25 +11:00
sam abcb72a76a feat(curator): dry-run self-intake pass with run inspection tools (#1770)
Curators could only reach the workflow/integration tools; there was no way
to survey task runs. Adds run_list/run_events to the shared registry
(guarded as read on task kind), attaches the instance's acting principal
to curator model calls so guarded tools authorize, and records a pass's
final text as a pass.summary action so the report is inspectable. Ships a
dry-run self-intake definition in dev.toml/config.example.toml declaring
only those two tools, so it cannot file issues yet.
2026-11-03 02:35:06 +11:00
sam 443a7a501b refactor(storecontract): split the store contract into topical files (#1781)
Pure move: one 624-line storecontract.go becomes storecontract.go
(package doc + composed TaskStore), task.go, capture.go, binding.go,
mapping.go, source.go, status.go, resource.go, credentials.go and
errors.go. The package remains the single seam; no declaration changed
(verified line-identical against HEAD). task check green.
2026-11-03 02:27:57 +11:00
sam 88e86776e8 feat(forge): add CreateIssue to the forge contract (#1770)
Quality / check (push) Successful in 4m10s
deploy / gate (push) Successful in 4m43s
deploy / archied-image (push) Successful in 2m54s
deploy / agent-image (push) Successful in 11s
deploy / dist-zip (push) Skipped
Issue-level writes could comment and close but not open an issue, so no
curator or workflow stage can file its own work yet. Adds the rpc to
proto/forge/v1, regenerates the contracts, and threads it through the
domain interface, forgerpc client/server (comment permission, like
CloseIssue), forgeext, and the archipelago SDK + gitea/github plugins.
2026-11-03 02:04:56 +11:00
sam e10bb161fe docs(prds): mark the self-development ADR as decided, not built (#1769) 2026-11-03 01:52:06 +11:00
sam 3b525b7482 docs(prds): mark the self-development ADR as record, not mechanism (#1769) 2026-11-03 01:50:54 +11:00
sam c2cc10ebfa docs(prds): record the self-development loop decision (#1769) 2026-11-03 01:36:31 +11:00
sam 2f8076d7f8 fix(access): forbid clause scopes the canary grant against its developer role (#1727)
Quality / check (push) Successful in 3m37s
deploy / gate (push) Successful in 4m45s
deploy / archied-image (push) Successful in 2m53s
deploy / agent-image (push) Successful in 10s
deploy / dist-zip (push) Skipped
Service accounts created through the identities API are assigned the
developer role in the request's org, whose shipped policy permits read and
write across the org -- the permit alone did not scope the canary. Install a
matching org-canary-grant-forbid policy (access.CanaryGrantForbidPolicy) that
negates exactly the permit's surface for the canary identity; a forbid wins
within the level, so the role can no longer widen access. Engine tests pin
the surface with the principal carrying the developer role, and the
rehearsal now proves it live: the scoped token gets 403 on /api/access/policies
and 200 on /api/chat/update, and the full canary loop runs on it.

task check passes; task canary:rehearse green (REHEARSE_EXIT=0).
2026-11-02 06:23:38 +11:00
sam c180a2debb feat(access): scoped canary grant replaces instance-admin CANARY_TOKEN (#1727)
Quality / check (push) Successful in 3m49s
deploy / gate (push) Successful in 4m48s
deploy / archied-image (push) Successful in 2m55s
deploy / agent-image (push) Successful in 11s
deploy / dist-zip (push) Skipped
The canary now authenticates as a dedicated service-account identity in the
system org whose only grant is access.CalaryGrantPolicy: read the signal
endpoints (chat update, alerts, logs, tasks), read and write the
update-settings resource, and trigger an update install. CANARY_TOKEN no
longer carries instance admin; DEPLOY_TOKEN stays CI-only.

- authorize: POST /api/chat/update/install and /defer map to
  update on Object::"update" (dashboard) instead of run on any workflow,
  so the grant can cover installs without granting workflow runs
- accounts: active service-account identities may authenticate with bearer
  tokens (CanAct), not just users
- new POST /api/identities/{id}/tokens (behind manage_identities) mints a
  token for a named non-user identity; new AccountService RPC
  BindIdentityPersonalToken backs it remotely, refusing user-kind targets,
  with the caller recorded as audit actor
- engine tests pin the grant's exact allow/deny surface

RELEASING.md documents the one-time setup. task check passes on this tree.
2026-11-02 06:03:41 +11:00
sam 5356745968 fix(releaseupdate): address review findings on the #1725 canary change
Quality / check (push) Successful in 3m39s
deploy / gate (push) Successful in 4m28s
deploy / archied-image (push) Successful in 3m11s
deploy / agent-image (push) Successful in 11s
deploy / dist-zip (push) Skipped
- one shared UpdateStateDir() resolver for daemon and dashboard, instead of
  two copies that could drift
- the recovery path for a committed/rolled-back journal writes
  installed.json too, so a crash after the outcome phase cannot lose the
  install record
- JudgeCanaryNow is the explicit signals-only entry point for promoting
  without the window, replacing the zero-install-time sentinel
- canary version comparisons use IssuedAt, matching Promote's replay rule,
  so semver/issued-at divergence cannot wedge check red; queuedBehind
  reuses the judgeable predicate instead of a looser check
- promote prints the channel/pin; promote.yml cancels superseded runs
- canary card: no duplicated elapsed rendering, channel row waits for the
  settings resource instead of showing a default, agent fallback '?'
- rehearsal script bounds its docker build/push/run calls

task check passes on this tree.
2026-11-02 02:45:26 +11:00
sam 5b5059615b feat(releaseupdate): judge the installed release, window from install (#1725)
Quality / check (push) Successful in 4m2s
deploy / gate (push) Successful in 4m31s
deploy / archied-image (push) Successful in 3m14s
deploy / agent-image (push) Successful in 11s
deploy / dist-zip (push) Skipped
The canary window now counts from when a release is installed on the host
(installed.json / installed_at in the update snapshot), not from the
statement's issued_at, and 'release canary check' judges the release the
canary actually runs via its exact-pin tag instead of the moving next tag.
A newer release on next queues behind the one being judged instead of
restarting the clock, so stable moves once per release.

New subcommands: canary status (read-only state, signals, verdict), canary
promote (promote now when hard checks pass), canary unpin (back to next),
and start -force. A held/pinned canary is verified installable every check
and a stranded pin fails the run red instead of looking green. Rollback
pre-flight checks stable's zip and agent image digests before pinning.
Relative signals are judged whenever both windows carry minimum data, so a
breach rolls back mid-window; promote still needs the full window unless
the operator promotes early (new promote.yml workflow_dispatch). The window
is configurable via -window / CANARY_WINDOW.

Also: dashboard canary status card (ui), and task canary:rehearse, a local
end-to-end rehearsal of publish -> canary start -> status -> check ->
promote against a throwaway registry and host.

task check passes; rehearsal run green (REHEARSE_EXIT=0).
2026-11-02 01:15:29 +11:00
64 changed files with 4155 additions and 1288 deletions

No files matched your search

+12 -4
View File
@@ -1,7 +1,9 @@
# Every 15 minutes, checks how the newest release on the `next` channel is
# running on the canary host. If a hard check fails, the canary goes back to
# the stable release straight away. If the release stays healthy for 24 hours,
# it's promoted to stable. A rollback fails the run, so it shows up red.
# Every 15 minutes, checks how the release installed on the canary host is
# running, judged over the window counted from its install (-window, default
# 24h; CANARY_WINDOW overrides it). If a hard check fails, the canary goes
# back to the stable release straight away. If the release stays healthy for
# the window, it's promoted to stable. A rollback fails the run, so it shows
# up red.
name: canary
on:
@@ -48,6 +50,12 @@ jobs:
- name: Judge the canary
env:
ARCHIE_CANARY_TOKEN: ${{ secrets.CANARY_TOKEN }}
CANARY_WINDOW: ${{ vars.CANARY_WINDOW }}
run: |
window_args=()
if [ -n "$CANARY_WINDOW" ]; then
window_args=(-window "$CANARY_WINDOW")
fi
"$RUNNER_TEMP/archied" release canary check -dashboard "${{ vars.CANARY_URL }}" \
"${window_args[@]}" \
-latest git.catlow.cloud/sam/archied,git.catlow.cloud/sam/archie-agent
+6 -2
View File
@@ -418,8 +418,12 @@ jobs:
"$api/repos/$repo/releases" >/dev/null
echo "published release notes for $tag"
# The canary host follows the `next` channel. canary.yml then decides
# whether this release is promoted to stable or the canary is rolled back.
# The canary host follows the `next` channel. canary.yml then judges the
# release installed on the canary and decides whether it is promoted to
# stable or the canary is rolled back. The start is queue-safe: a release
# published while the canary still judges a newer one is queued behind
# it and picked up by the next check, so the running window isn't
# restarted under a different release.
- name: Install the release on the canary
if: vars.CANARY_URL != ''
env:
+55
View File
@@ -0,0 +1,55 @@
# Promotes the release the canary is running right now, without waiting out
# the judging window: the canary's signals must show no hard failure and no
# relative breach, otherwise the run refuses and fails. Dispatch it with the
# version the canary runs (`archied release canary status` shows it).
name: promote
on:
workflow_dispatch:
inputs:
version:
description: "release the canary is expected to run; must match what it runs"
required: true
type: string
concurrency:
group: promote
cancel-in-progress: true
permissions:
contents: read
packages: write
jobs:
promote:
if: vars.CANARY_URL != ''
runs-on: self-hosted
steps:
- name: Checkout
uses: actions/checkout@v4
with:
ref: main
- name: Set up Go
uses: actions/setup-go@v5
with:
go-version-file: go.mod
# The self-hosted runner keeps the Go caches on disk between jobs, and
# archiving them for the Actions cache takes minutes.
cache: false
- name: Build archied
# The promote never serves the dashboard, so the build leaves it out.
run: go build -tags no_ui -o "$RUNNER_TEMP/archied" ./cmd/archied
# Promotion retags stable and the images' latest in the registry.
- name: Log in to the Gitea registry
run: echo "${{ secrets.DEPLOY_TOKEN }}" | docker login git.catlow.cloud -u "${{ github.actor }}" --password-stdin
- name: Promote the canary's release
env:
ARCHIE_CANARY_TOKEN: ${{ secrets.CANARY_TOKEN }}
run: |
"$RUNNER_TEMP/archied" release canary promote -dashboard "${{ vars.CANARY_URL }}" \
-version "${{ inputs.version }}" \
-latest git.catlow.cloud/sam/archied,git.catlow.cloud/sam/archie-agent
+6
View File
@@ -5,6 +5,12 @@ release's per-component sections are labelled beneath its heading.
## [Unreleased]
## [1.59.0] - 2026-11-02
### archied
- Forge extensions can open issues: the forge surface gains `CreateIssue` alongside list, comment and close, and the bundled Gitea and GitHub extensions implement it.
## [1.58.1] - 2026-11-01
### archied
+122 -20
View File
@@ -78,27 +78,64 @@ release rather than committing the fix on top of a tagged one.
The canary is the production host, following `next`. Every quarter hour
`canary.yml` runs `archied release canary check`, which reads the canary
through its dashboard API and judges the release on `next`:
through its dashboard API and judges **the release the canary actually runs**,
not the moving `next` tag:
| Signal | Source | Fails when |
| --- | --- | --- |
| Install outcome | `GET /api/chat/update` | the canary doesn't run the release (the watchdog rolled it back) |
| Install outcome | `GET /api/chat/update` | the canary doesn't run the judged release (the watchdog rolled it back) |
| Readiness | `GET /health/detailed` | the rollup isn't `ok` |
| Alerts | `GET /api/alerts` | an open `action` alert was first raised after the release was issued |
| Error log | `GET /api/logs?level=error` | error lines per day exceed `2 × baseline + 10` |
| Alerts | `GET /api/alerts` | an open `action` alert was first raised after the release was installed |
| Error log | `GET /api/logs?level=error` | error lines per window exceed `2 × baseline + 10` |
| Task outcomes | `GET /api/tasks` | the share of finished tasks that parked or died rose more than 10 points |
- **Control.** The canary's own 24 hours before the release was issued. With
- **Control.** The canary's own window before the release was installed. With
one production host there's no simultaneous control.
- **Window.** 24 hours from issue, one cycle of schedules and traffic. The
first 30 minutes are for the install and restart.
- **Window.** 24 hours counted from the **install** on the canary, not from
the release's issue time: the host records it in `installed.json`
(`committed_at`) and reports it as `installed_at` in `GET /api/chat/update`.
One cycle of schedules and traffic. The first 30 minutes are for the install
and restart. `canary.yml` passes `-window` when the `CANARY_WINDOW` Actions
variable is set; the flag defaults to 24h. A host that doesn't report an
install time degrades to the release statement's issue time.
- **Hard signals** (install, readiness, alerts) roll back at any check after
that. **Relative signals** (errors, tasks) are judged at the end of the
window.
that. **Relative signals** (errors, tasks) are judged against the baseline
whenever both windows carry enough data, so a breach rolls the release back
even mid-window; a full window with no failure promotes it.
- **Too little data skips a signal** rather than failing it: fewer than 5
finished tasks in the window, or an error log that reaches back less than an
hour into the baseline. A log read that stops short of a window is scaled to
a full day from what it covers.
a full window from what it covers.
### Queueing
`deploy.yml` installs each new release on the canary with
`archied release canary start -version V`, which first points the canary back
at `next` (clearing any rollback pin) and then installs `V` — unless the
canary is already judging a release newer than stable that isn't `V`, in which
case `V` is **queued** behind it and the canary keeps running what it judges.
`-force` installs regardless. A `check` that promotes (or finds nothing to
judge) installs the newer `next` in the same run, so a queue drains one
release per promotion.
### Subcommands
```
archied release canary status read-only: channel/pin, installed release and
installed_at, stable/next, window progress, and
the verdict the current signals would give
archied release canary start point the canary at next and install -version,
queued behind a release being judged (-force to
override)
archied release canary check judge the installed release over -window
(default 24h): promote, pick up a newer next,
or roll back; a held canary is reported, and a
held pin that is no longer installable fails
the run red
archied release canary promote promote the installed release now if its
signals pass; refuses with exit 1 otherwise
archied release canary unpin return the canary to next from any pin
```
### Promote
@@ -106,32 +143,97 @@ A release that passes the window is promoted: `stable` is retagged to the
`v<version>` manifest. The signature covers the statement, not the tag, so the
retag needs no signing key. The `archied` and `archie-agent` images' `:latest`
move to their `:v<version>` first, and the agent image must be the digest the
statement pins. Promotion refuses a prerelease and a release issued
before the one `stable` names, the same replay rule hosts enforce. The decision
and its reasons are in the `canary` run log.
statement pins. Promotion refuses a prerelease and a release issued before the
one `stable` names, the same replay rule hosts enforce. The decision and its
reasons are in the `canary` run log.
Early promotion is a dispatch away: the **promote** workflow
(`.github/workflows/promote.yml`) takes a `version` input and runs
`archied release canary promote -version V` on the canary. It judges the
release the canary runs — the window doesn't matter for the decision — and
refuses (red run) on any hard failure or relative breach with enough data.
### Roll back
`stable` stays put, and the run turns red. The canary is pinned to the `stable`
version through its update settings and reinstalled through its dashboard.
`stable` stays put, and the run turns red. Before the canary is pinned to
`stable`, `check` verifies `stable` is actually installable — its statement's
zip blob must still be in the release repository and its pinned agent image
must still resolve (`releaseupdate.Installable`). If it isn't, the run fails
loudly and the canary stays on `next` rather than being stranded on a pin.
Otherwise the canary is pinned to the `stable` version through its update
settings and reinstalled through its dashboard.
A release whose migrations differ from `stable`'s can't go back without
restoring the pre-update database snapshot, which loses every write since. The
canary is held on the failed release instead (pinned to it) and the fix goes
forward in the next release. The next release's deploy points the canary back at
`next`.
forward in the next release. The next release's deploy points the canary back
at `next`.
A pinned canary isn't judged, so a rollback is decided once.
A pinned canary isn't judged, so a rollback is decided once — but `check`
verifies the pin is still installable every run, so a stranded pin shows red
instead of green. `archied release canary unpin` returns the canary to `next`
by hand.
### Configuration
| Name | Kind | Holds |
| --- | --- | --- |
| `CANARY_URL` | Actions variable | the canary's dashboard URL; unset disables the canary steps |
| `CANARY_TOKEN` | Actions secret | a personal API token on the canary with instance admin |
| `DEPLOY_TOKEN` | Actions secret | registry and repository write, for publishing, promoting and the release push |
| `CANARY_TOKEN` | Actions secret | an API token bound to a dedicated `service_account` identity on the canary, carrying only the canary grant policy (see below) — never instance admin |
| `CANARY_WINDOW` | Actions variable | optional `-window` override for `canary check`; unset is 24h |
| `DEPLOY_TOKEN` | Actions secret | registry and repository write, for publishing, promoting and the release push; stays CI-only, promotion runs in CI and never on the host |
| `RELEASE_SIGNING_KEY` | Actions secret | the release signing seed |
#### Setting up `CANARY_TOKEN` once
`CANARY_TOKEN` is a bearer token for a dedicated service-account identity in
the system org whose only grant is the canary policy
(`access.CanaryGrantPolicy`): read the signal endpoints (`GET /api/chat/update`,
`GET /api/alerts`, `GET /api/logs`, `GET /api/tasks`), read and write the
`update-settings` resource, and trigger an update install
(`POST /api/chat/update/install`). It carries no other rights, and instance
admin is never needed. With an instance-admin token (for example the operator
session), run against the canary host:
```bash
# 1. Create the service-account identity in the system org.
curl -X POST "$CANARY_URL/api/identities" -H "Authorization: Bearer $ADMIN" \
-H 'Content-Type: application/json' \
-d '{"kind":"service_account","display_name":"ci-canary"}'
# -> {"id":"<canary-identity-id>", ...}
# 2. Issue its token (shown exactly once).
curl -X POST "$CANARY_URL/api/identities/<canary-identity-id>/tokens" \
-H "Authorization: Bearer $ADMIN" -H 'Content-Type: application/json' \
-d '{"name":"ci-canary","days":90}'
# -> {"id":"<token-hash>","token":"archie_pat_..."} -- store the token value as the CANARY_TOKEN secret
# 3. Install the grant pair, scoped to that identity. The policies' org is
# pinned to the caller's org (org-sys for the instance admin), so the
# bodies need no org field. The permit alone is not enough: service
# accounts created through the API are assigned the developer role, so a
# matching forbid (installed second) negates everything outside the
# permit's surface for that identity.
curl -X PUT "$CANARY_URL/api/access/policies" -H "Authorization: Bearer $ADMIN" \
-H 'Content-Type: application/json' \
-d '{"id":"org-canary-grant","level":"org","text":"permit(principal, action, resource) when {\n resource.org == principal.org &&\n principal == Archie::Identity::\"<canary-identity-id>\" &&\n (\n (action == Archie::Action::\"read\" && [\"dashboard\", \"task\"].contains(resource.kind)) ||\n (action == Archie::Action::\"read\" && resource == Archie::Object::\"update-settings\") ||\n (action == Archie::Action::\"update\" && resource == Archie::Object::\"update\") ||\n (action == Archie::Action::\"manage_identities\" && resource == Archie::Object::\"update-settings\")\n )\n};"}'
```
The second policy forbids the canary identity from everything the permit does
not name, so its developer role cannot widen the grant:
```bash
curl -X PUT "$CANARY_URL/api/access/policies" -H "Authorization: Bearer $ADMIN" \
-H 'Content-Type: application/json' \
-d '{"id":"org-canary-grant-forbid","level":"org","text":"forbid(principal, action, resource) when {\\n resource.org == principal.org &&\\n principal == Archie::Identity::\\\"<canary-identity-id>\\\" &&\\n !(\\n (action == Archie::Action::\\\"read\\\" && [\\\"dashboard\\\", \\\"task\\\"].contains(resource.kind)) ||\\n (action == Archie::Action::\\\"read\\\" && resource == Archie::Object::\\\"update-settings\\\") ||\\n (action == Archie::Action::\\\"update\\\" && resource == Archie::Object::\\\"update\\\") ||\\n (action == Archie::Action::\\\"manage_identities\\\" && resource == Archie::Object::\\\"update-settings\\\")\\n )\\n};"}'
```
The policy texts are exactly `access.CanaryGrantPolicy` and
`access.CanaryGrantForbidPolicy` from `internal/domain/access/canary.go` with
the identity id filled in. The canary needs no other rights: `GET
/health/detailed` is unauthenticated, and every other call it makes is covered
by the grant pair.
The runner must reach `CANARY_URL`. Without a canary a release stays on `next`
until promoted by hand, under the same refusals:
+7
View File
@@ -221,6 +221,13 @@ tasks:
cmds:
- node e2e/run.cjs {{.CLI_ARGS}}
canary:rehearse:
# Local rehearsal only: spins up its own registry, database and host, and
# is deliberately absent from check and CI.
desc: Rehearse the release-canary loop on a throwaway local host (needs docker; never part of the gate)
cmds:
- sh tools/canary-rehearse.sh
build:
desc: Build archie services and agent binaries
deps: [ui]
+15
View File
@@ -94,3 +94,18 @@ target = "127.0.0.1:9090"
# releases_key = "base64 public key"
# catalogue = "registry.example/owner/archipelago/catalogue"
# catalogue_key = "base64 public key"
# Long-running agent loops that maintain memory, skills and — in dry run —
# file follow-up issues from recent runs. Definitions are data: the server
# validates them and the gateway applies them live.
# [[curators]]
# name = "self-intake"
# interval = "1h"
# tools = ["run_list", "run_events"]
# instructions = """
# You are archie's self-intake curator, in dry run. Each pass: list recent
# task runs with run_list, inspect anything parked or failed with run_events,
# then report candidate follow-up issues — concrete, each tied to the run
# that produced it. Do not create issues; this pass reports only (no
# issue-creating tool is declared, so it cannot).
# """
+11
View File
@@ -45,3 +45,14 @@ listen = "127.0.0.1:8585"
[services.daemon]
target = "127.0.0.1:8587"
listen = "127.0.0.1:8587"
# Dry-run self-intake curator (#1770): surveys recent runs and reports
# candidate follow-up issues as pass summaries; declares no issue-creating
# tool, so it cannot file. Needs a chat model configured to run at all.
[[curators]]
name = "self-intake"
interval = "1h"
tools = ["run_list", "run_events"]
instructions = """
You are archie's self-intake curator, in dry run. Each pass: list recent task runs with run_list, inspect anything parked or failed with run_events, then report candidate follow-up issues — concrete, each tied to the run that produced it. Do not create issues; this pass reports only (no issue-creating tool is declared, so it cannot). End your reply with the report.
"""
+2
View File
@@ -88,6 +88,7 @@
"/news/archie/1.57.0/": "/news/1.57.0/",
"/news/archie/1.58.0/": "/news/1.58.0/",
"/news/archie/1.58.1/": "/news/1.58.1/",
"/news/archie/1.59.0/": "/news/1.59.0/",
"/news/archie/1.6.0/": "/news/1.6.0/",
"/news/archie/1.7.0/": "/news/1.7.0/",
"/news/archie/1.8.0/": "/news/1.8.0/",
@@ -192,6 +193,7 @@
"/news/archied/1.57.0/": "/news/1.57.0/",
"/news/archied/1.58.0/": "/news/1.58.0/",
"/news/archied/1.58.1/": "/news/1.58.1/",
"/news/archied/1.59.0/": "/news/1.59.0/",
"/news/archied/1.6.0/": "/news/1.6.0/",
"/news/archied/1.7.0/": "/news/1.7.0/",
"/news/archied/1.8.0/": "/news/1.8.0/",
+5
View File
@@ -1,4 +1,9 @@
[
{
"version": "1.59.0",
"date": "2026-11-02",
"body": "### archied\n\n- Forge extensions can open issues: the forge surface gains `CreateIssue` alongside list, comment and close, and the bundled Gitea and GitHub extensions implement it."
},
{
"version": "1.58.1",
"date": "2026-11-01",
+68
View File
@@ -0,0 +1,68 @@
# Self-development loop: archie develops its own codebase
**Status:** Decided, not yet built (2026-11-03, sam) **Scope:** how archie
persistently takes on development of archie-core itself. This file records a
desired state, not an implementation or a product: nothing below exists unless
the "Built today" section says so. The plan is tracked as epic #1769 with child
issues #1770–#1775. This file is a record, not a mechanism: agents only see
what is in their context, so verify every claim here against the code before
acting on it — where they disagree, the code wins. The boundary below is
load-bearing only where it is enforced (the gate, access control, the daemon's
git monopoly) and stated in `AGENTS.md`; everywhere else this file is a pointer.
## Built today
The machinery the loop will reuse exists: shipped triage/implement/pr-review
workflows, the adversarial self-review stage before a PR opens (epic #1348,
closed), the prbench judge for review quality with its acceptance bar, canary
releases judged on the installed release (releaseupdate), and the curator
engine. What does not exist is the loop itself: no self-intake curator, no
approved-issue auto-run, no judge for diffs, no outcome distillation, no
canary routing specific to self-directed changes.
## Decision
Archie improves its own codebase through a closed loop, built in stages:
1. **Self-intake** (#1770): a curator pass reads run outcomes, step transcripts,
gate failures and alerts, dedupes against open issues, and files new issues.
Archie files its own work; the maintainer approves priority.
2. **Approved-issue loop** (#1771): an approved issue runs the shipped
triage/implement workflows end to end — read-only plan, gated build,
adversarial self-review, daemon commits and opens a green PR. The maintainer
still merges at this stage.
3. **Implementation judge** (#1772): the prbench judge pattern scores diffs,
calibrated against the maintainer's merge decisions; auto-merge applies only
when the gate is green, the review stage is clean, and the judge is above the
calibrated bar.
4. **Outcome distillation** (#1773): a curator turns merged-run postmortems into
proposals for the repo's agent instructions, each added only because it
changes a decision; rules that stop changing decisions are removed.
5. **Canary** (#1774): self-directed changes ship through the canary release
window and are judged on the installed release before promotion. Rollback is
a plain revert, because every self-directed change is one gated commit.
## Boundary
Enforcement lives in the harness, never in the prompt (#1775). Changes to the
commit gate, the invariants in `AGENTS.md`, access control and grant scoping,
the daemon-only git path, and webhook HMAC verification may be proposed by
archie but are never merged by archie — they require a maintainer merge.
Everything else (workflows, curators, memory, docs, the dashboard) is fair game
for the loop.
## Why
Self-improvement degrades when it relies on the model choosing to follow rules.
Gates, scoped grants and the daemon's monopoly on git cannot be argued with; a
prompt can. Keeping quality measurable — a judge bar and a canary verdict as
numbers, tests guarding the protected seams — is what lets the loop widen
without turning the codebase to garbage.
## Consequences
- One issue → one small PR applies doubly to self-directed work: past about 100
lines or any new mechanism, the change stops and reassesses.
- Every self-directed commit cites the issue that authorized it.
- Rule proposals from the distillation curator must name the run that triggered
them, and `AGENTS.md` stays short enough to read in full every session.
+5 -2
View File
@@ -19,8 +19,11 @@ const releaseUsage = `usage: archied release <command>
keygen -seed FILE write a new signing key's seed to FILE and print its public key
publish sign a release and push it to a release source's next channel
promote -version V point stable at a published release by hand
canary start point the canary at next and install a release on it
canary check judge the release on next and promote it or roll the canary back`
canary status show the canary's channel, installed release, window and verdict (read-only)
canary start point the canary at next and install a release on it, queued behind one being judged
canary check judge the release the canary runs: promote it, pick up a newer next, or roll back
canary promote promote the release the canary runs now, if its signals pass
canary unpin return the canary to the next channel from any pin`
// RunRelease is the publisher's side of a release source: it makes the key
// a source signs with and pushes signed releases to it.
+549 -87
View File
@@ -25,129 +25,505 @@ const canaryInstallWait = 20 * time.Minute
const migrationsDir = "internal/infrastructure/postgres/migrations"
func runReleaseCanary(args []string, out, stderr io.Writer) int {
if len(args) == 0 || (args[0] != "start" && args[0] != "check") {
if len(args) == 0 {
fmt.Fprintln(stderr, releaseUsage)
return 2
}
flags := flag.NewFlagSet("release canary "+args[0], flag.ContinueOnError)
switch args[0] {
case "status":
return runCanaryStatus(args[1:], out, stderr)
case "start":
return runCanaryStart(args[1:], out, stderr)
case "check":
return runCanaryCheck(args[1:], out, stderr)
case "promote":
return runCanaryPromote(args[1:], out, stderr)
case "unpin":
return runCanaryUnpin(args[1:], out, stderr)
default:
fmt.Fprintln(stderr, releaseUsage)
return 2
}
}
// addCanaryFlags registers the flags every canary subcommand takes.
func addCanaryFlags(flags *flag.FlagSet) (dashboardURL, tokenEnv *string) {
dashboardURL = flags.String("dashboard", "", "canary dashboard URL")
tokenEnv = flags.String("token-env", "ARCHIE_CANARY_TOKEN", "environment variable holding a dashboard API token for the canary")
return dashboardURL, tokenEnv
}
// addSourceFlags registers the flags naming the release source.
func addSourceFlags(flags *flag.FlagSet) (reference, key *string) {
reference = flags.String("source", "", "OCI repository releases are published to; blank is the official releases")
key = flags.String("key", "", "base64 ed25519 public key the source signs with")
return reference, key
}
func canaryDashboard(url, tokenEnv string) (releaseupdate.CanaryDashboard, error) {
if url == "" {
return releaseupdate.CanaryDashboard{}, errors.New("-dashboard is required")
}
return releaseupdate.CanaryDashboard{URL: url, Token: os.Getenv(tokenEnv)}, nil
}
func canarySource(reference, key string) (distribution.Source, error) {
return distribution.Parse(reference, key, distribution.DefaultReleases())
}
// fetchChannel fetches a channel tag; found is false when the channel has no
// release yet.
func fetchChannel(ctx context.Context, source distribution.Source, tag string) (release releaseupdate.Release, found bool, err error) {
release, err = releaseupdate.Fetch(ctx, source, tag)
if errors.Is(err, errdef.ErrNotFound) {
return releaseupdate.Release{}, false, nil
}
return release, err == nil, err
}
// publishedChannels are the releases the source currently publishes.
type publishedChannels struct {
next, stable releaseupdate.Release
hasNext, hasStable bool
}
func fetchChannels(ctx context.Context, source distribution.Source) (publishedChannels, error) {
var channels publishedChannels
var err error
if channels.next, channels.hasNext, err = fetchChannel(ctx, source, "next"); err != nil {
return channels, err
}
if channels.stable, channels.hasStable, err = fetchChannel(ctx, source, "stable"); err != nil {
return channels, err
}
return channels, nil
}
// canaryRun is the release the canary actually runs: its version, when it was
// installed and its fetched release statement.
type canaryRun struct {
version string
installedAt time.Time
release releaseupdate.Release
found bool
}
// readCanaryRun reads what the canary runs. A host that doesn't record install
// times (it updated before they were tracked) degrades to the release
// statement's issue time.
func readCanaryRun(ctx context.Context, dashboard releaseupdate.CanaryDashboard, source distribution.Source) (canaryRun, error) {
var run canaryRun
version, installedAt, _, err := dashboard.Installed(ctx)
if err != nil {
return run, err
}
run.version, run.installedAt = version, installedAt
release, found, err := fetchChannel(ctx, source, releaseupdate.Tag("exact-pin", version))
if err != nil {
return run, err
}
run.release, run.found = release, found
if run.installedAt.IsZero() && found {
run.installedAt = release.Statement.IssuedAt
}
return run, nil
}
// newerIssued reports whether release a was issued after b. IssuedAt, not
// semver order: Promote refuses a release issued before the one stable names,
// so the judge must agree with that replay rule.
func newerIssued(a, b releaseupdate.Release) bool {
return a.Statement.IssuedAt.After(b.Statement.IssuedAt)
}
func displayVersion(version string) string {
if version == "" {
return "unknown"
}
return version
}
func displayRelease(release releaseupdate.Release, found bool) string {
if !found {
return "none"
}
return release.Statement.Version
}
func printVerdict(out io.Writer, version string, verdict releaseupdate.CanaryVerdict) {
fmt.Fprintf(out, "%s: %s\n", displayVersion(version), verdict.Decision)
for _, reason := range verdict.Reasons {
fmt.Fprintf(out, " %s\n", reason)
}
}
func runCanaryStatus(args []string, out, stderr io.Writer) int {
flags := flag.NewFlagSet("release canary status", flag.ContinueOnError)
flags.SetOutput(stderr)
dashboardURL := flags.String("dashboard", "", "canary dashboard URL")
tokenEnv := flags.String("token-env", "ARCHIE_CANARY_TOKEN", "environment variable holding a dashboard API token for the canary")
version := flags.String("version", "", "release to install (start)")
reference := flags.String("source", "", "OCI repository releases are published to; blank is the official releases (check)")
key := flags.String("key", "", "base64 ed25519 public key the source signs with (check)")
latest := flags.String("latest", "", "comma-separated image repositories whose v<version> tag becomes latest on promotion (check)")
checkout := flags.String("checkout", ".", "repository checkout with release tags, to see whether a release migrated the database (check)")
if err := flags.Parse(args[1:]); err != nil {
dashboardURL, tokenEnv := addCanaryFlags(flags)
reference, key := addSourceFlags(flags)
window := flags.Duration("window", releaseupdate.CanaryWindow, "window a release is judged over, counted from its install")
if err := flags.Parse(args); err != nil {
return 2
}
dashboard := releaseupdate.CanaryDashboard{URL: *dashboardURL, Token: os.Getenv(*tokenEnv)}
if *dashboardURL == "" {
fmt.Fprintln(stderr, "release canary: -dashboard is required")
return 2
}
ctx := context.Background()
if args[0] == "start" {
if *version == "" {
fmt.Fprintln(stderr, "release canary start: -version is required")
return 2
}
if err := startCanary(ctx, dashboard, *version); err != nil {
fmt.Fprintln(stderr, err)
return 1
}
fmt.Fprintf(out, "canary follows next and runs %s\n", *version)
return 0
}
source, err := distribution.Parse(*reference, *key, distribution.DefaultReleases())
dashboard, err := canaryDashboard(*dashboardURL, *tokenEnv)
if err != nil {
fmt.Fprintln(stderr, "release canary check:", err)
fmt.Fprintln(stderr, "release canary status:", err)
return 2
}
rolledBack, err := checkCanary(ctx, dashboard, source, splitList(*latest), *checkout, out)
source, err := canarySource(*reference, *key)
if err != nil {
fmt.Fprintln(stderr, err)
return 1
fmt.Fprintln(stderr, "release canary status:", err)
return 2
}
if rolledBack {
if err := printCanaryStatus(context.Background(), dashboard, source, *window, out); err != nil {
fmt.Fprintln(stderr, "release canary status:", err)
return 1
}
return 0
}
func startCanary(ctx context.Context, dashboard releaseupdate.CanaryDashboard, version string) error {
if err := dashboard.Follow(ctx, "next", ""); err != nil {
return fmt.Errorf("point the canary at next: %w", err)
}
return dashboard.Install(ctx, version, canaryInstallWait)
}
// checkCanary judges the release on the next channel once and acts on the
// result. It reports rolledBack so that the caller can fail the run.
func checkCanary(ctx context.Context, dashboard releaseupdate.CanaryDashboard, source distribution.Source, latest []string, checkout string, out io.Writer) (rolledBack bool, err error) {
next, err := releaseupdate.Fetch(ctx, source, "next")
if err != nil {
return false, err
}
stable, err := releaseupdate.Fetch(ctx, source, "stable")
hasStable := err == nil
if err != nil && !errors.Is(err, errdef.ErrNotFound) {
return false, err
}
release := next.Statement
if release.Prerelease || (hasStable && !release.IssuedAt.After(stable.Statement.IssuedAt)) {
fmt.Fprintf(out, "nothing to judge: next is %s and isn't a newer release than stable\n", release.Version)
return false, nil
}
// printCanaryStatus reports the canary's channel, installed release, the
// published channels, window progress and the verdict the current signals
// would give, without acting on anything.
func printCanaryStatus(ctx context.Context, dashboard releaseupdate.CanaryDashboard, source distribution.Source, window time.Duration, out io.Writer) error {
channel, pin, err := dashboard.Channel(ctx)
if err != nil {
return false, err
return err
}
if channel != "next" {
fmt.Fprintf(out, "nothing to judge: the canary is held on %s %s\n", channel, pin)
return false, nil
channels, err := fetchChannels(ctx, source)
if err != nil {
return err
}
run, err := readCanaryRun(ctx, dashboard, source)
if err != nil {
return err
}
printCanaryState(out, channel, pin, run, channels, window)
return printCanaryVerdict(ctx, dashboard, run, window, out)
}
func printCanaryState(out io.Writer, channel, pin string, run canaryRun, channels publishedChannels, window time.Duration) {
fmt.Fprintf(out, "channel: %s\n", channelDisplay(channel, pin))
fmt.Fprintf(out, "installed: %s", displayVersion(run.version))
if run.installedAt.IsZero() {
fmt.Fprintln(out, " (installed_at not reported)")
} else {
fmt.Fprintf(out, " since %s\n", run.installedAt.Format(time.RFC3339))
}
fmt.Fprintf(out, "stable: %s\n", displayRelease(channels.stable, channels.hasStable))
fmt.Fprintf(out, "next: %s\n", displayRelease(channels.next, channels.hasNext))
if run.installedAt.IsZero() {
fmt.Fprintln(out, "window: unknown, no install time to count from")
} else {
elapsed := time.Since(run.installedAt)
fmt.Fprintf(out, "window: %s of %s elapsed since the install\n", elapsed.Round(time.Minute), window)
}
}
func printCanaryVerdict(ctx context.Context, dashboard releaseupdate.CanaryDashboard, run canaryRun, window time.Duration, out io.Writer) error {
if run.installedAt.IsZero() {
fmt.Fprintln(out, "verdict: unknown, no install time to judge from")
return nil
}
now := time.Now().UTC()
signals, err := dashboard.Signals(ctx, release.IssuedAt, now)
signals, err := dashboard.Signals(ctx, run.installedAt, now, window)
if err != nil {
return false, fmt.Errorf("read canary signals: %w", err)
return fmt.Errorf("read canary signals: %w", err)
}
verdict := releaseupdate.JudgeCanary(release.Version, now.Sub(release.IssuedAt), signals)
fmt.Fprintf(out, "%s: %s\n", release.Version, verdict.Decision)
printSignals(out, signals)
verdict := releaseupdate.JudgeCanary(run.version, run.installedAt, now, window, signals)
fmt.Fprintf(out, "verdict on %s: %s (read-only)\n", displayVersion(run.version), verdict.Decision)
for _, reason := range verdict.Reasons {
fmt.Fprintf(out, " %s\n", reason)
}
switch verdict.Decision {
case releaseupdate.CanaryPromote:
if _, err := releaseupdate.Promote(ctx, source.Reference, source.Key, release.Version, latest); err != nil {
return false, fmt.Errorf("promote %s: %w", release.Version, err)
return nil
}
func printSignals(out io.Writer, s releaseupdate.CanarySignals) {
fmt.Fprintf(out, "signals: runs %q, ready=%t, new action alerts=%d\n", s.Installed, s.Ready, len(s.NewActionAlerts))
fmt.Fprintf(out, " tasks finished %d, parked or died %d (baseline %d, %d)\n",
s.Canary.Finished, s.Canary.Bad, s.Baseline.Finished, s.Baseline.Bad)
fmt.Fprintf(out, " error lines %d, log covers %s (baseline %d, covers %s)\n",
s.Canary.Errors, s.Canary.Covered.Round(time.Minute), s.Baseline.Errors, s.Baseline.Covered.Round(time.Minute))
}
func channelDisplay(channel, pin string) string {
if pin != "" {
return channel + " (pinned to " + pin + ")"
}
return channel
}
func runCanaryStart(args []string, out, stderr io.Writer) int {
flags := flag.NewFlagSet("release canary start", flag.ContinueOnError)
flags.SetOutput(stderr)
dashboardURL, tokenEnv := addCanaryFlags(flags)
reference, key := addSourceFlags(flags)
version := flags.String("version", "", "release to install on the canary")
force := flags.Bool("force", false, "install even when the canary is still judging a newer release")
if err := flags.Parse(args); err != nil {
return 2
}
dashboard, err := canaryDashboard(*dashboardURL, *tokenEnv)
if err != nil {
fmt.Fprintln(stderr, "release canary start:", err)
return 2
}
if *version == "" {
fmt.Fprintln(stderr, "release canary start: -version is required")
return 2
}
source, err := canarySource(*reference, *key)
if err != nil {
fmt.Fprintln(stderr, "release canary start:", err)
return 2
}
if err := startCanary(context.Background(), dashboard, source, *version, *force, out); err != nil {
fmt.Fprintln(stderr, "release canary start:", err)
return 1
}
return 0
}
// startCanary points the canary at next — clearing any rollback pin — and
// installs version on it. A release published while the canary still judges a
// newer one queues behind it, so the running window isn't restarted under a
// different release.
func startCanary(ctx context.Context, dashboard releaseupdate.CanaryDashboard, source distribution.Source, version string, force bool, out io.Writer) error {
// The channel is read before following next: a canary already on next is
// judging the release it runs, and a new release queues behind that one.
channel, _, err := dashboard.Channel(ctx)
if err != nil {
return err
}
if err := dashboard.Follow(ctx, "next", ""); err != nil {
return fmt.Errorf("point the canary at next: %w", err)
}
if !force {
queued, err := queuedBehind(ctx, dashboard, source, channel, version, out)
if err != nil {
return err
}
fmt.Fprintf(out, "stable is %s\n", release.Version)
if queued {
return nil
}
}
if err := dashboard.Install(ctx, version, canaryInstallWait); err != nil {
return err
}
fmt.Fprintf(out, "the canary follows next and runs %s\n", version)
return nil
}
// queuedBehind reports whether version must wait: the canary already follows
// next and is still judging the release it runs (a judgeable one), which is a
// different release from version.
func queuedBehind(ctx context.Context, dashboard releaseupdate.CanaryDashboard, source distribution.Source, channel, version string, out io.Writer) (bool, error) {
if channel != "next" {
return false, nil
case releaseupdate.CanaryRollBack:
return true, rollBackCanary(ctx, dashboard, release.Version, stable.Statement.Version, hasStable, checkout, out)
}
run, err := readCanaryRun(ctx, dashboard, source)
if err != nil {
return false, err
}
if run.version == version {
return false, nil
}
channels, err := fetchChannels(ctx, source)
if err != nil {
return false, err
}
if judgeable(run, channels) {
fmt.Fprintf(out, "%s is queued behind %s, which the canary is still judging\n", version, run.version)
return true, nil
}
return false, nil
}
// rollBackCanary pins the canary to the stable release and reinstalls it.
// Going back past a migration needs the pre-update database snapshot, which
// loses every write since, so a release that migrated is held instead.
func rollBackCanary(ctx context.Context, dashboard releaseupdate.CanaryDashboard, failed, stable string, hasStable bool, checkout string, out io.Writer) error {
if !hasStable || migrated(ctx, checkout, stable, failed) {
if err := dashboard.Follow(ctx, "exact-pin", failed); err != nil {
return fmt.Errorf("hold the canary on %s: %w", failed, err)
func runCanaryCheck(args []string, out, stderr io.Writer) int {
flags := flag.NewFlagSet("release canary check", flag.ContinueOnError)
flags.SetOutput(stderr)
dashboardURL, tokenEnv := addCanaryFlags(flags)
reference, key := addSourceFlags(flags)
latest := flags.String("latest", "", "comma-separated image repositories whose v<version> tag becomes latest on promotion")
checkout := flags.String("checkout", ".", "repository checkout with release tags, to see whether a release migrated the database")
window := flags.Duration("window", releaseupdate.CanaryWindow, "window the installed release is judged over, counted from its install")
if err := flags.Parse(args); err != nil {
return 2
}
dashboard, err := canaryDashboard(*dashboardURL, *tokenEnv)
if err != nil {
fmt.Fprintln(stderr, "release canary check:", err)
return 2
}
source, err := canarySource(*reference, *key)
if err != nil {
fmt.Fprintln(stderr, "release canary check:", err)
return 2
}
code, err := checkCanary(context.Background(), dashboard, source, splitList(*latest), *checkout, *window, out)
if err != nil {
fmt.Fprintln(stderr, "release canary check:", err)
return 1
}
return code
}
// checkCanary judges the release the canary actually runs — not the moving
// next tag — and acts on the verdict. The exit code is 1 when the run should
// show red: a rollback happened, or the canary is held on a pin that can no
// longer be installed.
func checkCanary(ctx context.Context, dashboard releaseupdate.CanaryDashboard, source distribution.Source, latest []string, checkout string, window time.Duration, out io.Writer) (int, error) {
channels, err := fetchChannels(ctx, source)
if err != nil {
return 1, err
}
channel, pin, err := dashboard.Channel(ctx)
if err != nil {
return 1, err
}
if channel != "next" {
return heldCanary(ctx, source, channel, pin, out)
}
run, err := readCanaryRun(ctx, dashboard, source)
if err != nil {
return 1, err
}
if !judgeable(run, channels) {
fmt.Fprintf(out, "nothing to judge: the canary runs %s\n", displayVersion(run.version))
return pickupNext(ctx, dashboard, channels, run.version, out)
}
return judgeInstalled(ctx, dashboard, source, run, channels, latest, checkout, window, out)
}
// judgeable reports whether the installed release is one the canary judges: a
// published, non-prerelease release issued after stable's.
func judgeable(run canaryRun, channels publishedChannels) bool {
if !run.found || run.release.Statement.Prerelease {
return false
}
return !channels.hasStable || newerIssued(run.release, channels.stable)
}
func judgeInstalled(ctx context.Context, dashboard releaseupdate.CanaryDashboard, source distribution.Source, run canaryRun, channels publishedChannels, latest []string, checkout string, window time.Duration, out io.Writer) (int, error) {
now := time.Now().UTC()
signals, err := dashboard.Signals(ctx, run.installedAt, now, window)
if err != nil {
return 1, fmt.Errorf("read canary signals: %w", err)
}
verdict := releaseupdate.JudgeCanary(run.version, run.installedAt, now, window, signals)
printVerdict(out, run.version, verdict)
switch verdict.Decision {
case releaseupdate.CanaryPromote:
return 0, promoteJudged(ctx, dashboard, source, run, channels, latest, out)
case releaseupdate.CanaryRollBack:
return 1, rollBackCanary(ctx, dashboard, source, run, channels, checkout, out)
default:
return 0, nil
}
}
// promoteJudged moves stable to the judged release, then picks up a newer next
// queued behind it.
func promoteJudged(ctx context.Context, dashboard releaseupdate.CanaryDashboard, source distribution.Source, run canaryRun, channels publishedChannels, latest []string, out io.Writer) error {
if _, err := releaseupdate.Promote(ctx, source.Reference, source.Key, run.version, latest); err != nil {
return fmt.Errorf("promote %s: %w", run.version, err)
}
fmt.Fprintf(out, "stable is %s\n", run.version)
fresh := channels
fresh.stable, fresh.hasStable = run.release, true
_, err := pickupNext(ctx, dashboard, fresh, run.version, out)
return err
}
// pickupNext installs the next release when it is newer than stable and the
// canary doesn't already run it.
func pickupNext(ctx context.Context, dashboard releaseupdate.CanaryDashboard, channels publishedChannels, installed string, out io.Writer) (int, error) {
if !channels.hasNext || channels.next.Statement.Version == installed {
return 0, nil
}
if channels.hasStable && !newerIssued(channels.next, channels.stable) {
return 0, nil
}
if err := dashboard.Install(ctx, channels.next.Statement.Version, canaryInstallWait); err != nil {
return 1, err
}
fmt.Fprintf(out, "the canary picks up %s from next\n", channels.next.Statement.Version)
return 0, nil
}
// heldCanary reports a canary that isn't following next. Its pin must still be
// installable: a stranded pin fails the run instead of looking green.
func heldCanary(ctx context.Context, source distribution.Source, channel, pin string, out io.Writer) (int, error) {
if pin != "" {
err := checkPin(ctx, source, pin)
if errors.Is(err, errStrandedPin) {
fmt.Fprintf(out, "ERROR: the canary is held on %s %s, which is stranded: %v; unpin it or republish the release\n", channel, pin, err)
return 1, nil
}
fmt.Fprintf(out, "%s changed the database schema or there's no stable release to return to: the canary is held on %s and stable is unchanged; fix forward\n", failed, failed)
return nil
if err != nil {
return 1, err
}
fmt.Fprintf(out, "held on %s %s, nothing to judge\n", channel, pin)
return 0, nil
}
if err := dashboard.Follow(ctx, "exact-pin", stable); err != nil {
return fmt.Errorf("pin the canary to %s: %w", stable, err)
fmt.Fprintf(out, "held on %s, nothing to judge\n", channel)
return 0, nil
}
// errStrandedPin marks a held pin that can no longer be installed.
var errStrandedPin = errors.New("pin is stranded")
// checkPin fails when a held pin can no longer be installed: the release is
// gone from the source, or its artifacts are.
func checkPin(ctx context.Context, source distribution.Source, pin string) error {
release, found, err := fetchChannel(ctx, source, releaseupdate.Tag("exact-pin", pin))
if err != nil {
return err
}
if err := dashboard.Install(ctx, stable, canaryInstallWait); err != nil {
return fmt.Errorf("return the canary to %s: %w", stable, err)
if !found {
return fmt.Errorf("%w: no release %s in the source", errStrandedPin, releaseupdate.Tag("exact-pin", pin))
}
fmt.Fprintf(out, "the canary is back on %s and stable is unchanged\n", stable)
if err := releaseupdate.Installable(ctx, source, release); err != nil {
return fmt.Errorf("%w: %w", errStrandedPin, err)
}
return nil
}
// rollBackCanary returns the canary to stable after a failed verdict. stable
// is checked installable before the canary is pinned to it: a pin whose
// artifacts are gone would strand the canary, so the run fails loudly and the
// canary stays on next. A release that changed the migrations is held on the
// failed version instead, because going back past a migration needs the
// pre-update database snapshot.
func rollBackCanary(ctx context.Context, dashboard releaseupdate.CanaryDashboard, source distribution.Source, run canaryRun, channels publishedChannels, checkout string, out io.Writer) error {
failed := run.version
if !channels.hasStable {
return holdCanary(ctx, dashboard, failed, "there's no stable release to return to", out)
}
stable := channels.stable
if err := releaseupdate.Installable(ctx, source, stable); err != nil {
return fmt.Errorf("stable %s is not installable, the canary stays on next: %w", stable.Statement.Version, err)
}
if migrated(ctx, checkout, stable.Statement.Version, failed) {
return holdCanary(ctx, dashboard, failed, failed+" changed the database schema", out)
}
if err := dashboard.Follow(ctx, "exact-pin", stable.Statement.Version); err != nil {
return fmt.Errorf("pin the canary to %s: %w", stable.Statement.Version, err)
}
if err := dashboard.Install(ctx, stable.Statement.Version, canaryInstallWait); err != nil {
return fmt.Errorf("return the canary to %s: %w", stable.Statement.Version, err)
}
fmt.Fprintf(out, "the canary is back on %s and stable is unchanged\n", stable.Statement.Version)
return nil
}
func holdCanary(ctx context.Context, dashboard releaseupdate.CanaryDashboard, version, why string, out io.Writer) error {
if err := dashboard.Follow(ctx, "exact-pin", version); err != nil {
return fmt.Errorf("hold the canary on %s: %w", version, err)
}
fmt.Fprintf(out, "%s: the canary is held on %s and stable is unchanged; fix forward\n", why, version)
return nil
}
@@ -158,3 +534,89 @@ func migrated(ctx context.Context, checkout, from, to string) bool {
err := exec.CommandContext(ctx, "git", "-C", checkout, "diff", "--quiet", "v"+from, "v"+to, "--", migrationsDir).Run()
return err != nil
}
func runCanaryPromote(args []string, out, stderr io.Writer) int {
flags := flag.NewFlagSet("release canary promote", flag.ContinueOnError)
flags.SetOutput(stderr)
dashboardURL, tokenEnv := addCanaryFlags(flags)
reference, key := addSourceFlags(flags)
latest := flags.String("latest", "", "comma-separated image repositories whose v<version> tag becomes latest on promotion")
version := flags.String("version", "", "release expected on the canary; must match what it runs")
window := flags.Duration("window", releaseupdate.CanaryWindow, "window the signals are read over, counted from the install")
if err := flags.Parse(args); err != nil {
return 2
}
dashboard, err := canaryDashboard(*dashboardURL, *tokenEnv)
if err != nil {
fmt.Fprintln(stderr, "release canary promote:", err)
return 2
}
source, err := canarySource(*reference, *key)
if err != nil {
fmt.Fprintln(stderr, "release canary promote:", err)
return 2
}
code, err := promoteCanaryNow(context.Background(), dashboard, source, *version, splitList(*latest), *window, out)
if err != nil {
fmt.Fprintln(stderr, "release canary promote:", err)
return 1
}
return code
}
// promoteCanaryNow promotes the release the canary runs right now, without
// waiting out the window: the signals must show no hard failure and no
// relative breach. It refuses, with exit 1, when anything fails.
func promoteCanaryNow(ctx context.Context, dashboard releaseupdate.CanaryDashboard, source distribution.Source, expectVersion string, latest []string, window time.Duration, out io.Writer) (int, error) {
run, err := readCanaryRun(ctx, dashboard, source)
if err != nil {
return 1, err
}
channel, pin, err := dashboard.Channel(ctx)
if err != nil {
return 1, err
}
fmt.Fprintf(out, "channel: %s\n", channelDisplay(channel, pin))
if expectVersion != "" && expectVersion != run.version {
return 1, fmt.Errorf("the canary runs %s, not %s", displayVersion(run.version), expectVersion)
}
if !run.found {
return 1, fmt.Errorf("no release %s in the source to promote", displayVersion(run.version))
}
now := time.Now().UTC()
signals, err := dashboard.Signals(ctx, run.installedAt, now, window)
if err != nil {
return 1, fmt.Errorf("read canary signals: %w", err)
}
verdict := releaseupdate.JudgeCanaryNow(run.version, now, window, signals)
printVerdict(out, run.version, verdict)
if verdict.Decision == releaseupdate.CanaryRollBack {
fmt.Fprintln(out, "refusing to promote: the canary's signals fail")
return 1, nil
}
if _, err := releaseupdate.Promote(ctx, source.Reference, source.Key, run.version, latest); err != nil {
return 1, fmt.Errorf("promote %s: %w", run.version, err)
}
fmt.Fprintf(out, "stable is %s\n", run.version)
return 0, nil
}
func runCanaryUnpin(args []string, out, stderr io.Writer) int {
flags := flag.NewFlagSet("release canary unpin", flag.ContinueOnError)
flags.SetOutput(stderr)
dashboardURL, tokenEnv := addCanaryFlags(flags)
if err := flags.Parse(args); err != nil {
return 2
}
dashboard, err := canaryDashboard(*dashboardURL, *tokenEnv)
if err != nil {
fmt.Fprintln(stderr, "release canary unpin:", err)
return 2
}
if err := dashboard.Follow(context.Background(), "next", ""); err != nil {
fmt.Fprintln(stderr, "release canary unpin:", err)
return 1
}
fmt.Fprintln(out, "the canary follows next again, with no pin")
return 0
}
+1 -4
View File
@@ -295,10 +295,7 @@ func hasConfigSection(document map[string]any, section string) bool {
}
func updateStateDir() string {
if dir := os.Getenv("ARCHIE_UPDATE_STATE_DIR"); dir != "" {
return dir
}
return configuration.DefaultUpdateStateDir()
return configuration.UpdateStateDir()
}
// resumeUpdate hands an interrupted transaction to the frozen watchdog and
+39 -1
View File
@@ -12,7 +12,9 @@ import (
"github.com/samcharles93/archie-core/internal/agentexec/modelloop"
"github.com/samcharles93/archie-core/internal/config"
"github.com/samcharles93/archie-core/internal/domain/access"
"github.com/samcharles93/archie-core/internal/domain/curator"
"github.com/samcharles93/archie-core/internal/domain/org"
"github.com/samcharles93/archie-core/internal/domain/usage"
"github.com/samcharles93/archie-core/internal/events"
"github.com/samcharles93/archie-core/internal/infrastructure/controlplanestore"
@@ -40,7 +42,7 @@ func (b *server) setupCurators(ctx context.Context) bool {
MemoryEngines: b.memEngines,
Skills: skillcurator.NewStore(skillsRoot),
Conversations: sessioncurator.NewAdapter(b.chatSessionStore, b.cfg.BotUser),
LLM: curatorLLMRunner{llm: b.chatLLM, outcomes: b.providerOutcomes, usage: b.usage},
LLM: actingPrincipalRunner{inner: curatorLLMRunner{llm: b.chatLLM, outcomes: b.providerOutcomes, usage: b.usage}, resolve: b.actingPrincipal},
Model: model,
})
@@ -95,6 +97,42 @@ func (s curatorEventSink) Emit(kind, detail string, data map[string]any) {
s.b.Publish(context.Background(), events.Event{Kind: kind, Detail: detail, Data: data})
}
// actingPrincipal resolves the identity the instance acts as for automated
// work (the default chat identity, falling back to the bot user), so curator
// passes authorize guarded tools exactly as that identity would.
func (b *server) actingPrincipal(ctx context.Context) (access.Principal, error) {
name := b.defaultChatIdentity
if name == "" {
name = b.cfg.BotUser
}
if name == "" {
return access.Principal{}, fmt.Errorf("no acting identity configured (chat identity or bot user)")
}
idn, err := b.stateStore.ResolveLegacyName(ctx, name)
if err != nil {
return access.Principal{}, fmt.Errorf("resolve acting identity %q: %w", name, err)
}
return b.stateStore.PrincipalFor(ctx, idn.ID)
}
// actingPrincipalRunner attaches the acting principal to every curator model
// call. Tool handlers run in the call's context, so guarded tools see the
// curator as the instance's identity, never as an anonymous or caller-supplied
// one; a pass that cannot resolve the principal fails closed.
type actingPrincipalRunner struct {
inner curator.LLMRunner
resolve func(context.Context) (access.Principal, error)
}
func (r actingPrincipalRunner) Chat(ctx context.Context, req curator.ChatRequest) (curator.ChatResult, error) {
p, err := r.resolve(ctx)
if err != nil {
return curator.ChatResult{}, fmt.Errorf("curator pass: %w", err)
}
ctx = org.WithScope(org.WithOrg(access.WithPrincipal(ctx, p), p.Org), p.Org)
return r.inner.Chat(ctx, req)
}
// curatorLLMRunner adapts the shared ai-sdk runtime to the curator
// family's narrow LLMRunner contract: one model reference, plain
// messages, and the declared tool set -- no streaming. Tools are built
+3
View File
@@ -109,6 +109,9 @@ func (b *server) registerWorkflowTools(ctx context.Context) {
authz := infraaccess.StartLive(ctx, b.stateStore.ListPolicies, b.stateStore.PoliciesVersion, b.log)
workflows := controlplanerpc.NewWorkflows(b.stateStore.ControlPlane())
entries := append(gateway.WorkflowTools(workflows, authz), gateway.IntegrationTools(integrationSource{Workflows: workflows, store: b.stateStore}, authz)...)
// Run-inspection tools back long-running curators (self-intake first);
// the State Store client satisfies the source directly.
entries = append(entries, gateway.RunTools(b.stateStore, authz)...)
for _, entry := range entries {
if err := b.toolReg.Register(entry); err != nil {
b.log.WarnContext(ctx, "workflow tool registration failed", "tool", entry.Name, "err", err)
File diff suppressed because it is too large. Load diff
@@ -23,6 +23,7 @@ const (
ForgeService_AssignedIssues_FullMethodName = "/forge.v1.ForgeService/AssignedIssues"
ForgeService_IssuesWithLabel_FullMethodName = "/forge.v1.ForgeService/IssuesWithLabel"
ForgeService_Comment_FullMethodName = "/forge.v1.ForgeService/Comment"
ForgeService_CreateIssue_FullMethodName = "/forge.v1.ForgeService/CreateIssue"
ForgeService_CloseIssue_FullMethodName = "/forge.v1.ForgeService/CloseIssue"
ForgeService_React_FullMethodName = "/forge.v1.ForgeService/React"
ForgeService_SetStateLabel_FullMethodName = "/forge.v1.ForgeService/SetStateLabel"
@@ -60,6 +61,7 @@ type ForgeServiceClient interface {
AssignedIssues(ctx context.Context, in *AssignedIssuesRequest, opts ...grpc.CallOption) (*AssignedIssuesResponse, error)
IssuesWithLabel(ctx context.Context, in *IssuesWithLabelRequest, opts ...grpc.CallOption) (*IssuesWithLabelResponse, error)
Comment(ctx context.Context, in *CommentRequest, opts ...grpc.CallOption) (*CommentResponse, error)
CreateIssue(ctx context.Context, in *CreateIssueRequest, opts ...grpc.CallOption) (*CreateIssueResponse, error)
CloseIssue(ctx context.Context, in *CloseIssueRequest, opts ...grpc.CallOption) (*CloseIssueResponse, error)
React(ctx context.Context, in *ReactRequest, opts ...grpc.CallOption) (*ReactResponse, error)
SetStateLabel(ctx context.Context, in *SetStateLabelRequest, opts ...grpc.CallOption) (*SetStateLabelResponse, error)
@@ -132,6 +134,16 @@ func (c *forgeServiceClient) Comment(ctx context.Context, in *CommentRequest, op
return out, nil
}
func (c *forgeServiceClient) CreateIssue(ctx context.Context, in *CreateIssueRequest, opts ...grpc.CallOption) (*CreateIssueResponse, error) {
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
out := new(CreateIssueResponse)
err := c.cc.Invoke(ctx, ForgeService_CreateIssue_FullMethodName, in, out, cOpts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *forgeServiceClient) CloseIssue(ctx context.Context, in *CloseIssueRequest, opts ...grpc.CallOption) (*CloseIssueResponse, error) {
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
out := new(CloseIssueResponse)
@@ -338,6 +350,7 @@ type ForgeServiceServer interface {
AssignedIssues(context.Context, *AssignedIssuesRequest) (*AssignedIssuesResponse, error)
IssuesWithLabel(context.Context, *IssuesWithLabelRequest) (*IssuesWithLabelResponse, error)
Comment(context.Context, *CommentRequest) (*CommentResponse, error)
CreateIssue(context.Context, *CreateIssueRequest) (*CreateIssueResponse, error)
CloseIssue(context.Context, *CloseIssueRequest) (*CloseIssueResponse, error)
React(context.Context, *ReactRequest) (*ReactResponse, error)
SetStateLabel(context.Context, *SetStateLabelRequest) (*SetStateLabelResponse, error)
@@ -382,6 +395,9 @@ func (UnimplementedForgeServiceServer) IssuesWithLabel(context.Context, *IssuesW
func (UnimplementedForgeServiceServer) Comment(context.Context, *CommentRequest) (*CommentResponse, error) {
return nil, status.Error(codes.Unimplemented, "method Comment not implemented")
}
func (UnimplementedForgeServiceServer) CreateIssue(context.Context, *CreateIssueRequest) (*CreateIssueResponse, error) {
return nil, status.Error(codes.Unimplemented, "method CreateIssue not implemented")
}
func (UnimplementedForgeServiceServer) CloseIssue(context.Context, *CloseIssueRequest) (*CloseIssueResponse, error) {
return nil, status.Error(codes.Unimplemented, "method CloseIssue not implemented")
}
@@ -529,6 +545,24 @@ func _ForgeService_Comment_Handler(srv interface{}, ctx context.Context, dec fun
return interceptor(ctx, in, info, handler)
}
func _ForgeService_CreateIssue_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(CreateIssueRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(ForgeServiceServer).CreateIssue(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: ForgeService_CreateIssue_FullMethodName,
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(ForgeServiceServer).CreateIssue(ctx, req.(*CreateIssueRequest))
}
return interceptor(ctx, in, info, handler)
}
func _ForgeService_CloseIssue_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(CloseIssueRequest)
if err := dec(in); err != nil {
@@ -869,6 +903,10 @@ var ForgeService_ServiceDesc = grpc.ServiceDesc{
MethodName: "Comment",
Handler: _ForgeService_Comment_Handler,
},
{
MethodName: "CreateIssue",
Handler: _ForgeService_CreateIssue_Handler,
},
{
MethodName: "CloseIssue",
Handler: _ForgeService_CloseIssue_Handler,
File diff suppressed because it is too large. Load diff
@@ -38,6 +38,7 @@ const (
AccountService_AddPersonalToken_FullMethodName = "/state.v1.AccountService/AddPersonalToken"
AccountService_ListPersonalTokens_FullMethodName = "/state.v1.AccountService/ListPersonalTokens"
AccountService_RevokePersonalToken_FullMethodName = "/state.v1.AccountService/RevokePersonalToken"
AccountService_BindIdentityPersonalToken_FullMethodName = "/state.v1.AccountService/BindIdentityPersonalToken"
)
// AccountServiceClient is the client API for AccountService service.
@@ -65,6 +66,12 @@ type AccountServiceClient interface {
AddPersonalToken(ctx context.Context, in *AddPersonalTokenRequest, opts ...grpc.CallOption) (*AddPersonalTokenResponse, error)
ListPersonalTokens(ctx context.Context, in *ListPersonalTokensRequest, opts ...grpc.CallOption) (*ListPersonalTokensResponse, error)
RevokePersonalToken(ctx context.Context, in *RevokePersonalTokenRequest, opts ...grpc.CallOption) (*RevokePersonalTokenResponse, error)
// BindIdentityPersonalToken binds a personal token to a NAMED identity
// instead of the caller's principal, which is how a service account gets
// its bearer credential. Only non-user targets are accepted: a person's
// token comes from AddPersonalToken. The audit actor is the caller's
// principal, never a request field.
BindIdentityPersonalToken(ctx context.Context, in *BindIdentityPersonalTokenRequest, opts ...grpc.CallOption) (*BindIdentityPersonalTokenResponse, error)
}
type accountServiceClient struct {
@@ -265,6 +272,16 @@ func (c *accountServiceClient) RevokePersonalToken(ctx context.Context, in *Revo
return out, nil
}
func (c *accountServiceClient) BindIdentityPersonalToken(ctx context.Context, in *BindIdentityPersonalTokenRequest, opts ...grpc.CallOption) (*BindIdentityPersonalTokenResponse, error) {
cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
out := new(BindIdentityPersonalTokenResponse)
err := c.cc.Invoke(ctx, AccountService_BindIdentityPersonalToken_FullMethodName, in, out, cOpts...)
if err != nil {
return nil, err
}
return out, nil
}
// AccountServiceServer is the server API for AccountService service.
// All implementations must embed UnimplementedAccountServiceServer
// for forward compatibility.
@@ -290,6 +307,12 @@ type AccountServiceServer interface {
AddPersonalToken(context.Context, *AddPersonalTokenRequest) (*AddPersonalTokenResponse, error)
ListPersonalTokens(context.Context, *ListPersonalTokensRequest) (*ListPersonalTokensResponse, error)
RevokePersonalToken(context.Context, *RevokePersonalTokenRequest) (*RevokePersonalTokenResponse, error)
// BindIdentityPersonalToken binds a personal token to a NAMED identity
// instead of the caller's principal, which is how a service account gets
// its bearer credential. Only non-user targets are accepted: a person's
// token comes from AddPersonalToken. The audit actor is the caller's
// principal, never a request field.
BindIdentityPersonalToken(context.Context, *BindIdentityPersonalTokenRequest) (*BindIdentityPersonalTokenResponse, error)
mustEmbedUnimplementedAccountServiceServer()
}
@@ -357,6 +380,9 @@ func (UnimplementedAccountServiceServer) ListPersonalTokens(context.Context, *Li
func (UnimplementedAccountServiceServer) RevokePersonalToken(context.Context, *RevokePersonalTokenRequest) (*RevokePersonalTokenResponse, error) {
return nil, status.Error(codes.Unimplemented, "method RevokePersonalToken not implemented")
}
func (UnimplementedAccountServiceServer) BindIdentityPersonalToken(context.Context, *BindIdentityPersonalTokenRequest) (*BindIdentityPersonalTokenResponse, error) {
return nil, status.Error(codes.Unimplemented, "method BindIdentityPersonalToken not implemented")
}
func (UnimplementedAccountServiceServer) mustEmbedUnimplementedAccountServiceServer() {}
func (UnimplementedAccountServiceServer) testEmbeddedByValue() {}
@@ -720,6 +746,24 @@ func _AccountService_RevokePersonalToken_Handler(srv interface{}, ctx context.Co
return interceptor(ctx, in, info, handler)
}
func _AccountService_BindIdentityPersonalToken_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
in := new(BindIdentityPersonalTokenRequest)
if err := dec(in); err != nil {
return nil, err
}
if interceptor == nil {
return srv.(AccountServiceServer).BindIdentityPersonalToken(ctx, in)
}
info := &grpc.UnaryServerInfo{
Server: srv,
FullMethod: AccountService_BindIdentityPersonalToken_FullMethodName,
}
handler := func(ctx context.Context, req interface{}) (interface{}, error) {
return srv.(AccountServiceServer).BindIdentityPersonalToken(ctx, req.(*BindIdentityPersonalTokenRequest))
}
return interceptor(ctx, in, info, handler)
}
// AccountService_ServiceDesc is the grpc.ServiceDesc for AccountService service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
@@ -803,6 +847,10 @@ var AccountService_ServiceDesc = grpc.ServiceDesc{
MethodName: "RevokePersonalToken",
Handler: _AccountService_RevokePersonalToken_Handler,
},
{
MethodName: "BindIdentityPersonalToken",
Handler: _AccountService_BindIdentityPersonalToken_Handler,
},
},
Streams: []grpc.StreamDesc{},
Metadata: "state/v1/account.proto",
+59
View File
@@ -0,0 +1,59 @@
package access
import "github.com/samcharles93/archie-core/internal/domain/org"
// CanaryGrantID is the ID the canary's scoped grant is known by in the policy
// store and in denial records. A stored policy must not reuse it: the store's
// seeding and the reset command overwrite shipped IDs, and this one is
// installed by the operator from CanaryGrantPolicy's text.
const CanaryGrantID = "org-canary-grant"
// CanaryGrantForbidID is the matching forbid's ID: the grant only scopes the
// canary if everything else it could reach is forbidden, because the identity
// may also carry a role (API-created service accounts are assigned developer)
// whose shipped policy permits broadly within the org. A forbid wins within
// the level, so the pair scopes the identity regardless of its role.
const CanaryGrantForbidID = "org-canary-grant-forbid"
// canaryGrantActions is the exact action surface the canary needs, as one
// Cedar condition shared by the grant's permit and its forbid.
func canaryGrantActions() string {
return `(
(action == Archie::Action::"read" && ["dashboard", "task"].contains(resource.kind)) ||
(action == Archie::Action::"read" && resource == Archie::Object::"update-settings") ||
(action == Archie::Action::"update" && resource == Archie::Object::"update") ||
(action == Archie::Action::"manage_identities" && resource == Archie::Object::"update-settings")
)`
}
func canaryPrincipal(identityID string) string {
return `principal == Archie::Identity::"` + identityID + `"`
}
// CanaryGrantPolicy is the grant a CI canary carries instead of instance
// admin: exactly one named identity may read the dashboard's signal surface
// (chat update, alerts, logs, tasks), read and write the update-settings
// resource, and trigger an update install or deferral. Install it together
// with CanaryGrantForbidPolicy, which forbids the same identity from
// everything else. Every clause is guarded by the resource belonging to the
// principal's own org, which the engine enforces structurally anyway.
func CanaryGrantPolicy(orgID org.OrgID, identityID string) Policy {
text := `permit(principal, action, resource) when {
resource.org == principal.org &&
` + canaryPrincipal(identityID) + ` &&
` + canaryGrantActions() + `
};`
return Policy{ID: CanaryGrantID, Level: LevelOrg, OrgID: orgID, Text: text}
}
// CanaryGrantForbidPolicy forbids the canary identity from everything outside
// CanaryGrantPolicy's surface, so a role assigned to the identity (service
// accounts created through the API carry developer) cannot widen it.
func CanaryGrantForbidPolicy(orgID org.OrgID, identityID string) Policy {
text := `forbid(principal, action, resource) when {
resource.org == principal.org &&
` + canaryPrincipal(identityID) + ` &&
!` + canaryGrantActions() + `
};`
return Policy{ID: CanaryGrantForbidID, Level: LevelOrg, OrgID: orgID, Text: text}
}
+54
View File
@@ -0,0 +1,54 @@
package access
import (
"strings"
"testing"
"github.com/samcharles93/archie-core/internal/domain/org"
)
// TestCanaryGrantPolicy pins the shape of the canary grant: it names exactly
// the one identity it is built for, scoped to the org it serves, so a token
// carrying it cannot act as anyone else or reach another org.
func TestCanaryGrantPolicy(t *testing.T) {
p := CanaryGrantPolicy(org.DefaultOrgID, "canary-svc")
if err := p.Validate(); err != nil {
t.Fatalf("Validate: %v", err)
}
if p.ID != CanaryGrantID || p.Level != LevelOrg || p.OrgID != org.DefaultOrgID {
t.Fatalf("policy = %+v, want ID %q at org level in %q", p, CanaryGrantID, org.DefaultOrgID)
}
if !strings.Contains(p.Text, `principal == Archie::Identity::"canary-svc"`) {
t.Fatalf("text does not name the canary identity:\n%s", p.Text)
}
other := CanaryGrantPolicy(org.DefaultOrgID, "another")
if strings.Contains(other.Text, "canary-svc") || !strings.Contains(other.Text, `Archie::Identity::"another"`) {
t.Fatalf("grant for another identity must name that identity only:\n%s", other.Text)
}
}
// TestCanaryGrantForbidPolicy pins the forbid that keeps a role assigned to
// the canary identity from widening the grant: it names the same identity and
// negates exactly the permit's action surface.
func TestCanaryGrantForbidPolicy(t *testing.T) {
permit := CanaryGrantPolicy(org.DefaultOrgID, "canary-svc")
forbid := CanaryGrantForbidPolicy(org.DefaultOrgID, "canary-svc")
if err := forbid.Validate(); err != nil {
t.Fatalf("Validate: %v", err)
}
if forbid.ID != CanaryGrantForbidID || forbid.Level != LevelOrg || forbid.OrgID != org.DefaultOrgID {
t.Fatalf("forbid = %+v, want ID %q at org level in %q", forbid, CanaryGrantForbidID, org.DefaultOrgID)
}
if !strings.HasPrefix(forbid.Text, "forbid(") {
t.Fatalf("forbid text must be a forbid:\n%s", forbid.Text)
}
if !strings.Contains(forbid.Text, `principal == Archie::Identity::"canary-svc"`) {
t.Fatalf("forbid does not name the canary identity:\n%s", forbid.Text)
}
// The forbid must negate the permit's surface, not the permit itself.
permitBody := strings.TrimSuffix(strings.SplitN(permit.Text, "when {", 2)[1], "};")
forbidBody := strings.TrimSuffix(strings.SplitN(forbid.Text, "when {", 2)[1], "};")
if !strings.Contains(forbidBody, "!"+canaryGrantActions()) {
t.Fatalf("forbid does not negate the grant's action surface:\npermit:%s\nforbid:%s", permitBody, forbidBody)
}
}
+13 -1
View File
@@ -13,6 +13,10 @@ import (
// registry's activity surface and events.
const ActionToolCalled = "tool.called"
// ActionSummary is the Action.Type recorded for the pass's final text: the
// report a definition pass produces, kept inspectable in the activity trail.
const ActionSummary = "pass.summary"
// defaultDefinitionMaxSteps bounds the model/tool loop of one definition pass.
const defaultDefinitionMaxSteps = 10
@@ -84,7 +88,7 @@ func (e *DefinitionEngine) Pass(ctx context.Context, in PassInput) (PassResult,
return PassResult{}, err
}
actions := make([]Action, 0, len(res.ToolCalls))
actions := make([]Action, 0, len(res.ToolCalls)+1)
for _, call := range res.ToolCalls {
actions = append(actions, Action{
At: e.host.Clock.Now(),
@@ -93,6 +97,14 @@ func (e *DefinitionEngine) Pass(ctx context.Context, in PassInput) (PassResult,
Reason: in.Reason,
})
}
if summary := strings.TrimSpace(res.Text); summary != "" {
actions = append(actions, Action{
At: e.host.Clock.Now(),
Type: ActionSummary,
Detail: summary,
Reason: in.Reason,
})
}
return PassResult{Actions: actions}, nil
}
@@ -139,3 +139,31 @@ func TestInstructionOnlyRegistrarViewFiltered(t *testing.T) {
t.Error("registrar view has no clock; time is always bound")
}
}
// TestDefinitionPassRecordsSummary pins that a pass's final text is recorded
// as a pass.summary action, so a definition's report stays inspectable in the
// activity trail instead of being dropped when the model returns.
func TestDefinitionPassRecordsSummary(t *testing.T) {
llm := &fakeLLM{}
registry := NewRegistry(fullHost(llm))
engine := NewDefinitionEngine(instructionOnlyDefinition())
if err := registry.Register(engine); err != nil {
t.Fatal(err)
}
res, err := engine.Pass(t.Context(), PassInput{Reason: "test"})
if err != nil {
t.Fatalf("pass: %v", err)
}
var summary *Action
for i, a := range res.Actions {
if a.Type == ActionSummary {
summary = &res.Actions[i]
}
}
if summary == nil {
t.Fatalf("no %s action recorded; actions: %+v", ActionSummary, res.Actions)
}
if summary.Detail != "done" {
t.Errorf("summary detail = %q, want the model's final text %q", summary.Detail, "done")
}
}
+87
View File
@@ -0,0 +1,87 @@
package storecontract
import (
"context"
"time"
"github.com/samcharles93/archie-core/internal/domain/binding"
"github.com/samcharles93/archie-core/internal/domain/workflow/task"
)
// BindingStore persists bindings and their draft -> pending_approval ->
// armed states.
type BindingStore interface {
InsertBinding(ctx context.Context, b binding.Binding) (string, error)
GetBinding(ctx context.Context, id string) (*binding.Binding, error)
ListBindings(ctx context.Context) ([]binding.Binding, error)
UpdateBinding(ctx context.Context, b binding.Binding) error
DeleteBinding(ctx context.Context, id string) error
ApproveBinding(ctx context.Context, id string) error
PauseBinding(ctx context.Context, id string) error
ResumeBinding(ctx context.Context, id string) error
}
// DispatchLedger reads the binding dispatch ledger.
type DispatchLedger interface {
// ListDispatches returns the newest ledger rows matching filter.
ListDispatches(ctx context.Context, filter DispatchFilter) ([]Dispatch, error)
}
// Dispatch is one binding/capture ledger row: the task it started, or the
// reason it started none.
type Dispatch struct {
BindingID string `json:"binding_id"`
BindingVersion int64 `json:"binding_version"`
CaptureID string `json:"capture_id"`
TaskID int64 `json:"task_id,omitempty"`
Reason string `json:"reason,omitempty"`
DispatchedAt time.Time `json:"dispatched_at"`
}
// DispatchFilter narrows ListDispatches; empty fields match any row.
type DispatchFilter struct {
BindingID string
CaptureID string
TaskID int64
Limit int
}
// BindingDispatcher looks up armed bindings, lists undispatched captures and
// records dispatches.
type BindingDispatcher interface {
ArmedBindingsForSource(ctx context.Context, source string) ([]binding.Binding, error)
RecordDispatch(
ctx context.Context,
bindingID string,
bindingVersion int64,
captureID string,
// taskID addresses the SQLite-owned task tables, which are not
// migrating: it stays an integer on purpose. A dispatch that starts
// a task is recorded by EnqueueBindingTask instead.
taskID int64,
// reason is empty for a dispatch and names the terminal outcome of
// an evaluation that started no task.
reason string,
) error
ListUndispatchedCaptures(ctx context.Context, bindings []string, limit int) ([]CapturedEvent, error)
}
// BindingTaskCreator is the single-method consumer-facing surface for
// enqueueing a task triggered by a binding. Splitting it off TaskLifecycle
// keeps the lifecycle surface narrow (8 methods, the interfacebloat limit)
// and keeps the binding-specific shape on the binding interfaces.
type BindingTaskCreator interface {
// EnqueueBindingTask claims the binding's dispatch of captureID in the
// ledger, enqueues the task and records its provenance as one unit: an
// error leaves none of them, and a delivery already dispatched for the
// binding returns ErrAlreadyDispatched.
EnqueueBindingTask(ctx context.Context, owner, repo, title, body, wf, identity, bindingID string, bindingVersion int, captureID string, inputs map[string]any) (*task.Task, error)
}
// PlaybookDispatcher records a playbook action dispatch before its side
// effect runs, returning ErrAlreadyDispatched for a duplicate.
// DeletePlaybookDispatches deletes one playbook's records.
type PlaybookDispatcher interface {
RecordPlaybookDispatch(ctx context.Context, playbookID, playbookVersion, eventID, actionID string) error
DeletePlaybookDispatches(ctx context.Context, playbookID string) error
}
+73
View File
@@ -0,0 +1,73 @@
package storecontract
import (
"context"
"time"
"github.com/samcharles93/archie-core/internal/domain/eventtype"
)
// CaptureStore persists inbound webhook captures.
type CaptureStore interface {
InsertCapture(ctx context.Context, c CapturedEvent, retention time.Duration, maxEvents int) (string, error)
ListCaptures(ctx context.Context, limit int) ([]CapturedEvent, error)
}
// CaptureRefusalStore counts the events network rules refused, per source.
type CaptureRefusalStore interface {
RecordCaptureRefusal(ctx context.Context, source, addr string, at time.Time) error
CaptureRefusals(ctx context.Context, since time.Time) ([]CaptureRefusals, error)
}
// CaptureRefusals is one source's refusals and accepted captures since a
// time, and the addresses it refused.
type CaptureRefusals struct {
Source string `json:"source"`
Refused int64 `json:"refused"`
Accepted int64 `json:"accepted"`
Addrs []string `json:"addrs"`
}
// EventTypeStore persists event types. Insert and Update refuse a type whose
// rule overlaps another on the same source with eventtype.ErrOverlap, and a
// malformed one with eventtype.ErrInvalid. Update rewrites the name and rule;
// the schema is the one the type was created with.
type EventTypeStore interface {
InsertEventType(ctx context.Context, t eventtype.EventType) (string, error)
UpdateEventType(ctx context.Context, t eventtype.EventType) error
DeleteEventType(ctx context.Context, id string) error
ListEventTypes(ctx context.Context) ([]eventtype.EventType, error)
}
// CapturedEvent is one unbound inbound webhook capture: no workflow binding,
// no forge/task association -- just what arrived, from where, and when.
type CapturedEvent struct {
ID string `json:"id"`
ReceivedAt time.Time `json:"received_at"`
Source string `json:"source"`
RemoteAddr string `json:"remote_addr"`
ContentType string `json:"content_type"`
// Headers and Body are redacted (webhookguard.RedactPayload) before
// they ever reach InsertCapture; the store persists what it is given.
Headers string `json:"headers"`
Body string `json:"body"`
Authenticated bool `json:"authenticated"`
// EventType is the ID of the event type the capture was identified as
// when it arrived, or empty when it matched none. An unidentified capture
// is never dispatched.
EventType string `json:"event_type"`
// Unsigned marks an event that arrived on an approved unsigned source.
// It dispatches without Authenticated and is flagged wherever it shows.
Unsigned bool `json:"unsigned"`
// Delivery names the sender's delivery; a retry of one delivery shares
// it, so a binding dispatches each delivery once. Intake sets it from the
// source's delivery header; the store fills the capture ID when empty.
Delivery string `json:"delivery"`
// OrgID is honoured only for a schedule-fired capture, whose source is
// reserved and so names no org; every other capture takes its source's.
OrgID string `json:"org_id,omitempty"`
}
// Dispatchable reports whether a binding may start a task from this event:
// a valid signature, or a source approved to take unsigned events.
func (c CapturedEvent) Dispatchable() bool { return c.Authenticated || c.Unsigned }
@@ -0,0 +1,25 @@
package storecontract
import (
"context"
"time"
"github.com/samcharles93/archie-core/internal/domain/harnesssecret"
)
// HarnessSecretStore stores one org's OAuth token set per credential binding
// service, encrypted at rest.
type HarnessSecretStore interface {
GetHarnessSecret(ctx context.Context, org, service string) (harnesssecret.Secret, error)
PutHarnessSecret(ctx context.Context, s harnesssecret.Secret) error
}
// RunCredentialStore keeps run credentials by digest: the SHA-256 of the
// token a task's container presents. A lookup of an unknown or expired
// digest reports ErrRunCredentialUnknown.
type RunCredentialStore interface {
PutRunCredential(ctx context.Context, digest [32]byte, taskID int64, expires time.Time) error
DeleteRunCredential(ctx context.Context, digest [32]byte) error
RunCredentialTask(ctx context.Context, digest [32]byte, now time.Time) (int64, error)
DeleteExpiredRunCredentials(ctx context.Context, now time.Time) error
}
+90
View File
@@ -0,0 +1,90 @@
package storecontract
import (
"errors"
)
// Sentinel errors, part of the wire contract: staterpc's
// mapError/unmapError match these by (code, canonical message) across the
// gRPC boundary, so their message strings are load-bearing and must never
// change.
var (
// ErrStaleTransition is returned when a task transition's expected
// from status does not match the task's current status.
ErrStaleTransition = errors.New("store: stale transition: task status does not match expected from status")
// ErrIllegalTransition is returned when the transition table does not allow
// the status pair.
ErrIllegalTransition = errors.New("store: illegal transition: status pair is not in the transition table")
// ErrInvalidStep is returned when a step-execution request names a kind the
// store does not record or a step whose identifying fields do not resolve.
// Distinct from the transition sentinels, which cover a row's state.
ErrInvalidStep = errors.New("store: invalid step execution request")
// ErrResumeIncomplete is returned when a retry resumes after a stage whose
// last run did not complete, so there are no results to start from.
ErrResumeIncomplete = errors.New("store: the step before the resume point did not complete in its last run")
// ErrBindingNotFound is returned when a binding ID does not exist.
ErrBindingNotFound = errors.New("store: binding not found")
// ErrBindingOverlap is returned when a binding's matcher overlaps an
// existing binding for the same source.
ErrBindingOverlap = errors.New("store: binding overlaps existing binding for source")
// ErrBindingTransition is returned when a binding state transition is
// rejected by the draft -> pending_approval -> armed machine.
ErrBindingTransition = errors.New("store: binding state transition rejected")
// ErrAlreadyDispatched is returned when a dispatch ledger already holds the
// key.
ErrAlreadyDispatched = errors.New("store: binding already dispatched for capture")
// ErrCallNotYours is returned when a workflow.call status read names a
// task that is not a callee of the calling task, or the caller itself
// does not exist: a caller reads only the tasks it started
ErrCallNotYours = errors.New("store: task is not a callee of the calling task")
// ErrCallCallerNotRunning is returned when a workflow.call enqueue names
// a caller that is not running: a stale retry, or a bug in the caller.
ErrCallCallerNotRunning = errors.New("store: workflow.call caller is not running")
// ErrCallDepthExceeded is returned when a workflow.call enqueue would
// pass workflow.MaxCallDepth. The engine refuses the same call first;
// the store re-checks because it owns the table.
ErrCallDepthExceeded = errors.New("store: workflow.call would pass the depth limit")
// ErrMappingNotFound is returned when a mapping ID does not exist.
ErrMappingNotFound = errors.New("store: mapping not found")
// ErrEventTypeNotFound is returned when an event type ID does not exist.
ErrEventTypeNotFound = errors.New("store: event type not found")
// ErrSourceNotFound is returned when a source path does not exist.
ErrSourceNotFound = errors.New("store: source not found")
// ErrSourceInUse is returned when deleting a source an armed binding
// fires on.
ErrSourceInUse = errors.New("store: source has an armed binding")
// ErrSourcePathTaken is returned when a new source's path is in use.
ErrSourcePathTaken = errors.New("store: source path already taken")
// ErrSourceSigningStale is returned when a signing write's expected
// from state does not match the stored one.
ErrSourceSigningStale = errors.New("store: source signing does not match expected state")
// ErrHarnessSecretNotFound is returned when no OAuth token set is
// stored for an org/service pair -- the setup terminal has not
// captured one yet.
ErrHarnessSecretNotFound = errors.New("store: harness secret not found")
// ErrRereviewCapReached is returned when a review gate re-review would
// round past prreview.MaxRereviewRounds. The task stays waiting and its
// gate row is unchanged. The dashboard answers it 409, like every other
// conflict.
ErrRereviewCapReached = errors.New("store: re-review cap reached")
// ErrResourceNotFound is returned when a control-plane resource kind has
// no stored document. It is in-process only (not on the gRPC wire): the
// control plane runs in the daemon against the local store.
ErrResourceNotFound = errors.New("resource not found")
// ErrResourceVersionConflict is returned when a resource write carries an
// expected version that does not match the stored revision.
ErrResourceVersionConflict = errors.New("resource version conflict")
)
// ErrUnavailable means the store could not serve a request now: it is
// restarting or unreachable. It is not paired with a canonical message the way
// the sentinels above are -- staterpc derives it from the Unavailable code
// alone, whose text varies by transport -- and it is the one store error a
// caller with budget may answer by retrying rather than by failing its own
// work. The wrapping keeps the gRPC status code readable through the chain.
var ErrUnavailable = errors.New("store: state store unavailable")
// ErrRunCredentialUnknown is a run credential that was never issued, was
// revoked, or has expired.
var ErrRunCredentialUnknown = errors.New("run credential unknown or expired")
+26
View File
@@ -0,0 +1,26 @@
package storecontract
import (
"context"
"github.com/samcharles93/archie-core/internal/domain/mapping"
)
// MappingStore persists payload field mappings. Deliberately separate from
// TaskStore and CaptureStore for the same reason those are split: the
// dashboard's mapping editor should only acquire the mapping surface, not the
// full task or capture APIs. See
type MappingStore interface {
InsertMapping(ctx context.Context, m mapping.Mapping) (string, error)
GetMapping(ctx context.Context, id string) (*mapping.Mapping, error)
ListMappings(ctx context.Context) ([]mapping.Mapping, error)
UpdateMapping(ctx context.Context, m mapping.Mapping) error
DeleteMapping(ctx context.Context, id string) error
}
// MappingMatchRecorder counts the events each mapping resolved, which the
// store reports as Mapping.MatchCount and LastMatchedAt. Recording the same
// (mapping, capture) twice counts once.
type MappingMatchRecorder interface {
RecordMappingMatch(ctx context.Context, mappingID, captureID string) error
}
+50
View File
@@ -0,0 +1,50 @@
package storecontract
import (
"time"
)
// Resource is one control-plane resource document: the stored value for an
// org's kind, its revision, and the audit record written with the last write.
// Resource and ResourceWrite live here so the UI-side consumers can reference
// them without linking the PostgreSQL implementation.
type Resource struct {
OrgID string
Kind string
Value []byte
Version int64
Actor string
Source string
RequestID string
ExpectedVersion int64
CurrentVersion int64
At time.Time
}
// DefaultOrgID is the org every resource written before orgs existed belongs
// to, and the org a request that names none acts in.
const DefaultOrgID = "org-sys"
// ResourceAuditKey is the sys_audit record key of one org's resource kind. The
// default org keeps the bare kind, so audit rows written before resources were
// per-org still resolve.
func ResourceAuditKey(orgID, kind string) string {
if orgID == DefaultOrgID {
return kind
}
return orgID + "/" + kind
}
// ResourceWrite is a control-plane resource write request. ExpectedVersion is
// the optimistic-concurrency guard: a write whose expectation does not match
// the stored revision is refused with ErrResourceVersionConflict.
type ResourceWrite struct {
OrgID string
Kind string
Value []byte
Actor string
Source string
RequestID string
ExpectedVersion int64
At time.Time
}
+23
View File
@@ -0,0 +1,23 @@
package storecontract
import (
"context"
"github.com/samcharles93/archie-core/internal/domain/source"
)
// SourceStore persists capture sources keyed by path. Secrets are encrypted
// at rest; signing transitions use an expected-from guard.
type SourceStore interface {
InsertSource(ctx context.Context, s source.Source) error
// GetSource returns (nil, nil) for an unknown path.
GetSource(ctx context.Context, path string) (*source.Source, error)
ListSources(ctx context.Context) ([]source.Source, error)
SetSourceSigning(ctx context.Context, path string, from, to source.Signing) error
SetSourceSecret(ctx context.Context, path, secret string) error
SetSourceName(ctx context.Context, path, name string) error
SetSourceDeliveryHeader(ctx context.Context, path, header string) error
// DeleteSource refuses with ErrSourceInUse while an armed binding fires
// on the source.
DeleteSource(ctx context.Context, path string) error
}
+87
View File
@@ -0,0 +1,87 @@
package storecontract
import (
"context"
"time"
"github.com/samcharles93/archie-core/internal/domain/health"
)
// ConfigSnapshotStore holds the published configuration view.
type ConfigSnapshotStore interface {
PutConfigSnapshot(ctx context.Context, snapshot ConfigSnapshot) error
ConfigSnapshot(ctx context.Context) (ConfigSnapshot, bool, error)
}
// ChannelStatusStore holds channel runtime state published by the process
// hosting the channels.
type ChannelStatusStore interface {
// PutChannelStatus records the reporting process's whole set: a channel it no
// longer reports is removed rather than left behind, because a stale "running"
// row is a lie the dashboard would show indefinitely.
PutChannelStatus(ctx context.Context, channels []ChannelStatus) error
ChannelStatus(ctx context.Context) ([]ChannelStatus, error)
}
// ApplyStatusStore holds which version of each control-plane resource each
// process is running. Same split as ConfigSnapshotStore and for the same
// reason: the writers are the processes that apply a resource, the reader is
// the UI, and a task-scoped credential must reach neither.
type ApplyStatusStore interface {
PutApplyStatus(ctx context.Context, status ApplyStatus) error
ListApplyStatus(ctx context.Context) ([]ApplyStatus, error)
}
// PresenceStore holds one record per running service instance. Writers are
// the services themselves; readers are the UI and archied status.
type PresenceStore interface {
PutPresence(ctx context.Context, presence Presence) error
ListPresence(ctx context.Context) ([]Presence, error)
}
// ConfigSnapshot is the published, secret-free configuration view. Schema
// names Document's shape.
type ConfigSnapshot struct {
Schema string
Document []byte
PublishedAt time.Time
}
// ChannelStatus is one channel's runtime state as the process hosting it
// reports it. ReloadSupported is a capability declaration rather than a request:
// asking for a reload travels on its own surface, because a transient request and
// a durable state do not share a lifetime.
type ChannelStatus struct {
ID string
Name string
State string
Detail string
Configured bool
ReloadSupported bool
ObservedAt time.Time
}
// ApplyStatus is one process's report on one resource kind. On error,
// AppliedVersion stays at the last applied version. ReportedAt is
// re-stamped periodically.
type ApplyStatus struct {
Process string `json:"process"`
Kind string `json:"kind"`
AppliedVersion int64 `json:"applied_version"`
Error string `json:"error,omitempty"`
ReportedAt time.Time `json:"reported_at"`
}
// Presence is one running service instance. Ready and Detail summarise its
// readiness probes; Detail names the degraded ones.
type Presence struct {
Checks []health.Component `json:"checks"`
Service string `json:"service"`
InstanceID string `json:"instance_id"`
Version string `json:"version"`
InstallType string `json:"install_type"`
StartedAt time.Time `json:"started_at"`
ReportedAt time.Time `json:"reported_at"`
Ready bool `json:"ready"`
Detail string `json:"detail,omitempty"`
}
@@ -2,23 +2,6 @@
// without an implementation.
package storecontract
import (
"context"
"errors"
"io"
"time"
"github.com/samcharles93/archie-core/internal/domain/binding"
"github.com/samcharles93/archie-core/internal/domain/eventtype"
"github.com/samcharles93/archie-core/internal/domain/harnesssecret"
"github.com/samcharles93/archie-core/internal/domain/health"
"github.com/samcharles93/archie-core/internal/domain/mapping"
"github.com/samcharles93/archie-core/internal/domain/source"
"github.com/samcharles93/archie-core/internal/domain/workflow/task"
"github.com/samcharles93/archie-core/internal/events"
"github.com/samcharles93/archie-core/internal/logging"
)
// TaskStore is the full store surface the daemon needs.
// Consumers depend on TaskStore, never on a concrete type.
type TaskStore interface {
@@ -31,594 +14,3 @@ type TaskStore interface {
ReviewGateResponder
RemediationStarter
}
// TaskLifecycle manages the core task state machine and enqueuing.
// Binding-triggered task creation lives on BindingTaskCreator, not here,
// so the lifecycle surface stays narrow and non-binding consumers (forge
// poll, chat spawn, drain loop) do not acquire a binding-specific shape.
type TaskLifecycle interface {
EnqueueIssue(ctx context.Context, owner, repo string, number int, title, body, labels, identity string) (bool, error)
EnqueueChatTask(ctx context.Context, owner, repo, title, body, wf, identity, origin, draft string, inputs map[string]any) (*task.Task, error)
ClaimNext(ctx context.Context) (*task.Task, error)
ClaimByIssue(ctx context.Context, owner, repo string, number int) (*task.Task, error)
Transition(ctx context.Context, taskID int64, from, to, detail string) error
Update(ctx context.Context, t *task.Task) error
Requeue(ctx context.Context, taskID int64, fromStatus, workflow string) error
RecoverStale(ctx context.Context) (int64, error)
}
// TaskParker parks a task with a park class and the blocker the park site
// knows, if any. Unknown classes become needs_decision.
type TaskParker interface {
ParkTask(ctx context.Context, taskID int64, from, detail, class, blocker string) error
}
// StepRecorder records a running execution's steps.
type StepRecorder interface {
StartStep(ctx context.Context, s task.StepStart) (int64, events.Event, error)
FinishStep(ctx context.Context, s task.StepFinish) (events.Event, error)
}
// ExecutionCanceller cancels an execution and its current attempt's open
// steps in one transaction. It also cancels the callees the execution was
// waiting on, and returns their ids (nested callees included) so the caller
// can stop their runs too.
type ExecutionCanceller interface {
CancelExecution(ctx context.Context, taskID int64, reason, to string) ([]int64, error)
}
// StepReader lists one execution's recorded steps.
type StepReader interface {
ListSteps(ctx context.Context, executionID int64, attempt int) ([]task.StepExecution, error)
}
// HarnessSecretStore stores one org's OAuth token set per credential binding
// service, encrypted at rest.
type HarnessSecretStore interface {
GetHarnessSecret(ctx context.Context, org, service string) (harnesssecret.Secret, error)
PutHarnessSecret(ctx context.Context, s harnesssecret.Secret) error
}
// TaskArchiver removes one terminal task's local record with an optimistic
// status guard. It is separate from the already broad lifecycle contract so
// consumers that only run tasks do not acquire an operator-only capability.
type TaskArchiver interface {
OutcomePoster
ArchiveTask(ctx context.Context, taskID int64, fromStatus string, audit events.Event) (eventID int64, err error)
ClearTerminalTasks(ctx context.Context) (int64, error)
}
// TaskRetryer atomically requeues recoverable work and accounts for the new
// attempt so a partial write cannot evade the retry cap. retryMode is the
// operator's worktree choice for the next dispatch (taskstate.RetryMode),
// persisted on the row so the daemon reads it instead of inferring it. resume
// is where the attempt starts; a resume whose After stage did not complete in
// its last run is refused with ErrResumeIncomplete.
type TaskRetryer interface {
RetryTask(ctx context.Context, taskID int64, fromStatus, workflow, retryMode string, resume task.Resume, currentDefinition bool) error
}
// ReviewGateResponder records the operator's review-gate answer. A re-review
// increments rereview_rounds and requeues; one past the cap returns
// ErrRereviewCapReached and writes nothing.
type ReviewGateResponder interface {
RespondReviewGate(ctx context.Context, taskID int64, fromStatus, gate string, rereview bool, maxRounds int) error
}
// RemediationStarter queues a review-triggered remediation for an Archie-owned
// open-PR task: one guarded transition that carries the JSON-encoded review
// unit in the same write, so a claimed remediation always has its input. Runs
// for one task are serialised, so a distinct review that arrives while a
// remediation owns the task is queued behind it and remediated once that run
// finishes; a re-delivered unit is absorbed, not queued twice.
// UpdateReviewPayload merges late-arriving comments into the unclaimed unit
// for the same review, active or queued behind a running remediation.
type RemediationStarter interface {
BeginRemediation(ctx context.Context, taskID int64, payload string) error
UpdateReviewPayload(ctx context.Context, taskID int64, payload string) error
// SetReviewCursors persists the poll backstop's per-task review and
// comment high-water marks (pr-review-remediation.md decision 2). The
// pr_open guard is part of the contract: cursors only move while no
// remediation run owns the task.
SetReviewCursors(ctx context.Context, taskID, reviewCursor, commentCursor int64) error
}
// OutcomePoster tracks which finished chat tasks have reported back to their
// conversation.
type OutcomePoster interface {
// UnpostedOutcomes returns finished chat tasks whose outcome has not been
// posted to the conversation that created them.
UnpostedOutcomes(ctx context.Context) ([]*task.Task, error)
// MarkOutcomePosted records that the task's state at status was posted.
MarkOutcomePosted(ctx context.Context, taskID int64, status string) error
}
// TaskQueries groups read-only task accessors.
type TaskQueries interface {
TaskByIssue(ctx context.Context, owner, repo string, number int) (*task.Task, error)
OpenTaskByPR(ctx context.Context, owner, repo string, number int) (*task.Task, error)
TaskByID(ctx context.Context, taskID int64) (*task.Task, error)
OpenPRs(ctx context.Context) ([]task.Task, error)
// ActiveTasksByOrigin returns the queued and running tasks the
// conversation origin created, for its /stop.
ActiveTasksByOrigin(ctx context.Context, origin string) ([]*task.Task, error)
// Tasks returns the most recently updated tasks.
Tasks(ctx context.Context, limit int) ([]task.Task, error)
// TasksPage returns one page of tasks, most recently updated first.
TasksPage(ctx context.Context, page TaskPage) ([]task.Task, error)
StatusCounts(ctx context.Context) (map[string]int, error)
}
// TaskEvents groups observability and lifecycle methods.
type TaskEvents interface {
InsertEvent(ctx context.Context, e events.Event) (int64, error)
EventsSince(ctx context.Context, cursor string, limit int) ([]events.Event, error)
// TaskEvents returns a task's timeline, without agent transcripts.
TaskEvents(ctx context.Context, taskID int64) ([]events.Event, error)
// TaskTranscript returns one attempt's agent transcript entries in order.
TaskTranscript(ctx context.Context, taskID int64, attempt int) ([]events.Event, error)
WorkflowStats(ctx context.Context) ([]WorkflowStat, error)
StageStats(ctx context.Context) ([]StageStat, error)
TokensByDay(ctx context.Context, days int) ([]DayTokens, error)
Close() error
}
// CaptureStore persists inbound webhook captures.
type CaptureStore interface {
InsertCapture(ctx context.Context, c CapturedEvent, retention time.Duration, maxEvents int) (string, error)
ListCaptures(ctx context.Context, limit int) ([]CapturedEvent, error)
}
// CaptureRefusalStore counts the events network rules refused, per source.
type CaptureRefusalStore interface {
RecordCaptureRefusal(ctx context.Context, source, addr string, at time.Time) error
CaptureRefusals(ctx context.Context, since time.Time) ([]CaptureRefusals, error)
}
// CaptureRefusals is one source's refusals and accepted captures since a
// time, and the addresses it refused.
type CaptureRefusals struct {
Source string `json:"source"`
Refused int64 `json:"refused"`
Accepted int64 `json:"accepted"`
Addrs []string `json:"addrs"`
}
// ConfigSnapshotStore holds the published configuration view.
type ConfigSnapshotStore interface {
PutConfigSnapshot(ctx context.Context, snapshot ConfigSnapshot) error
ConfigSnapshot(ctx context.Context) (ConfigSnapshot, bool, error)
}
// ChannelStatusStore holds channel runtime state published by the process
// hosting the channels.
type ChannelStatusStore interface {
// PutChannelStatus records the reporting process's whole set: a channel it no
// longer reports is removed rather than left behind, because a stale "running"
// row is a lie the dashboard would show indefinitely.
PutChannelStatus(ctx context.Context, channels []ChannelStatus) error
ChannelStatus(ctx context.Context) ([]ChannelStatus, error)
}
// ApplyStatusStore holds which version of each control-plane resource each
// process is running. Same split as ConfigSnapshotStore and for the same
// reason: the writers are the processes that apply a resource, the reader is
// the UI, and a task-scoped credential must reach neither.
type ApplyStatusStore interface {
PutApplyStatus(ctx context.Context, status ApplyStatus) error
ListApplyStatus(ctx context.Context) ([]ApplyStatus, error)
}
// PresenceStore holds one record per running service instance. Writers are
// the services themselves; readers are the UI and archied status.
type PresenceStore interface {
PutPresence(ctx context.Context, presence Presence) error
ListPresence(ctx context.Context) ([]Presence, error)
}
// MappingStore persists payload field mappings. Deliberately separate from
// TaskStore and CaptureStore for the same reason those are split: the
// dashboard's mapping editor should only acquire the mapping surface, not the
// full task or capture APIs. See
type MappingStore interface {
InsertMapping(ctx context.Context, m mapping.Mapping) (string, error)
GetMapping(ctx context.Context, id string) (*mapping.Mapping, error)
ListMappings(ctx context.Context) ([]mapping.Mapping, error)
UpdateMapping(ctx context.Context, m mapping.Mapping) error
DeleteMapping(ctx context.Context, id string) error
}
// MappingMatchRecorder counts the events each mapping resolved, which the
// store reports as Mapping.MatchCount and LastMatchedAt. Recording the same
// (mapping, capture) twice counts once.
type MappingMatchRecorder interface {
RecordMappingMatch(ctx context.Context, mappingID, captureID string) error
}
// EventTypeStore persists event types. Insert and Update refuse a type whose
// rule overlaps another on the same source with eventtype.ErrOverlap, and a
// malformed one with eventtype.ErrInvalid. Update rewrites the name and rule;
// the schema is the one the type was created with.
type EventTypeStore interface {
InsertEventType(ctx context.Context, t eventtype.EventType) (string, error)
UpdateEventType(ctx context.Context, t eventtype.EventType) error
DeleteEventType(ctx context.Context, id string) error
ListEventTypes(ctx context.Context) ([]eventtype.EventType, error)
}
// BindingStore persists bindings and their draft -> pending_approval ->
// armed states.
type BindingStore interface {
InsertBinding(ctx context.Context, b binding.Binding) (string, error)
GetBinding(ctx context.Context, id string) (*binding.Binding, error)
ListBindings(ctx context.Context) ([]binding.Binding, error)
UpdateBinding(ctx context.Context, b binding.Binding) error
DeleteBinding(ctx context.Context, id string) error
ApproveBinding(ctx context.Context, id string) error
PauseBinding(ctx context.Context, id string) error
ResumeBinding(ctx context.Context, id string) error
}
// SourceStore persists capture sources keyed by path. Secrets are encrypted
// at rest; signing transitions use an expected-from guard.
type SourceStore interface {
InsertSource(ctx context.Context, s source.Source) error
// GetSource returns (nil, nil) for an unknown path.
GetSource(ctx context.Context, path string) (*source.Source, error)
ListSources(ctx context.Context) ([]source.Source, error)
SetSourceSigning(ctx context.Context, path string, from, to source.Signing) error
SetSourceSecret(ctx context.Context, path, secret string) error
SetSourceName(ctx context.Context, path, name string) error
SetSourceDeliveryHeader(ctx context.Context, path, header string) error
// DeleteSource refuses with ErrSourceInUse while an armed binding fires
// on the source.
DeleteSource(ctx context.Context, path string) error
}
// DispatchLedger reads the binding dispatch ledger.
type DispatchLedger interface {
// ListDispatches returns the newest ledger rows matching filter.
ListDispatches(ctx context.Context, filter DispatchFilter) ([]Dispatch, error)
}
// TaskPage selects one page of the task list. Empty Statuses matches every
// status. A zero After starts at the newest task; otherwise the page begins
// after the task it names, in (updated_at, id) descending order.
type TaskPage struct {
Statuses []string
// Workflow, when set, keeps only that workflow's tasks.
Workflow string
After TaskCursor
Limit int
}
// TaskCursor is the position of the last task a page returned.
type TaskCursor struct {
UpdatedAt time.Time
ID int64
}
// Dispatch is one binding/capture ledger row: the task it started, or the
// reason it started none.
type Dispatch struct {
BindingID string `json:"binding_id"`
BindingVersion int64 `json:"binding_version"`
CaptureID string `json:"capture_id"`
TaskID int64 `json:"task_id,omitempty"`
Reason string `json:"reason,omitempty"`
DispatchedAt time.Time `json:"dispatched_at"`
}
// DispatchFilter narrows ListDispatches; empty fields match any row.
type DispatchFilter struct {
BindingID string
CaptureID string
TaskID int64
Limit int
}
// BindingDispatcher looks up armed bindings, lists undispatched captures and
// records dispatches.
type BindingDispatcher interface {
ArmedBindingsForSource(ctx context.Context, source string) ([]binding.Binding, error)
RecordDispatch(
ctx context.Context,
bindingID string,
bindingVersion int64,
captureID string,
// taskID addresses the SQLite-owned task tables, which are not
// migrating: it stays an integer on purpose. A dispatch that starts
// a task is recorded by EnqueueBindingTask instead.
taskID int64,
// reason is empty for a dispatch and names the terminal outcome of
// an evaluation that started no task.
reason string,
) error
ListUndispatchedCaptures(ctx context.Context, bindings []string, limit int) ([]CapturedEvent, error)
}
// BindingTaskCreator is the single-method consumer-facing surface for
// enqueueing a task triggered by a binding. Splitting it off TaskLifecycle
// keeps the lifecycle surface narrow (8 methods, the interfacebloat limit)
// and keeps the binding-specific shape on the binding interfaces.
type BindingTaskCreator interface {
// EnqueueBindingTask claims the binding's dispatch of captureID in the
// ledger, enqueues the task and records its provenance as one unit: an
// error leaves none of them, and a delivery already dispatched for the
// binding returns ErrAlreadyDispatched.
EnqueueBindingTask(ctx context.Context, owner, repo, title, body, wf, identity, bindingID string, bindingVersion int, captureID string, inputs map[string]any) (*task.Task, error)
}
// WorkflowCaller starts a workflow.call callee and reads it back.
type WorkflowCaller = task.Caller
// PlaybookDispatcher records a playbook action dispatch before its side
// effect runs, returning ErrAlreadyDispatched for a duplicate.
// DeletePlaybookDispatches deletes one playbook's records.
type PlaybookDispatcher interface {
RecordPlaybookDispatch(ctx context.Context, playbookID, playbookVersion, eventID, actionID string) error
DeletePlaybookDispatches(ctx context.Context, playbookID string) error
}
// TaskLogStore reads one task attempt's log. Found=false means no log;
// ErrTaskLogsUnavailable means this process cannot read logs.
type TaskLogStore interface {
// TaskLog returns a page of one attempt's decoded log. attempt 0 selects
// the task's current attempt.
TaskLog(ctx context.Context, taskID int64, attempt int, q logging.Query) (logging.TaskLogPage, error)
// TaskLogContent writes one attempt's log verbatim to w, for a download.
// found is false, with a nil error, when the attempt has no log file.
TaskLogContent(ctx context.Context, taskID int64, attempt int, w io.Writer) (found bool, err error)
}
// CapturedEvent is one unbound inbound webhook capture: no workflow binding,
// no forge/task association -- just what arrived, from where, and when.
type CapturedEvent struct {
ID string `json:"id"`
ReceivedAt time.Time `json:"received_at"`
Source string `json:"source"`
RemoteAddr string `json:"remote_addr"`
ContentType string `json:"content_type"`
// Headers and Body are redacted (webhookguard.RedactPayload) before
// they ever reach InsertCapture; the store persists what it is given.
Headers string `json:"headers"`
Body string `json:"body"`
Authenticated bool `json:"authenticated"`
// EventType is the ID of the event type the capture was identified as
// when it arrived, or empty when it matched none. An unidentified capture
// is never dispatched.
EventType string `json:"event_type"`
// Unsigned marks an event that arrived on an approved unsigned source.
// It dispatches without Authenticated and is flagged wherever it shows.
Unsigned bool `json:"unsigned"`
// Delivery names the sender's delivery; a retry of one delivery shares
// it, so a binding dispatches each delivery once. Intake sets it from the
// source's delivery header; the store fills the capture ID when empty.
Delivery string `json:"delivery"`
// OrgID is honoured only for a schedule-fired capture, whose source is
// reserved and so names no org; every other capture takes its source's.
OrgID string `json:"org_id,omitempty"`
}
// Dispatchable reports whether a binding may start a task from this event:
// a valid signature, or a source approved to take unsigned events.
func (c CapturedEvent) Dispatchable() bool { return c.Authenticated || c.Unsigned }
// ConfigSnapshot is the published, secret-free configuration view. Schema
// names Document's shape.
type ConfigSnapshot struct {
Schema string
Document []byte
PublishedAt time.Time
}
// ChannelStatus is one channel's runtime state as the process hosting it
// reports it. ReloadSupported is a capability declaration rather than a request:
// asking for a reload travels on its own surface, because a transient request and
// a durable state do not share a lifetime.
type ChannelStatus struct {
ID string
Name string
State string
Detail string
Configured bool
ReloadSupported bool
ObservedAt time.Time
}
// ApplyStatus is one process's report on one resource kind. On error,
// AppliedVersion stays at the last applied version. ReportedAt is
// re-stamped periodically.
type ApplyStatus struct {
Process string `json:"process"`
Kind string `json:"kind"`
AppliedVersion int64 `json:"applied_version"`
Error string `json:"error,omitempty"`
ReportedAt time.Time `json:"reported_at"`
}
// Presence is one running service instance. Ready and Detail summarise its
// readiness probes; Detail names the degraded ones.
type Presence struct {
Checks []health.Component `json:"checks"`
Service string `json:"service"`
InstanceID string `json:"instance_id"`
Version string `json:"version"`
InstallType string `json:"install_type"`
StartedAt time.Time `json:"started_at"`
ReportedAt time.Time `json:"reported_at"`
Ready bool `json:"ready"`
Detail string `json:"detail,omitempty"`
}
// WorkflowStat is one row of the per-workflow metrics table.
type WorkflowStat struct {
Workflow string `json:"workflow"`
Runs int `json:"runs"`
Merged int `json:"merged"`
Completed int `json:"completed"`
PROpen int `json:"pr_open"`
Parked int `json:"parked"`
AvgTokens int `json:"avg_tokens"`
AvgSteps float64 `json:"avg_steps"`
TotalToken int `json:"total_tokens"`
// Running and LastStatus describe the workflow now: how many of its runs
// are working, and how its newest one ended.
Running int `json:"running"`
LastStatus string `json:"last_status"`
}
// StageStat is average stage duration and failure counts per stage.
type StageStat struct {
Workflow string `json:"workflow"`
Stage string `json:"stage"`
Runs int `json:"runs"`
AvgMs int `json:"avg_ms"`
Errors int `json:"errors"`
}
// DayTokens is token spend per UTC day.
type DayTokens struct {
Day string `json:"day"`
Tokens int `json:"tokens"`
}
// Sentinel errors, part of the wire contract: staterpc's
// mapError/unmapError match these by (code, canonical message) across the
// gRPC boundary, so their message strings are load-bearing and must never
// change.
var (
// ErrStaleTransition is returned when a task transition's expected
// from status does not match the task's current status.
ErrStaleTransition = errors.New("store: stale transition: task status does not match expected from status")
// ErrIllegalTransition is returned when the transition table does not allow
// the status pair.
ErrIllegalTransition = errors.New("store: illegal transition: status pair is not in the transition table")
// ErrInvalidStep is returned when a step-execution request names a kind the
// store does not record or a step whose identifying fields do not resolve.
// Distinct from the transition sentinels, which cover a row's state.
ErrInvalidStep = errors.New("store: invalid step execution request")
// ErrResumeIncomplete is returned when a retry resumes after a stage whose
// last run did not complete, so there are no results to start from.
ErrResumeIncomplete = errors.New("store: the step before the resume point did not complete in its last run")
// ErrBindingNotFound is returned when a binding ID does not exist.
ErrBindingNotFound = errors.New("store: binding not found")
// ErrBindingOverlap is returned when a binding's matcher overlaps an
// existing binding for the same source.
ErrBindingOverlap = errors.New("store: binding overlaps existing binding for source")
// ErrBindingTransition is returned when a binding state transition is
// rejected by the draft -> pending_approval -> armed machine.
ErrBindingTransition = errors.New("store: binding state transition rejected")
// ErrAlreadyDispatched is returned when a dispatch ledger already holds the
// key.
ErrAlreadyDispatched = errors.New("store: binding already dispatched for capture")
// ErrCallNotYours is returned when a workflow.call status read names a
// task that is not a callee of the calling task, or the caller itself
// does not exist: a caller reads only the tasks it started
ErrCallNotYours = errors.New("store: task is not a callee of the calling task")
// ErrCallCallerNotRunning is returned when a workflow.call enqueue names
// a caller that is not running: a stale retry, or a bug in the caller.
ErrCallCallerNotRunning = errors.New("store: workflow.call caller is not running")
// ErrCallDepthExceeded is returned when a workflow.call enqueue would
// pass workflow.MaxCallDepth. The engine refuses the same call first;
// the store re-checks because it owns the table.
ErrCallDepthExceeded = errors.New("store: workflow.call would pass the depth limit")
// ErrMappingNotFound is returned when a mapping ID does not exist.
ErrMappingNotFound = errors.New("store: mapping not found")
// ErrEventTypeNotFound is returned when an event type ID does not exist.
ErrEventTypeNotFound = errors.New("store: event type not found")
// ErrSourceNotFound is returned when a source path does not exist.
ErrSourceNotFound = errors.New("store: source not found")
// ErrSourceInUse is returned when deleting a source an armed binding
// fires on.
ErrSourceInUse = errors.New("store: source has an armed binding")
// ErrSourcePathTaken is returned when a new source's path is in use.
ErrSourcePathTaken = errors.New("store: source path already taken")
// ErrSourceSigningStale is returned when a signing write's expected
// from state does not match the stored one.
ErrSourceSigningStale = errors.New("store: source signing does not match expected state")
// ErrHarnessSecretNotFound is returned when no OAuth token set is
// stored for an org/service pair -- the setup terminal has not
// captured one yet.
ErrHarnessSecretNotFound = errors.New("store: harness secret not found")
// ErrRereviewCapReached is returned when a review gate re-review would
// round past prreview.MaxRereviewRounds. The task stays waiting and its
// gate row is unchanged. The dashboard answers it 409, like every other
// conflict.
ErrRereviewCapReached = errors.New("store: re-review cap reached")
// ErrResourceNotFound is returned when a control-plane resource kind has
// no stored document. It is in-process only (not on the gRPC wire): the
// control plane runs in the daemon against the local store.
ErrResourceNotFound = errors.New("resource not found")
// ErrResourceVersionConflict is returned when a resource write carries an
// expected version that does not match the stored revision.
ErrResourceVersionConflict = errors.New("resource version conflict")
)
// ErrUnavailable means the store could not serve a request now: it is
// restarting or unreachable. It is not paired with a canonical message the way
// the sentinels above are -- staterpc derives it from the Unavailable code
// alone, whose text varies by transport -- and it is the one store error a
// caller with budget may answer by retrying rather than by failing its own
// work. The wrapping keeps the gRPC status code readable through the chain.
var ErrUnavailable = errors.New("store: state store unavailable")
// Resource is one control-plane resource document: the stored value for an
// org's kind, its revision, and the audit record written with the last write.
// Resource and ResourceWrite live here so the UI-side consumers can reference
// them without linking the PostgreSQL implementation.
type Resource struct {
OrgID string
Kind string
Value []byte
Version int64
Actor string
Source string
RequestID string
ExpectedVersion int64
CurrentVersion int64
At time.Time
}
// DefaultOrgID is the org every resource written before orgs existed belongs
// to, and the org a request that names none acts in.
const DefaultOrgID = "org-sys"
// ResourceAuditKey is the sys_audit record key of one org's resource kind. The
// default org keeps the bare kind, so audit rows written before resources were
// per-org still resolve.
func ResourceAuditKey(orgID, kind string) string {
if orgID == DefaultOrgID {
return kind
}
return orgID + "/" + kind
}
// ResourceWrite is a control-plane resource write request. ExpectedVersion is
// the optimistic-concurrency guard: a write whose expectation does not match
// the stored revision is refused with ErrResourceVersionConflict.
type ResourceWrite struct {
OrgID string
Kind string
Value []byte
Actor string
Source string
RequestID string
ExpectedVersion int64
At time.Time
}
// ErrRunCredentialUnknown is a run credential that was never issued, was
// revoked, or has expired.
var ErrRunCredentialUnknown = errors.New("run credential unknown or expired")
// RunCredentialStore keeps run credentials by digest: the SHA-256 of the
// token a task's container presents. A lookup of an unknown or expired
// digest reports ErrRunCredentialUnknown.
type RunCredentialStore interface {
PutRunCredential(ctx context.Context, digest [32]byte, taskID int64, expires time.Time) error
DeleteRunCredential(ctx context.Context, digest [32]byte) error
RunCredentialTask(ctx context.Context, digest [32]byte, now time.Time) (int64, error)
DeleteExpiredRunCredentials(ctx context.Context, now time.Time) error
}
+198
View File
@@ -0,0 +1,198 @@
package storecontract
import (
"context"
"io"
"time"
"github.com/samcharles93/archie-core/internal/domain/workflow/task"
"github.com/samcharles93/archie-core/internal/events"
"github.com/samcharles93/archie-core/internal/logging"
)
// TaskLifecycle manages the core task state machine and enqueuing.
// Binding-triggered task creation lives on BindingTaskCreator, not here,
// so the lifecycle surface stays narrow and non-binding consumers (forge
// poll, chat spawn, drain loop) do not acquire a binding-specific shape.
type TaskLifecycle interface {
EnqueueIssue(ctx context.Context, owner, repo string, number int, title, body, labels, identity string) (bool, error)
EnqueueChatTask(ctx context.Context, owner, repo, title, body, wf, identity, origin, draft string, inputs map[string]any) (*task.Task, error)
ClaimNext(ctx context.Context) (*task.Task, error)
ClaimByIssue(ctx context.Context, owner, repo string, number int) (*task.Task, error)
Transition(ctx context.Context, taskID int64, from, to, detail string) error
Update(ctx context.Context, t *task.Task) error
Requeue(ctx context.Context, taskID int64, fromStatus, workflow string) error
RecoverStale(ctx context.Context) (int64, error)
}
// TaskParker parks a task with a park class and the blocker the park site
// knows, if any. Unknown classes become needs_decision.
type TaskParker interface {
ParkTask(ctx context.Context, taskID int64, from, detail, class, blocker string) error
}
// StepRecorder records a running execution's steps.
type StepRecorder interface {
StartStep(ctx context.Context, s task.StepStart) (int64, events.Event, error)
FinishStep(ctx context.Context, s task.StepFinish) (events.Event, error)
}
// ExecutionCanceller cancels an execution and its current attempt's open
// steps in one transaction. It also cancels the callees the execution was
// waiting on, and returns their ids (nested callees included) so the caller
// can stop their runs too.
type ExecutionCanceller interface {
CancelExecution(ctx context.Context, taskID int64, reason, to string) ([]int64, error)
}
// StepReader lists one execution's recorded steps.
type StepReader interface {
ListSteps(ctx context.Context, executionID int64, attempt int) ([]task.StepExecution, error)
}
// TaskArchiver removes one terminal task's local record with an optimistic
// status guard. It is separate from the already broad lifecycle contract so
// consumers that only run tasks do not acquire an operator-only capability.
type TaskArchiver interface {
OutcomePoster
ArchiveTask(ctx context.Context, taskID int64, fromStatus string, audit events.Event) (eventID int64, err error)
ClearTerminalTasks(ctx context.Context) (int64, error)
}
// TaskRetryer atomically requeues recoverable work and accounts for the new
// attempt so a partial write cannot evade the retry cap. retryMode is the
// operator's worktree choice for the next dispatch (taskstate.RetryMode),
// persisted on the row so the daemon reads it instead of inferring it. resume
// is where the attempt starts; a resume whose After stage did not complete in
// its last run is refused with ErrResumeIncomplete.
type TaskRetryer interface {
RetryTask(ctx context.Context, taskID int64, fromStatus, workflow, retryMode string, resume task.Resume, currentDefinition bool) error
}
// ReviewGateResponder records the operator's review-gate answer. A re-review
// increments rereview_rounds and requeues; one past the cap returns
// ErrRereviewCapReached and writes nothing.
type ReviewGateResponder interface {
RespondReviewGate(ctx context.Context, taskID int64, fromStatus, gate string, rereview bool, maxRounds int) error
}
// RemediationStarter queues a review-triggered remediation for an Archie-owned
// open-PR task: one guarded transition that carries the JSON-encoded review
// unit in the same write, so a claimed remediation always has its input. Runs
// for one task are serialised, so a distinct review that arrives while a
// remediation owns the task is queued behind it and remediated once that run
// finishes; a re-delivered unit is absorbed, not queued twice.
// UpdateReviewPayload merges late-arriving comments into the unclaimed unit
// for the same review, active or queued behind a running remediation.
type RemediationStarter interface {
BeginRemediation(ctx context.Context, taskID int64, payload string) error
UpdateReviewPayload(ctx context.Context, taskID int64, payload string) error
// SetReviewCursors persists the poll backstop's per-task review and
// comment high-water marks (pr-review-remediation.md decision 2). The
// pr_open guard is part of the contract: cursors only move while no
// remediation run owns the task.
SetReviewCursors(ctx context.Context, taskID, reviewCursor, commentCursor int64) error
}
// OutcomePoster tracks which finished chat tasks have reported back to their
// conversation.
type OutcomePoster interface {
// UnpostedOutcomes returns finished chat tasks whose outcome has not been
// posted to the conversation that created them.
UnpostedOutcomes(ctx context.Context) ([]*task.Task, error)
// MarkOutcomePosted records that the task's state at status was posted.
MarkOutcomePosted(ctx context.Context, taskID int64, status string) error
}
// TaskQueries groups read-only task accessors.
type TaskQueries interface {
TaskByIssue(ctx context.Context, owner, repo string, number int) (*task.Task, error)
OpenTaskByPR(ctx context.Context, owner, repo string, number int) (*task.Task, error)
TaskByID(ctx context.Context, taskID int64) (*task.Task, error)
OpenPRs(ctx context.Context) ([]task.Task, error)
// ActiveTasksByOrigin returns the queued and running tasks the
// conversation origin created, for its /stop.
ActiveTasksByOrigin(ctx context.Context, origin string) ([]*task.Task, error)
// Tasks returns the most recently updated tasks.
Tasks(ctx context.Context, limit int) ([]task.Task, error)
// TasksPage returns one page of tasks, most recently updated first.
TasksPage(ctx context.Context, page TaskPage) ([]task.Task, error)
StatusCounts(ctx context.Context) (map[string]int, error)
}
// TaskEvents groups observability and lifecycle methods.
type TaskEvents interface {
InsertEvent(ctx context.Context, e events.Event) (int64, error)
EventsSince(ctx context.Context, cursor string, limit int) ([]events.Event, error)
// TaskEvents returns a task's timeline, without agent transcripts.
TaskEvents(ctx context.Context, taskID int64) ([]events.Event, error)
// TaskTranscript returns one attempt's agent transcript entries in order.
TaskTranscript(ctx context.Context, taskID int64, attempt int) ([]events.Event, error)
WorkflowStats(ctx context.Context) ([]WorkflowStat, error)
StageStats(ctx context.Context) ([]StageStat, error)
TokensByDay(ctx context.Context, days int) ([]DayTokens, error)
Close() error
}
// TaskPage selects one page of the task list. Empty Statuses matches every
// status. A zero After starts at the newest task; otherwise the page begins
// after the task it names, in (updated_at, id) descending order.
type TaskPage struct {
Statuses []string
// Workflow, when set, keeps only that workflow's tasks.
Workflow string
After TaskCursor
Limit int
}
// TaskCursor is the position of the last task a page returned.
type TaskCursor struct {
UpdatedAt time.Time
ID int64
}
// WorkflowCaller starts a workflow.call callee and reads it back.
type WorkflowCaller = task.Caller
// TaskLogStore reads one task attempt's log. Found=false means no log;
// ErrTaskLogsUnavailable means this process cannot read logs.
type TaskLogStore interface {
// TaskLog returns a page of one attempt's decoded log. attempt 0 selects
// the task's current attempt.
TaskLog(ctx context.Context, taskID int64, attempt int, q logging.Query) (logging.TaskLogPage, error)
// TaskLogContent writes one attempt's log verbatim to w, for a download.
// found is false, with a nil error, when the attempt has no log file.
TaskLogContent(ctx context.Context, taskID int64, attempt int, w io.Writer) (found bool, err error)
}
// WorkflowStat is one row of the per-workflow metrics table.
type WorkflowStat struct {
Workflow string `json:"workflow"`
Runs int `json:"runs"`
Merged int `json:"merged"`
Completed int `json:"completed"`
PROpen int `json:"pr_open"`
Parked int `json:"parked"`
AvgTokens int `json:"avg_tokens"`
AvgSteps float64 `json:"avg_steps"`
TotalToken int `json:"total_tokens"`
// Running and LastStatus describe the workflow now: how many of its runs
// are working, and how its newest one ended.
Running int `json:"running"`
LastStatus string `json:"last_status"`
}
// StageStat is average stage duration and failure counts per stage.
type StageStat struct {
Workflow string `json:"workflow"`
Stage string `json:"stage"`
Runs int `json:"runs"`
AvgMs int `json:"avg_ms"`
Errors int `json:"errors"`
}
// DayTokens is token spend per UTC day.
type DayTokens struct {
Day string `json:"day"`
Tokens int `json:"tokens"`
}
+5
View File
@@ -45,6 +45,11 @@ type recordedForge struct {
deliveries Deliveries
}
func (f recordedForge) CreateIssue(ctx context.Context, owner, repo, title, _ string, _ []string) (int, error) {
f.deliveries.Record(ctx, fmt.Sprintf("open issue %q in %s/%s", title, owner, repo))
return 0, nil
}
func (f recordedForge) CloseIssue(ctx context.Context, owner, repo string, number int, _ string) error {
f.deliveries.Record(ctx, fmt.Sprintf("close issue %s/%s#%d", owner, repo, number))
return nil
+4
View File
@@ -38,6 +38,10 @@ type IssueForge interface {
// Comment posts an issue (or PR) comment and returns its id.
Comment(ctx context.Context, owner, repo string, number int, body string) (int64, error)
// CreateIssue opens an issue with title, body and optional labels,
// returning its number.
CreateIssue(ctx context.Context, owner, repo, title, body string, labels []string) (int, error)
// CloseIssue closes an issue with an optional final comment.
CloseIssue(ctx context.Context, owner, repo string, number int, comment string) error
+4
View File
@@ -30,6 +30,10 @@ func (n *NoopForge) Comment(ctx context.Context, owner, repo string, number int,
return 0, nil
}
func (n *NoopForge) CreateIssue(ctx context.Context, owner, repo, title, body string, labels []string) (int, error) {
return 0, nil
}
func (n *NoopForge) CloseIssue(ctx context.Context, owner, repo string, number int, comment string) error {
return nil
}
+43 -2
View File
@@ -23,6 +23,7 @@ import (
const (
SubjectComment = "archie.forge.comment"
SubjectCreateIssue = "archie.forge.create_issue"
SubjectCloseIssue = "archie.forge.close_issue"
SubjectCreatePR = "archie.forge.create_pr"
SubjectLinkBranch = "archie.forge.link_branch"
@@ -35,8 +36,9 @@ const (
// set a task of that identity may publish to.
func Subjects(identity string) []string {
bases := []string{
SubjectComment, SubjectCloseIssue, SubjectCreatePR, SubjectLinkBranch,
SubjectSetStateLabel, SubjectCreateReviewComment, SubjectReplyToReview,
SubjectComment, SubjectCreateIssue, SubjectCloseIssue, SubjectCreatePR,
SubjectLinkBranch, SubjectSetStateLabel, SubjectCreateReviewComment,
SubjectReplyToReview,
}
out := make([]string, len(bases))
for i, base := range bases {
@@ -80,6 +82,17 @@ type CommentResponse struct {
natsrpc.Envelope
}
type CreateIssueRequest struct {
Target
Title, Body string
Labels []string
}
type CreateIssueResponse struct {
Number int `json:"number"`
natsrpc.Envelope
}
type CloseIssueRequest struct {
Target
Number int
@@ -168,6 +181,7 @@ func (s *Server) RegisterFor(nc *nats.Conn, identity string) (unsubscribe func()
}
return natsrpc.RegisterAll(nc, []natsrpc.Registration{
{Subject: serverSubject(identity, SubjectComment), Handler: as(s.handleComment)},
{Subject: serverSubject(identity, SubjectCreateIssue), Handler: as(s.handleCreateIssue)},
{Subject: serverSubject(identity, SubjectCloseIssue), Handler: as(s.handleCloseIssue)},
{Subject: serverSubject(identity, SubjectCreatePR), Handler: as(s.handleCreatePR)},
{Subject: serverSubject(identity, SubjectLinkBranch), Handler: as(s.handleLinkBranch)},
@@ -249,6 +263,21 @@ func (s *Server) handleComment(ctx context.Context, identity string, msg *nats.M
s.respond(msg, CommentResponse{ID: id, Envelope: natsrpc.NewEnvelope(err)})
}
func (s *Server) handleCreateIssue(ctx context.Context, identity string, msg *nats.Msg) {
var req CreateIssueRequest
if err := json.Unmarshal(msg.Data, &req); err != nil {
s.respond(msg, CreateIssueResponse{Envelope: natsrpc.NewEnvelope(fmt.Errorf("decode create_issue request: %w", err))})
return
}
client, err := s.authorizedForge(ctx, identity, req.Target, "comment")
if err != nil {
s.respond(msg, CreateIssueResponse{Envelope: natsrpc.NewEnvelope(err)})
return
}
number, err := client.CreateIssue(ctx, req.Owner, req.Repo, req.Title, req.Body, req.Labels)
s.respond(msg, CreateIssueResponse{Number: number, Envelope: natsrpc.NewEnvelope(err)})
}
func (s *Server) handleCloseIssue(ctx context.Context, identity string, msg *nats.Msg) {
var req CloseIssueRequest
if err := json.Unmarshal(msg.Data, &req); err != nil {
@@ -392,6 +421,18 @@ func (c *Client) Comment(ctx context.Context, owner, repo string, number int, bo
return resp.ID, nil
}
func (c *Client) CreateIssue(ctx context.Context, owner, repo, title, body string, labels []string) (int, error) {
req := CreateIssueRequest{Target: c.target(owner, repo), Title: title, Body: body, Labels: labels}
resp, err := natsrpc.Call[CreateIssueResponse](ctx, c.rpc(), c.subject(SubjectCreateIssue), req)
if err != nil {
return 0, err
}
if err := resp.Err(); err != nil {
return 0, err
}
return resp.Number, nil
}
func (c *Client) CloseIssue(ctx context.Context, owner, repo string, number int, comment string) error {
req := CloseIssueRequest{Target: c.target(owner, repo), Number: number, Comment: comment}
resp, err := natsrpc.Call[Response](ctx, c.rpc(), c.subject(SubjectCloseIssue), req)
+137
View File
@@ -0,0 +1,137 @@
package gateway
import (
"context"
"fmt"
"time"
"github.com/samcharles93/archie-core/internal/domain/access"
"github.com/samcharles93/archie-core/internal/domain/workflow/task"
"github.com/samcharles93/archie-core/internal/events"
"github.com/samcharles93/archie-core/internal/tools"
)
// RunSource is the state-store surface the run-inspection tools use. The
// State Store client satisfies it directly.
type RunSource interface {
// Tasks returns the most recently updated tasks.
Tasks(ctx context.Context, limit int) ([]task.Task, error)
// TaskEvents returns one task's events, oldest first.
TaskEvents(ctx context.Context, taskID int64) ([]events.Event, error)
}
// RunSummary is one task as run_list shows it.
type RunSummary struct {
ID int64 `json:"id"`
Repo string `json:"repo"`
Title string `json:"title"`
Status string `json:"status"`
Workflow string `json:"workflow,omitempty"`
Issue int `json:"issue,omitempty"`
PRNumber int `json:"pr_number,omitempty"`
ParkReason string `json:"park_reason,omitempty"`
UpdatedAt time.Time `json:"updated_at"`
}
// RunEvent is one task event as run_events shows it.
type RunEvent struct {
At time.Time `json:"at"`
Kind string `json:"kind"`
Stage string `json:"stage,omitempty"`
Detail string `json:"detail,omitempty"`
}
// RunTools returns the read-only run-inspection tools for long-running
// curators: what ran recently, and each run's event trail. Reads are checked
// as reading tasks, the same check the dashboard's task list gets. Nil
// source or authorizer registers none.
func RunTools(source RunSource, authz access.Authorizer) []tools.ToolEntry {
if source == nil || authz == nil {
return nil
}
read := func(entry tools.ToolEntry) tools.ToolEntry {
return guarded(authz, access.ActionRead, access.KindTask, nil, entry)
}
return []tools.ToolEntry{
read(runListTool(source)),
read(runEventsTool(source)),
}
}
func runListTool(source RunSource) tools.ToolEntry {
return tools.ToolEntry{
Name: "run_list",
Toolset: "runs",
Description: "List the most recently updated task runs across the instance, most recent first. " +
"Use it to survey what ran, what parked and why.",
Classification: tools.ClassIdempotent,
Schema: tools.JSONSchema{
"type": "object",
"properties": map[string]any{
"limit": map[string]any{
"type": "integer",
"description": fmt.Sprintf(
"Maximum runs to return. Defaults to %d, capped at %d.",
defaultTaskListLimit, maxTaskListLimit,
),
},
},
},
Handler: func(ctx context.Context, input map[string]any) (any, error) {
rows, err := source.Tasks(ctx, taskListLimit(input))
if err != nil {
return nil, fmt.Errorf("run_list: %w", err)
}
out := make([]RunSummary, 0, len(rows))
for _, t := range rows {
out = append(out, RunSummary{
ID: t.ID,
Repo: t.Owner + "/" + t.Repo,
Title: t.Title,
Status: t.Status,
Workflow: t.Workflow,
Issue: t.IssueNumber,
PRNumber: t.PRNumber,
ParkReason: t.ParkReason,
UpdatedAt: t.UpdatedAt,
})
}
return out, nil
},
}
}
func runEventsTool(source RunSource) tools.ToolEntry {
return tools.ToolEntry{
Name: "run_events",
Toolset: "runs",
Description: "List one task run's event trail, oldest first: stage transitions, deliveries, " +
"failures and park reasons. Use it to see why a run ended the way it did.",
Classification: tools.ClassIdempotent,
Schema: tools.JSONSchema{
"type": "object",
"properties": map[string]any{
"task_id": map[string]any{
"type": "integer",
"description": "The task run's ID, as run_list reports it.",
},
},
"required": []string{"task_id"},
},
Handler: func(ctx context.Context, input map[string]any) (any, error) {
id, ok := asInt64(input["task_id"])
if !ok || id <= 0 {
return nil, fmt.Errorf("run_events: task_id must be a positive integer")
}
evs, err := source.TaskEvents(ctx, id)
if err != nil {
return nil, fmt.Errorf("run_events: %w", err)
}
out := make([]RunEvent, 0, len(evs))
for _, e := range evs {
out = append(out, RunEvent{At: e.At, Kind: e.Kind, Stage: e.Stage, Detail: e.Detail})
}
return out, nil
},
}
}
@@ -112,3 +112,84 @@ func TestWorkspaceEnvironment(t *testing.T) {
})
}
}
// TestCanaryGrant pins the scoped canary grant: the one identity it names may
// read the signal surface, read and write update-settings, and trigger an
// install -- and nothing else, neither for it nor for anyone else. The canary
// principal carries the developer role (API-created service accounts are
// assigned it); the grant's forbid must keep the role from widening access.
func TestCanaryGrant(t *testing.T) {
const canaryID = identity.IdentityID("canary-svc")
grant := access.CanaryGrantPolicy(org.DefaultOrgID, string(canaryID))
forbid := access.CanaryGrantForbidPolicy(org.DefaultOrgID, string(canaryID))
engine := New(append(access.ShippedOrgPolicies(org.DefaultOrgID), grant, forbid))
if len(engine.Problems()) != 0 {
t.Fatalf("problems = %v, want the canary grant to compile", engine.Problems())
}
canary := access.Principal{
IdentityID: canaryID, Org: org.DefaultOrgID,
Memberships: []org.Membership{{IdentityID: canaryID, OrgID: org.DefaultOrgID, Role: org.RoleDeveloper}},
}
other := access.Principal{IdentityID: "someone-else", Org: org.DefaultOrgID}
at := func(kind access.ResourceKind, id string) access.Resource {
return access.Resource{Kind: kind, ID: id, Org: org.DefaultOrgID}
}
tests := []struct {
name string
principal access.Principal
action access.Action
resource access.Resource
allowed bool
}{
{"read the dashboard", canary, access.ActionRead, at(access.KindDashboard, ""), true},
{"read tasks", canary, access.ActionRead, at(access.KindTask, ""), true},
{"read one task", canary, access.ActionRead, at(access.KindTask, "7"), true},
{"read update-settings", canary, access.ActionRead, at(access.KindPolicy, "update-settings"), true},
{"install an update", canary, access.ActionUpdate, at(access.KindDashboard, "update"), true},
{"replace update-settings", canary, access.ActionManageIdentities, at(access.KindPolicy, "update-settings"), true},
{"read a secret", canary, access.ActionReadSecret, at(access.KindSecret, "github-token"), false},
{"delete a task", canary, access.ActionDelete, at(access.KindTask, "7"), false},
{"manage policies", canary, access.ActionManagePolicies, at(access.KindPolicy, "org-role-read"), false},
{"run a workflow", canary, access.ActionRun, at(access.KindWorkflow, "triage"), false},
{"create anything", canary, access.ActionCreate, at(access.KindTask, ""), false},
{"update another object", canary, access.ActionUpdate, at(access.KindDashboard, "other"), false},
{"read another object", canary, access.ActionRead, at(access.KindPolicy, "other-policy"), false},
{"manage identities on another object", canary, access.ActionManageIdentities, at(access.KindIdentity, "someone-else"), false},
{"read logs", canary, access.ActionReadLogs, at(access.KindTask, "7"), false},
{"read the audit feed", canary, access.ActionReadAudit, at(access.KindAudit, ""), false},
{"a resource of another org", canary, access.ActionRead, access.Resource{Kind: access.KindDashboard, Org: "acme"}, false},
{"another identity reads the dashboard", other, access.ActionRead, at(access.KindDashboard, ""), false},
{"another identity installs an update", other, access.ActionUpdate, at(access.KindDashboard, "update"), false},
{"another identity replaces update-settings", other, access.ActionManageIdentities, at(access.KindPolicy, "update-settings"), false},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
got := engine.Authorize(tt.principal, tt.action, tt.resource, access.Context{})
if got.Allowed != tt.allowed {
t.Fatalf("allowed = %v, want %v (%+v)", got.Allowed, tt.allowed, got)
}
})
}
}
// TestCanaryGrantValidates pins that the canary grant passes the domain's
// structural check and the engine's schema validation, so it can be installed
// through the policy store.
func TestCanaryGrantValidates(t *testing.T) {
grant := access.CanaryGrantPolicy(org.DefaultOrgID, "canary-svc")
forbid := access.CanaryGrantForbidPolicy(org.DefaultOrgID, "canary-svc")
for _, p := range []access.Policy{grant, forbid} {
if err := p.Validate(); err != nil {
t.Fatalf("Validate %s: %v", p.ID, err)
}
}
engine := New([]access.Policy{grant, forbid})
for _, p := range []access.Policy{grant, forbid} {
if err := engine.Validate(p); err != nil {
t.Fatalf("engine Validate %s: %v", p.ID, err)
}
}
if len(engine.Problems()) != 0 {
t.Fatalf("problems = %v, want none", engine.Problems())
}
}
@@ -52,3 +52,13 @@ func DefaultUpdateStateDir() string {
}
return filepath.Join(dir, InstanceName(), "update")
}
// UpdateStateDir is the one resolution of the host's update state directory:
// ARCHIE_UPDATE_STATE_DIR when set, else the default. The daemon's
// transactions and the dashboard's update snapshot must read the same one.
func UpdateStateDir() string {
if dir := os.Getenv("ARCHIE_UPDATE_STATE_DIR"); dir != "" {
return dir
}
return DefaultUpdateStateDir()
}
@@ -195,6 +195,16 @@ func (f *Forge) Comment(ctx context.Context, owner, repo string, number int, bod
return resp.GetId(), err
}
func (f *Forge) CreateIssue(ctx context.Context, owner, repo, title, body string, labels []string) (int, error) {
resp, err := call(ctx, f, "create issue", func(c forgev1.ForgeServiceClient) (*forgev1.CreateIssueResponse, error) {
return c.CreateIssue(ctx, &forgev1.CreateIssueRequest{Repo: ref(owner, repo), Title: title, Body: body, Labels: labels})
})
if err != nil {
return 0, err
}
return int(resp.GetNumber()), nil
}
func (f *Forge) CloseIssue(ctx context.Context, owner, repo string, number int, comment string) error {
_, err := call(ctx, f, "close issue", func(c forgev1.ForgeServiceClient) (*forgev1.CloseIssueResponse, error) {
return c.CloseIssue(ctx, &forgev1.CloseIssueRequest{Repo: ref(owner, repo), Number: int32(number), Comment: comment}) // issue numbers fit int32
@@ -90,6 +90,40 @@ func (s *accountServer) RevokePersonalToken(ctx context.Context, r *pb.RevokePer
return &pb.RevokePersonalTokenResponse{}, nil
}
// BindIdentityPersonalToken binds a token to a named non-user identity, the
// credential a service account acts with. The audit actor is the caller's
// principal, so the request never names who did it.
func (s *accountServer) BindIdentityPersonalToken(ctx context.Context, r *pb.BindIdentityPersonalTokenRequest) (*pb.BindIdentityPersonalTokenResponse, error) {
if s.deps.PersonalTokens == nil {
return nil, status.Error(codes.Unavailable, "personal tokens unavailable")
}
if s.deps.Identities == nil {
return nil, status.Error(codes.Unavailable, "identity store unavailable")
}
caller, ok := access.PrincipalFromContext(ctx)
if !ok || caller.IdentityID == "" {
return nil, status.Error(codes.Unauthenticated, "binding an identity token requires a principal")
}
target, err := s.deps.Identities.Get(ctx, identity.IdentityID(r.GetIdentityId()))
if err != nil {
return nil, s.identityStatus(ctx, err)
}
if target.Kind == identity.KindUser {
return nil, s.identityStatus(ctx, fmt.Errorf("%w: personal tokens belong to a signed-in person", identity.ErrInvalid))
}
if !target.CanAct() {
return nil, s.identityStatus(ctx, fmt.Errorf("%w: identity is not active", identity.ErrIllegalTransition))
}
subject, err := tokenSubject(r.GetId())
if err != nil {
return nil, err
}
if err := s.deps.PersonalTokens.BindPersonalToken(ctx, target.ID, subject, r.GetName(), optionalTime(r.GetExpiresAt()), tokenAudit(ctx, caller.IdentityID, "bind", r.GetId())); err != nil {
return nil, s.identityStatus(ctx, err)
}
return &pb.BindIdentityPersonalTokenResponse{}, nil
}
func (c *Client) AddPersonalToken(ctx context.Context, subject identity.Subject, name string, expiresAt *time.Time) error {
_, err := c.account.AddPersonalToken(ctx, &pb.AddPersonalTokenRequest{Id: subject.Subject, Name: name, ExpiresAt: optionalTimestamp(expiresAt)})
return identityClientError(err)
@@ -115,6 +149,15 @@ func (c *Client) RevokePersonalToken(ctx context.Context, id string) error {
return identityClientError(err)
}
// BindPersonalToken binds a token to a named identity rather than the caller's
// principal. The audit argument is accepted for the caller-side contract but
// never sent: the store attributes the bind to the caller's own principal, so
// a request cannot claim an actor.
func (c *Client) BindPersonalToken(ctx context.Context, id identity.IdentityID, subject identity.Subject, name string, expiresAt *time.Time, _ identity.Audit) error {
_, err := c.account.BindIdentityPersonalToken(ctx, &pb.BindIdentityPersonalTokenRequest{IdentityId: string(id), Id: subject.Subject, Name: name, ExpiresAt: optionalTimestamp(expiresAt)})
return identityClientError(err)
}
func optionalTimestamp(t *time.Time) *timestamppb.Timestamp {
if t == nil {
return nil
@@ -6,6 +6,10 @@ import (
"testing"
"time"
"google.golang.org/grpc/codes"
"google.golang.org/grpc/status"
"google.golang.org/protobuf/types/known/timestamppb"
pb "github.com/samcharles93/archie-core/internal/contracts/state/v1"
"github.com/samcharles93/archie-core/internal/domain/access"
"github.com/samcharles93/archie-core/internal/domain/identity"
@@ -49,3 +53,88 @@ func TestPersonalTokenOwner(t *testing.T) {
})
}
}
type bindCalls struct {
identity.PersonalTokenStore
bound bool
id identity.IdentityID
subject identity.Subject
name string
expires *time.Time
audit identity.Audit
}
func (b *bindCalls) BindPersonalToken(_ context.Context, id identity.IdentityID, subject identity.Subject, name string, expiresAt *time.Time, audit identity.Audit) error {
b.bound, b.id, b.subject, b.name, b.expires, b.audit = true, id, subject, name, expiresAt, audit
return nil
}
type bindIdentityRepo struct {
identity.Repository
values map[identity.IdentityID]identity.Identity
}
func (r bindIdentityRepo) Get(_ context.Context, id identity.IdentityID) (identity.Identity, error) {
if value, ok := r.values[id]; ok {
return value, nil
}
return identity.Identity{}, identity.ErrNotFound
}
// TestBindIdentityPersonalToken pins the named-identity bind: a service
// account gets the token with the caller as audit actor, while a user target,
// an unknown or inactive identity, a malformed token id and a caller with no
// principal are all refused without binding.
func TestBindIdentityPersonalToken(t *testing.T) {
id := strings.Repeat("ab", 32)
sa := identity.Identity{ID: "sa1", Kind: identity.KindServiceAccount, DisplayName: "Canary", Lifecycle: identity.LifecycleActive}
user := identity.Identity{ID: "u1", Kind: identity.KindUser, DisplayName: "Alice", Lifecycle: identity.LifecycleActive}
suspended := identity.Identity{ID: "sa2", Kind: identity.KindBot, DisplayName: "Old", Lifecycle: identity.LifecycleSuspended}
repo := bindIdentityRepo{values: map[identity.IdentityID]identity.Identity{sa.ID: sa, user.ID: user, suspended.ID: suspended}}
tests := []struct {
name string
target identity.IdentityID
tokenID string
noPrincipal bool
wantCode codes.Code
wantBound bool
}{
{"service account binds with the caller as actor", sa.ID, id, false, codes.OK, true},
{"user target is refused", user.ID, id, false, codes.FailedPrecondition, false},
{"unknown identity is refused", "nope", id, false, codes.NotFound, false},
{"inactive identity is refused", suspended.ID, id, false, codes.FailedPrecondition, false},
{"malformed token id is refused", sa.ID, "not-hex", false, codes.FailedPrecondition, false},
{"no principal is refused", sa.ID, id, true, codes.Unauthenticated, false},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
store := &bindCalls{}
s := &accountServer{server: &server{deps: Deps{PersonalTokens: store, Identities: repo}}}
ctx := context.Background()
if !tt.noPrincipal {
ctx = access.WithPrincipal(ctx, access.Principal{IdentityID: "alice"})
}
expires := time.Now().UTC().Add(30 * 24 * time.Hour).Truncate(time.Second)
_, err := s.BindIdentityPersonalToken(ctx, &pb.BindIdentityPersonalTokenRequest{IdentityId: string(tt.target), Id: tt.tokenID, Name: "ci", ExpiresAt: timestamppb.New(expires)})
if got := status.Code(err); got != tt.wantCode {
t.Fatalf("code=%v want=%v err=%v", got, tt.wantCode, err)
}
if store.bound != tt.wantBound {
t.Fatalf("bound=%v want=%v", store.bound, tt.wantBound)
}
if !tt.wantBound {
return
}
wantSubject := identity.Subject{Issuer: identity.PersonalTokenIssuer, Subject: id}
if store.id != sa.ID || store.name != "ci" || store.subject != wantSubject {
t.Fatalf("bind id=%q name=%q subject=%+v, want %q %q %+v", store.id, store.name, store.subject, sa.ID, "ci", wantSubject)
}
if store.expires == nil || !store.expires.Equal(expires) {
t.Fatalf("expires=%v want %v", store.expires, expires)
}
if store.audit.ActorID != "alice" || store.audit.RequestID != "personal-token:bind:"+id {
t.Fatalf("audit=%+v, want actor alice request personal-token:bind:<id>", store.audit)
}
})
}
}
+37 -23
View File
@@ -6,14 +6,17 @@ import (
)
// The canary host installs each release from the next channel. Its behaviour
// in the 24 hours after a release is compared with its own behaviour in the
// 24 hours before, because there's only one production host to compare with.
// in the window after a release was installed is compared with its own
// behaviour in the window before, because there's only one production host to
// compare with.
const (
// CanaryWindow is how long a release runs on the canary before it can be
// promoted. A day covers one full cycle of schedules and traffic.
// CanaryWindow is the default window a release runs on the canary before
// it can be promoted. A day covers one full cycle of schedules and
// traffic.
CanaryWindow = 24 * time.Hour
// canarySettle is how long the install and restart get, counted from when
// the release was issued, before any check can fail the release.
// the release was installed on the canary, before any check can fail the
// release.
canarySettle = 30 * time.Minute
// minFinished is the fewest finished tasks needed to judge the park rate.
minFinished = 5
@@ -47,7 +50,7 @@ type CanarySignals struct {
Installed string
Ready bool
// NewActionAlerts are open action-severity alerts first raised since
// the release was issued.
// the release was installed.
NewActionAlerts []string
Baseline CanaryWindowSignals
Canary CanaryWindowSignals
@@ -59,11 +62,20 @@ type CanaryVerdict struct {
Reasons []string
}
// JudgeCanary decides what to do with a release, given how long ago it was
// issued. Once the release has settled, a failed hard check rolls it back at
// any time. Error and park rates are compared with the baseline only after the
// full window has passed.
func JudgeCanary(version string, elapsed time.Duration, s CanarySignals) CanaryVerdict {
// JudgeCanaryNow decides from the current signals alone, for an operator
// promoting without waiting out the window: the settle and window waits are
// skipped by construction, every hard and relative check still applies.
func JudgeCanaryNow(version string, now time.Time, window time.Duration, s CanarySignals) CanaryVerdict {
return JudgeCanary(version, now.Add(-(window + canarySettle)), now, window, s)
}
// JudgeCanary decides what to do with a release, given when it was installed
// on the canary host. Once the release has settled, a failed hard check rolls
// it back at any time. Error and park rates are judged against the baseline
// whenever both windows carry enough data, so a breach rolls the release back
// even mid-window; a full window with no failure promotes it.
func JudgeCanary(version string, installedAt, now time.Time, window time.Duration, s CanarySignals) CanaryVerdict {
elapsed := now.Sub(installedAt)
if elapsed < canarySettle {
return CanaryVerdict{Decision: CanaryWait, Reasons: []string{"settling after install"}}
}
@@ -80,11 +92,8 @@ func JudgeCanary(version string, elapsed time.Duration, s CanarySignals) CanaryV
if len(failed) > 0 {
return CanaryVerdict{Decision: CanaryRollBack, Reasons: failed}
}
if elapsed < CanaryWindow {
return CanaryVerdict{Decision: CanaryWait, Reasons: []string{fmt.Sprintf("%s of %s elapsed", elapsed.Round(time.Minute), CanaryWindow)}}
}
var notes []string
if reason, ok := judgeErrors(s.Baseline, s.Canary); !ok {
if reason, ok := judgeErrors(s.Baseline, s.Canary, window); !ok {
failed = append(failed, reason)
} else {
notes = append(notes, reason)
@@ -97,32 +106,37 @@ func JudgeCanary(version string, elapsed time.Duration, s CanarySignals) CanaryV
if len(failed) > 0 {
return CanaryVerdict{Decision: CanaryRollBack, Reasons: failed}
}
if elapsed < window {
reasons := append([]string{fmt.Sprintf("%s of %s elapsed since the install", elapsed.Round(time.Minute), window)}, notes...)
return CanaryVerdict{Decision: CanaryWait, Reasons: reasons}
}
return CanaryVerdict{Decision: CanaryPromote, Reasons: notes}
}
// judgeErrors fails when the canary logged more than twice the baseline's
// error lines plus ten. Each count is scaled up to a full day when the log
// error lines plus ten. Each count is scaled up to a full window when the log
// covers only part of its window.
func judgeErrors(baseline, canary CanaryWindowSignals) (string, bool) {
func judgeErrors(baseline, canary CanaryWindowSignals, window time.Duration) (string, bool) {
if baseline.Covered < minLogCoverage || canary.Covered <= 0 {
return "error log doesn't reach back over the baseline; error signal skipped", true
}
scale := func(w CanaryWindowSignals) float64 {
return float64(w.Errors) * float64(CanaryWindow) / float64(w.Covered)
return float64(w.Errors) * float64(window) / float64(w.Covered)
}
before, after := scale(baseline), scale(canary)
limit := 2*before + 10
if after > limit {
return fmt.Sprintf("%.0f error log lines per day against a limit of %.0f (baseline %.0f)", after, limit, before), false
return fmt.Sprintf("%.0f error log lines per window against a limit of %.0f (baseline %.0f)", after, limit, before), false
}
return fmt.Sprintf("%.0f error log lines per day, limit %.0f", after, limit), true
return fmt.Sprintf("%.0f error log lines per window, limit %.0f", after, limit), true
}
// judgeParks fails when the share of finished tasks that parked or died rose
// more than ten points over the baseline.
// more than ten points over the baseline. Both windows need the minimum
// finished tasks before the rates are compared.
func judgeParks(baseline, canary CanaryWindowSignals) (string, bool) {
if canary.Finished < minFinished {
return fmt.Sprintf("%d finished tasks, fewer than %d; park signal skipped", canary.Finished, minFinished), true
if canary.Finished < minFinished || baseline.Finished < minFinished {
return fmt.Sprintf("%d finished tasks on the canary and %d in the baseline, fewer than %d each; park signal skipped", canary.Finished, baseline.Finished, minFinished), true
}
rate := func(w CanaryWindowSignals) float64 {
if w.Finished == 0 {
+29 -26
View File
@@ -32,44 +32,47 @@ var (
const updateSettingsPath = "/api/control-plane/resources/update-settings"
// Signals reads the canary's current state. Tasks and error lines are split
// into the day before the release was issued and the time since.
func (d CanaryDashboard) Signals(ctx context.Context, issued, now time.Time) (CanarySignals, error) {
// into the window before the release was installed on the canary and the time
// since.
func (d CanaryDashboard) Signals(ctx context.Context, installedAt, now time.Time, window time.Duration) (CanarySignals, error) {
var s CanarySignals
var err error
if s.Installed, _, err = d.installed(ctx); err != nil {
if s.Installed, _, _, err = d.Installed(ctx); err != nil {
return s, err
}
if s.Ready, err = d.ready(ctx); err != nil {
return s, err
}
if s.NewActionAlerts, err = d.actionAlerts(ctx, issued); err != nil {
if s.NewActionAlerts, err = d.actionAlerts(ctx, installedAt); err != nil {
return s, err
}
if err := d.tasks(ctx, issued, &s); err != nil {
if err := d.tasks(ctx, installedAt, window, &s); err != nil {
return s, err
}
return s, d.errors(ctx, issued, now, &s)
return s, d.errors(ctx, installedAt, now, window, &s)
}
// installed returns the daemon version the canary runs, and the raw update
// snapshot it offers, which an install request must send back unchanged.
func (d CanaryDashboard) installed(ctx context.Context) (string, json.RawMessage, error) {
// Installed returns the daemon version the canary runs, when that release was
// installed on the canary host (zero when the host doesn't report it), and
// the raw update snapshot it offers, which an install request must send back
// unchanged.
func (d CanaryDashboard) Installed(ctx context.Context) (version string, installedAt time.Time, snapshot json.RawMessage, err error) {
var body struct {
Snapshot json.RawMessage `json:"snapshot"`
}
if _, err := d.call(ctx, http.MethodGet, "/api/chat/update", nil, &body); err != nil {
return "", nil, err
return "", time.Time{}, nil, err
}
var snapshot Snapshot
if err := json.Unmarshal(body.Snapshot, &snapshot); err != nil {
return "", nil, fmt.Errorf("decode update snapshot: %w", err)
var snap Snapshot
if err := json.Unmarshal(body.Snapshot, &snap); err != nil {
return "", time.Time{}, nil, fmt.Errorf("decode update snapshot: %w", err)
}
for _, c := range snapshot.Components {
for _, c := range snap.Components {
if c.ID == "daemon" {
return c.Installed, body.Snapshot, nil
return c.Installed, snap.InstalledAt, body.Snapshot, nil
}
}
return "", body.Snapshot, errors.New("canary reports no daemon version")
return "", time.Time{}, body.Snapshot, errors.New("canary reports no daemon version")
}
func (d CanaryDashboard) ready(ctx context.Context) (bool, error) {
@@ -104,8 +107,8 @@ func (d CanaryDashboard) actionAlerts(ctx context.Context, since time.Time) ([]s
// tasks reads tasks, newest update first, until it reaches tasks older than
// the baseline window.
func (d CanaryDashboard) tasks(ctx context.Context, issued time.Time, s *CanarySignals) error {
from := issued.Add(-CanaryWindow)
func (d CanaryDashboard) tasks(ctx context.Context, at time.Time, window time.Duration, s *CanarySignals) error {
from := at.Add(-window)
cursor := ""
for range 50 {
var page []struct {
@@ -125,7 +128,7 @@ func (d CanaryDashboard) tasks(ctx context.Context, issued time.Time, s *CanaryS
continue
}
w := &s.Canary
if t.UpdatedAt.Before(issued) {
if t.UpdatedAt.Before(at) {
w = &s.Baseline
}
w.Finished++
@@ -144,7 +147,7 @@ func (d CanaryDashboard) tasks(ctx context.Context, issued time.Time, s *CanaryS
// errors counts error-level lines in each window. A log read returns a
// limited number of lines, so a truncated read only reaches back as far as
// its oldest line.
func (d CanaryDashboard) errors(ctx context.Context, issued, now time.Time, s *CanarySignals) error {
func (d CanaryDashboard) errors(ctx context.Context, at, now time.Time, window time.Duration, s *CanarySignals) error {
var body struct {
Entries []struct {
Time time.Time `json:"time"`
@@ -154,24 +157,24 @@ func (d CanaryDashboard) errors(ctx context.Context, issued, now time.Time, s *C
if _, err := d.call(ctx, http.MethodGet, "/api/logs?level=error&limit=2000", nil, &body); err != nil {
return err
}
from := issued.Add(-CanaryWindow)
from := at.Add(-window)
if body.Truncated {
from = now
if len(body.Entries) > 0 {
from = later(body.Entries[0].Time, issued.Add(-CanaryWindow))
from = later(body.Entries[0].Time, at.Add(-window))
}
}
for _, e := range body.Entries {
switch {
case e.Time.Before(from):
case e.Time.Before(issued):
case e.Time.Before(at):
s.Baseline.Errors++
default:
s.Canary.Errors++
}
}
s.Baseline.Covered = max(issued.Sub(from), 0)
s.Canary.Covered = now.Sub(later(from, issued))
s.Baseline.Covered = max(at.Sub(from), 0)
s.Canary.Covered = now.Sub(later(from, at))
return nil
}
@@ -232,7 +235,7 @@ func (d CanaryDashboard) Install(ctx context.Context, version string, wait time.
deadline := time.Now().Add(wait)
requested := false
for {
installed, snapshot, err := d.installed(ctx)
installed, _, snapshot, err := d.Installed(ctx)
switch {
case err != nil:
// The dashboard drops off while the install restarts it.
+51 -18
View File
@@ -5,10 +5,11 @@ import (
"time"
)
// A release promotes only after a full window with no hard failure and no
// relative signal past its threshold; any hard failure after settling rolls
// it back at once.
// A release promotes only after a full window counted from its install with
// no hard failure and no relative signal past its threshold; any failure after
// settling rolls it back at once, even mid-window.
func TestJudgeCanary(t *testing.T) {
installed := time.Date(2026, 1, 2, 12, 0, 0, 0, time.UTC)
healthy := func() CanarySignals {
return CanarySignals{
Installed: "1.1.0", Ready: true,
@@ -23,34 +24,66 @@ func TestJudgeCanary(t *testing.T) {
}
cases := []struct {
name string
elapsed time.Duration
elapsed time.Duration // now minus the install time
window time.Duration
signals CanarySignals
want CanaryDecision
}{
{"settling ignores a failed check", 10 * time.Minute, with(func(s *CanarySignals) { s.Ready = false }), CanaryWait},
{"healthy mid-window waits", 2 * time.Hour, healthy(), CanaryWait},
{"healthy at the window promotes", CanaryWindow, healthy(), CanaryPromote},
{"the watchdog rolled the install back", 2 * time.Hour, with(func(s *CanarySignals) { s.Installed = "1.0.0" }), CanaryRollBack},
{"readiness degraded", 2 * time.Hour, with(func(s *CanarySignals) { s.Ready = false }), CanaryRollBack},
{"a new action alert", 2 * time.Hour, with(func(s *CanarySignals) { s.NewActionAlerts = []string{"queue stalled"} }), CanaryRollBack},
{"errors past twice the baseline plus ten", CanaryWindow, with(func(s *CanarySignals) { s.Canary.Errors = 31 }), CanaryRollBack},
{"errors at the limit", CanaryWindow, with(func(s *CanarySignals) { s.Canary.Errors = 30 }), CanaryPromote},
{"errors scaled from a partly covered log", CanaryWindow, with(func(s *CanarySignals) {
{"settling counts from the install", 10 * time.Minute, CanaryWindow, with(func(s *CanarySignals) { s.Ready = false }), CanaryWait},
{"healthy mid-window waits", 2 * time.Hour, CanaryWindow, healthy(), CanaryWait},
{"healthy at the window promotes", CanaryWindow, CanaryWindow, healthy(), CanaryPromote},
{"healthy at a custom window promotes", 12 * time.Hour, 12 * time.Hour, healthy(), CanaryPromote},
{"the watchdog rolled the install back", 2 * time.Hour, CanaryWindow, with(func(s *CanarySignals) { s.Installed = "1.0.0" }), CanaryRollBack},
{"readiness degraded", 2 * time.Hour, CanaryWindow, with(func(s *CanarySignals) { s.Ready = false }), CanaryRollBack},
{"a new action alert", 2 * time.Hour, CanaryWindow, with(func(s *CanarySignals) { s.NewActionAlerts = []string{"queue stalled"} }), CanaryRollBack},
{"errors past twice the baseline plus ten", CanaryWindow, CanaryWindow, with(func(s *CanarySignals) { s.Canary.Errors = 31 }), CanaryRollBack},
{"errors at the limit", CanaryWindow, CanaryWindow, with(func(s *CanarySignals) { s.Canary.Errors = 30 }), CanaryPromote},
{"errors scaled from a partly covered log", CanaryWindow, CanaryWindow, with(func(s *CanarySignals) {
s.Canary.Errors, s.Canary.Covered = 8, 6*time.Hour
}), CanaryRollBack},
{"a baseline the log doesn't reach skips errors", CanaryWindow, with(func(s *CanarySignals) {
{"a baseline the log doesn't reach skips errors", CanaryWindow, CanaryWindow, with(func(s *CanarySignals) {
s.Baseline.Covered, s.Canary.Errors = 30*time.Minute, 500
}), CanaryPromote},
{"park rate up more than ten points", CanaryWindow, with(func(s *CanarySignals) { s.Canary.Bad = 5 }), CanaryRollBack},
{"park rate up ten points", CanaryWindow, with(func(s *CanarySignals) { s.Canary.Bad = 4 }), CanaryPromote},
{"too few tasks skips the park rate", CanaryWindow, with(func(s *CanarySignals) { s.Canary = CanaryWindowSignals{Finished: 4, Bad: 4, Covered: CanaryWindow} }), CanaryPromote},
{"a mid-window error breach rolls back early", 2 * time.Hour, CanaryWindow, with(func(s *CanarySignals) { s.Canary.Errors = 31 }), CanaryRollBack},
{"park rate up more than ten points", CanaryWindow, CanaryWindow, with(func(s *CanarySignals) { s.Canary.Bad = 5 }), CanaryRollBack},
{"park rate up ten points", CanaryWindow, CanaryWindow, with(func(s *CanarySignals) { s.Canary.Bad = 4 }), CanaryPromote},
{"too few canary tasks skips the park rate", CanaryWindow, CanaryWindow, with(func(s *CanarySignals) { s.Canary = CanaryWindowSignals{Finished: 4, Bad: 4, Covered: CanaryWindow} }), CanaryPromote},
{"a thin baseline skips the park rate", CanaryWindow, CanaryWindow, with(func(s *CanarySignals) {
s.Baseline.Finished, s.Baseline.Bad = 2, 0
s.Canary.Bad = 5
}), CanaryPromote},
{"a mid-window park breach rolls back early", 2 * time.Hour, CanaryWindow, with(func(s *CanarySignals) { s.Canary.Bad = 5 }), CanaryRollBack},
}
for _, tc := range cases {
t.Run(tc.name, func(t *testing.T) {
got := JudgeCanary("1.1.0", tc.elapsed, tc.signals)
got := JudgeCanary("1.1.0", installed, installed.Add(tc.elapsed), tc.window, tc.signals)
if got.Decision != tc.want {
t.Fatalf("decision = %s, want %s (%v)", got.Decision, tc.want, got.Reasons)
}
})
}
}
// Judging "now" skips the settle and window waits but still applies every
// hard and relative check.
func TestJudgeCanaryNow(t *testing.T) {
healthy := CanarySignals{
Installed: "1.1.0", Ready: true,
Baseline: CanaryWindowSignals{Finished: 20, Bad: 2, Errors: 10, Covered: CanaryWindow},
Canary: CanaryWindowSignals{Finished: 20, Bad: 2, Errors: 12, Covered: CanaryWindow},
}
now := time.Date(2026, 1, 2, 12, 10, 0, 0, time.UTC)
if got := JudgeCanaryNow("1.1.0", now, CanaryWindow, healthy); got.Decision != CanaryPromote {
t.Fatalf("healthy now = %s, want promote (%v)", got.Decision, got.Reasons)
}
degraded := healthy
degraded.Ready = false
if got := JudgeCanaryNow("1.1.0", now, CanaryWindow, degraded); got.Decision != CanaryRollBack {
t.Fatalf("degraded now = %s, want roll back (%v)", got.Decision, got.Reasons)
}
breached := healthy
breached.Canary.Bad = 10
if got := JudgeCanaryNow("1.1.0", now, CanaryWindow, breached); got.Decision != CanaryRollBack {
t.Fatalf("park breach now = %s, want roll back (%v)", got.Decision, got.Reasons)
}
}
+47
View File
@@ -0,0 +1,47 @@
package releaseupdate
import (
"context"
"fmt"
digest "github.com/opencontainers/go-digest"
ocispec "github.com/opencontainers/image-spec/specs-go/v1"
"oras.land/oras-go/v2/registry"
"github.com/samcharles93/archie-core/internal/domain/distribution"
)
// Installable reports whether a release can still be installed from source:
// the zip blob its statement names must be present in the release repository
// and the agent image it pins must still resolve. A canary must never be
// pinned to a release whose artifacts are gone, or it would be stranded on a
// version it can never install again.
func Installable(ctx context.Context, source distribution.Source, release Release) error {
zipDigest, err := digest.Parse(release.Statement.Zip.Digest)
if err != nil {
return fmt.Errorf("zip digest %q: %w", release.Statement.Zip.Digest, err)
}
repo, err := pushRepository(source.Reference)
if err != nil {
return err
}
exists, err := repo.Exists(ctx, ocispec.Descriptor{Digest: zipDigest})
if err != nil {
return fmt.Errorf("resolve zip blob %s in %s: %w", release.Statement.Zip.Digest, source.Reference, err)
}
if !exists {
return fmt.Errorf("zip blob %s (%s) is absent from %s", release.Statement.Zip.Digest, release.Statement.Zip.Name, source.Reference)
}
image, err := registry.ParseReference(release.Statement.AgentImage)
if err != nil {
return fmt.Errorf("agent image %q: %w", release.Statement.AgentImage, err)
}
imageRepo, err := pushRepository(image.Registry + "/" + image.Repository)
if err != nil {
return err
}
if _, err := imageRepo.Resolve(ctx, image.Reference); err != nil {
return fmt.Errorf("agent image %s: %w", release.Statement.AgentImage, err)
}
return nil
}
+3
View File
@@ -44,6 +44,9 @@ type Component struct {
type Snapshot struct {
Components []Component
Deferred bool
// InstalledAt is when the installed release was committed on this host,
// from its installed.json. Zero when the host doesn't record one.
InstalledAt time.Time `json:"installed_at"`
}
func (s Snapshot) Available() []Component {
+54
View File
@@ -40,6 +40,7 @@ const (
journalDir = "transaction"
journalFile = "journal.json"
snapshotFile = "db.pre-update.dump"
installedFile = "installed.json"
lockWait = 60 * time.Second
)
@@ -126,6 +127,39 @@ type journal struct {
// JournalPath is where an unfinished transaction lives.
func JournalPath(stateDir string) string { return filepath.Join(stateDir, journalDir) }
// installedRecord is the host's durable note of which release it last
// committed (or rolled back to) and when, so a canary can count its window
// from the actual install rather than the release statement.
type installedRecord struct {
Version string `json:"version"`
CommittedAt time.Time `json:"committed_at"`
}
// recordInstall writes installed.json atomically: the file is the source of
// truth for when the running release was installed.
func recordInstall(stateDir, version string, at time.Time) error {
data, err := json.Marshal(installedRecord{Version: version, CommittedAt: at.UTC()})
if err != nil {
return err
}
return fsutil.WriteFileAtomic(filepath.Join(stateDir, installedFile), data, 0o600)
}
// LastInstall reads the host's installed record. ok is false when the file is
// missing or malformed, as on a host that updated before install times were
// recorded.
func LastInstall(stateDir string) (version string, at time.Time, ok bool) {
data, err := os.ReadFile(filepath.Join(stateDir, installedFile))
if err != nil {
return "", time.Time{}, false
}
var record installedRecord
if err := json.Unmarshal(data, &record); err != nil || record.Version == "" || record.CommittedAt.IsZero() {
return "", time.Time{}, false
}
return record.Version, record.CommittedAt, true
}
// Run drives the transaction in the journal to an outcome. recovering is set
// on boot: it never waits for the lock, and a transaction that was prepared
// but never started is abandoned rather than started unattended.
@@ -158,6 +192,17 @@ func (t *Transaction) Run(ctx context.Context, recovering bool) error {
if err := t.startUnits(ctx, j, ""); err != nil {
return err
}
// A crash between the outcome phase and recordInstall must not lose
// the install record, so the recovery path writes it too.
version := j.Version
if j.Phase == phaseRolledBack {
version = j.Previous[ComponentDaemon]
}
if version != "" {
if err := recordInstall(t.StateDir, version, time.Now().UTC()); err != nil {
return err
}
}
return t.remove()
default:
return t.rollback(ctx, j)
@@ -182,6 +227,9 @@ func (t *Transaction) promote(ctx context.Context, j journal) error {
if err := t.setPhase(&j, phaseCommitted); err != nil {
return err
}
if err := recordInstall(t.StateDir, j.Version, time.Now().UTC()); err != nil {
return fmt.Errorf("record the install: %w", err)
}
return t.remove()
}
@@ -252,6 +300,12 @@ func (t *Transaction) rollback(ctx context.Context, j journal) error {
if err := t.setPhase(&j, phaseRolledBack); err != nil {
return t.incomplete(err)
}
// The host is back on the previous release; installed.json follows it.
if version := j.Previous[ComponentDaemon]; version != "" {
if err := recordInstall(t.StateDir, version, time.Now().UTC()); err != nil {
return t.incomplete(err)
}
}
if err := t.startUnits(ctx, j, started); err != nil {
return t.incomplete(err)
}
@@ -21,6 +21,7 @@ import (
digest "github.com/opencontainers/go-digest"
ocispec "github.com/opencontainers/image-spec/specs-go/v1"
"github.com/samcharles93/archie-core/internal/buildinfo"
"github.com/samcharles93/archie-core/internal/domain/distribution"
"github.com/samcharles93/archie-core/internal/infrastructure/signedoci"
)
@@ -146,6 +147,11 @@ func TestTransaction(t *testing.T) {
// the env file beside its config; pin both to this test's own files so
// the result never depends on the machine's real archie config.
t.Setenv(DatabasePasswordEnv, "test-password")
// Stamp this binary as a release, as a host installed from one is, so the
// journal's previous daemon version is a real version.
stamped := buildinfo.Version
buildinfo.Version = "1.0.0"
defer func() { buildinfo.Version = stamped }()
configPath := filepath.Join(t.TempDir(), "config.toml")
if err := os.WriteFile(configPath, []byte("database_url = \"postgres://archie@/archie?host=/tmp/archie-test\"\n"), 0o600); err != nil {
t.Fatal(err)
@@ -257,10 +263,51 @@ func TestTransaction(t *testing.T) {
found && (got.HealthCheck != tt.want.report || got.RolledBack != (tt.want.report == "failed") || got.RestoredDatabase != tt.want.restoredDatabase) {
t.Errorf("report = %+v (found %v), want %+v", got, found, tt.want)
}
// A transaction that ran to an outcome records which release the
// host now runs and when it was installed.
if tt.prepare == "" && tt.crashAt == "" {
if version, at, ok := LastInstall(tx.StateDir); !ok || version != tt.want.version || at.IsZero() {
t.Errorf("installed.json after the transaction = %q, %v, %v; want %s", version, at, ok, tt.want.version)
}
}
})
}
}
// installed.json is the host's durable record of which release it last
// committed or rolled back to, and when.
func TestLastInstall(t *testing.T) {
dir := t.TempDir()
if _, _, ok := LastInstall(dir); ok {
t.Fatal("a missing installed.json reports ok")
}
at := time.Date(2026, 1, 2, 3, 4, 5, 0, time.UTC)
if err := recordInstall(dir, "1.2.3", at); err != nil {
t.Fatal(err)
}
var raw map[string]any
data, err := os.ReadFile(filepath.Join(dir, installedFile))
if err != nil {
t.Fatal(err)
}
if err := json.Unmarshal(data, &raw); err != nil {
t.Fatalf("installed.json is not JSON: %v", err)
}
if raw["version"] != "1.2.3" || raw["committed_at"] != "2026-01-02T03:04:05Z" {
t.Fatalf("installed.json = %v, want version 1.2.3 and committed_at 2026-01-02T03:04:05Z", raw)
}
version, got, ok := LastInstall(dir)
if !ok || version != "1.2.3" || !got.Equal(at) {
t.Fatalf("LastInstall = %q, %v, %v; want 1.2.3, %v, true", version, got, ok, at)
}
if err := os.WriteFile(filepath.Join(dir, installedFile), []byte("{not json"), 0o600); err != nil {
t.Fatal(err)
}
if _, _, ok := LastInstall(dir); ok {
t.Fatal("a malformed installed.json reports ok")
}
}
// releaseHandler serves one release's zip and SHA256SUMS the way GitHub
// release downloads are laid out.
func releaseHandler(t *testing.T, candidate string, corrupt bool) (http.Handler, ed25519.PublicKey) {
+5 -1
View File
@@ -58,8 +58,12 @@ func (s *Server) accountIdentity(r *http.Request) (identity.Identity, error) {
func (s *Server) requireAccount(h http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
// Any active identity may authenticate: a person, or a service
// account whose bearer token carries a scoped grant. What the
// identity may then do is the policy chain's call, not the
// credential kind's; an inactive identity is refused here.
value, err := s.accountIdentity(r)
if err != nil || value.Kind != identity.KindUser || !value.CanAct() {
if err != nil || !value.CanAct() {
if err == nil {
err = identity.ErrCredentialRejected
}
+144
View File
@@ -2,6 +2,7 @@ package webui
import (
"context"
"encoding/json"
"errors"
"net/http"
"net/http/httptest"
@@ -131,6 +132,149 @@ func TestAccountSessionFailureIsClosed(t *testing.T) {
}
}
// TestRequireAccountAdmitsAnyActiveIdentity pins the bearer-token gate: any
// active identity -- a person or a service account -- is admitted and rides
// the context as the acting identity, while an inactive one is refused, so a
// scoped service-account token can use the API without being a user.
func TestRequireAccountAdmitsAnyActiveIdentity(t *testing.T) {
tests := []struct {
name string
value identity.Identity
want int
}{
{"active user", identity.Identity{ID: "u1", Kind: identity.KindUser, DisplayName: "User", Lifecycle: identity.LifecycleActive}, http.StatusOK},
{"active service account", identity.Identity{ID: "sa1", Kind: identity.KindServiceAccount, DisplayName: "Canary", Lifecycle: identity.LifecycleActive}, http.StatusOK},
{"active bot", identity.Identity{ID: "b1", Kind: identity.KindBot, DisplayName: "Bot", Lifecycle: identity.LifecycleActive}, http.StatusOK},
{"suspended user", identity.Identity{ID: "u2", Kind: identity.KindUser, DisplayName: "User", Lifecycle: identity.LifecycleSuspended}, http.StatusUnauthorized},
{"retired service account", identity.Identity{ID: "sa2", Kind: identity.KindServiceAccount, DisplayName: "Canary", Lifecycle: identity.LifecycleRetired}, http.StatusUnauthorized},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
srv := &Server{
Authenticate: func(context.Context, string) (identity.Identity, error) { return tt.value, nil },
}
var acting identity.IdentityID
handler := srv.requireAccount(http.HandlerFunc(func(_ http.ResponseWriter, r *http.Request) {
if value, ok := ActingIdentity(r.Context()); ok {
acting = value.ID
}
}))
req := httptest.NewRequestWithContext(t.Context(), http.MethodGet, "https://archie.example/api/summary", nil)
req.Header.Set("Authorization", "Bearer archie_pat_test")
rec := httptest.NewRecorder()
handler.ServeHTTP(rec, req)
if rec.Code != tt.want {
t.Fatalf("status=%d want=%d body=%s", rec.Code, tt.want, rec.Body.String())
}
if tt.want == http.StatusOK && acting != tt.value.ID {
t.Fatalf("acting identity = %q, want %q", acting, tt.value.ID)
}
})
}
}
// identityRepo answers Get for the identities a test names.
type identityRepo struct {
identity.Repository
values map[identity.IdentityID]identity.Identity
}
func (s identityRepo) Get(_ context.Context, id identity.IdentityID) (identity.Identity, error) {
value, ok := s.values[id]
if !ok {
return identity.Identity{}, identity.ErrNotFound
}
return value, nil
}
// identityTokenStore carries both token contracts: the remote caller's view
// (embedded) and the store side, whose BindPersonalToken names an identity.
type identityTokenStore struct {
identity.PersonalTokens
bound bool
id identity.IdentityID
subject identity.Subject
name string
}
func (s *identityTokenStore) BindPersonalToken(_ context.Context, id identity.IdentityID, subject identity.Subject, name string, _ *time.Time, _ identity.Audit) error {
s.bound, s.id, s.subject, s.name = true, id, subject, name
return nil
}
func (s *identityTokenStore) SubjectsOf(context.Context, identity.IdentityID, string) ([]identity.PersonalToken, error) {
return nil, nil
}
func (s *identityTokenStore) UnbindSubject(context.Context, identity.IdentityID, identity.Subject, identity.Audit) error {
return nil
}
func (s *identityTokenStore) PersonalTokenOf(context.Context, identity.Subject) (identity.PersonalToken, error) {
return identity.PersonalToken{}, identity.ErrNotFound
}
func (s *identityTokenStore) TouchPersonalToken(context.Context, identity.Subject, time.Time) error {
return nil
}
// TestIdentityTokenCreate pins the per-identity token route: an active
// service account gets its raw token exactly once and the store binds only
// its hash, while an unknown or inactive identity is refused.
func TestIdentityTokenCreate(t *testing.T) {
active := identity.Identity{ID: "sa1", Kind: identity.KindServiceAccount, DisplayName: "Canary", Lifecycle: identity.LifecycleActive}
suspended := identity.Identity{ID: "sa2", Kind: identity.KindServiceAccount, DisplayName: "Old", Lifecycle: identity.LifecycleSuspended}
tests := []struct {
name, id, body string
want int
}{
{"active service account", "sa1", `{"name":"ci","days":30}`, http.StatusCreated},
{"unknown identity", "nope", `{"name":"ci","days":30}`, http.StatusBadRequest},
{"inactive identity", "sa2", `{"name":"ci","days":30}`, http.StatusConflict},
{"bad name", "sa1", `{"name":" ","days":30}`, http.StatusBadRequest},
{"bad lifetime", "sa1", `{"name":"ci","days":10}`, http.StatusBadRequest},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
store := &identityTokenStore{}
srv := &Server{
Identities: identityRepo{values: map[identity.IdentityID]identity.Identity{active.ID: active, suspended.ID: suspended}},
PersonalTokens: store,
}
req := httptest.NewRequestWithContext(t.Context(), http.MethodPost, "https://archie.example/api/identities/"+tt.id+"/tokens", strings.NewReader(tt.body))
req.Header.Set("Content-Type", "application/json")
req.SetPathValue("id", tt.id)
rec := httptest.NewRecorder()
srv.handleIdentityTokenCreate(rec, req)
if rec.Code != tt.want {
t.Fatalf("status=%d want=%d body=%s", rec.Code, tt.want, rec.Body.String())
}
if tt.want != http.StatusCreated {
if store.bound {
t.Fatal("a refused request still bound a token")
}
return
}
var body struct {
ID string `json:"id"`
Token string `json:"token"`
}
if err := json.Unmarshal(rec.Body.Bytes(), &body); err != nil {
t.Fatalf("response: %v (%s)", err, rec.Body.String())
}
if !strings.HasPrefix(body.Token, "archie_pat_") || body.ID == "" {
t.Fatalf("response must show the raw token once: %+v", body)
}
if !store.bound || store.id != active.ID || store.name != "ci" {
t.Fatalf("bound = %+v, want id %q name %q", store, active.ID, "ci")
}
if store.subject.Issuer != identity.PersonalTokenIssuer || store.subject.Subject != body.ID {
t.Fatalf("store kept subject %+v, want the token's hash %q under %q", store.subject, body.ID, identity.PersonalTokenIssuer)
}
})
}
}
type unavailableAccounts struct{ identity.Accounts }
func (unavailableAccounts) AccountSetupRequired(context.Context) (bool, error) {
+13
View File
@@ -15,6 +15,7 @@ import (
"github.com/samcharles93/archie-core/internal/domain/lifecycle"
"github.com/samcharles93/archie-core/internal/domain/messaging"
"github.com/samcharles93/archie-core/internal/infrastructure/configuration"
"github.com/samcharles93/archie-core/internal/releaseupdate"
)
@@ -513,6 +514,11 @@ func (s *Server) handleChatUpdate(w http.ResponseWriter, r *http.Request) {
writeUpdateCheckError(w, err)
return
}
// The snapshot carries when the installed release was committed on this
// host, so a canary can count its window from the actual install.
if _, at, ok := releaseupdate.LastInstall(updateStateDir()); ok {
snapshot.InstalledAt = at
}
writeJSON(w, map[string]any{
"snapshot": snapshot,
"available": snapshot.Available(),
@@ -520,6 +526,13 @@ func (s *Server) handleChatUpdate(w http.ResponseWriter, r *http.Request) {
})
}
// updateStateDir resolves the host's update state directory the same way the
// daemon does, so the dashboard reads the installed.json its transactions
// write.
func updateStateDir() string {
return configuration.UpdateStateDir()
}
func (s *Server) handleChatUpdateDefer(w http.ResponseWriter, r *http.Request) {
chat, ok := s.chatReady(w)
if !ok {
+66
View File
@@ -7,12 +7,25 @@ import (
"errors"
"net/http"
"strings"
"time"
"github.com/samcharles93/archie-core/internal/domain/access"
"github.com/samcharles93/archie-core/internal/domain/identity"
"github.com/samcharles93/archie-core/internal/domain/org"
"github.com/samcharles93/archie-core/internal/infrastructure/staterpc"
)
// identityTokenBinder is the one store-side operation the per-identity token
// route needs: binding a token to a NAMED identity. The remote client's
// caller-scoped PersonalTokens view cannot express that, so the store fronts
// it as its own RPC and the Client carries it under this name.
type identityTokenBinder interface {
BindPersonalToken(ctx context.Context, id identity.IdentityID, subject identity.Subject, name string, expiresAt *time.Time, audit identity.Audit) error
}
// The production store client satisfies the route's narrow contract.
var _ identityTokenBinder = (*staterpc.Client)(nil)
type identityRequest struct {
DisplayName string `json:"display_name"`
Kind identity.Kind `json:"kind"`
@@ -81,6 +94,59 @@ func (s *Server) handleIdentityCommand(w http.ResponseWriter, r *http.Request) {
writeJSON(w, value)
}
// handleIdentityTokenCreate issues an API token for one named identity, which
// is how a non-user identity gets its bearer credential: a person's token
// comes from /api/tokens, a service account's from here. The raw token is
// returned exactly once; the store keeps only its hash.
func (s *Server) handleIdentityTokenCreate(w http.ResponseWriter, r *http.Request) {
id := identity.IdentityID(r.PathValue("id"))
if s.Identities == nil {
http.Error(w, "identity store unavailable", http.StatusServiceUnavailable)
return
}
value, err := s.Identities.Get(r.Context(), id)
if errors.Is(err, identity.ErrNotFound) {
http.Error(w, "No such identity.", http.StatusBadRequest)
return
}
if err != nil {
writeIdentityError(w, err)
return
}
if !value.CanAct() {
http.Error(w, "That identity may not act.", http.StatusConflict)
return
}
name, expiresAt, ok := decodeTokenRequest(w, r)
if !ok {
return
}
// The store side of the PersonalTokens contract binds a token to a named
// identity; the remote caller's view only ever names its own principal.
binder, ok := s.PersonalTokens.(identityTokenBinder)
if !ok {
http.Error(w, "identity token binding unavailable", http.StatusServiceUnavailable)
return
}
raw, subject, err := identity.NewPersonalToken()
if err != nil {
http.Error(w, "cannot create token", http.StatusInternalServerError)
return
}
audit, err := webAudit(r.Context())
if err != nil {
http.Error(w, "cannot create request ID", http.StatusInternalServerError)
return
}
if err := binder.BindPersonalToken(r.Context(), id, subject, name, expiresAt, audit); err != nil {
writeIdentityError(w, err)
return
}
w.Header().Set("Cache-Control", "no-store")
w.WriteHeader(http.StatusCreated)
writeJSON(w, map[string]string{"id": subject.Subject, "token": raw})
}
// webAudit attributes a dashboard write to the request's own principal: the
// person the dashboard acts as. Only a request with no principal at all falls
// back to the System identity, which is a real identity the repository
+31 -21
View File
@@ -41,27 +41,8 @@ func (s *Server) handlePersonalTokenCreate(w http.ResponseWriter, r *http.Reques
if !s.personalTokensReady(w, r) {
return
}
var body struct {
Name string `json:"name"`
Days int `json:"days"`
}
if err := json.NewDecoder(http.MaxBytesReader(w, r.Body, 4<<10)).Decode(&body); err != nil {
http.Error(w, "invalid request", http.StatusBadRequest)
return
}
name := strings.TrimSpace(body.Name)
if name == "" || utf8.RuneCountInString(name) > maxTokenNameLength {
http.Error(w, "Name a token in up to 40 characters.", http.StatusBadRequest)
return
}
var expiresAt *time.Time
switch body.Days {
case 0:
case 7, 30, 90:
t := time.Now().UTC().AddDate(0, 0, body.Days)
expiresAt = &t
default:
http.Error(w, "Lifetime is 7, 30 or 90 days, or none.", http.StatusBadRequest)
name, expiresAt, ok := decodeTokenRequest(w, r)
if !ok {
return
}
raw, subject, err := identity.NewPersonalToken()
@@ -78,6 +59,35 @@ func (s *Server) handlePersonalTokenCreate(w http.ResponseWriter, r *http.Reques
writeJSON(w, map[string]string{"id": subject.Subject, "token": raw})
}
// decodeTokenRequest reads a token request's name and lifetime, the shape the
// personal-token route and the per-identity token route share.
func decodeTokenRequest(w http.ResponseWriter, r *http.Request) (string, *time.Time, bool) {
var body struct {
Name string `json:"name"`
Days int `json:"days"`
}
if err := json.NewDecoder(http.MaxBytesReader(w, r.Body, 4<<10)).Decode(&body); err != nil {
http.Error(w, "invalid request", http.StatusBadRequest)
return "", nil, false
}
name := strings.TrimSpace(body.Name)
if name == "" || utf8.RuneCountInString(name) > maxTokenNameLength {
http.Error(w, "Name a token in up to 40 characters.", http.StatusBadRequest)
return "", nil, false
}
var expiresAt *time.Time
switch body.Days {
case 0:
case 7, 30, 90:
t := time.Now().UTC().AddDate(0, 0, body.Days)
expiresAt = &t
default:
http.Error(w, "Lifetime is 7, 30 or 90 days, or none.", http.StatusBadRequest)
return "", nil, false
}
return name, expiresAt, true
}
func (s *Server) handlePersonalTokenRevoke(w http.ResponseWriter, r *http.Request) {
if !s.personalTokensReady(w, r) {
return
+22 -5
View File
@@ -318,16 +318,17 @@ func routeOverride(r *http.Request, action access.Action, path string) (access.A
return actionManage(action), access.KindPolicy, segmentValue(path, 2), true
case matchPrefix(path, "/api/control-plane/resources"):
return controlPlaneResourceRoute(action, path)
case updateCommandRoute(action, path):
// Triggering or deferring an install changes the update object, not
// a workflow run: the dashboard kind carries the update's policy.
return access.ActionUpdate, access.KindDashboard, "update", true
case matchPrefix(path, "/api/chat"):
return chatRoute(action)
case matchSegment(path, "/api/sources/", "/secret"):
// Rotating a source's secret hands back its value.
return access.ActionReadSecret, access.KindSecret, segmentValue(path, 2), true
case matchPrefix(path, "/api/harness/terminal"):
// Opening the setup terminal updates the binding's secret.
return access.ActionUpdate, access.KindSecret, "", true
case matchPrefix(path, "/api/harness/bindings"):
return access.ActionRead, access.KindSecret, "", true
case matchPrefix(path, "/api/harness/terminal"), matchPrefix(path, "/api/harness/bindings"):
return harnessSecretRoute(path)
case matchPrefix(path, "/api/channels"), matchPrefix(path, "/api/config"),
matchPrefix(path, "/api/logs"), matchPrefix(path, "/api/tokens"):
return dashboardRoute(action, path)
@@ -335,6 +336,15 @@ func routeOverride(r *http.Request, action access.Action, path string) (access.A
return action, "", "", false
}
// harnessSecretRoute maps the harness surfaces, which work with the binding's
// secret: opening the setup terminal updates it, the bindings view reads it.
func harnessSecretRoute(path string) (access.Action, access.ResourceKind, string, bool) {
if matchPrefix(path, "/api/harness/terminal") {
return access.ActionUpdate, access.KindSecret, "", true
}
return access.ActionRead, access.KindSecret, "", true
}
// dashboardRoute maps the dashboard's own routes: channel settings are
// instance administration, while config, logs and a person's own tokens act
// only as that person, needing no more than a dashboard read.
@@ -395,6 +405,13 @@ func orgRouteAction(action access.Action, path string) access.Action {
return access.ActionUpdate
}
// updateCommandRoute reports whether the request is one of the chat update
// commands, which act on the update object rather than running a workflow.
func updateCommandRoute(action access.Action, path string) bool {
return action == access.ActionCreate &&
(path == "/api/chat/update/install" || path == "/api/chat/update/defer")
}
// chatRoute maps a chat request: posting runs a workflow, anything else reads
// the dashboard.
func chatRoute(action access.Action) (access.Action, access.ResourceKind, string, bool) {
+29
View File
@@ -223,6 +223,35 @@ func TestChannelReloadRoute(t *testing.T) {
}
}
// TestChatRouteMapping pins the chat routes' actions: posting a message runs a
// workflow, while triggering or deferring an update changes the update object
// on the dashboard kind, so a scoped grant can carry it without any run right.
func TestChatRouteMapping(t *testing.T) {
tests := []struct {
method, path string
action access.Action
kind access.ResourceKind
id string
}{
{http.MethodPost, "/api/chat/update/install", access.ActionUpdate, access.KindDashboard, "update"},
{http.MethodPost, "/api/chat/update/defer", access.ActionUpdate, access.KindDashboard, "update"},
{http.MethodPost, "/api/chat/message", access.ActionRun, access.KindWorkflow, ""},
{http.MethodPost, "/api/chat/stream", access.ActionRun, access.KindWorkflow, ""},
{http.MethodPost, "/api/chat/cancel", access.ActionRun, access.KindWorkflow, ""},
{http.MethodPost, "/api/chat/answer", access.ActionRun, access.KindWorkflow, ""},
{http.MethodGet, "/api/chat/update", access.ActionRead, access.KindDashboard, ""},
{http.MethodGet, "/api/chat/sessions", access.ActionRead, access.KindDashboard, ""},
}
for _, tt := range tests {
t.Run(tt.method+" "+tt.path, func(t *testing.T) {
action, kind, id := accessRequest(httptest.NewRequestWithContext(t.Context(), tt.method, tt.path, nil))
if action != tt.action || kind != tt.kind || id != tt.id {
t.Fatalf("accessRequest = %q on %q (%q), want %q on %q (%q)", action, kind, id, tt.action, tt.kind, tt.id)
}
})
}
}
func TestPersonalTokensWithoutPerson(t *testing.T) {
for _, method := range []string{http.MethodGet, http.MethodPost, http.MethodDelete} {
t.Run(method, func(t *testing.T) {
+1
View File
@@ -409,6 +409,7 @@ func (s *Server) registerConfigAndLogRoutes(mux *http.ServeMux) {
mux.HandleFunc("DELETE /api/tokens/{id}", s.handlePersonalTokenRevoke)
mux.HandleFunc("POST /api/identities", instanceOnly(s.handleIdentityCreate))
mux.HandleFunc("POST /api/identities/{id}/{command}", instanceOnly(s.handleIdentityCommand))
mux.HandleFunc("POST /api/identities/{id}/tokens", instanceOnly(s.handleIdentityTokenCreate))
mux.HandleFunc("GET /api/config", instanceOnly(s.handleConfig))
mux.HandleFunc("GET /api/secret-engines", instanceOnly(s.handleSecretEngines))
mux.HandleFunc("POST /api/secret-references/check", instanceOnly(s.handleSecretCheck))
+11
View File
@@ -18,6 +18,7 @@ service ForgeService {
rpc AssignedIssues(AssignedIssuesRequest) returns (AssignedIssuesResponse);
rpc IssuesWithLabel(IssuesWithLabelRequest) returns (IssuesWithLabelResponse);
rpc Comment(CommentRequest) returns (CommentResponse);
rpc CreateIssue(CreateIssueRequest) returns (CreateIssueResponse);
rpc CloseIssue(CloseIssueRequest) returns (CloseIssueResponse);
rpc React(ReactRequest) returns (ReactResponse);
rpc SetStateLabel(SetStateLabelRequest) returns (SetStateLabelResponse);
@@ -86,6 +87,16 @@ message CommentRequest {
}
message CommentResponse { int64 id = 1; }
// CreateIssueRequest opens an issue with title, body and optional labels,
// returning its number.
message CreateIssueRequest {
RepoRef repo = 1;
string title = 2;
string body = 3;
repeated string labels = 4;
}
message CreateIssueResponse { int32 number = 1; }
message CloseIssueRequest {
RepoRef repo = 1;
int32 number = 2;
+13
View File
@@ -27,6 +27,12 @@ service AccountService {
rpc AddPersonalToken(AddPersonalTokenRequest) returns (AddPersonalTokenResponse);
rpc ListPersonalTokens(ListPersonalTokensRequest) returns (ListPersonalTokensResponse);
rpc RevokePersonalToken(RevokePersonalTokenRequest) returns (RevokePersonalTokenResponse);
// BindIdentityPersonalToken binds a personal token to a NAMED identity
// instead of the caller's principal, which is how a service account gets
// its bearer credential. Only non-user targets are accepted: a person's
// token comes from AddPersonalToken. The audit actor is the caller's
// principal, never a request field.
rpc BindIdentityPersonalToken(BindIdentityPersonalTokenRequest) returns (BindIdentityPersonalTokenResponse);
}
// PersonalToken identifies a token by the SHA-256 it binds as; the token
@@ -48,6 +54,13 @@ message ListPersonalTokensRequest {}
message ListPersonalTokensResponse { repeated PersonalToken tokens = 1; }
message RevokePersonalTokenRequest { string id = 1; }
message RevokePersonalTokenResponse {}
message BindIdentityPersonalTokenRequest {
string identity_id = 1;
string id = 2;
string name = 3;
google.protobuf.Timestamp expires_at = 4; // unset: never expires
}
message BindIdentityPersonalTokenResponse {}
message AccountSetupRequest {}
message AccountSetupResponse { bool required = 1; }
message RegisterAccountRequest {
+424
View File
@@ -0,0 +1,424 @@
#!/bin/sh
# Rehearse the release-canary loop against a throwaway local host. Nothing
# here touches production: a local OCI registry (docker run registry:2 on a
# loopback port), a throwaway signing key, a test release published to that
# registry (a stamped archied binary and a real agent image in a proper
# distribution zip), and a local stack (state store, gateway, archied,
# archie-ui) with its own config, state dir and ports. The loop's commands --
# release canary start, release canary status, release canary check and
# release canary promote -- are then run against that host, each step printed.
# The loop authenticates with a scoped service-account token carrying only
# the org-canary-grant policy (#1727), and a step proves that token is denied
# everything outside the grant.
# The local host has no systemd, so once the install has switched the binary
# the script restarts archied itself, the way an unmanaged host's operator
# would.
#
# A step that fails is printed and makes the run exit nonzero, so a rehearsal
# never looks greener than it was. The only hard precondition is docker:
# without it there is no registry, PostgreSQL or agent image.
#
# Never part of the gate: task check and CI do not call this.
set -eu
repo=$(CDPATH= cd -- "$(dirname -- "$0")/.." && pwd)
work=$(mktemp -d "${TMPDIR:-/tmp}/archie-canary-rehearse.XXXXXX")
name=$(basename "$work")
bin=$work/bin
logs=$work/logs
pids=""
containers=""
keep=0 # set when a step fails: the workdir is kept for inspection
cleanup() {
trap - EXIT INT TERM
for pid in $pids; do kill -- "-$pid" 2>/dev/null || kill "$pid" 2>/dev/null || true; done
for c in $containers; do docker rm -f "$c" >/dev/null 2>&1 || true; done
if [ "$keep" -gt 0 ]; then
echo "canary-rehearse: keeping $work for inspection" >&2
else
rm -rf "$work"
fi
}
trap cleanup EXIT INT TERM
die() {
echo "canary-rehearse: $*" >&2
keep=1
exit 1
}
# --- preflight ---------------------------------------------------------------
for tool in go curl python3 zip sha256sum timeout setsid openssl docker; do
command -v "$tool" >/dev/null 2>&1 || die "$tool is required but not on PATH"
done
if ! docker info >/dev/null 2>&1; then
die "docker is unavailable (docker info failed): the rehearsal needs it for the local OCI registry and PostgreSQL. Start the docker daemon or skip task canary:rehearse"
fi
release_version=${CANARY_REHEARSE_VERSION:-9.9.9-canary.1}
host_version="0.0.0-rehearse"
# Seven loopback ports, picked by binding port 0.
set -- $(python3 -c '
import socket
ports = []
while len(ports) < 7:
s = socket.socket()
s.bind(("127.0.0.1", 0))
ports.append(s.getsockname()[1])
s.close()
print(" ".join(map(str, ports)))
')
reg_port=$1 pg_port=$2 web_port=$3 state_port=$4 gw_port=$5 daemon_port=$6 health_port=$7
# --- registry and PostgreSQL -------------------------------------------------
echo "== starting local OCI registry on 127.0.0.1:$reg_port and PostgreSQL on 127.0.0.1:$pg_port"
timeout 300 docker run -d --name "$name-registry" -p "127.0.0.1:$reg_port:5000" registry:2 >/dev/null ||
die "could not start registry:2 (is the image pullable?)"
containers="$containers $name-registry"
timeout 300 docker run -d --name "$name-pg" \
-e POSTGRES_USER=archie -e POSTGRES_PASSWORD=archie -e POSTGRES_DB=archie \
-p "127.0.0.1:$pg_port:5432" postgres:18 >/dev/null ||
die "could not start postgres:18 (is the image pullable?)"
containers="$containers $name-pg"
# --- build the host's binaries (no_ui: the rehearsal never serves the SPA) ----
echo "== building archie-state-store, archie-gateway, archied, archie-ui (no_ui)"
mkdir -p "$bin" "$logs"
ldflags="-X github.com/samcharles93/archie-core/internal/installtype.buildType=binary -X github.com/samcharles93/archie-core/internal/buildinfo.Version=$host_version"
for svc in archie-state-store archie-gateway archied archie-ui; do
go -C "$repo" build -tags no_ui -trimpath -ldflags "$ldflags" -o "$bin/$svc" "./cmd/$svc" ||
die "go build ./cmd/$svc failed"
done
wait_http() { # url label tries
i=0
while [ "$i" -lt "${3:-30}" ]; do
if curl -fsS --max-time 2 "$1" >/dev/null 2>&1; then return 0; fi
i=$((i + 1)); sleep 1
done
die "$2 did not answer at $1 within ${3:-30}s"
}
wait_http "http://127.0.0.1:$reg_port/v2/" "the local registry" 30
i=0
while ! docker exec "$name-pg" pg_isready -h 127.0.0.1 -p 5432 -U archie >/dev/null 2>&1; do
i=$((i + 1))
[ "$i" -gt 90 ] && die "PostgreSQL did not become ready within 90s"
sleep 1
done
# --- throwaway signing key and a test release --------------------------------
echo "== generating a throwaway release signing key"
pub=$("$bin/archied" release keygen -seed "$work/seed") || die "release keygen failed"
[ -n "$pub" ] || die "release keygen printed no public key"
seed=$(cat "$work/seed")
# A real agent image in the local registry, so the install's image pull by
# digest succeeds. The Dockerfile stamps the agent with the release version.
echo "== building and pushing the archie-agent test image (this takes a few minutes)"
timeout 1200 docker build -q -f "$repo/Dockerfile" --build-arg RUNTIME_VERSION="$release_version" \
-t "127.0.0.1:$reg_port/archie-agent:v$release_version" "$repo" >/dev/null ||
die "docker build of the agent image failed"
timeout 600 docker push -q "127.0.0.1:$reg_port/archie-agent:v$release_version" >/dev/null ||
die "docker push of the agent image failed"
agent_image=$(docker image inspect -f '{{range .RepoDigests}}{{println .}}{{end}}' \
"127.0.0.1:$reg_port/archie-agent:v$release_version" | grep "^127\.0\.0\.1:$reg_port/" | head -1)
[ -n "$agent_image" ] || die "could not resolve the pushed agent image digest"
# A proper distribution zip, built the way deploy.yml builds it: every binary
# the repo's release.json names, each stamped with the release version, plus
# the manifest with the agent image pinned in.
dist="archie-core-archied-v$release_version-linux-amd64"
echo "== building the stamped release binaries and zipping $dist.zip"
mkdir -p "$work/dist/$dist"
release_ldflags="-X github.com/samcharles93/archie-core/internal/installtype.buildType=binary -X github.com/samcharles93/archie-core/internal/buildinfo.Version=$release_version -X github.com/samcharles93/archie-core/internal/buildinfo.Runtime=$release_version -X github.com/samcharles93/archie-core/internal/app/agentworker.version=$release_version"
for cmd in $(python3 -c 'import json; print(" ".join(json.load(open("'"$repo"'/release.json"))["required_topology"]["units"] + json.load(open("'"$repo"'/release.json"))["required_topology"].get("binaries", [])))'); do
go -C "$repo" build -tags no_ui -trimpath -ldflags "$release_ldflags" \
-o "$work/dist/$dist/$cmd" "./cmd/$cmd" || die "go build of $cmd failed"
done
python3 -c 'import json, sys
m = json.load(open(sys.argv[1])); m["agent_image"] = sys.argv[2]
print(json.dumps(m))' "$repo/release.json" "$agent_image" > "$work/dist/$dist/release.json"
(CDPATH= cd -- "$work/dist" && zip -q -r "$work/release.zip" "$dist")
echo "== publishing test release $release_version to 127.0.0.1:$reg_port/archie"
ARCHIE_RELEASE_SEED=$seed "$bin/archied" release publish \
-source "127.0.0.1:$reg_port/archie" -version "$release_version" \
-zip "$work/release.zip" -agent-image "$agent_image" ||
die "release publish failed"
# --- the local host ----------------------------------------------------------
export XDG_CONFIG_HOME=$work/config XDG_DATA_HOME=$work/data XDG_STATE_HOME=$work/state
export ARCHIE_UPDATE_STATE_DIR=$work/update-state
# Point XDG_RUNTIME_DIR at a path that doesn't exist, so systemctl --user has
# no bus: the rehearsal host reports unmanaged and the install switches the
# binaries without trying to restart units through systemd.
export XDG_RUNTIME_DIR=$work/no-user-bus
mkdir -p "$XDG_CONFIG_HOME/archie" "$XDG_DATA_HOME" "$XDG_STATE_HOME" "$ARCHIE_UPDATE_STATE_DIR"
cfg=$XDG_CONFIG_HOME/archie/config.toml
# A throwaway CA and per-service certificates, the way `task dev:tls` issues
# them: archie-ui dials the daemon's harness sessions over mTLS even on
# loopback, so the host cannot come up without [tls].
tls=$work/tls
mkdir -p "$tls"
openssl req -x509 -newkey ec -pkeyopt ec_paramgen_curve:prime256v1 -nodes -days 3650 \
-subj "/CN=archie-rehearse-ca" -keyout "$tls/ca-key.pem" -out "$tls/ca.pem" 2>/dev/null ||
die "could not create the throwaway CA"
for s in archied archie-gateway archie-messaging archie-state-store archie-ui; do
openssl req -x509 -newkey ec -pkeyopt ec_paramgen_curve:prime256v1 -nodes -days 3650 \
-subj "/CN=$s" -addext "subjectAltName=DNS:$s" -addext extendedKeyUsage=serverAuth,clientAuth \
-CA "$tls/ca.pem" -CAkey "$tls/ca-key.pem" -keyout "$tls/$s-key.pem" -out "$tls/$s.pem" 2>/dev/null ||
die "could not issue a certificate for $s"
done
sed \
-e "s|^# database_url = .*|database_url = \"postgres://archie:archie@127.0.0.1:$pg_port/archie?sslmode=disable\"|" \
-e "s|^listen = \"127.0.0.1:8485\"|listen = \"127.0.0.1:$health_port\"|" \
-e "s|^listen = \"127.0.0.1:8484\"|listen = \"127.0.0.1:$web_port\"|" \
-e "s|^target = \"127.0.0.1:8585\"|target = \"127.0.0.1:$gw_port\"\nlisten = \"127.0.0.1:$gw_port\"|" \
-e "s|^target = \"127.0.0.1:9090\"|target = \"127.0.0.1:$state_port\"\nlisten = \"127.0.0.1:$state_port\"|" \
"$repo/config.example.toml" > "$cfg"
cat >> "$cfg" <<EOF
[services.daemon]
target = "127.0.0.1:$daemon_port"
listen = "127.0.0.1:$daemon_port"
[tls]
ca_file = "$tls/ca.pem"
cert_dir = "$tls"
EOF
spawn() { # name command...
svc=$1; shift
setsid "$@" >"$logs/$svc.log" 2>&1 &
pids="$pids $!"
}
wait_port() { # port label tries
i=0
while [ "$i" -lt "${3:-90}" ]; do
if python3 -c "import socket,sys; s=socket.socket(); s.settimeout(1); sys.exit(0 if s.connect_ex(('127.0.0.1', $1)) == 0 else 1)"; then
return 0
fi
i=$((i + 1)); sleep 1
done
die "$2 did not listen on 127.0.0.1:$1; see $logs/$2.log (removed on exit -- rerun to inspect)"
}
host_pids=""
start_host() {
spawn archie-state-store "$bin/archie-state-store"
wait_port "$state_port" archie-state-store
# The gateway only listens once archied has published its embedded NATS
# endpoint, so the rest start together, as e2e/stack.sh does.
spawn archie-gateway "$bin/archie-gateway"
spawn archied "$bin/archied"
spawn archie-ui "$bin/archie-ui"
host_pids="$pids"
wait_port "$gw_port" archie-gateway
wait_port "$daemon_port" archied
wait_port "$web_port" archie-ui
}
echo "== starting the local host (state store, gateway, archied, archie-ui)"
start_host
base="http://127.0.0.1:$web_port"
cookie=$work/cookies.txt
api() { # method path [body]
method=$1 path=$2 body=${3-}
if [ -n "$body" ]; then
curl -sS --max-time 15 -b "$cookie" -c "$cookie" -X "$method" "$base$path" \
-H 'Content-Type: application/json' -H 'X-Archie-CSRF: 1' -H "Origin: $base" -d "$body"
else
curl -sS --max-time 15 -b "$cookie" -c "$cookie" "$base$path"
fi
}
py() { python3 -c "import sys, json; d = json.load(sys.stdin); print($1)"; }
# One throwaway account on the throwaway host, then a personal API token,
# which is what the canary commands authenticate with.
email="canary-rehearse@example.test"
password="archie-canary-rehearse-password"
account=$(python3 -c 'import json, sys
print(json.dumps(dict(email=sys.argv[1], password=sys.argv[2], display_name="Canary rehearsal",
organisation_name="Canary rehearsal", workspace_name="Rehearsal", public_url=sys.argv[3])))' \
"$email" "$password" "$base")
setup=$(api GET /api/auth/status)
if printf '%s' "$setup" | py 'd["setup_required"]' | grep -q True; then
api POST /api/auth/setup "$account" >/dev/null || die "account setup failed"
else
api POST /api/auth/login "$account" >/dev/null || die "login failed: $setup"
fi
token=$(api POST /api/tokens '{"name":"canary-rehearse","days":7}' | py 'd["token"]') ||
die "could not create a personal API token on the local host"
# Point the host's update settings at the local registry and key.
doc=$(api GET /api/control-plane/resources/update-settings)
ver=$(printf '%s' "$doc" | py 'd["resource"]["version"]')
value=$(python3 -c 'import json, sys
print(json.dumps({"channel": "stable", "pin": "", "source": sys.argv[1], "key": sys.argv[2]}))' \
"127.0.0.1:$reg_port/archie" "$pub")
resp=$(api POST /api/control-plane/resources/update-settings/commands/replace \
"{\"value\":$value,\"expected_version\":$ver}")
printf '%s' "$resp" | grep -q '"resource"' || die "could not set update-settings on the local host: $resp"
# --- the scoped canary grant (#1727): a service account, not instance admin --
# Create a service_account identity, mint a token for it, install the
# org-canary-grant policy, then prove the token can read the signals but
# nothing else.
echo
echo "== creating the canary service account and installing the scoped grant"
canary_id=$(api POST /api/identities '{"display_name":"canary","kind":"service_account"}' | py 'd["id"]') ||
die "could not create the canary service account"
[ -n "$canary_id" ] || die "identity create printed no id"
scoped=$(api POST "/api/identities/$canary_id/tokens" '{"name":"canary","days":7}' | py 'd["token"]') ||
die "could not mint a token for the canary identity"
[ -n "$scoped" ] || die "token create printed no token"
grant_policy() { # id prefix permit|forbid -> policy JSON on stdout
python3 -c 'import json, sys
who, effect, identity = sys.argv[1], sys.argv[2], sys.argv[3]
actions = """(
(action == Archie::Action::"read" && ["dashboard", "task"].contains(resource.kind)) ||
(action == Archie::Action::"read" && resource == Archie::Object::"update-settings") ||
(action == Archie::Action::"update" && resource == Archie::Object::"update") ||
(action == Archie::Action::"manage_identities" && resource == Archie::Object::"update-settings")
)"""
body = """ resource.org == principal.org &&
principal == Archie::Identity::"%s" &&
%s%s""" % (identity, "!" if effect == "forbid" else "", actions)
print(json.dumps({"id": "org-canary-grant" + ("-forbid" if effect == "forbid" else ""),
"level": "org", "org_id": "org-sys",
"text": "%s(principal, action, resource) when {\n%s\n};" % (effect, body)}))' "$1" "$2" "$canary_id"
}
for effect in permit forbid; do
resp=$(api PUT /api/access/policies "$(grant_policy grant "$effect")")
printf '%s' "$resp" | grep -q '"version"' || die "could not install the canary grant $effect policy: $resp"
done
bearer() { # path -> curl with the scoped token, prints the status code
curl -sS --max-time 15 -o /dev/null -w '%{http_code}' \
-H "Authorization: Bearer $scoped" "$base$1"
}
bearer_body() { # path -> curl with the scoped token, prints the body
curl -sS --max-time 15 -H "Authorization: Bearer $scoped" "$base$1"
}
# The policy chain reloads asynchronously; allow a few seconds for the grant.
# The negative probe can run now; the positive one must wait for the canary
# loop to switch the channel to next (a missing stable tag is a 502 from the
# update check, not an authorization answer).
i=0
code=000
while :; do
code=$(bearer /api/access/policies)
[ "$code" != "200" ] && break
i=$((i + 1)); [ "$i" -gt 45 ] && die "the scoped canary token can read the policies API: the grant is not scoped"
sleep 1
done
echo "scoped token reads /api/access/policies: $code (denied, as intended)"
# --- the canary loop, each step printed ---------------------------------------
failed=0
run_step() { # description command...
desc=$1; shift
echo
echo "== $desc"
printf '$ %s\n' "$*"
if "$@" 2>&1; then
echo "-- ok"
else
rc=$?
echo "-- FAILED (exit $rc)"
failed=$((failed + 1))
keep=1
fi
}
# The canary loop runs with the scoped service-account token, not the admin
# one: that is the point of #1727.
export ARCHIE_CANARY_TOKEN=$scoped
echo
echo "== release canary start -- point the host at next and install $release_version"
printf '$ archied release canary start -dashboard %s -version %s -source 127.0.0.1:%s/archie -key <pub>\n' \
"$base" "$release_version" "$reg_port"
timeout 600 "$bin/archied" release canary start -dashboard "$base" -version "$release_version" \
-source "127.0.0.1:$reg_port/archie" -key "$pub" >"$work/start.out" 2>&1 &
start_pid=$!
# The local host has no systemd: the install switches the binary and records
# the install time, but nothing restarts the daemon. Restart archied once the
# install has committed, the way an unmanaged host's operator would, so the
# host reports the new version.
i=0
while [ ! -f "$ARCHIE_UPDATE_STATE_DIR/installed.json" ]; do
kill -0 "$start_pid" 2>/dev/null || break
i=$((i + 1)); [ "$i" -gt 300 ] && break
sleep 1
done
if [ -f "$ARCHIE_UPDATE_STATE_DIR/installed.json" ]; then
# Restart every service, not just the daemon: the update snapshot reports
# the serving binary's version, so the whole host must come back on the
# new release.
for pid in $host_pids; do kill "$pid" 2>/dev/null || true; done
sleep 1
pids=""
start_host
fi
start_rc=0
wait "$start_pid" || start_rc=$?
cat "$work/start.out"
if [ "$start_rc" -eq 0 ]; then
echo "-- ok"
else
echo "-- FAILED (exit $start_rc)"
failed=$((failed + 1))
keep=1
fi
# Now that the canary follows next, the scoped token's positive probe: the
# policy chain reloads asynchronously, so allow a few seconds.
i=0
code=000
while :; do
code=$(bearer /api/chat/update)
[ "$code" = "200" ] && break
i=$((i + 1)); [ "$i" -gt 45 ] && die "the scoped canary token never got read access to /api/chat/update (last status $code: $(bearer_body /api/chat/update))"
sleep 1
done
echo "scoped token reads /api/chat/update: 200"
run_step "release canary status -- what the canary runs and how the window is going" \
timeout 120 "$bin/archied" release canary status -dashboard "$base" \
-source "127.0.0.1:$reg_port/archie" -key "$pub"
run_step "release canary check -- judge the installed release (still settling right after the install)" \
timeout 300 "$bin/archied" release canary check -dashboard "$base" \
-source "127.0.0.1:$reg_port/archie" -key "$pub" -checkout "$repo"
run_step "release canary promote -- promote $release_version now that its hard checks pass" \
timeout 120 "$bin/archied" release canary promote -dashboard "$base" -version "$release_version" \
-source "127.0.0.1:$reg_port/archie" -key "$pub"
echo
if [ "$failed" -gt 0 ]; then
echo "canary-rehearse: $failed step(s) failed; the steps above show why." >&2
if [ "$keep" -gt 0 ] && [ -d "$logs" ]; then
for f in "$logs"/*.log; do
echo "--- $f" >&2
tail -n 20 "$f" >&2
done
fi
exit 1
fi
echo "canary-rehearse: every step ran clean; host was $base, registry 127.0.0.1:$reg_port (both torn down)"
+187
View File
@@ -0,0 +1,187 @@
<script setup lang="ts">
import { computed, onMounted, onUnmounted, ref } from "vue";
import { Badge } from "@/components/ui/badge";
import { MetadataList } from "@/components/ui/metadata-list";
import { Progress } from "@/components/ui/progress";
import { Section } from "@/components/ui/section";
import { Timestamp } from "@/components/ui/timestamp";
import { ApiError, api } from "@/lib/api";
import { useSettingsStore } from "@/stores/settings";
/**
* The release canary on this host, read-only: the update settings in force,
* the installed release, how long it has been installed and how far through
* the default canary window that is. Installing and promoting releases run
* in the update UI and CI, not here.
*/
// The wire shape of GET /api/chat/update: Go's default field names, except
// installed_at, which the server tags. Zero time means no install recorded.
interface UpdateComponent {
ID: string;
Label: string;
Installed: string;
Available: string;
Reference?: string;
Changelog?: string;
}
interface UpdateSnapshot {
Components: UpdateComponent[];
Deferred?: boolean;
installed_at?: string;
}
interface ChatUpdate {
snapshot: UpdateSnapshot;
available: UpdateComponent[] | null;
can_install: boolean;
}
interface UpdateSettings {
channel?: string;
pin?: string;
}
// The default window a release runs on the canary before it can be promoted,
// mirroring releaseupdate.CanaryWindow on the server.
const CANARY_WINDOW_MS = 24 * 60 * 60 * 1000;
const KIND = "update-settings";
const store = useSettingsStore();
const update = ref<ChatUpdate | null>(null);
const notConfigured = ref(false);
const loading = ref(true);
const error = ref<string | null>(null);
const now = ref(Date.now());
let timer: ReturnType<typeof setInterval> | undefined;
let alive = true;
const settingsResource = computed(() => store.stateFor(KIND).resource);
const settings = computed(() => (settingsResource.value?.value ?? {}) as UpdateSettings);
const channel = computed(() => settings.value.channel || "stable");
const pin = computed(() => settings.value.pin || "");
const pinned = computed(() => channel.value === "exact-pin");
const channelLabel: Record<string, string> = {
stable: "Stable",
next: "Prereleases",
"exact-pin": "Pinned",
};
const daemon = computed(() => update.value?.snapshot.Components.find((c) => c.ID === "daemon"));
const available = computed(() => update.value?.available ?? []);
const installedAt = computed(() => {
const raw = update.value?.snapshot.installed_at;
if (!raw) return null;
const at = new Date(raw);
// The zero time serialises as year 1: no install was recorded.
if (Number.isNaN(at.getTime()) || at.getFullYear() <= 1) return null;
return at;
});
const elapsedMs = computed(() =>
installedAt.value ? Math.max(0, now.value - installedAt.value.getTime()) : null,
);
const windowProgress = computed(() =>
elapsedMs.value == null ? null : Math.min(100, (elapsedMs.value / CANARY_WINDOW_MS) * 100),
);
const elapsedText = computed(() => (elapsedMs.value == null ? "" : elapsed(elapsedMs.value)));
function elapsed(ms: number): string {
const totalMinutes = Math.floor(ms / 60_000);
const days = Math.floor(totalMinutes / 1440);
const hours = Math.floor((totalMinutes % 1440) / 60);
const minutes = totalMinutes % 60;
if (days) return `${days}d ${hours}h`;
if (hours) return `${hours}h ${minutes}m`;
return `${minutes}m`;
}
const rows = computed(() => {
const list: { label: string; value?: string; mono?: boolean }[] = [
// The settings resource loads asynchronously; until it arrives the channel
// is unknown, not "stable".
{ label: "Channel", value: settingsResource.value ? (channelLabel[channel.value] ?? channel.value) : "loading…" },
{ label: "Installed", value: daemon.value?.Installed || "unknown", mono: true },
{ label: "Installed at", value: installedAt.value ? "" : "not recorded" },
{
label: "Available",
value: available.value.length
? available.value.map((c) => `${c.Label || c.ID} ${c.Installed || "?"} → ${c.Available}`).join(", ")
: "none",
mono: true,
},
];
return list;
});
async function load(): Promise<void> {
loading.value = true;
error.value = null;
try {
const fresh = await api.updateSnapshot<ChatUpdate>();
if (!alive) return;
update.value = fresh;
notConfigured.value = false;
} catch (err) {
if (!alive) return;
if (err instanceof ApiError && err.status === 501) {
notConfigured.value = true;
update.value = null;
} else {
error.value = err instanceof Error ? err.message : String(err);
}
} finally {
if (alive) loading.value = false;
}
}
onMounted(() => {
void store.load();
void load();
timer = setInterval(() => {
now.value = Date.now();
void load();
}, 15_000);
});
onUnmounted(() => {
alive = false;
if (timer) clearInterval(timer);
});
</script>
<template>
<Section title="Release canary">
<p v-if="notConfigured" class="text-sm text-fg-muted">Update checks not configured.</p>
<template v-else>
<p v-if="error" class="text-sm text-danger">{{ error }}</p>
<p v-else-if="loading && !update" class="text-sm text-fg-muted">Checking…</p>
<template v-else>
<MetadataList :rows="rows">
<template #value="{ row }">
<template v-if="row.label === 'Channel' && pinned">
<Badge variant="danger" class="mr-2">held</Badge>
<span class="font-mono">{{ pin }}</span>
</template>
<template v-else-if="row.label === 'Installed at' && installedAt">
<Timestamp :at="installedAt" absolute /> · {{ elapsedText }} elapsed
</template>
<template v-else>{{ row.value }}</template>
</template>
</MetadataList>
<div v-if="windowProgress != null" class="mt-3">
<Progress :model-value="windowProgress" aria-label="Canary window elapsed" />
<p class="mt-1 text-caption text-fg-muted">
{{ elapsedText }} of 24h elapsed (default window)
</p>
</div>
<p v-else class="mt-3 text-caption text-fg-muted">
Install time not recorded, so the window cannot be measured.
</p>
</template>
</template>
</Section>
</template>
+2
View File
@@ -6,6 +6,7 @@ import PageHeader from "@/base/PageHeader.vue";
import { Alert, AlertDescription, AlertTitle } from "@/components/ui/alert";
import { Section } from "@/components/ui/section";
import { Table, TableBody, TableCell, TableRow } from "@/components/ui/table";
import CanaryStatusCard from "./CanaryStatusCard.vue";
import ServicesCard from "./ServicesCard.vue";
import UpdateSettingsCard from "./UpdateSettingsCard.vue";
import VersionsCard from "./VersionsCard.vue";
@@ -32,6 +33,7 @@ onUnmounted(() => clearInterval(timer));
<ServicesCard />
<VersionsCard />
<UpdateSettingsCard />
<CanaryStatusCard />
<Section v-if="config?.bootstrap && Object.keys(config.bootstrap).length" title="Startup settings">
<Table>
<TableBody>