Compare commits
@@ -1,12 +0,0 @@
|
||||
title = "AIOS secret scan policy"
|
||||
|
||||
[extend]
|
||||
useDefault = true
|
||||
|
||||
[[allowlists]]
|
||||
description = "Known non-secret idempotency key used twice by the shadow RBAC test"
|
||||
targetRules = ["generic-api-key"]
|
||||
condition = "AND"
|
||||
regexTarget = "line"
|
||||
paths = ['''tests/task_plane/public_interface/test_shadow_client_rbac\.py$''']
|
||||
regexes = ['''idempotency_key="shadow-rbac-idempotent-v1"''']
|
||||
@@ -1,2 +0,0 @@
|
||||
# Exact historical fingerprint for the removed test-only scanner self-reference.
|
||||
a42f16d4f73b11fd23448da2711d49d5e9f49d9e:tests/fastlane/test_fastlane_assets_contract.py:generic-api-key:135
|
||||
@@ -1,7 +1,7 @@
|
||||
e4a1f86ef92ec1d3ff724eb75cf9c01758c1cc997e1afadc1c8b561bce5b813a FULL_PACKAGE_MANIFEST.json
|
||||
c59c0288d4d999fbd79a2f275d4fb8c369029cb8bb721f95408308cc51eaa3a2 README.md
|
||||
1095953d5764d9c72f02e84b1d525e265d3a67a5bdb451ab9ef51a8e8b3032b8 VERSION
|
||||
ee6e4fc6bc98a590fbc3585b62707e2562115e5a3f722e69a7c464d966bdc458 active-runtime/app/aios_gitops_model_api.py
|
||||
b090062a92aeb14211bbfc1fcd43b5ee4f315d30054b437f3bcdac657210ee95 VERSION
|
||||
a664714bc1e13160cdd0dc32de460c65a83a3a95aa5cdad1833b1b650ab90e9d active-runtime/app/aios_gitops_model_api.py
|
||||
0ffadf6ee1f297842bc44c6e753010fd2b7b02b1f5fb0d7e0676b7bec898db08 active-runtime/app/aios_v5_webops_app.py
|
||||
0ffadf6ee1f297842bc44c6e753010fd2b7b02b1f5fb0d7e0676b7bec898db08 active-runtime/app/aios_webops_app.py
|
||||
0eb12e0161371464605577707c84df413b555277933f9eb4488ab38032ff699b active-runtime/migrations/001_webops_core_sqlite.sql
|
||||
@@ -13,7 +13,7 @@ ee6e4fc6bc98a590fbc3585b62707e2562115e5a3f722e69a7c464d966bdc458 adapters/gitop
|
||||
013813b58d7844f3860d6f9bb484f84f92487652b573976c474bb35c91df8ae8 adapters/openclaw/openclaw_gitops_commands.py
|
||||
7a34ccdfdcdc132fe5daf01cd1acd9d9b7adbd0429d575b65e0771962ccedc62 adapters/webops/gitops_model_menu_fragment.html
|
||||
86b0cb6ee3192565b080672e5305dabba1283486442e630c71244ebac4910916 config/digital_life.yaml
|
||||
a3872f24e4cd64288758846ecd0b374db4aa41111feec3b17c41438136d6d5d0 config/domains.env
|
||||
5a27d48db343dcb723bcc1d9d8222aa3f72094c57cc43640aebe6558963bd20f config/domains.env
|
||||
7a6f82cbddfc5c74bd37229e4f37fe4e73430ae585b4846abd1a80d852f2fed0 config/gitops_short_links.yaml
|
||||
4139d915bdd733171734d5d5d3411e6fc4f8f202c49af4321d706da176da690b config/model_registry.yaml
|
||||
8d6202d3da60366c96a208f5e5eed1f09fd36d122f4cabdc038c21ce2e72ea16 config/npm_custom_locations.yaml
|
||||
@@ -55,7 +55,7 @@ d8cea35eb6c1300d20804ef480312d26dbdc2ad3a2d26b9430c6ca4808155a95 fixes/patch_ru
|
||||
0eb12e0161371464605577707c84df413b555277933f9eb4488ab38032ff699b migrations/001_webops_core_sqlite.sql
|
||||
6d61da88e7d6b208e7eee7195b521dc47cb68587f91987d7a0dd1c8801ef168d migrations/002_seed_owner_admin_user.sql
|
||||
a2c0c7699e1eb46cfdeabfc905cb79b71ed14fb6bcf81ecc99ec47975cf05767 migrations/004_gitops_custom_llm_runtime.sql
|
||||
b77bce1ca78cede27de6594e25f6ce5bb0c4990c0953eeb79f7e2608d2515c32 package_verify_full.sh
|
||||
ca49f4165b50171968485ffa5535bc33d2158237ea55af10a3888a5fa0f7a535 package_verify_full.sh
|
||||
f65b7fba5d6bdac3070ff4309830e286cd6319a80ab2e55263e46022fed2bf7f scripts/apply_migrations.py
|
||||
bc0452d261def2366cdefd845e62d7177b42806f93ba78294ece29a8a369157e scripts/backup_before_fix.sh
|
||||
bdb439086c86b3b23f8240cb2bef0f757a6be242d21d13a79eb1e44434efbe2e scripts/create_patch.sh
|
||||
@@ -63,11 +63,11 @@ bdb439086c86b3b23f8240cb2bef0f757a6be242d21d13a79eb1e44434efbe2e scripts/create
|
||||
1fdeecf0315f3ab4ec461c3376128054df9ac48e2fe5a3f64a138cd7d710d44d scripts/generate_release_manifest.py
|
||||
80c6c10f259245681c42932f3f5f9b9a0fbd9cadce6a3f495d82cbdbc8618c73 scripts/healthcheck.sh
|
||||
3795cadfa6429a434c955913dbdcbf552181c88301a196b4b458f4f5dd206cd8 scripts/init_gitops_baseline.sh
|
||||
4d54a4ed6d35bbb6e9fe2924f3cfceeea9c3eed898017788f6c5ab8041394a47 scripts/install_v1r1c0_gitops_model_overlay.sh
|
||||
e76cd986d2387b76439e4a7fe503e48a2de8fc70fb52c45a13641c9d943f108f scripts/install_v1r1c0_gitops_model_overlay.sh
|
||||
0064539ac1e1bd32dc8062ecc307ad2bc8520895009583a72d46868d1cf44e3c scripts/install_webops_overlay.sh
|
||||
9fadafc4b4d098c006d159cb3b401eb19cf9ab9c5fa4b5cb109e946501c0b8e1 scripts/owner_wechat_notify_worker.py
|
||||
e0abd8ad44d4f088108f2046fd9d7bbd4465af50f79bd3b9fcbb72a8c61bee65 scripts/package_contract_check_v1r1c0.sh
|
||||
abef8df642c6d233af4a03c512876b02b326e19c924020b8dd8cc74236d18817 scripts/release_version.sh
|
||||
f537c58fc08685601f47fac5c0a3a2856e3ce9806c1918848c87a194a49c28a0 scripts/package_contract_check_v1r1c0.sh
|
||||
14ab40a7c342e21e8315def14d552dcff4b214d23f1f4be493e9d3fc2cee1a2f scripts/release_version.sh
|
||||
bbdb3f9992b203ddc2a6a83241052663de4f021d0705724bd9df05acaa99b022 scripts/rollback_last_delta.sh
|
||||
0814c26ecf6732cf2c24f5f414ad0128a159768cfbbeb21d557274064feb1188 scripts/rollback_version.sh
|
||||
da84a5cc61c1d54a7d1e96e4b0a7186e192edf3ec12d694fc9d7608c3b1086ef scripts/run_acceptance_with_autofix.sh
|
||||
|
||||
@@ -1,27 +0,0 @@
|
||||
"""AIOS-managed Hermes runtime boundary."""
|
||||
|
||||
from .adapter import (
|
||||
HermesAdapter,
|
||||
HermesConflict,
|
||||
HermesNotFound,
|
||||
HermesRuntimeError,
|
||||
InMemoryHermesStore,
|
||||
SQLiteHermesStore,
|
||||
)
|
||||
from .contract import HermesHealth, HermesJob, HermesJobState, HermesResult
|
||||
from .worker import HermesWorker, WorkerRunResult
|
||||
|
||||
__all__ = [
|
||||
"HermesAdapter",
|
||||
"HermesConflict",
|
||||
"HermesHealth",
|
||||
"HermesJob",
|
||||
"HermesJobState",
|
||||
"HermesNotFound",
|
||||
"HermesResult",
|
||||
"HermesRuntimeError",
|
||||
"HermesWorker",
|
||||
"InMemoryHermesStore",
|
||||
"SQLiteHermesStore",
|
||||
"WorkerRunResult",
|
||||
]
|
||||
@@ -1,593 +0,0 @@
|
||||
"""Tenant-partitioned Hermes queue and worker lease boundary."""
|
||||
from __future__ import annotations
|
||||
|
||||
import hashlib
|
||||
import json
|
||||
import sqlite3
|
||||
import threading
|
||||
from dataclasses import asdict, replace
|
||||
from datetime import datetime, timedelta, timezone
|
||||
from pathlib import Path
|
||||
from typing import Iterable, Mapping
|
||||
|
||||
from .contract import (
|
||||
ALLOWED_TRANSITIONS,
|
||||
TERMINAL_STATES,
|
||||
HermesHealth,
|
||||
HermesJob,
|
||||
HermesJobState,
|
||||
HermesResult,
|
||||
utc_now,
|
||||
)
|
||||
|
||||
|
||||
class HermesRuntimeError(RuntimeError):
|
||||
"""Base Hermes runtime-boundary failure."""
|
||||
|
||||
|
||||
class HermesNotFound(HermesRuntimeError):
|
||||
"""A tenant-scoped job was not found."""
|
||||
|
||||
|
||||
class HermesConflict(HermesRuntimeError):
|
||||
"""A state, lease, idempotency, or revision conflict occurred."""
|
||||
|
||||
|
||||
class InMemoryHermesStore:
|
||||
"""Thread-safe reference store; production backends implement this contract."""
|
||||
|
||||
def __init__(self) -> None:
|
||||
self.lock = threading.RLock()
|
||||
self.jobs: dict[str, HermesJob] = {}
|
||||
self.results: dict[str, HermesResult] = {}
|
||||
self.idempotency: dict[tuple[str, str], tuple[str, str]] = {}
|
||||
self.worker_heartbeats: dict[str, tuple[str, str | None]] = {}
|
||||
|
||||
def persist_locked(self) -> None:
|
||||
"""Persist a mutation while ``lock`` is held; memory stores are a no-op."""
|
||||
|
||||
|
||||
class SQLiteHermesStore(InMemoryHermesStore):
|
||||
"""Durable snapshot for the existing Hermes queue state machine.
|
||||
|
||||
The adapter remains the sole owner of transitions and lease rules. This
|
||||
store only makes its jobs, results, idempotency keys and worker heartbeats
|
||||
survive a process restart.
|
||||
"""
|
||||
|
||||
def __init__(self, path: str | Path) -> None:
|
||||
self.path = Path(path).resolve()
|
||||
self.path.parent.mkdir(parents=True, exist_ok=True)
|
||||
super().__init__()
|
||||
with self._connect() as connection:
|
||||
connection.execute(
|
||||
"""
|
||||
CREATE TABLE IF NOT EXISTS hermes_state (
|
||||
singleton INTEGER PRIMARY KEY CHECK (singleton = 1),
|
||||
payload TEXT NOT NULL
|
||||
)
|
||||
"""
|
||||
)
|
||||
self._load()
|
||||
|
||||
def _connect(self) -> sqlite3.Connection:
|
||||
connection = sqlite3.connect(str(self.path), timeout=30)
|
||||
connection.execute("PRAGMA journal_mode=WAL")
|
||||
connection.execute("PRAGMA synchronous=FULL")
|
||||
return connection
|
||||
|
||||
@staticmethod
|
||||
def _record(value: HermesJob | HermesResult) -> dict[str, object]:
|
||||
record = asdict(value)
|
||||
record["state"] = value.state.value
|
||||
return record
|
||||
|
||||
def _load(self) -> None:
|
||||
with self.lock, self._connect() as connection:
|
||||
row = connection.execute(
|
||||
"SELECT payload FROM hermes_state WHERE singleton = 1"
|
||||
).fetchone()
|
||||
if row is None:
|
||||
return
|
||||
payload = json.loads(str(row[0]))
|
||||
self.jobs = {
|
||||
str(item["job_id"]): HermesJob(**item)
|
||||
for item in payload.get("jobs", [])
|
||||
}
|
||||
self.results = {
|
||||
str(item["job_id"]): HermesResult(**item)
|
||||
for item in payload.get("results", [])
|
||||
}
|
||||
self.idempotency = {
|
||||
(str(item["tenant_id"]), str(item["idempotency_key"])): (
|
||||
str(item["job_id"]),
|
||||
str(item["digest"]),
|
||||
)
|
||||
for item in payload.get("idempotency", [])
|
||||
}
|
||||
self.worker_heartbeats = {
|
||||
str(item["worker_id"]): (
|
||||
str(item["heartbeat_at"]),
|
||||
str(item["job_id"]) if item.get("job_id") is not None else None,
|
||||
)
|
||||
for item in payload.get("worker_heartbeats", [])
|
||||
}
|
||||
|
||||
def persist_locked(self) -> None:
|
||||
payload = {
|
||||
"version": 1,
|
||||
"jobs": [self._record(item) for item in self.jobs.values()],
|
||||
"results": [self._record(item) for item in self.results.values()],
|
||||
"idempotency": [
|
||||
{
|
||||
"tenant_id": tenant_id,
|
||||
"idempotency_key": idempotency_key,
|
||||
"job_id": job_id,
|
||||
"digest": digest,
|
||||
}
|
||||
for (tenant_id, idempotency_key), (job_id, digest)
|
||||
in self.idempotency.items()
|
||||
],
|
||||
"worker_heartbeats": [
|
||||
{
|
||||
"worker_id": worker_id,
|
||||
"heartbeat_at": heartbeat_at,
|
||||
"job_id": job_id,
|
||||
}
|
||||
for worker_id, (heartbeat_at, job_id)
|
||||
in self.worker_heartbeats.items()
|
||||
],
|
||||
}
|
||||
encoded = json.dumps(
|
||||
payload,
|
||||
ensure_ascii=False,
|
||||
sort_keys=True,
|
||||
separators=(",", ":"),
|
||||
)
|
||||
with self._connect() as connection:
|
||||
connection.execute("BEGIN IMMEDIATE")
|
||||
connection.execute(
|
||||
"""
|
||||
INSERT INTO hermes_state(singleton, payload) VALUES(1, ?)
|
||||
ON CONFLICT(singleton) DO UPDATE SET payload=excluded.payload
|
||||
""",
|
||||
(encoded,),
|
||||
)
|
||||
connection.commit()
|
||||
|
||||
|
||||
class HermesAdapter:
|
||||
"""Queue and reconcile Hermes jobs without owning AIOS policy."""
|
||||
|
||||
def __init__(
|
||||
self,
|
||||
store: InMemoryHermesStore | None = None,
|
||||
*,
|
||||
runtime_id: str = "hermes-runtime",
|
||||
runtime_version: str = "v1",
|
||||
default_lease_seconds: int = 60,
|
||||
) -> None:
|
||||
if default_lease_seconds < 5:
|
||||
raise ValueError("default_lease_seconds must be >= 5")
|
||||
self.store = store or InMemoryHermesStore()
|
||||
self.runtime_id = runtime_id
|
||||
self.runtime_version = runtime_version
|
||||
self.default_lease_seconds = int(default_lease_seconds)
|
||||
|
||||
@staticmethod
|
||||
def _digest(job: HermesJob) -> str:
|
||||
raw = json.dumps(
|
||||
{
|
||||
"tenant_id": job.tenant_id,
|
||||
"cell_id": job.cell_id,
|
||||
"profile_id": job.profile_id,
|
||||
"task_id": job.task_id,
|
||||
"trace_id": job.trace_id,
|
||||
"action": job.action,
|
||||
"payload": dict(job.payload),
|
||||
"priority": job.priority,
|
||||
},
|
||||
ensure_ascii=False,
|
||||
sort_keys=True,
|
||||
separators=(",", ":"),
|
||||
default=str,
|
||||
).encode("utf-8")
|
||||
return hashlib.sha256(raw).hexdigest()
|
||||
|
||||
@staticmethod
|
||||
def _parse(value: str | None) -> datetime | None:
|
||||
if value is None:
|
||||
return None
|
||||
normalized = value[:-1] + "+00:00" if value.endswith("Z") else value
|
||||
parsed = datetime.fromisoformat(normalized)
|
||||
if parsed.tzinfo is None:
|
||||
raise ValueError("timestamp must include timezone")
|
||||
return parsed.astimezone(timezone.utc)
|
||||
|
||||
@staticmethod
|
||||
def _format(value: datetime) -> str:
|
||||
return value.astimezone(timezone.utc).isoformat().replace("+00:00", "Z")
|
||||
|
||||
@staticmethod
|
||||
def _assert_tenant(job: HermesJob, tenant_id: str) -> None:
|
||||
if job.tenant_id != tenant_id:
|
||||
raise HermesNotFound("job not found")
|
||||
|
||||
def enqueue(self, job: HermesJob) -> HermesJob:
|
||||
if job.state != HermesJobState.QUEUED or job.revision != 1:
|
||||
raise HermesConflict("new job must be QUEUED at revision 1")
|
||||
digest = self._digest(job)
|
||||
idem_ref = (job.tenant_id, job.idempotency_key)
|
||||
with self.store.lock:
|
||||
existing = self.store.jobs.get(job.job_id)
|
||||
if existing is not None:
|
||||
if self._digest(existing) != digest:
|
||||
raise HermesConflict("job_id reused with different content")
|
||||
return existing
|
||||
prior = self.store.idempotency.get(idem_ref)
|
||||
if prior is not None:
|
||||
prior_id, prior_digest = prior
|
||||
if prior_digest != digest:
|
||||
raise HermesConflict("idempotency key reused with different content")
|
||||
return self.store.jobs[prior_id]
|
||||
self.store.jobs[job.job_id] = job
|
||||
self.store.idempotency[idem_ref] = (job.job_id, digest)
|
||||
self.store.persist_locked()
|
||||
return job
|
||||
|
||||
def get(self, job_id: str, *, tenant_id: str) -> HermesJob:
|
||||
with self.store.lock:
|
||||
job = self.store.jobs.get(job_id)
|
||||
if job is None:
|
||||
raise HermesNotFound("job not found")
|
||||
self._assert_tenant(job, tenant_id)
|
||||
return job
|
||||
|
||||
def list_jobs(
|
||||
self,
|
||||
*,
|
||||
tenant_id: str,
|
||||
cell_id: str | None = None,
|
||||
profile_id: str | None = None,
|
||||
states: Iterable[HermesJobState | str] | None = None,
|
||||
) -> list[HermesJob]:
|
||||
state_filter = {HermesJobState(item) for item in states} if states else None
|
||||
with self.store.lock:
|
||||
if self._requeue_expired_locked():
|
||||
self.store.persist_locked()
|
||||
jobs = [
|
||||
job
|
||||
for job in self.store.jobs.values()
|
||||
if job.tenant_id == tenant_id
|
||||
and (cell_id is None or job.cell_id == cell_id)
|
||||
and (profile_id is None or job.profile_id == profile_id)
|
||||
and (state_filter is None or job.state in state_filter)
|
||||
]
|
||||
return sorted(jobs, key=lambda item: (item.priority, item.created_at, item.job_id))
|
||||
|
||||
def claim(
|
||||
self,
|
||||
*,
|
||||
tenant_id: str,
|
||||
cell_id: str,
|
||||
profile_id: str,
|
||||
worker_id: str,
|
||||
lease_seconds: int | None = None,
|
||||
job_id: str | None = None,
|
||||
) -> HermesJob | None:
|
||||
worker_id = str(worker_id or "").strip()
|
||||
if not worker_id:
|
||||
raise ValueError("worker_id is required")
|
||||
duration = int(lease_seconds or self.default_lease_seconds)
|
||||
if duration < 5:
|
||||
raise ValueError("lease_seconds must be >= 5")
|
||||
with self.store.lock:
|
||||
self._requeue_expired_locked()
|
||||
candidates = [
|
||||
job
|
||||
for job in self.store.jobs.values()
|
||||
if job.tenant_id == tenant_id
|
||||
and job.cell_id == cell_id
|
||||
and job.profile_id == profile_id
|
||||
and (job_id is None or job.job_id == job_id)
|
||||
and job.state == HermesJobState.QUEUED
|
||||
]
|
||||
self.store.worker_heartbeats[worker_id] = (utc_now(), None)
|
||||
if not candidates:
|
||||
self.store.persist_locked()
|
||||
return None
|
||||
current = sorted(
|
||||
candidates,
|
||||
key=lambda item: (item.priority, item.created_at, item.job_id),
|
||||
)[0]
|
||||
claimed = self._transition_locked(
|
||||
current,
|
||||
HermesJobState.CLAIMED,
|
||||
assigned_worker_id=worker_id,
|
||||
lease_expires_at=self._format(
|
||||
datetime.now(timezone.utc) + timedelta(seconds=duration)
|
||||
),
|
||||
)
|
||||
self.store.worker_heartbeats[worker_id] = (utc_now(), claimed.job_id)
|
||||
self.store.persist_locked()
|
||||
return claimed
|
||||
|
||||
def start(
|
||||
self,
|
||||
job_id: str,
|
||||
*,
|
||||
tenant_id: str,
|
||||
worker_id: str,
|
||||
expected_revision: int | None = None,
|
||||
) -> HermesJob:
|
||||
with self.store.lock:
|
||||
self._requeue_expired_locked()
|
||||
current = self._owned_job_locked(job_id, tenant_id, worker_id)
|
||||
self._assert_revision(current, expected_revision)
|
||||
updated = self._transition_locked(current, HermesJobState.RUNNING)
|
||||
self.store.persist_locked()
|
||||
return updated
|
||||
|
||||
def heartbeat(
|
||||
self,
|
||||
job_id: str,
|
||||
*,
|
||||
tenant_id: str,
|
||||
worker_id: str,
|
||||
lease_seconds: int | None = None,
|
||||
) -> HermesJob:
|
||||
duration = int(lease_seconds or self.default_lease_seconds)
|
||||
if duration < 5:
|
||||
raise ValueError("lease_seconds must be >= 5")
|
||||
with self.store.lock:
|
||||
self._requeue_expired_locked()
|
||||
current = self._owned_job_locked(job_id, tenant_id, worker_id)
|
||||
if current.state not in {HermesJobState.CLAIMED, HermesJobState.RUNNING}:
|
||||
raise HermesConflict("job does not accept heartbeat")
|
||||
updated = replace(
|
||||
current,
|
||||
revision=current.revision + 1,
|
||||
lease_expires_at=self._format(
|
||||
datetime.now(timezone.utc) + timedelta(seconds=duration)
|
||||
),
|
||||
updated_at=utc_now(),
|
||||
)
|
||||
self.store.jobs[job_id] = updated
|
||||
self.store.worker_heartbeats[worker_id] = (utc_now(), job_id)
|
||||
self.store.persist_locked()
|
||||
return updated
|
||||
|
||||
def complete(
|
||||
self,
|
||||
job_id: str,
|
||||
*,
|
||||
tenant_id: str,
|
||||
worker_id: str,
|
||||
output: Mapping[str, object],
|
||||
expected_revision: int | None = None,
|
||||
) -> HermesResult:
|
||||
return self._finish(
|
||||
job_id,
|
||||
tenant_id=tenant_id,
|
||||
worker_id=worker_id,
|
||||
state=HermesJobState.COMPLETED,
|
||||
output=output,
|
||||
expected_revision=expected_revision,
|
||||
)
|
||||
|
||||
def fail(
|
||||
self,
|
||||
job_id: str,
|
||||
*,
|
||||
tenant_id: str,
|
||||
worker_id: str,
|
||||
error: Mapping[str, object],
|
||||
expected_revision: int | None = None,
|
||||
) -> HermesResult:
|
||||
return self._finish(
|
||||
job_id,
|
||||
tenant_id=tenant_id,
|
||||
worker_id=worker_id,
|
||||
state=HermesJobState.FAILED,
|
||||
error=error,
|
||||
expected_revision=expected_revision,
|
||||
)
|
||||
|
||||
def cancel(
|
||||
self,
|
||||
job_id: str,
|
||||
*,
|
||||
tenant_id: str,
|
||||
expected_revision: int | None = None,
|
||||
) -> HermesResult:
|
||||
with self.store.lock:
|
||||
current = self.store.jobs.get(job_id)
|
||||
if current is None:
|
||||
raise HermesNotFound("job not found")
|
||||
self._assert_tenant(current, tenant_id)
|
||||
self._assert_revision(current, expected_revision)
|
||||
if current.state in TERMINAL_STATES:
|
||||
result = self.store.results.get(job_id)
|
||||
if result is None:
|
||||
raise HermesConflict("terminal result missing")
|
||||
if result.state != HermesJobState.CANCELLED:
|
||||
raise HermesConflict("job already has a different terminal result")
|
||||
return result
|
||||
updated = self._transition_locked(current, HermesJobState.CANCELLED)
|
||||
result = HermesResult(
|
||||
job_id=updated.job_id,
|
||||
tenant_id=updated.tenant_id,
|
||||
task_id=updated.task_id,
|
||||
trace_id=updated.trace_id,
|
||||
state=HermesJobState.CANCELLED,
|
||||
worker_id=updated.assigned_worker_id,
|
||||
error={"code": "cancelled", "message": "cancelled by AIOS"},
|
||||
finished_at=utc_now(),
|
||||
)
|
||||
self.store.results[job_id] = result
|
||||
self.store.persist_locked()
|
||||
return result
|
||||
|
||||
def result(self, job_id: str, *, tenant_id: str) -> HermesResult:
|
||||
with self.store.lock:
|
||||
job = self.store.jobs.get(job_id)
|
||||
if job is None:
|
||||
raise HermesNotFound("job not found")
|
||||
self._assert_tenant(job, tenant_id)
|
||||
result = self.store.results.get(job_id)
|
||||
if result is None:
|
||||
raise HermesConflict("job has no terminal result")
|
||||
return result
|
||||
|
||||
def requeue_expired(self) -> tuple[str, ...]:
|
||||
"""Persistently release expired leases without changing policy state."""
|
||||
with self.store.lock:
|
||||
changed = self._requeue_expired_locked()
|
||||
if changed:
|
||||
self.store.persist_locked()
|
||||
return tuple(sorted(changed))
|
||||
|
||||
def health(self) -> HermesHealth:
|
||||
with self.store.lock:
|
||||
if self._requeue_expired_locked():
|
||||
self.store.persist_locked()
|
||||
active_jobs = sum(
|
||||
1 for job in self.store.jobs.values()
|
||||
if job.state in {HermesJobState.CLAIMED, HermesJobState.RUNNING}
|
||||
)
|
||||
queued_jobs = sum(
|
||||
1 for job in self.store.jobs.values()
|
||||
if job.state == HermesJobState.QUEUED
|
||||
)
|
||||
partitions = {
|
||||
(job.tenant_id, job.cell_id, job.profile_id)
|
||||
for job in self.store.jobs.values()
|
||||
}
|
||||
active_workers = sum(
|
||||
1 for heartbeat, _ in self.store.worker_heartbeats.values()
|
||||
if self._parse(heartbeat)
|
||||
and self._parse(heartbeat) >= datetime.now(timezone.utc) - timedelta(seconds=120)
|
||||
)
|
||||
return HermesHealth(
|
||||
runtime_id=self.runtime_id,
|
||||
status="healthy",
|
||||
version=self.runtime_version,
|
||||
heartbeat_at=utc_now(),
|
||||
active_workers=active_workers,
|
||||
active_jobs=active_jobs,
|
||||
queued_jobs=queued_jobs,
|
||||
tenant_partitions=len(partitions),
|
||||
profile_isolation_enforced=True,
|
||||
details={"store": type(self.store).__name__},
|
||||
)
|
||||
|
||||
def _finish(
|
||||
self,
|
||||
job_id: str,
|
||||
*,
|
||||
tenant_id: str,
|
||||
worker_id: str,
|
||||
state: HermesJobState,
|
||||
output: Mapping[str, object] | None = None,
|
||||
error: Mapping[str, object] | None = None,
|
||||
expected_revision: int | None,
|
||||
) -> HermesResult:
|
||||
with self.store.lock:
|
||||
self._requeue_expired_locked()
|
||||
current = self._owned_job_locked(job_id, tenant_id, worker_id)
|
||||
if current.state in TERMINAL_STATES:
|
||||
existing = self.store.results.get(job_id)
|
||||
if existing is None:
|
||||
raise HermesConflict("terminal result missing")
|
||||
if (
|
||||
existing.state == state
|
||||
and existing.worker_id == worker_id
|
||||
and existing.output == output
|
||||
and existing.error == error
|
||||
):
|
||||
return existing
|
||||
raise HermesConflict("job already has a different terminal result")
|
||||
self._assert_revision(current, expected_revision)
|
||||
updated = self._transition_locked(current, state)
|
||||
result = HermesResult(
|
||||
job_id=updated.job_id,
|
||||
tenant_id=updated.tenant_id,
|
||||
task_id=updated.task_id,
|
||||
trace_id=updated.trace_id,
|
||||
state=state,
|
||||
worker_id=worker_id,
|
||||
output=output,
|
||||
error=error,
|
||||
started_at=current.updated_at,
|
||||
finished_at=utc_now(),
|
||||
)
|
||||
self.store.results[job_id] = result
|
||||
self.store.worker_heartbeats[worker_id] = (utc_now(), None)
|
||||
self.store.persist_locked()
|
||||
return result
|
||||
|
||||
def _owned_job_locked(self, job_id: str, tenant_id: str, worker_id: str) -> HermesJob:
|
||||
current = self.store.jobs.get(job_id)
|
||||
if current is None:
|
||||
raise HermesNotFound("job not found")
|
||||
self._assert_tenant(current, tenant_id)
|
||||
if current.assigned_worker_id != worker_id:
|
||||
raise HermesConflict("worker does not own job lease")
|
||||
return current
|
||||
|
||||
@staticmethod
|
||||
def _assert_revision(job: HermesJob, expected: int | None) -> None:
|
||||
if expected is not None and job.revision != expected:
|
||||
raise HermesConflict("job revision changed")
|
||||
|
||||
def _transition_locked(
|
||||
self,
|
||||
current: HermesJob,
|
||||
target: HermesJobState,
|
||||
*,
|
||||
assigned_worker_id: str | None = None,
|
||||
lease_expires_at: str | None = None,
|
||||
) -> HermesJob:
|
||||
if target not in ALLOWED_TRANSITIONS[current.state]:
|
||||
raise HermesConflict(
|
||||
f"invalid transition {current.state.value} -> {target.value}"
|
||||
)
|
||||
updated = replace(
|
||||
current,
|
||||
state=target,
|
||||
revision=current.revision + 1,
|
||||
assigned_worker_id=(
|
||||
assigned_worker_id
|
||||
if assigned_worker_id is not None
|
||||
else current.assigned_worker_id
|
||||
),
|
||||
lease_expires_at=(
|
||||
lease_expires_at
|
||||
if lease_expires_at is not None
|
||||
else (None if target in TERMINAL_STATES else current.lease_expires_at)
|
||||
),
|
||||
updated_at=utc_now(),
|
||||
)
|
||||
self.store.jobs[current.job_id] = updated
|
||||
return updated
|
||||
|
||||
def _requeue_expired_locked(self) -> set[str]:
|
||||
now = datetime.now(timezone.utc)
|
||||
changed: set[str] = set()
|
||||
for current in list(self.store.jobs.values()):
|
||||
expiry = self._parse(current.lease_expires_at)
|
||||
if (
|
||||
current.state in {HermesJobState.CLAIMED, HermesJobState.RUNNING}
|
||||
and expiry is not None
|
||||
and expiry <= now
|
||||
):
|
||||
self.store.jobs[current.job_id] = replace(
|
||||
current,
|
||||
state=HermesJobState.QUEUED,
|
||||
revision=current.revision + 1,
|
||||
assigned_worker_id=None,
|
||||
lease_expires_at=None,
|
||||
updated_at=utc_now(),
|
||||
)
|
||||
changed.add(current.job_id)
|
||||
return changed
|
||||
@@ -1,153 +0,0 @@
|
||||
"""Tenant-scoped Hermes runtime contracts."""
|
||||
from __future__ import annotations
|
||||
|
||||
import json
|
||||
import uuid
|
||||
from dataclasses import dataclass, field
|
||||
from datetime import datetime, timezone
|
||||
from enum import Enum
|
||||
from typing import Any, Mapping
|
||||
|
||||
|
||||
def utc_now() -> str:
|
||||
return datetime.now(timezone.utc).isoformat().replace("+00:00", "Z")
|
||||
|
||||
|
||||
def _required(value: str, label: str) -> str:
|
||||
normalized = str(value or "").strip()
|
||||
if not normalized:
|
||||
raise ValueError(f"{label} is required")
|
||||
return normalized
|
||||
|
||||
|
||||
def _safe_mapping(value: Mapping[str, Any] | None) -> dict[str, Any]:
|
||||
return json.loads(json.dumps(dict(value or {}), ensure_ascii=False, sort_keys=True, default=str))
|
||||
|
||||
|
||||
class HermesJobState(str, Enum):
|
||||
QUEUED = "QUEUED"
|
||||
CLAIMED = "CLAIMED"
|
||||
RUNNING = "RUNNING"
|
||||
COMPLETED = "COMPLETED"
|
||||
FAILED = "FAILED"
|
||||
CANCELLED = "CANCELLED"
|
||||
|
||||
|
||||
ALLOWED_TRANSITIONS: Mapping[HermesJobState, frozenset[HermesJobState]] = {
|
||||
HermesJobState.QUEUED: frozenset({HermesJobState.CLAIMED, HermesJobState.CANCELLED}),
|
||||
HermesJobState.CLAIMED: frozenset({HermesJobState.RUNNING, HermesJobState.CANCELLED}),
|
||||
HermesJobState.RUNNING: frozenset(
|
||||
{HermesJobState.COMPLETED, HermesJobState.FAILED, HermesJobState.CANCELLED}
|
||||
),
|
||||
HermesJobState.COMPLETED: frozenset(),
|
||||
HermesJobState.FAILED: frozenset(),
|
||||
HermesJobState.CANCELLED: frozenset(),
|
||||
}
|
||||
TERMINAL_STATES = frozenset(
|
||||
{HermesJobState.COMPLETED, HermesJobState.FAILED, HermesJobState.CANCELLED}
|
||||
)
|
||||
|
||||
|
||||
@dataclass(frozen=True)
|
||||
class HermesJob:
|
||||
job_id: str
|
||||
tenant_id: str
|
||||
cell_id: str
|
||||
profile_id: str
|
||||
task_id: str
|
||||
trace_id: str
|
||||
action: str
|
||||
payload: Mapping[str, Any] = field(default_factory=dict)
|
||||
idempotency_key: str = ""
|
||||
priority: int = 100
|
||||
state: HermesJobState = HermesJobState.QUEUED
|
||||
revision: int = 1
|
||||
assigned_worker_id: str | None = None
|
||||
lease_expires_at: str | None = None
|
||||
created_at: str = field(default_factory=utc_now)
|
||||
updated_at: str = field(default_factory=utc_now)
|
||||
|
||||
def __post_init__(self) -> None:
|
||||
for name in (
|
||||
"job_id", "tenant_id", "cell_id", "profile_id", "task_id",
|
||||
"trace_id", "action", "idempotency_key", "created_at", "updated_at",
|
||||
):
|
||||
object.__setattr__(self, name, _required(getattr(self, name), name))
|
||||
object.__setattr__(self, "payload", _safe_mapping(self.payload))
|
||||
object.__setattr__(self, "state", HermesJobState(self.state))
|
||||
if not 0 <= int(self.priority) <= 1000:
|
||||
raise ValueError("priority must be between 0 and 1000")
|
||||
if self.revision < 1:
|
||||
raise ValueError("revision must be >= 1")
|
||||
|
||||
@classmethod
|
||||
def create(
|
||||
cls,
|
||||
*,
|
||||
tenant_id: str,
|
||||
cell_id: str,
|
||||
profile_id: str,
|
||||
task_id: str,
|
||||
trace_id: str,
|
||||
action: str,
|
||||
payload: Mapping[str, Any] | None,
|
||||
idempotency_key: str,
|
||||
priority: int = 100,
|
||||
) -> "HermesJob":
|
||||
return cls(
|
||||
job_id=f"hermes_{uuid.uuid4().hex}",
|
||||
tenant_id=tenant_id,
|
||||
cell_id=cell_id,
|
||||
profile_id=profile_id,
|
||||
task_id=task_id,
|
||||
trace_id=trace_id,
|
||||
action=action,
|
||||
payload=_safe_mapping(payload),
|
||||
idempotency_key=idempotency_key,
|
||||
priority=priority,
|
||||
)
|
||||
|
||||
|
||||
@dataclass(frozen=True)
|
||||
class HermesResult:
|
||||
job_id: str
|
||||
tenant_id: str
|
||||
task_id: str
|
||||
trace_id: str
|
||||
state: HermesJobState
|
||||
worker_id: str | None = None
|
||||
output: Mapping[str, Any] | None = None
|
||||
error: Mapping[str, Any] | None = None
|
||||
started_at: str | None = None
|
||||
finished_at: str | None = None
|
||||
|
||||
def __post_init__(self) -> None:
|
||||
for name in ("job_id", "tenant_id", "task_id", "trace_id"):
|
||||
object.__setattr__(self, name, _required(getattr(self, name), name))
|
||||
object.__setattr__(self, "state", HermesJobState(self.state))
|
||||
if self.output is not None:
|
||||
object.__setattr__(self, "output", _safe_mapping(self.output))
|
||||
if self.error is not None:
|
||||
object.__setattr__(self, "error", _safe_mapping(self.error))
|
||||
|
||||
|
||||
@dataclass(frozen=True)
|
||||
class HermesHealth:
|
||||
runtime_id: str
|
||||
status: str
|
||||
version: str
|
||||
heartbeat_at: str
|
||||
active_workers: int = 0
|
||||
active_jobs: int = 0
|
||||
queued_jobs: int = 0
|
||||
tenant_partitions: int = 0
|
||||
profile_isolation_enforced: bool = True
|
||||
details: Mapping[str, Any] = field(default_factory=dict)
|
||||
|
||||
def __post_init__(self) -> None:
|
||||
for name in ("runtime_id", "status", "version", "heartbeat_at"):
|
||||
object.__setattr__(self, name, _required(getattr(self, name), name))
|
||||
for name in ("active_workers", "active_jobs", "queued_jobs", "tenant_partitions"):
|
||||
if int(getattr(self, name)) < 0:
|
||||
raise ValueError(f"{name} must be >= 0")
|
||||
object.__setattr__(self, "details", _safe_mapping(self.details))
|
||||
@@ -1,155 +0,0 @@
|
||||
"""Hermes worker loop with lease renewal and bounded recovery."""
|
||||
from __future__ import annotations
|
||||
|
||||
import threading
|
||||
from dataclasses import dataclass
|
||||
from typing import Any, Callable, Mapping
|
||||
|
||||
from .adapter import HermesAdapter, HermesConflict
|
||||
from .contract import HermesJob, HermesJobState
|
||||
|
||||
|
||||
JobHandler = Callable[[HermesJob], Mapping[str, Any]]
|
||||
|
||||
|
||||
@dataclass(frozen=True)
|
||||
class WorkerRunResult:
|
||||
claimed: bool
|
||||
job_id: str | None = None
|
||||
state: str | None = None
|
||||
error: str | None = None
|
||||
|
||||
|
||||
class HermesWorker:
|
||||
"""Poll one tenant/cell/profile partition and execute jobs safely."""
|
||||
|
||||
def __init__(
|
||||
self,
|
||||
adapter: HermesAdapter,
|
||||
handler: JobHandler,
|
||||
*,
|
||||
worker_id: str,
|
||||
tenant_id: str,
|
||||
cell_id: str,
|
||||
profile_id: str,
|
||||
poll_seconds: float = 1.0,
|
||||
heartbeat_seconds: float = 10.0,
|
||||
) -> None:
|
||||
if poll_seconds <= 0 or heartbeat_seconds <= 0:
|
||||
raise ValueError("poll_seconds and heartbeat_seconds must be positive")
|
||||
for name, value in {
|
||||
"worker_id": worker_id,
|
||||
"tenant_id": tenant_id,
|
||||
"cell_id": cell_id,
|
||||
"profile_id": profile_id,
|
||||
}.items():
|
||||
if not str(value or "").strip():
|
||||
raise ValueError(f"{name} is required")
|
||||
self.adapter = adapter
|
||||
self.handler = handler
|
||||
self.worker_id = worker_id
|
||||
self.tenant_id = tenant_id
|
||||
self.cell_id = cell_id
|
||||
self.profile_id = profile_id
|
||||
self.poll_seconds = float(poll_seconds)
|
||||
self.heartbeat_seconds = float(heartbeat_seconds)
|
||||
self._stop = threading.Event()
|
||||
|
||||
def stop(self) -> None:
|
||||
self._stop.set()
|
||||
|
||||
def run_once(self) -> WorkerRunResult:
|
||||
job = self.adapter.claim(
|
||||
tenant_id=self.tenant_id,
|
||||
cell_id=self.cell_id,
|
||||
profile_id=self.profile_id,
|
||||
worker_id=self.worker_id,
|
||||
)
|
||||
if job is None:
|
||||
return WorkerRunResult(claimed=False)
|
||||
|
||||
running = self.adapter.start(
|
||||
job.job_id,
|
||||
tenant_id=self.tenant_id,
|
||||
worker_id=self.worker_id,
|
||||
expected_revision=job.revision,
|
||||
)
|
||||
|
||||
heartbeat_stop = threading.Event()
|
||||
heartbeat_thread = threading.Thread(
|
||||
target=self._heartbeat_loop,
|
||||
args=(running.job_id, heartbeat_stop),
|
||||
name=f"hermes-heartbeat-{self.worker_id}",
|
||||
daemon=True,
|
||||
)
|
||||
heartbeat_thread.start()
|
||||
|
||||
output: Mapping[str, Any] | None = None
|
||||
execution_error: Exception | None = None
|
||||
try:
|
||||
output = dict(self.handler(running))
|
||||
except Exception as exc: # runtime boundary: normalize below
|
||||
execution_error = exc
|
||||
finally:
|
||||
# Stop the lease heartbeat before reading the final revision. This
|
||||
# prevents a revision increment racing with complete/fail.
|
||||
heartbeat_stop.set()
|
||||
heartbeat_thread.join(timeout=max(self.heartbeat_seconds * 2, 1.0))
|
||||
|
||||
try:
|
||||
current = self.adapter.get(running.job_id, tenant_id=self.tenant_id)
|
||||
if execution_error is None:
|
||||
result = self.adapter.complete(
|
||||
running.job_id,
|
||||
tenant_id=self.tenant_id,
|
||||
worker_id=self.worker_id,
|
||||
output=dict(output or {}),
|
||||
expected_revision=current.revision,
|
||||
)
|
||||
return WorkerRunResult(
|
||||
claimed=True,
|
||||
job_id=result.job_id,
|
||||
state=result.state.value,
|
||||
)
|
||||
|
||||
result = self.adapter.fail(
|
||||
running.job_id,
|
||||
tenant_id=self.tenant_id,
|
||||
worker_id=self.worker_id,
|
||||
error={
|
||||
"code": "worker_error",
|
||||
"message": str(execution_error),
|
||||
},
|
||||
expected_revision=current.revision,
|
||||
)
|
||||
return WorkerRunResult(
|
||||
claimed=True,
|
||||
job_id=result.job_id,
|
||||
state=result.state.value,
|
||||
error=str(execution_error),
|
||||
)
|
||||
except HermesConflict as exc:
|
||||
return WorkerRunResult(
|
||||
claimed=True,
|
||||
job_id=running.job_id,
|
||||
state=HermesJobState.FAILED.value,
|
||||
error=f"reconciliation_conflict: {exc}",
|
||||
)
|
||||
|
||||
def run_forever(self) -> None:
|
||||
while not self._stop.is_set():
|
||||
result = self.run_once()
|
||||
if not result.claimed:
|
||||
self._stop.wait(self.poll_seconds)
|
||||
|
||||
def _heartbeat_loop(self, job_id: str, stop_event: threading.Event) -> None:
|
||||
while not stop_event.wait(self.heartbeat_seconds):
|
||||
try:
|
||||
self.adapter.heartbeat(
|
||||
job_id,
|
||||
tenant_id=self.tenant_id,
|
||||
worker_id=self.worker_id,
|
||||
)
|
||||
except Exception:
|
||||
stop_event.set()
|
||||
return
|
||||
@@ -1,45 +0,0 @@
|
||||
"""AIOS-managed OpenClaw Ed25519 execution adapter."""
|
||||
|
||||
from .adapter import (
|
||||
AdapterError,
|
||||
CommandConflict,
|
||||
CommandNotFound,
|
||||
CommandRejected,
|
||||
InMemoryCallbackSink,
|
||||
OpenClawAdapter,
|
||||
)
|
||||
from .contract import (
|
||||
CONTRACT_VERSION,
|
||||
SIGNATURE_ALGORITHM,
|
||||
CommandState,
|
||||
Ed25519CommandSigner,
|
||||
Ed25519CommandVerifier,
|
||||
OpenClawCommand,
|
||||
OpenClawResult,
|
||||
RuntimeHealth,
|
||||
sign_command,
|
||||
verify_command_signature,
|
||||
)
|
||||
from .transport import HTTPRuntimeTransport, InProcessRuntimeTransport, RuntimeTransport
|
||||
|
||||
__all__ = [
|
||||
"AdapterError",
|
||||
"CONTRACT_VERSION",
|
||||
"CommandConflict",
|
||||
"CommandNotFound",
|
||||
"CommandRejected",
|
||||
"CommandState",
|
||||
"Ed25519CommandSigner",
|
||||
"Ed25519CommandVerifier",
|
||||
"HTTPRuntimeTransport",
|
||||
"InMemoryCallbackSink",
|
||||
"InProcessRuntimeTransport",
|
||||
"OpenClawAdapter",
|
||||
"OpenClawCommand",
|
||||
"OpenClawResult",
|
||||
"RuntimeHealth",
|
||||
"RuntimeTransport",
|
||||
"SIGNATURE_ALGORITHM",
|
||||
"sign_command",
|
||||
"verify_command_signature",
|
||||
]
|
||||
@@ -1,228 +0,0 @@
|
||||
"""Signed, tenant-isolated execution adapter for OpenClaw runtimes."""
|
||||
from __future__ import annotations
|
||||
|
||||
import threading
|
||||
from dataclasses import replace
|
||||
from typing import Callable, Mapping, Protocol
|
||||
|
||||
from .contract import (
|
||||
CommandState,
|
||||
OpenClawCommand,
|
||||
OpenClawResult,
|
||||
RuntimeHealth,
|
||||
utc_now,
|
||||
verify_command_signature,
|
||||
)
|
||||
|
||||
|
||||
class AdapterError(RuntimeError):
|
||||
"""Base adapter failure."""
|
||||
|
||||
|
||||
class CommandRejected(AdapterError):
|
||||
"""A command failed signature or contract validation."""
|
||||
|
||||
|
||||
class CommandNotFound(AdapterError):
|
||||
"""A tenant-scoped command is not visible."""
|
||||
|
||||
|
||||
class CommandConflict(AdapterError):
|
||||
"""A command or idempotency key conflicts with an existing execution."""
|
||||
|
||||
|
||||
class RuntimeTransport(Protocol):
|
||||
def execute(self, command: OpenClawCommand, timeout_seconds: float) -> OpenClawResult: ...
|
||||
def cancel(self, command_id: str) -> bool: ...
|
||||
def health(self) -> RuntimeHealth: ...
|
||||
|
||||
|
||||
class CallbackSink(Protocol):
|
||||
def on_started(self, result: OpenClawResult) -> None: ...
|
||||
def on_completed(self, result: OpenClawResult) -> None: ...
|
||||
def on_failed(self, result: OpenClawResult) -> None: ...
|
||||
|
||||
|
||||
class InMemoryCallbackSink:
|
||||
def __init__(self) -> None:
|
||||
self._lock = threading.RLock()
|
||||
self.started: list[OpenClawResult] = []
|
||||
self.completed: list[OpenClawResult] = []
|
||||
self.failed: list[OpenClawResult] = []
|
||||
|
||||
def on_started(self, result: OpenClawResult) -> None:
|
||||
with self._lock:
|
||||
self.started.append(result)
|
||||
|
||||
def on_completed(self, result: OpenClawResult) -> None:
|
||||
with self._lock:
|
||||
self.completed.append(result)
|
||||
|
||||
def on_failed(self, result: OpenClawResult) -> None:
|
||||
with self._lock:
|
||||
self.failed.append(result)
|
||||
|
||||
|
||||
SigningMaterialResolver = Callable[[str, str], bytes | str]
|
||||
|
||||
|
||||
class OpenClawAdapter:
|
||||
"""Verify, de-duplicate, execute, cancel and reconcile commands."""
|
||||
|
||||
def __init__(
|
||||
self,
|
||||
transport: RuntimeTransport,
|
||||
signing_material_resolver: SigningMaterialResolver,
|
||||
*,
|
||||
callback_sink: CallbackSink | None = None,
|
||||
default_timeout_seconds: float = 300.0,
|
||||
) -> None:
|
||||
if default_timeout_seconds <= 0:
|
||||
raise ValueError("default_timeout_seconds must be positive")
|
||||
self.transport = transport
|
||||
self.signing_material_resolver = signing_material_resolver
|
||||
self.callback_sink = callback_sink or InMemoryCallbackSink()
|
||||
self.default_timeout_seconds = float(default_timeout_seconds)
|
||||
self._lock = threading.RLock()
|
||||
self._commands: dict[str, OpenClawCommand] = {}
|
||||
self._results: dict[str, OpenClawResult] = {}
|
||||
self._idempotency: dict[tuple[str, str], tuple[str, str]] = {}
|
||||
|
||||
def _verify(self, command: OpenClawCommand) -> None:
|
||||
try:
|
||||
key_material = self.signing_material_resolver(command.tenant_id, command.key_id)
|
||||
except Exception as exc:
|
||||
raise CommandRejected("signing material unavailable") from exc
|
||||
if not verify_command_signature(command, key_material):
|
||||
raise CommandRejected("invalid or expired command signature")
|
||||
|
||||
@staticmethod
|
||||
def _validate_result(command: OpenClawCommand, result: OpenClawResult) -> None:
|
||||
if (
|
||||
result.command_id != command.command_id
|
||||
or result.tenant_id != command.tenant_id
|
||||
or result.task_id != command.task_id
|
||||
or result.trace_id != command.trace_id
|
||||
):
|
||||
raise AdapterError("runtime returned mismatched command identity")
|
||||
if result.state not in {
|
||||
CommandState.COMPLETED,
|
||||
CommandState.FAILED,
|
||||
CommandState.CANCELLED,
|
||||
CommandState.TIMED_OUT,
|
||||
}:
|
||||
raise AdapterError("runtime returned a non-terminal result")
|
||||
|
||||
def execute(
|
||||
self,
|
||||
command: OpenClawCommand,
|
||||
*,
|
||||
timeout_seconds: float | None = None,
|
||||
) -> OpenClawResult:
|
||||
timeout = self.default_timeout_seconds if timeout_seconds is None else float(timeout_seconds)
|
||||
if timeout <= 0:
|
||||
raise ValueError("timeout_seconds must be positive")
|
||||
self._verify(command)
|
||||
digest = command.signature
|
||||
idem_ref = (command.tenant_id, command.idempotency_key)
|
||||
|
||||
with self._lock:
|
||||
prior_command = self._commands.get(command.command_id)
|
||||
if prior_command is not None:
|
||||
if prior_command.signature != command.signature:
|
||||
raise CommandConflict("command_id reused with different content")
|
||||
return self._results[command.command_id]
|
||||
prior_idem = self._idempotency.get(idem_ref)
|
||||
if prior_idem is not None:
|
||||
prior_id, prior_digest = prior_idem
|
||||
if prior_digest != digest:
|
||||
raise CommandConflict("idempotency key reused with different content")
|
||||
return self._results[prior_id]
|
||||
running = OpenClawResult(
|
||||
command_id=command.command_id,
|
||||
tenant_id=command.tenant_id,
|
||||
task_id=command.task_id,
|
||||
trace_id=command.trace_id,
|
||||
state=CommandState.RUNNING,
|
||||
started_at=utc_now(),
|
||||
)
|
||||
self._commands[command.command_id] = command
|
||||
self._results[command.command_id] = running
|
||||
self._idempotency[idem_ref] = (command.command_id, digest)
|
||||
|
||||
self.callback_sink.on_started(running)
|
||||
try:
|
||||
result = self.transport.execute(command, timeout)
|
||||
self._validate_result(command, result)
|
||||
except TimeoutError as exc:
|
||||
result = replace(
|
||||
running,
|
||||
state=CommandState.TIMED_OUT,
|
||||
error={"code": "runtime_timeout", "message": str(exc) or "runtime timeout"},
|
||||
finished_at=utc_now(),
|
||||
)
|
||||
except Exception as exc:
|
||||
result = replace(
|
||||
running,
|
||||
state=CommandState.FAILED,
|
||||
error={"code": "runtime_error", "message": str(exc)},
|
||||
finished_at=utc_now(),
|
||||
)
|
||||
|
||||
if result.started_at is None:
|
||||
result = replace(result, started_at=running.started_at)
|
||||
if result.finished_at is None:
|
||||
result = replace(result, finished_at=utc_now())
|
||||
with self._lock:
|
||||
self._results[command.command_id] = result
|
||||
if result.state == CommandState.COMPLETED:
|
||||
self.callback_sink.on_completed(result)
|
||||
else:
|
||||
self.callback_sink.on_failed(result)
|
||||
return result
|
||||
|
||||
def status(self, command_id: str, *, tenant_id: str) -> OpenClawResult:
|
||||
with self._lock:
|
||||
command = self._commands.get(command_id)
|
||||
result = self._results.get(command_id)
|
||||
if command is None or result is None or command.tenant_id != tenant_id:
|
||||
raise CommandNotFound("command not found")
|
||||
return result
|
||||
|
||||
def cancel(self, command_id: str, *, tenant_id: str) -> OpenClawResult:
|
||||
with self._lock:
|
||||
command = self._commands.get(command_id)
|
||||
current = self._results.get(command_id)
|
||||
if command is None or current is None or command.tenant_id != tenant_id:
|
||||
raise CommandNotFound("command not found")
|
||||
if current.state in {
|
||||
CommandState.COMPLETED,
|
||||
CommandState.FAILED,
|
||||
CommandState.CANCELLED,
|
||||
CommandState.TIMED_OUT,
|
||||
CommandState.REJECTED,
|
||||
}:
|
||||
return current
|
||||
if not self.transport.cancel(command_id):
|
||||
raise AdapterError("runtime rejected cancellation")
|
||||
cancelled = replace(
|
||||
current,
|
||||
state=CommandState.CANCELLED,
|
||||
error={"code": "cancelled", "message": "cancelled by AIOS"},
|
||||
finished_at=utc_now(),
|
||||
)
|
||||
with self._lock:
|
||||
self._results[command_id] = cancelled
|
||||
self.callback_sink.on_failed(cancelled)
|
||||
return cancelled
|
||||
|
||||
def health(self) -> RuntimeHealth:
|
||||
return self.transport.health()
|
||||
|
||||
def snapshot(self, *, tenant_id: str) -> Mapping[str, OpenClawResult]:
|
||||
with self._lock:
|
||||
return {
|
||||
command_id: result
|
||||
for command_id, result in self._results.items()
|
||||
if self._commands[command_id].tenant_id == tenant_id
|
||||
}
|
||||
@@ -1,97 +0,0 @@
|
||||
"""Audit-oriented lifecycle callbacks for OpenClaw execution."""
|
||||
from __future__ import annotations
|
||||
|
||||
import json
|
||||
import threading
|
||||
from dataclasses import dataclass, field
|
||||
from typing import Any, Mapping, Protocol
|
||||
|
||||
from .contract import OpenClawResult, utc_now
|
||||
|
||||
|
||||
class EventPublisher(Protocol):
|
||||
def publish(self, event: Mapping[str, Any]) -> None: ...
|
||||
|
||||
|
||||
@dataclass(frozen=True)
|
||||
class ExecutionEvent:
|
||||
event_type: str
|
||||
tenant_id: str
|
||||
task_id: str
|
||||
trace_id: str
|
||||
command_id: str
|
||||
state: str
|
||||
created_at: str = field(default_factory=utc_now)
|
||||
details: Mapping[str, Any] = field(default_factory=dict)
|
||||
|
||||
def as_dict(self) -> dict[str, Any]:
|
||||
return {
|
||||
"event_type": self.event_type,
|
||||
"tenant_id": self.tenant_id,
|
||||
"task_id": self.task_id,
|
||||
"trace_id": self.trace_id,
|
||||
"command_id": self.command_id,
|
||||
"state": self.state,
|
||||
"created_at": self.created_at,
|
||||
"details": json.loads(
|
||||
json.dumps(dict(self.details), ensure_ascii=False, default=str)
|
||||
),
|
||||
}
|
||||
|
||||
|
||||
class InMemoryEventPublisher:
|
||||
"""Thread-safe publisher used by tests and first integration slice."""
|
||||
|
||||
def __init__(self) -> None:
|
||||
self._lock = threading.RLock()
|
||||
self.events: list[dict[str, Any]] = []
|
||||
|
||||
def publish(self, event: Mapping[str, Any]) -> None:
|
||||
with self._lock:
|
||||
self.events.append(
|
||||
json.loads(json.dumps(dict(event), ensure_ascii=False, default=str))
|
||||
)
|
||||
|
||||
|
||||
class AuditCallbackSink:
|
||||
"""Convert runtime callbacks into tenant-scoped audit events."""
|
||||
|
||||
def __init__(self, publisher: EventPublisher) -> None:
|
||||
self.publisher = publisher
|
||||
|
||||
@staticmethod
|
||||
def _event(
|
||||
event_type: str,
|
||||
result: OpenClawResult,
|
||||
) -> ExecutionEvent:
|
||||
details: dict[str, Any] = {
|
||||
"runtime_id": result.runtime_id,
|
||||
"attempts": result.attempts,
|
||||
}
|
||||
if result.error:
|
||||
details["error"] = dict(result.error)
|
||||
if result.output:
|
||||
details["output_present"] = True
|
||||
return ExecutionEvent(
|
||||
event_type=event_type,
|
||||
tenant_id=result.tenant_id,
|
||||
task_id=result.task_id,
|
||||
trace_id=result.trace_id,
|
||||
command_id=result.command_id,
|
||||
state=result.state.value,
|
||||
details=details,
|
||||
)
|
||||
|
||||
def on_started(self, result: OpenClawResult) -> None:
|
||||
self.publisher.publish(self._event("OPENCLAW_STARTED", result).as_dict())
|
||||
|
||||
def on_completed(self, result: OpenClawResult) -> None:
|
||||
self.publisher.publish(self._event("OPENCLAW_COMPLETED", result).as_dict())
|
||||
|
||||
def on_failed(self, result: OpenClawResult) -> None:
|
||||
event_type = {
|
||||
"CANCELLED": "OPENCLAW_CANCELLED",
|
||||
"TIMED_OUT": "OPENCLAW_TIMED_OUT",
|
||||
"REJECTED": "OPENCLAW_REJECTED",
|
||||
}.get(result.state.value, "OPENCLAW_FAILED")
|
||||
self.publisher.publish(self._event(event_type, result).as_dict())
|
||||
@@ -1,383 +0,0 @@
|
||||
"""AIOS 到 OpenClaw 的 Ed25519 执行合同。"""
|
||||
from __future__ import annotations
|
||||
|
||||
import base64
|
||||
import hashlib
|
||||
import hmac
|
||||
import json
|
||||
import uuid
|
||||
from dataclasses import dataclass, field, replace
|
||||
from datetime import datetime, timezone
|
||||
from enum import Enum
|
||||
from typing import Any, Mapping, Protocol
|
||||
|
||||
CONTRACT_VERSION = "aios.openclaw.command.v2"
|
||||
SIGNATURE_ALGORITHM = "Ed25519"
|
||||
DEFAULT_CLOCK_SKEW_SECONDS = 300
|
||||
|
||||
|
||||
def utc_now() -> str:
|
||||
return datetime.now(timezone.utc).isoformat().replace("+00:00", "Z")
|
||||
|
||||
|
||||
def _parse_timestamp(value: str) -> datetime:
|
||||
normalized = str(value or "").strip()
|
||||
if not normalized:
|
||||
raise ValueError("timestamp is required")
|
||||
if normalized.endswith("Z"):
|
||||
normalized = normalized[:-1] + "+00:00"
|
||||
parsed = datetime.fromisoformat(normalized)
|
||||
if parsed.tzinfo is None:
|
||||
raise ValueError("timestamp must include a timezone")
|
||||
return parsed.astimezone(timezone.utc)
|
||||
|
||||
|
||||
def _required(value: str, label: str) -> str:
|
||||
normalized = str(value or "").strip()
|
||||
if not normalized:
|
||||
raise ValueError(f"{label} is required")
|
||||
return normalized
|
||||
|
||||
|
||||
def _safe_mapping(value: Mapping[str, Any] | None) -> dict[str, Any]:
|
||||
return json.loads(
|
||||
json.dumps(dict(value or {}), ensure_ascii=False, sort_keys=True, default=str)
|
||||
)
|
||||
|
||||
|
||||
def _load_crypto() -> tuple[Any, Any, Any]:
|
||||
try:
|
||||
from cryptography.hazmat.primitives import serialization
|
||||
from cryptography.hazmat.primitives.asymmetric.ed25519 import (
|
||||
Ed25519PrivateKey,
|
||||
Ed25519PublicKey,
|
||||
)
|
||||
except ImportError as exc: # pragma: no cover
|
||||
raise RuntimeError("cryptography with Ed25519 support is required") from exc
|
||||
return serialization, Ed25519PrivateKey, Ed25519PublicKey
|
||||
|
||||
|
||||
class CommandSigner(Protocol):
|
||||
key_id: str
|
||||
fingerprint: str
|
||||
|
||||
def sign(self, payload: bytes) -> bytes: ...
|
||||
|
||||
|
||||
class CommandVerifier(Protocol):
|
||||
key_id: str
|
||||
fingerprint: str
|
||||
|
||||
def verify(self, payload: bytes, signature: bytes) -> bool: ...
|
||||
|
||||
|
||||
class Ed25519CommandSigner:
|
||||
def __init__(self, private_key: Any, *, key_id: str) -> None:
|
||||
serialization, private_cls, _ = _load_crypto()
|
||||
if not isinstance(private_key, private_cls):
|
||||
raise ValueError("private key is not Ed25519")
|
||||
self.private_key = private_key
|
||||
self.key_id = _required(key_id, "key_id")
|
||||
raw = private_key.public_key().public_bytes(
|
||||
encoding=serialization.Encoding.Raw,
|
||||
format=serialization.PublicFormat.Raw,
|
||||
)
|
||||
self.fingerprint = hashlib.sha256(raw).hexdigest()
|
||||
|
||||
@classmethod
|
||||
def from_bytes(cls, value: bytes | str, *, key_id: str) -> "Ed25519CommandSigner":
|
||||
serialization, private_cls, _ = _load_crypto()
|
||||
raw = value.encode("utf-8") if isinstance(value, str) else bytes(value)
|
||||
if raw.startswith(b"-----BEGIN"):
|
||||
key = serialization.load_pem_private_key(raw, password=None)
|
||||
elif len(raw) == 32:
|
||||
key = private_cls.from_private_bytes(raw)
|
||||
else:
|
||||
raise ValueError("Ed25519 private key must be PEM or a raw 32-byte seed")
|
||||
return cls(key, key_id=key_id)
|
||||
|
||||
def sign(self, payload: bytes) -> bytes:
|
||||
return self.private_key.sign(bytes(payload))
|
||||
|
||||
def verifier(self) -> "Ed25519CommandVerifier":
|
||||
return Ed25519CommandVerifier(self.private_key.public_key(), key_id=self.key_id)
|
||||
|
||||
|
||||
class Ed25519CommandVerifier:
|
||||
def __init__(self, public_key: Any, *, key_id: str) -> None:
|
||||
serialization, _, public_cls = _load_crypto()
|
||||
if not isinstance(public_key, public_cls):
|
||||
raise ValueError("public key is not Ed25519")
|
||||
self.public_key = public_key
|
||||
self.key_id = _required(key_id, "key_id")
|
||||
raw = public_key.public_bytes(
|
||||
encoding=serialization.Encoding.Raw,
|
||||
format=serialization.PublicFormat.Raw,
|
||||
)
|
||||
self.fingerprint = hashlib.sha256(raw).hexdigest()
|
||||
|
||||
@classmethod
|
||||
def from_bytes(cls, value: bytes | str, *, key_id: str) -> "Ed25519CommandVerifier":
|
||||
serialization, private_cls, public_cls = _load_crypto()
|
||||
raw = value.encode("utf-8") if isinstance(value, str) else bytes(value)
|
||||
if raw.startswith(b"-----BEGIN"):
|
||||
try:
|
||||
key = serialization.load_pem_public_key(raw)
|
||||
except ValueError:
|
||||
private = serialization.load_pem_private_key(raw, password=None)
|
||||
if not isinstance(private, private_cls):
|
||||
raise ValueError("key is not Ed25519")
|
||||
key = private.public_key()
|
||||
elif len(raw) == 32:
|
||||
key = public_cls.from_public_bytes(raw)
|
||||
else:
|
||||
raise ValueError("Ed25519 public key must be PEM or raw 32-byte key")
|
||||
return cls(key, key_id=key_id)
|
||||
|
||||
def verify(self, payload: bytes, signature: bytes) -> bool:
|
||||
try:
|
||||
self.public_key.verify(bytes(signature), bytes(payload))
|
||||
return True
|
||||
except Exception:
|
||||
return False
|
||||
|
||||
|
||||
class CommandState(str, Enum):
|
||||
ACCEPTED = "ACCEPTED"
|
||||
RUNNING = "RUNNING"
|
||||
COMPLETED = "COMPLETED"
|
||||
FAILED = "FAILED"
|
||||
CANCELLED = "CANCELLED"
|
||||
TIMED_OUT = "TIMED_OUT"
|
||||
REJECTED = "REJECTED"
|
||||
|
||||
|
||||
@dataclass(frozen=True)
|
||||
class OpenClawCommand:
|
||||
command_id: str
|
||||
tenant_id: str
|
||||
task_id: str
|
||||
trace_id: str
|
||||
action: str
|
||||
payload: Mapping[str, Any] = field(default_factory=dict)
|
||||
idempotency_key: str = ""
|
||||
created_at: str = field(default_factory=utc_now)
|
||||
expires_at: str | None = None
|
||||
contract_version: str = CONTRACT_VERSION
|
||||
signature_algorithm: str = SIGNATURE_ALGORITHM
|
||||
key_id: str = "default"
|
||||
public_key_fingerprint: str = ""
|
||||
signature: str = ""
|
||||
|
||||
def __post_init__(self) -> None:
|
||||
for field_name in (
|
||||
"command_id",
|
||||
"tenant_id",
|
||||
"task_id",
|
||||
"trace_id",
|
||||
"action",
|
||||
"idempotency_key",
|
||||
"created_at",
|
||||
"contract_version",
|
||||
"signature_algorithm",
|
||||
"key_id",
|
||||
):
|
||||
object.__setattr__(
|
||||
self, field_name, _required(getattr(self, field_name), field_name)
|
||||
)
|
||||
if self.contract_version != CONTRACT_VERSION:
|
||||
raise ValueError(f"unsupported contract_version: {self.contract_version}")
|
||||
if self.signature_algorithm != SIGNATURE_ALGORITHM:
|
||||
raise ValueError(
|
||||
f"unsupported signature_algorithm: {self.signature_algorithm}"
|
||||
)
|
||||
object.__setattr__(self, "payload", _safe_mapping(self.payload))
|
||||
object.__setattr__(
|
||||
self, "public_key_fingerprint", str(self.public_key_fingerprint or "").strip()
|
||||
)
|
||||
object.__setattr__(self, "signature", str(self.signature or "").strip())
|
||||
_parse_timestamp(self.created_at)
|
||||
if self.expires_at is not None:
|
||||
object.__setattr__(self, "expires_at", _required(self.expires_at, "expires_at"))
|
||||
if _parse_timestamp(self.expires_at) <= _parse_timestamp(self.created_at):
|
||||
raise ValueError("expires_at must be later than created_at")
|
||||
|
||||
@classmethod
|
||||
def create(
|
||||
cls,
|
||||
*,
|
||||
tenant_id: str,
|
||||
task_id: str,
|
||||
trace_id: str,
|
||||
action: str,
|
||||
payload: Mapping[str, Any] | None,
|
||||
idempotency_key: str,
|
||||
expires_at: str | None = None,
|
||||
key_id: str = "default",
|
||||
command_id: str | None = None,
|
||||
) -> "OpenClawCommand":
|
||||
return cls(
|
||||
command_id=command_id or f"cmd_{uuid.uuid4().hex}",
|
||||
tenant_id=tenant_id,
|
||||
task_id=task_id,
|
||||
trace_id=trace_id,
|
||||
action=action,
|
||||
payload=_safe_mapping(payload),
|
||||
idempotency_key=idempotency_key,
|
||||
expires_at=expires_at,
|
||||
key_id=key_id,
|
||||
)
|
||||
|
||||
def unsigned_dict(self) -> dict[str, Any]:
|
||||
return {
|
||||
"command_id": self.command_id,
|
||||
"tenant_id": self.tenant_id,
|
||||
"task_id": self.task_id,
|
||||
"trace_id": self.trace_id,
|
||||
"action": self.action,
|
||||
"payload": _safe_mapping(self.payload),
|
||||
"idempotency_key": self.idempotency_key,
|
||||
"created_at": self.created_at,
|
||||
"expires_at": self.expires_at,
|
||||
"contract_version": self.contract_version,
|
||||
"signature_algorithm": self.signature_algorithm,
|
||||
"key_id": self.key_id,
|
||||
"public_key_fingerprint": self.public_key_fingerprint,
|
||||
}
|
||||
|
||||
|
||||
@dataclass(frozen=True)
|
||||
class OpenClawResult:
|
||||
command_id: str
|
||||
tenant_id: str
|
||||
task_id: str
|
||||
trace_id: str
|
||||
state: CommandState
|
||||
output: Mapping[str, Any] | None = None
|
||||
error: Mapping[str, Any] | None = None
|
||||
started_at: str | None = None
|
||||
finished_at: str | None = None
|
||||
runtime_id: str | None = None
|
||||
attempts: int = 1
|
||||
|
||||
def __post_init__(self) -> None:
|
||||
for field_name in ("command_id", "tenant_id", "task_id", "trace_id"):
|
||||
object.__setattr__(
|
||||
self, field_name, _required(getattr(self, field_name), field_name)
|
||||
)
|
||||
object.__setattr__(self, "state", CommandState(self.state))
|
||||
if self.output is not None:
|
||||
object.__setattr__(self, "output", _safe_mapping(self.output))
|
||||
if self.error is not None:
|
||||
object.__setattr__(self, "error", _safe_mapping(self.error))
|
||||
if self.started_at is not None:
|
||||
_parse_timestamp(self.started_at)
|
||||
if self.finished_at is not None:
|
||||
_parse_timestamp(self.finished_at)
|
||||
if self.attempts < 1:
|
||||
raise ValueError("attempts must be >= 1")
|
||||
|
||||
|
||||
@dataclass(frozen=True)
|
||||
class RuntimeHealth:
|
||||
runtime: str
|
||||
runtime_id: str
|
||||
status: str
|
||||
version: str
|
||||
heartbeat_at: str
|
||||
active_tasks: int = 0
|
||||
workspace_isolated: bool = False
|
||||
credential_ref_configured: bool = False
|
||||
details: Mapping[str, Any] = field(default_factory=dict)
|
||||
|
||||
def __post_init__(self) -> None:
|
||||
for field_name in (
|
||||
"runtime",
|
||||
"runtime_id",
|
||||
"status",
|
||||
"version",
|
||||
"heartbeat_at",
|
||||
):
|
||||
object.__setattr__(
|
||||
self, field_name, _required(getattr(self, field_name), field_name)
|
||||
)
|
||||
_parse_timestamp(self.heartbeat_at)
|
||||
if self.active_tasks < 0:
|
||||
raise ValueError("active_tasks must be >= 0")
|
||||
object.__setattr__(self, "details", _safe_mapping(self.details))
|
||||
|
||||
|
||||
def canonical_command_bytes(command: OpenClawCommand) -> bytes:
|
||||
return json.dumps(
|
||||
command.unsigned_dict(),
|
||||
ensure_ascii=False,
|
||||
sort_keys=True,
|
||||
separators=(",", ":"),
|
||||
).encode("utf-8")
|
||||
|
||||
|
||||
def _as_signer(command: OpenClawCommand, value: Any) -> CommandSigner:
|
||||
if hasattr(value, "sign") and hasattr(value, "fingerprint") and hasattr(value, "key_id"):
|
||||
return value
|
||||
return Ed25519CommandSigner.from_bytes(value, key_id=command.key_id)
|
||||
|
||||
|
||||
def _as_verifier(command: OpenClawCommand, value: Any) -> CommandVerifier:
|
||||
if isinstance(value, Ed25519CommandSigner):
|
||||
return value.verifier()
|
||||
if hasattr(value, "verify") and hasattr(value, "fingerprint") and hasattr(value, "key_id"):
|
||||
return value
|
||||
return Ed25519CommandVerifier.from_bytes(value, key_id=command.key_id)
|
||||
|
||||
|
||||
def sign_command(command: OpenClawCommand, signing_key: Any) -> OpenClawCommand:
|
||||
signer = _as_signer(command, signing_key)
|
||||
if signer.key_id != command.key_id:
|
||||
raise ValueError("command key_id does not match signer")
|
||||
prepared = replace(
|
||||
command,
|
||||
signature_algorithm=SIGNATURE_ALGORITHM,
|
||||
public_key_fingerprint=signer.fingerprint,
|
||||
signature="",
|
||||
)
|
||||
signature = base64.b64encode(
|
||||
signer.sign(canonical_command_bytes(prepared))
|
||||
).decode("ascii")
|
||||
return replace(prepared, signature=signature)
|
||||
|
||||
|
||||
def verify_command_signature(
|
||||
command: OpenClawCommand,
|
||||
verification_key: Any,
|
||||
*,
|
||||
now: datetime | None = None,
|
||||
clock_skew_seconds: int = DEFAULT_CLOCK_SKEW_SECONDS,
|
||||
) -> bool:
|
||||
if (
|
||||
not command.signature
|
||||
or command.contract_version != CONTRACT_VERSION
|
||||
or command.signature_algorithm != SIGNATURE_ALGORITHM
|
||||
):
|
||||
return False
|
||||
try:
|
||||
verifier = _as_verifier(command, verification_key)
|
||||
signature = base64.b64decode(command.signature, validate=True)
|
||||
except Exception:
|
||||
return False
|
||||
if verifier.key_id != command.key_id:
|
||||
return False
|
||||
if not command.public_key_fingerprint or not hmac.compare_digest(
|
||||
command.public_key_fingerprint, verifier.fingerprint
|
||||
):
|
||||
return False
|
||||
if not verifier.verify(canonical_command_bytes(command), signature):
|
||||
return False
|
||||
current = (now or datetime.now(timezone.utc)).astimezone(timezone.utc)
|
||||
created = _parse_timestamp(command.created_at)
|
||||
if created.timestamp() - current.timestamp() > clock_skew_seconds:
|
||||
return False
|
||||
if command.expires_at is not None:
|
||||
expires = _parse_timestamp(command.expires_at)
|
||||
if current.timestamp() - expires.timestamp() > clock_skew_seconds:
|
||||
return False
|
||||
return True
|
||||
@@ -1,103 +0,0 @@
|
||||
"""Health policy and self-healing decisions for OpenClaw runtimes."""
|
||||
from __future__ import annotations
|
||||
|
||||
from dataclasses import dataclass, field
|
||||
from datetime import datetime, timezone
|
||||
from typing import Mapping
|
||||
|
||||
from .contract import RuntimeHealth
|
||||
|
||||
|
||||
def _parse(value: str) -> datetime:
|
||||
normalized = value[:-1] + "+00:00" if value.endswith("Z") else value
|
||||
parsed = datetime.fromisoformat(normalized)
|
||||
if parsed.tzinfo is None:
|
||||
raise ValueError("heartbeat timestamp must include timezone")
|
||||
return parsed.astimezone(timezone.utc)
|
||||
|
||||
|
||||
@dataclass(frozen=True)
|
||||
class HealthPolicy:
|
||||
max_heartbeat_age_seconds: int = 90
|
||||
require_workspace_isolation: bool = True
|
||||
require_credential_ref: bool = True
|
||||
accepted_statuses: frozenset[str] = field(
|
||||
default_factory=lambda: frozenset({"healthy", "ready"})
|
||||
)
|
||||
|
||||
def __post_init__(self) -> None:
|
||||
if self.max_heartbeat_age_seconds < 5:
|
||||
raise ValueError("max_heartbeat_age_seconds must be >= 5")
|
||||
if not self.accepted_statuses:
|
||||
raise ValueError("accepted_statuses must not be empty")
|
||||
|
||||
|
||||
@dataclass(frozen=True)
|
||||
class HealthAssessment:
|
||||
healthy: bool
|
||||
reasons: tuple[str, ...]
|
||||
recoverable: bool
|
||||
recommended_action: str
|
||||
details: Mapping[str, object] = field(default_factory=dict)
|
||||
|
||||
|
||||
class RuntimeHealthMonitor:
|
||||
"""Evaluate runtime health and recommend bounded recovery actions."""
|
||||
|
||||
def __init__(self, policy: HealthPolicy | None = None) -> None:
|
||||
self.policy = policy or HealthPolicy()
|
||||
|
||||
def assess(
|
||||
self,
|
||||
health: RuntimeHealth,
|
||||
*,
|
||||
now: datetime | None = None,
|
||||
) -> HealthAssessment:
|
||||
current = (now or datetime.now(timezone.utc)).astimezone(timezone.utc)
|
||||
heartbeat = _parse(health.heartbeat_at)
|
||||
age = max(0.0, current.timestamp() - heartbeat.timestamp())
|
||||
reasons: list[str] = []
|
||||
|
||||
if health.status.lower() not in self.policy.accepted_statuses:
|
||||
reasons.append("runtime_status_unhealthy")
|
||||
if age > self.policy.max_heartbeat_age_seconds:
|
||||
reasons.append("heartbeat_stale")
|
||||
if self.policy.require_workspace_isolation and not health.workspace_isolated:
|
||||
reasons.append("workspace_not_isolated")
|
||||
if self.policy.require_credential_ref and not health.credential_ref_configured:
|
||||
reasons.append("credential_reference_missing")
|
||||
|
||||
if not reasons:
|
||||
return HealthAssessment(
|
||||
healthy=True,
|
||||
reasons=(),
|
||||
recoverable=True,
|
||||
recommended_action="none",
|
||||
details={"heartbeat_age_seconds": age},
|
||||
)
|
||||
|
||||
non_recoverable = {
|
||||
"workspace_not_isolated",
|
||||
"credential_reference_missing",
|
||||
}.intersection(reasons)
|
||||
if non_recoverable:
|
||||
action = "quarantine_runtime"
|
||||
recoverable = False
|
||||
elif "heartbeat_stale" in reasons:
|
||||
action = "restart_runtime"
|
||||
recoverable = True
|
||||
else:
|
||||
action = "drain_and_restart"
|
||||
recoverable = True
|
||||
|
||||
return HealthAssessment(
|
||||
healthy=False,
|
||||
reasons=tuple(reasons),
|
||||
recoverable=recoverable,
|
||||
recommended_action=action,
|
||||
details={
|
||||
"heartbeat_age_seconds": age,
|
||||
"runtime_id": health.runtime_id,
|
||||
"active_tasks": health.active_tasks,
|
||||
},
|
||||
)
|
||||
@@ -1,214 +0,0 @@
|
||||
"""Runtime transport implementations for the OpenClaw adapter."""
|
||||
from __future__ import annotations
|
||||
|
||||
import json
|
||||
import threading
|
||||
import urllib.error
|
||||
import urllib.parse
|
||||
import urllib.request
|
||||
from typing import Any, Callable, Mapping, Protocol
|
||||
|
||||
from .contract import (
|
||||
CommandState,
|
||||
OpenClawCommand,
|
||||
OpenClawResult,
|
||||
RuntimeHealth,
|
||||
utc_now,
|
||||
)
|
||||
|
||||
|
||||
class RuntimeTransport(Protocol):
|
||||
def execute(self, command: OpenClawCommand, timeout_seconds: float) -> OpenClawResult: ...
|
||||
def cancel(self, command_id: str) -> bool: ...
|
||||
def health(self) -> RuntimeHealth: ...
|
||||
|
||||
|
||||
class TransportError(RuntimeError):
|
||||
"""Runtime transport or protocol failure."""
|
||||
|
||||
|
||||
RuntimeHandler = Callable[[OpenClawCommand], Mapping[str, Any] | OpenClawResult]
|
||||
|
||||
|
||||
class InProcessRuntimeTransport:
|
||||
"""Deterministic runtime used by tests and controlled local integrations."""
|
||||
|
||||
def __init__(
|
||||
self,
|
||||
handler: RuntimeHandler,
|
||||
*,
|
||||
runtime_id: str = "openclaw-in-process",
|
||||
version: str = "v1",
|
||||
workspace_isolated: bool = True,
|
||||
credential_ref_configured: bool = True,
|
||||
) -> None:
|
||||
self.handler = handler
|
||||
self.runtime_id = runtime_id
|
||||
self.version = version
|
||||
self.workspace_isolated = workspace_isolated
|
||||
self.credential_ref_configured = credential_ref_configured
|
||||
self._lock = threading.RLock()
|
||||
self._running: set[str] = set()
|
||||
self._cancelled: set[str] = set()
|
||||
|
||||
def execute(self, command: OpenClawCommand, timeout_seconds: float) -> OpenClawResult:
|
||||
if timeout_seconds <= 0:
|
||||
raise ValueError("timeout_seconds must be positive")
|
||||
with self._lock:
|
||||
if command.command_id in self._cancelled:
|
||||
return OpenClawResult(
|
||||
command_id=command.command_id,
|
||||
tenant_id=command.tenant_id,
|
||||
task_id=command.task_id,
|
||||
trace_id=command.trace_id,
|
||||
state=CommandState.CANCELLED,
|
||||
error={"code": "cancelled", "message": "cancelled before execution"},
|
||||
finished_at=utc_now(),
|
||||
runtime_id=self.runtime_id,
|
||||
)
|
||||
self._running.add(command.command_id)
|
||||
try:
|
||||
raw = self.handler(command)
|
||||
if isinstance(raw, OpenClawResult):
|
||||
return raw
|
||||
if not isinstance(raw, Mapping):
|
||||
raise TransportError("runtime handler must return a mapping or OpenClawResult")
|
||||
return OpenClawResult(
|
||||
command_id=command.command_id,
|
||||
tenant_id=command.tenant_id,
|
||||
task_id=command.task_id,
|
||||
trace_id=command.trace_id,
|
||||
state=CommandState(str(raw.get("state", "COMPLETED"))),
|
||||
output=raw.get("output"),
|
||||
error=raw.get("error"),
|
||||
started_at=str(raw.get("started_at") or utc_now()),
|
||||
finished_at=str(raw.get("finished_at") or utc_now()),
|
||||
runtime_id=str(raw.get("runtime_id") or self.runtime_id),
|
||||
attempts=int(raw.get("attempts", 1)),
|
||||
)
|
||||
finally:
|
||||
with self._lock:
|
||||
self._running.discard(command.command_id)
|
||||
|
||||
def cancel(self, command_id: str) -> bool:
|
||||
with self._lock:
|
||||
self._cancelled.add(command_id)
|
||||
return command_id in self._running
|
||||
|
||||
def health(self) -> RuntimeHealth:
|
||||
with self._lock:
|
||||
active = len(self._running)
|
||||
return RuntimeHealth(
|
||||
runtime="openclaw",
|
||||
runtime_id=self.runtime_id,
|
||||
status="healthy",
|
||||
version=self.version,
|
||||
heartbeat_at=utc_now(),
|
||||
active_tasks=active,
|
||||
workspace_isolated=self.workspace_isolated,
|
||||
credential_ref_configured=self.credential_ref_configured,
|
||||
details={"transport": "in_process"},
|
||||
)
|
||||
|
||||
|
||||
class HTTPRuntimeTransport:
|
||||
"""Private HTTP transport for an OpenClaw runtime service."""
|
||||
|
||||
def __init__(
|
||||
self,
|
||||
base_url: str,
|
||||
*,
|
||||
runtime_id: str = "openclaw-http",
|
||||
credential_ref: str | None = None,
|
||||
max_response_bytes: int = 2_097_152,
|
||||
) -> None:
|
||||
normalized = str(base_url).rstrip("/")
|
||||
if not normalized.startswith(("http://", "https://")):
|
||||
raise ValueError("base_url must use http or https")
|
||||
self.base_url = normalized
|
||||
self.runtime_id = runtime_id
|
||||
self.credential_ref = credential_ref
|
||||
self.max_response_bytes = int(max_response_bytes)
|
||||
|
||||
def _request(
|
||||
self,
|
||||
method: str,
|
||||
path: str,
|
||||
*,
|
||||
payload: Mapping[str, Any] | None,
|
||||
timeout_seconds: float,
|
||||
) -> Mapping[str, Any]:
|
||||
body = None
|
||||
headers = {"Accept": "application/json", "User-Agent": "AIOS-OpenClaw/1"}
|
||||
if payload is not None:
|
||||
body = json.dumps(dict(payload), separators=(",", ":")).encode("utf-8")
|
||||
headers["Content-Type"] = "application/json"
|
||||
if self.credential_ref:
|
||||
headers["X-AIOS-Credential-Ref"] = self.credential_ref
|
||||
request = urllib.request.Request(
|
||||
f"{self.base_url}{path}",
|
||||
data=body,
|
||||
method=method,
|
||||
headers=headers,
|
||||
)
|
||||
try:
|
||||
with urllib.request.urlopen(request, timeout=timeout_seconds) as response:
|
||||
raw = response.read(self.max_response_bytes + 1)
|
||||
except urllib.error.HTTPError as exc:
|
||||
raise TransportError(f"runtime returned HTTP {exc.code}") from exc
|
||||
except urllib.error.URLError as exc:
|
||||
raise TransportError(f"runtime unavailable: {exc.reason}") from exc
|
||||
if len(raw) > self.max_response_bytes:
|
||||
raise TransportError("runtime response exceeded size limit")
|
||||
decoded = json.loads(raw.decode("utf-8"))
|
||||
if not isinstance(decoded, Mapping):
|
||||
raise TransportError("runtime response must be a JSON object")
|
||||
return decoded
|
||||
|
||||
@staticmethod
|
||||
def _command_payload(command: OpenClawCommand) -> dict[str, Any]:
|
||||
return {**command.unsigned_dict(), "signature": command.signature}
|
||||
|
||||
def execute(self, command: OpenClawCommand, timeout_seconds: float) -> OpenClawResult:
|
||||
value = self._request(
|
||||
"POST",
|
||||
"/v1/execute",
|
||||
payload=self._command_payload(command),
|
||||
timeout_seconds=timeout_seconds,
|
||||
)
|
||||
return OpenClawResult(
|
||||
command_id=str(value["command_id"]),
|
||||
tenant_id=str(value["tenant_id"]),
|
||||
task_id=str(value["task_id"]),
|
||||
trace_id=str(value["trace_id"]),
|
||||
state=CommandState(str(value["state"])),
|
||||
output=value.get("output"),
|
||||
error=value.get("error"),
|
||||
started_at=value.get("started_at"),
|
||||
finished_at=value.get("finished_at"),
|
||||
runtime_id=str(value.get("runtime_id") or self.runtime_id),
|
||||
attempts=int(value.get("attempts", 1)),
|
||||
)
|
||||
|
||||
def cancel(self, command_id: str) -> bool:
|
||||
value = self._request(
|
||||
"POST",
|
||||
f"/v1/commands/{urllib.parse.quote(command_id, safe='')}/cancel",
|
||||
payload={},
|
||||
timeout_seconds=10.0,
|
||||
)
|
||||
return bool(value.get("accepted"))
|
||||
|
||||
def health(self) -> RuntimeHealth:
|
||||
value = self._request("GET", "/v1/health", payload=None, timeout_seconds=5.0)
|
||||
return RuntimeHealth(
|
||||
runtime=str(value.get("runtime") or "openclaw"),
|
||||
runtime_id=str(value.get("runtime_id") or self.runtime_id),
|
||||
status=str(value.get("status") or "unknown"),
|
||||
version=str(value.get("version") or "unknown"),
|
||||
heartbeat_at=str(value.get("heartbeat_at") or utc_now()),
|
||||
active_tasks=int(value.get("active_tasks", 0)),
|
||||
workspace_isolated=bool(value.get("workspace_isolated", False)),
|
||||
credential_ref_configured=bool(value.get("credential_ref_configured", False)),
|
||||
details=value.get("details") if isinstance(value.get("details"), Mapping) else {},
|
||||
)
|
||||
@@ -1,110 +0,0 @@
|
||||
"""AIOS V2 控制面、执行编排与可信运行来源证明。"""
|
||||
|
||||
from .control_plane import (
|
||||
AgentRecord,
|
||||
AuditEvent,
|
||||
ControlPlaneError,
|
||||
ControlPlaneService,
|
||||
IdempotencyConflict,
|
||||
InMemoryControlPlaneStore,
|
||||
InvalidTransition,
|
||||
NotFound,
|
||||
PolicyDenied,
|
||||
RequestContext,
|
||||
RevisionConflict,
|
||||
TaskRecord,
|
||||
TaskState,
|
||||
TenantIsolationError,
|
||||
TenantRecord,
|
||||
Unauthorized,
|
||||
)
|
||||
from .execution_tracking import ExecutionEvidence, ExecutionTracker
|
||||
from .orchestrator import DispatchRecord, ExecutionOrchestrator, OrchestrationError
|
||||
from .provenance import (
|
||||
Ed25519PrivateKeySigner,
|
||||
Ed25519PublicKeyVerifier,
|
||||
ExecutionPath,
|
||||
GitOperation,
|
||||
PRODUCTION_POLICY_VERSION,
|
||||
ProvenanceAuthorization,
|
||||
ProvenanceControlledWriter,
|
||||
ProvenanceDenied,
|
||||
ProvenanceError,
|
||||
ProvenanceExpired,
|
||||
ProvenanceIssuer,
|
||||
ProvenanceNotFound,
|
||||
ProvenanceReplay,
|
||||
ProvenanceRevoked,
|
||||
ProvenanceSignatureError,
|
||||
ProvenanceStatus,
|
||||
ProvenanceVerifier,
|
||||
RunProvenance,
|
||||
SQLiteProvenanceStore,
|
||||
digest_payload,
|
||||
)
|
||||
from .provenance_git import (
|
||||
GitCommandResult,
|
||||
GitExecutionContext,
|
||||
ProvenanceGitError,
|
||||
ProvenanceGitWriter,
|
||||
)
|
||||
from .provenance_operations import (
|
||||
OperationContext,
|
||||
OperationReceipt,
|
||||
ProvenanceOperationGate,
|
||||
build_provenance_writer_from_env,
|
||||
context_from_environment,
|
||||
)
|
||||
|
||||
__all__ = [
|
||||
"AgentRecord",
|
||||
"AuditEvent",
|
||||
"ControlPlaneError",
|
||||
"ControlPlaneService",
|
||||
"DispatchRecord",
|
||||
"Ed25519PrivateKeySigner",
|
||||
"Ed25519PublicKeyVerifier",
|
||||
"ExecutionEvidence",
|
||||
"ExecutionOrchestrator",
|
||||
"ExecutionPath",
|
||||
"ExecutionTracker",
|
||||
"GitCommandResult",
|
||||
"GitExecutionContext",
|
||||
"GitOperation",
|
||||
"IdempotencyConflict",
|
||||
"InMemoryControlPlaneStore",
|
||||
"InvalidTransition",
|
||||
"NotFound",
|
||||
"OperationContext",
|
||||
"OperationReceipt",
|
||||
"OrchestrationError",
|
||||
"PRODUCTION_POLICY_VERSION",
|
||||
"PolicyDenied",
|
||||
"ProvenanceAuthorization",
|
||||
"ProvenanceControlledWriter",
|
||||
"ProvenanceDenied",
|
||||
"ProvenanceError",
|
||||
"ProvenanceExpired",
|
||||
"ProvenanceGitError",
|
||||
"ProvenanceGitWriter",
|
||||
"ProvenanceIssuer",
|
||||
"ProvenanceNotFound",
|
||||
"ProvenanceOperationGate",
|
||||
"ProvenanceReplay",
|
||||
"ProvenanceRevoked",
|
||||
"ProvenanceSignatureError",
|
||||
"ProvenanceStatus",
|
||||
"ProvenanceVerifier",
|
||||
"RequestContext",
|
||||
"RevisionConflict",
|
||||
"RunProvenance",
|
||||
"SQLiteProvenanceStore",
|
||||
"TaskRecord",
|
||||
"TaskState",
|
||||
"TenantIsolationError",
|
||||
"TenantRecord",
|
||||
"Unauthorized",
|
||||
"build_provenance_writer_from_env",
|
||||
"context_from_environment",
|
||||
"digest_payload",
|
||||
]
|
||||
@@ -1,807 +0,0 @@
|
||||
"""AIOS V2 production-candidate application entrypoint."""
|
||||
from __future__ import annotations
|
||||
|
||||
import dataclasses
|
||||
import json
|
||||
import os
|
||||
import stat
|
||||
import urllib.parse
|
||||
from enum import Enum
|
||||
from http import HTTPStatus
|
||||
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
|
||||
from pathlib import Path
|
||||
from typing import Any, Mapping
|
||||
|
||||
from aios_hermes import HermesAdapter, HermesJobState, HermesResult, SQLiteHermesStore
|
||||
from aios_openclaw import (
|
||||
Ed25519CommandSigner,
|
||||
HTTPRuntimeTransport,
|
||||
OpenClawAdapter,
|
||||
)
|
||||
from aios_openclaw.callback import AuditCallbackSink, EventPublisher
|
||||
|
||||
from .console import CONSOLE_HTML
|
||||
from .control_plane import AuditEvent, RequestContext, Unauthorized
|
||||
from .dispatch_store import SQLiteDispatchRepository
|
||||
from .execution_tracking import ExecutionEvidence, ExecutionTracker
|
||||
from .gateway import GatewayApplication, error_response
|
||||
from .gitops_status import collect_gitops_status
|
||||
from .orchestrator import ExecutionOrchestrator
|
||||
from .persistence import DurableControlPlaneService, SQLiteSnapshotRepository
|
||||
from .provenance_operations import build_provenance_writer_from_env
|
||||
|
||||
|
||||
def _json_value(value: Any) -> Any:
|
||||
if dataclasses.is_dataclass(value):
|
||||
return {
|
||||
item.name: _json_value(getattr(value, item.name))
|
||||
for item in dataclasses.fields(value)
|
||||
}
|
||||
if isinstance(value, Enum):
|
||||
return value.value
|
||||
if isinstance(value, Mapping):
|
||||
return {str(key): _json_value(item) for key, item in value.items()}
|
||||
if isinstance(value, (list, tuple, set, frozenset)):
|
||||
return [_json_value(item) for item in value]
|
||||
return value
|
||||
|
||||
|
||||
def _enabled(value: str | None) -> bool:
|
||||
return str(value or "").strip().lower() in {"1", "true", "yes", "on"}
|
||||
|
||||
|
||||
def _header(headers: Mapping[str, str], name: str) -> str | None:
|
||||
target = name.lower()
|
||||
for key, value in headers.items():
|
||||
if str(key).lower() == target:
|
||||
normalized = str(value or "").strip()
|
||||
return normalized or None
|
||||
return None
|
||||
|
||||
|
||||
def _provenance_context(
|
||||
headers: Mapping[str, str],
|
||||
payload: Mapping[str, Any],
|
||||
) -> tuple[str | None, str | None]:
|
||||
header_provenance = _header(headers, "X-AIOS-Provenance-ID")
|
||||
header_run = _header(headers, "X-AIOS-Run-ID")
|
||||
body_provenance = str(payload.get("provenance_id") or "").strip() or None
|
||||
body_run = str(payload.get("run_id") or "").strip() or None
|
||||
if header_provenance and body_provenance and header_provenance != body_provenance:
|
||||
raise ValueError("provenance_id header/body mismatch")
|
||||
if header_run and body_run and header_run != body_run:
|
||||
raise ValueError("run_id header/body mismatch")
|
||||
return header_provenance or body_provenance, header_run or body_run
|
||||
|
||||
|
||||
def _read_protected_file(path: Path, *, private: bool) -> bytes:
|
||||
flags = os.O_RDONLY
|
||||
if hasattr(os, "O_NOFOLLOW"):
|
||||
flags |= os.O_NOFOLLOW
|
||||
descriptor = os.open(str(path), flags)
|
||||
try:
|
||||
metadata = os.fstat(descriptor)
|
||||
if not stat.S_ISREG(metadata.st_mode):
|
||||
raise RuntimeError("key reference is not a regular file")
|
||||
denied = 0o077 if private else 0o022
|
||||
if metadata.st_mode & denied:
|
||||
raise RuntimeError(
|
||||
"private key file permissions must be 0600 or stricter"
|
||||
if private
|
||||
else "public key file must not be group/world writable"
|
||||
)
|
||||
chunks: list[bytes] = []
|
||||
while True:
|
||||
chunk = os.read(descriptor, 65536)
|
||||
if not chunk:
|
||||
break
|
||||
chunks.append(chunk)
|
||||
value = b"".join(chunks)
|
||||
if not value:
|
||||
raise RuntimeError("key file is empty")
|
||||
return value
|
||||
finally:
|
||||
os.close(descriptor)
|
||||
|
||||
|
||||
class FileCommandSignerResolver:
|
||||
"""Resolve tenant/key-id scoped OpenClaw Ed25519 signing material."""
|
||||
|
||||
def __init__(self, path: str | Path, *, configured_key_id: str) -> None:
|
||||
self.path = Path(path).resolve()
|
||||
self.configured_key_id = str(configured_key_id or "").strip()
|
||||
if not self.configured_key_id:
|
||||
raise ValueError("configured_key_id is required")
|
||||
|
||||
def __call__(self, tenant_id: str, key_id: str) -> Ed25519CommandSigner:
|
||||
if not str(tenant_id or "").strip():
|
||||
raise RuntimeError("tenant_id is required for command signing")
|
||||
if key_id != self.configured_key_id:
|
||||
raise RuntimeError("OpenClaw signing key_id mismatch")
|
||||
return Ed25519CommandSigner.from_bytes(
|
||||
_read_protected_file(self.path, private=True),
|
||||
key_id=key_id,
|
||||
)
|
||||
|
||||
|
||||
class ControlPlaneEventPublisher(EventPublisher):
|
||||
"""Append Runtime callback events to the tenant audit stream.
|
||||
|
||||
Callback audit remains informational. Authoritative task reconciliation is
|
||||
performed only by the orchestrator after dispatch/result validation.
|
||||
"""
|
||||
|
||||
def __init__(self, service: DurableControlPlaneService) -> None:
|
||||
self.service = service
|
||||
|
||||
def publish(self, event: Mapping[str, Any]) -> None:
|
||||
tenant_id = str(event.get("tenant_id") or "").strip()
|
||||
trace_id = str(event.get("trace_id") or "").strip()
|
||||
command_id = str(event.get("command_id") or "").strip()
|
||||
event_type = str(event.get("event_type") or "OPENCLAW_EVENT").strip()
|
||||
if not tenant_id or not trace_id or not command_id:
|
||||
raise ValueError("runtime audit event is missing tenant identity")
|
||||
state_value = str(event.get("state") or "unknown").lower()
|
||||
outcome = "allowed" if state_value == "completed" else state_value
|
||||
runtime = str(event.get("runtime") or "openclaw").strip().lower()
|
||||
principal_id = str(
|
||||
event.get("principal_id") or f"{runtime}-runtime"
|
||||
).strip()
|
||||
audit = AuditEvent(
|
||||
event_id=f"runtime_{command_id}_{len(self.service.store.audit_events) + 1}",
|
||||
tenant_id=tenant_id,
|
||||
principal_id=principal_id,
|
||||
trace_id=trace_id,
|
||||
action=event_type,
|
||||
resource_type=f"{runtime}_execution",
|
||||
resource_id=command_id,
|
||||
outcome=outcome,
|
||||
policy_version="runtime-v2",
|
||||
details=dict(event.get("details") or {}),
|
||||
)
|
||||
with self.service.store.lock:
|
||||
self.service.store.audit_events.append(audit)
|
||||
self.service.repository.save(self.service._snapshot())
|
||||
|
||||
|
||||
class CandidateApplication:
|
||||
def __init__(
|
||||
self,
|
||||
gateway: GatewayApplication,
|
||||
orchestrator: ExecutionOrchestrator,
|
||||
tracker: ExecutionTracker,
|
||||
hermes: HermesAdapter,
|
||||
openclaw: OpenClawAdapter | None,
|
||||
*,
|
||||
hermes_lifecycle_api_enabled: bool = False,
|
||||
) -> None:
|
||||
self.gateway = gateway
|
||||
self.orchestrator = orchestrator
|
||||
self.tracker = tracker
|
||||
self.hermes = hermes
|
||||
self.openclaw = openclaw
|
||||
self.hermes_lifecycle_api_enabled = bool(hermes_lifecycle_api_enabled)
|
||||
self.runtime_events = ControlPlaneEventPublisher(orchestrator.control_plane)
|
||||
|
||||
def context(self, headers: Mapping[str, str]) -> RequestContext:
|
||||
return self.gateway.context_from_headers(headers)
|
||||
|
||||
@staticmethod
|
||||
def _require_runtime_role(context: RequestContext) -> None:
|
||||
if not ({"runtime", "platform_admin"} & set(context.roles)):
|
||||
raise Unauthorized("runtime reconciliation role is required")
|
||||
|
||||
@staticmethod
|
||||
def _require_control_plane_cancel(context: RequestContext) -> None:
|
||||
required = {"runtime", "platform_admin"}
|
||||
if not required.issubset(set(context.roles)):
|
||||
raise Unauthorized(
|
||||
"Hermes cancellation requires trusted AIOS control-plane authority"
|
||||
)
|
||||
|
||||
@staticmethod
|
||||
def _required_identity(payload: Mapping[str, Any], name: str) -> str:
|
||||
value = str(payload.get(name) or "").strip()
|
||||
if not value:
|
||||
raise ValueError(f"{name} is required")
|
||||
return value
|
||||
|
||||
def _record_hermes_lifecycle(
|
||||
self,
|
||||
context: RequestContext,
|
||||
dispatch: Any,
|
||||
job: Any,
|
||||
*,
|
||||
action: str,
|
||||
worker_id: str | None,
|
||||
provenance_id: str,
|
||||
run_id: str,
|
||||
) -> None:
|
||||
executor = worker_id or "aios-control-plane"
|
||||
evidence = ExecutionEvidence(
|
||||
execution_id=job.job_id,
|
||||
tenant_id=job.tenant_id,
|
||||
task_id=job.task_id,
|
||||
agent_id=dispatch.agent_id,
|
||||
executor=executor,
|
||||
branch="runtime/hermes",
|
||||
status=job.state.value.lower(),
|
||||
progress_completed=0,
|
||||
progress_total=3,
|
||||
current_step=action,
|
||||
provenance_id=provenance_id,
|
||||
run_id=run_id,
|
||||
)
|
||||
current_evidence = self.tracker.claim(
|
||||
evidence,
|
||||
principal_id=context.principal_id,
|
||||
provenance_id=provenance_id,
|
||||
run_id=run_id,
|
||||
)
|
||||
if job.state in {
|
||||
HermesJobState.COMPLETED,
|
||||
HermesJobState.FAILED,
|
||||
HermesJobState.CANCELLED,
|
||||
}:
|
||||
if current_evidence.completed_at is None:
|
||||
self.tracker.complete(
|
||||
tenant_id=job.tenant_id,
|
||||
execution_id=job.job_id,
|
||||
status=job.state.value.lower(),
|
||||
test_status="runtime_terminal",
|
||||
test_summary={"lifecycle_action": action},
|
||||
result_summary={
|
||||
"state": job.state.value,
|
||||
"worker_id": worker_id,
|
||||
"dispatch_id": dispatch.dispatch_id,
|
||||
},
|
||||
principal_id=context.principal_id,
|
||||
provenance_id=provenance_id,
|
||||
run_id=run_id,
|
||||
)
|
||||
else:
|
||||
self.tracker.heartbeat(
|
||||
tenant_id=job.tenant_id,
|
||||
execution_id=job.job_id,
|
||||
status=job.state.value.lower(),
|
||||
current_step=action,
|
||||
progress_completed=(1 if job.state == HermesJobState.RUNNING else 0),
|
||||
progress_total=3,
|
||||
principal_id=context.principal_id,
|
||||
provenance_id=provenance_id,
|
||||
run_id=run_id,
|
||||
)
|
||||
self.runtime_events.publish(
|
||||
{
|
||||
"runtime": "hermes",
|
||||
"tenant_id": job.tenant_id,
|
||||
"principal_id": context.principal_id,
|
||||
"trace_id": job.trace_id,
|
||||
"command_id": job.job_id,
|
||||
"event_type": f"HERMES_{action.upper()}",
|
||||
"state": job.state.value,
|
||||
"details": {
|
||||
"dispatch_id": dispatch.dispatch_id,
|
||||
"task_id": job.task_id,
|
||||
"worker_id": worker_id,
|
||||
"cell_id": job.cell_id,
|
||||
"profile_id": job.profile_id,
|
||||
"revision": job.revision,
|
||||
"provenance_id": provenance_id,
|
||||
"run_id": run_id,
|
||||
},
|
||||
}
|
||||
)
|
||||
|
||||
def handle_json(
|
||||
self,
|
||||
method: str,
|
||||
raw_path: str,
|
||||
headers: Mapping[str, str],
|
||||
body: Any,
|
||||
) -> tuple[int, Mapping[str, Any]]:
|
||||
parsed = urllib.parse.urlparse(raw_path)
|
||||
path = parsed.path.rstrip("/") or "/"
|
||||
method = method.upper()
|
||||
|
||||
if method == "GET" and path == "/api/v2/gitops":
|
||||
context = self.context(headers)
|
||||
return HTTPStatus.OK, {
|
||||
"tenant_id": context.tenant_id,
|
||||
"gitops": collect_gitops_status().as_dict(),
|
||||
}
|
||||
|
||||
if method == "GET" and path == "/api/v2/runtime":
|
||||
context = self.context(headers)
|
||||
runtimes: list[dict[str, Any]] = []
|
||||
if self.openclaw is None:
|
||||
runtimes.append(
|
||||
{
|
||||
"name": "openclaw",
|
||||
"status": "disabled",
|
||||
"details": {"reason": "runtime_not_configured"},
|
||||
}
|
||||
)
|
||||
else:
|
||||
try:
|
||||
health = self.openclaw.health()
|
||||
runtimes.append(
|
||||
{
|
||||
"name": "openclaw",
|
||||
"status": health.status,
|
||||
"details": _json_value(health),
|
||||
}
|
||||
)
|
||||
except Exception as exc:
|
||||
runtimes.append(
|
||||
{
|
||||
"name": "openclaw",
|
||||
"status": "unavailable",
|
||||
"details": {"message": str(exc)},
|
||||
}
|
||||
)
|
||||
hermes_health = self.hermes.health()
|
||||
runtimes.append(
|
||||
{
|
||||
"name": "hermes",
|
||||
"status": hermes_health.status,
|
||||
"details": _json_value(hermes_health),
|
||||
}
|
||||
)
|
||||
return HTTPStatus.OK, {
|
||||
"tenant_id": context.tenant_id,
|
||||
"runtimes": runtimes,
|
||||
}
|
||||
|
||||
if method == "GET" and path == "/api/v2/executions":
|
||||
context = self.context(headers)
|
||||
return HTTPStatus.OK, {
|
||||
"executions": _json_value(
|
||||
self.tracker.list(tenant_id=context.tenant_id)
|
||||
)
|
||||
}
|
||||
|
||||
dispatch_match = __import__("re").fullmatch(
|
||||
r"/api/v2/tasks/([^/]+)/dispatch", path
|
||||
)
|
||||
if method == "POST" and dispatch_match:
|
||||
context = self.context(headers)
|
||||
task_id = urllib.parse.unquote(dispatch_match.group(1))
|
||||
payload = body if isinstance(body, Mapping) else {}
|
||||
timeout = payload.get("timeout_seconds")
|
||||
provenance_id, run_id = _provenance_context(headers, payload)
|
||||
record = self.orchestrator.dispatch(
|
||||
context,
|
||||
task_id=task_id,
|
||||
timeout_seconds=float(timeout) if timeout is not None else None,
|
||||
provenance_id=provenance_id,
|
||||
run_id=run_id,
|
||||
)
|
||||
return HTTPStatus.ACCEPTED, {"dispatch": _json_value(record)}
|
||||
|
||||
lifecycle_match = __import__("re").fullmatch(
|
||||
r"/api/v2/internal/runtime/hermes/lifecycle/"
|
||||
r"(claim|start|heartbeat|complete|fail|cancel|status)",
|
||||
path,
|
||||
)
|
||||
if method == "POST" and lifecycle_match:
|
||||
if not self.hermes_lifecycle_api_enabled:
|
||||
return HTTPStatus.NOT_FOUND, {
|
||||
"error": "not_found",
|
||||
"message": "route not found",
|
||||
}
|
||||
context = self.context(headers)
|
||||
self._require_runtime_role(context)
|
||||
if not isinstance(body, Mapping):
|
||||
raise ValueError("JSON body must be an object")
|
||||
payload = body
|
||||
action = lifecycle_match.group(1)
|
||||
identity = {
|
||||
name: self._required_identity(payload, name)
|
||||
for name in (
|
||||
"dispatch_id",
|
||||
"job_id",
|
||||
"tenant_id",
|
||||
"task_id",
|
||||
"trace_id",
|
||||
"principal_id",
|
||||
"provenance_id",
|
||||
"run_id",
|
||||
"cell_id",
|
||||
"profile_id",
|
||||
)
|
||||
}
|
||||
header_provenance, header_run = _provenance_context(headers, payload)
|
||||
if header_provenance != identity["provenance_id"]:
|
||||
raise ValueError("provenance_id context mismatch")
|
||||
if header_run != identity["run_id"]:
|
||||
raise ValueError("run_id context mismatch")
|
||||
requeued_job_ids = self.hermes.requeue_expired()
|
||||
dispatch, job = self.orchestrator.hermes_lifecycle_context(
|
||||
context,
|
||||
dispatch_id=identity["dispatch_id"],
|
||||
job_id=identity["job_id"],
|
||||
tenant_id=identity["tenant_id"],
|
||||
task_id=identity["task_id"],
|
||||
trace_id=identity["trace_id"],
|
||||
principal_id=identity["principal_id"],
|
||||
provenance_id=identity["provenance_id"],
|
||||
run_id=identity["run_id"],
|
||||
)
|
||||
if job.cell_id != identity["cell_id"]:
|
||||
raise ValueError("cell_id mismatch")
|
||||
if job.profile_id != identity["profile_id"]:
|
||||
raise ValueError("profile_id mismatch")
|
||||
|
||||
if action == "status":
|
||||
if job.job_id in requeued_job_ids:
|
||||
self._record_hermes_lifecycle(
|
||||
context,
|
||||
dispatch,
|
||||
job,
|
||||
action="lease_expired_requeue",
|
||||
worker_id=None,
|
||||
provenance_id=identity["provenance_id"],
|
||||
run_id=identity["run_id"],
|
||||
)
|
||||
task = self.orchestrator.control_plane.get_task(
|
||||
context, dispatch.task_id
|
||||
)
|
||||
response: dict[str, Any] = {
|
||||
"job": _json_value(job),
|
||||
"dispatch": _json_value(dispatch),
|
||||
"task": _json_value(task),
|
||||
}
|
||||
if job.state in {
|
||||
HermesJobState.COMPLETED,
|
||||
HermesJobState.FAILED,
|
||||
HermesJobState.CANCELLED,
|
||||
}:
|
||||
response["result"] = _json_value(
|
||||
self.hermes.result(job.job_id, tenant_id=job.tenant_id)
|
||||
)
|
||||
return HTTPStatus.OK, response
|
||||
|
||||
expected_revision = payload.get("expected_revision")
|
||||
expected = (
|
||||
int(expected_revision) if expected_revision is not None else None
|
||||
)
|
||||
if action == "cancel":
|
||||
self._require_control_plane_cancel(context)
|
||||
if payload.get("worker_id") is not None:
|
||||
raise Unauthorized("Hermes workers may observe but not initiate cancel")
|
||||
if payload.get("cancellation_source") != "aios-control-plane":
|
||||
raise ValueError(
|
||||
"cancellation_source must be aios-control-plane"
|
||||
)
|
||||
result = self.hermes.cancel(
|
||||
job.job_id,
|
||||
tenant_id=job.tenant_id,
|
||||
expected_revision=expected,
|
||||
)
|
||||
else:
|
||||
worker_id = self._required_identity(payload, "worker_id")
|
||||
if action == "claim":
|
||||
claimed = self.hermes.claim(
|
||||
tenant_id=job.tenant_id,
|
||||
cell_id=job.cell_id,
|
||||
profile_id=job.profile_id,
|
||||
worker_id=worker_id,
|
||||
lease_seconds=(
|
||||
int(payload["lease_seconds"])
|
||||
if payload.get("lease_seconds") is not None
|
||||
else None
|
||||
),
|
||||
job_id=job.job_id,
|
||||
)
|
||||
if claimed is None:
|
||||
raise ValueError("Hermes job is not claimable")
|
||||
bound = self.orchestrator.bind_hermes_worker(
|
||||
context,
|
||||
claimed,
|
||||
dispatch_id=dispatch.dispatch_id,
|
||||
provenance_id=identity["provenance_id"],
|
||||
run_id=identity["run_id"],
|
||||
worker_id=worker_id,
|
||||
)
|
||||
self._record_hermes_lifecycle(
|
||||
context,
|
||||
bound,
|
||||
claimed,
|
||||
action="claim",
|
||||
worker_id=worker_id,
|
||||
provenance_id=identity["provenance_id"],
|
||||
run_id=identity["run_id"],
|
||||
)
|
||||
return HTTPStatus.OK, {
|
||||
"job": _json_value(claimed),
|
||||
"dispatch": _json_value(bound),
|
||||
}
|
||||
if action == "start":
|
||||
started = self.hermes.start(
|
||||
job.job_id,
|
||||
tenant_id=job.tenant_id,
|
||||
worker_id=worker_id,
|
||||
expected_revision=expected,
|
||||
)
|
||||
self._record_hermes_lifecycle(
|
||||
context,
|
||||
dispatch,
|
||||
started,
|
||||
action="start",
|
||||
worker_id=worker_id,
|
||||
provenance_id=identity["provenance_id"],
|
||||
run_id=identity["run_id"],
|
||||
)
|
||||
return HTTPStatus.OK, {"job": _json_value(started)}
|
||||
if action == "heartbeat":
|
||||
heartbeat = self.hermes.heartbeat(
|
||||
job.job_id,
|
||||
tenant_id=job.tenant_id,
|
||||
worker_id=worker_id,
|
||||
lease_seconds=(
|
||||
int(payload["lease_seconds"])
|
||||
if payload.get("lease_seconds") is not None
|
||||
else None
|
||||
),
|
||||
)
|
||||
self._record_hermes_lifecycle(
|
||||
context,
|
||||
dispatch,
|
||||
heartbeat,
|
||||
action="heartbeat",
|
||||
worker_id=worker_id,
|
||||
provenance_id=identity["provenance_id"],
|
||||
run_id=identity["run_id"],
|
||||
)
|
||||
return HTTPStatus.OK, {"job": _json_value(heartbeat)}
|
||||
if action == "complete":
|
||||
output = payload.get("output")
|
||||
if not isinstance(output, Mapping):
|
||||
raise ValueError("output must be an object")
|
||||
result = self.hermes.complete(
|
||||
job.job_id,
|
||||
tenant_id=job.tenant_id,
|
||||
worker_id=worker_id,
|
||||
output=output,
|
||||
expected_revision=expected,
|
||||
)
|
||||
elif action == "fail":
|
||||
error = payload.get("error")
|
||||
if not isinstance(error, Mapping):
|
||||
raise ValueError("error must be an object")
|
||||
result = self.hermes.fail(
|
||||
job.job_id,
|
||||
tenant_id=job.tenant_id,
|
||||
worker_id=worker_id,
|
||||
error=error,
|
||||
expected_revision=expected,
|
||||
)
|
||||
else:
|
||||
raise ValueError("unsupported Hermes lifecycle action")
|
||||
|
||||
task = self.orchestrator.reconcile_hermes(
|
||||
context,
|
||||
result,
|
||||
dispatch_id=dispatch.dispatch_id,
|
||||
provenance_id=identity["provenance_id"],
|
||||
run_id=identity["run_id"],
|
||||
)
|
||||
updated_dispatch = self.orchestrator.dispatch_repository.get(
|
||||
dispatch.dispatch_id, tenant_id=dispatch.tenant_id
|
||||
)
|
||||
terminal_job = self.hermes.get(job.job_id, tenant_id=job.tenant_id)
|
||||
self._record_hermes_lifecycle(
|
||||
context,
|
||||
updated_dispatch,
|
||||
terminal_job,
|
||||
action=action,
|
||||
worker_id=result.worker_id,
|
||||
provenance_id=identity["provenance_id"],
|
||||
run_id=identity["run_id"],
|
||||
)
|
||||
return HTTPStatus.OK, {
|
||||
"result": _json_value(result),
|
||||
"task": _json_value(task),
|
||||
"dispatch": _json_value(updated_dispatch),
|
||||
}
|
||||
|
||||
if method == "POST" and path == "/api/v2/internal/runtime/hermes/reconcile":
|
||||
context = self.context(headers)
|
||||
self._require_runtime_role(context)
|
||||
if not isinstance(body, Mapping):
|
||||
raise ValueError("JSON body must be an object")
|
||||
provenance_id, run_id = _provenance_context(headers, body)
|
||||
if not provenance_id or not run_id:
|
||||
raise ValueError("provenance_id and run_id are required")
|
||||
dispatch_id = str(body.get("dispatch_id") or "").strip()
|
||||
if not dispatch_id:
|
||||
raise ValueError("dispatch_id is required")
|
||||
result = HermesResult(
|
||||
job_id=str(body["job_id"]),
|
||||
tenant_id=str(body["tenant_id"]),
|
||||
task_id=str(body["task_id"]),
|
||||
trace_id=str(body["trace_id"]),
|
||||
state=HermesJobState(str(body["state"])),
|
||||
worker_id=(
|
||||
str(body["worker_id"])
|
||||
if body.get("worker_id") is not None
|
||||
else None
|
||||
),
|
||||
output=body.get("output"),
|
||||
error=body.get("error"),
|
||||
started_at=body.get("started_at"),
|
||||
finished_at=body.get("finished_at"),
|
||||
)
|
||||
task = self.orchestrator.reconcile_hermes(
|
||||
context,
|
||||
result,
|
||||
dispatch_id=dispatch_id,
|
||||
provenance_id=provenance_id,
|
||||
run_id=run_id,
|
||||
)
|
||||
return HTTPStatus.OK, {"task": _json_value(task)}
|
||||
|
||||
if method == "POST" and path == "/api/v2/hermes/results/reconcile":
|
||||
return HTTPStatus.GONE, {
|
||||
"error": "RuntimeReconcileEndpointMoved",
|
||||
"message": "use /api/v2/internal/runtime/hermes/reconcile",
|
||||
}
|
||||
|
||||
return self.gateway.handle(method, raw_path, headers, body)
|
||||
|
||||
|
||||
class CandidateRequestHandler(BaseHTTPRequestHandler):
|
||||
server_version = "AIOSV2Candidate/2.0"
|
||||
max_body_bytes = 1_048_576
|
||||
|
||||
@property
|
||||
def application(self) -> CandidateApplication:
|
||||
return self.server.application # type: ignore[attr-defined]
|
||||
|
||||
def _read_body(self) -> Any:
|
||||
length = int(self.headers.get("Content-Length", "0") or "0")
|
||||
if length < 0 or length > self.max_body_bytes:
|
||||
raise ValueError("request body is too large")
|
||||
if length == 0:
|
||||
return {}
|
||||
content_type = self.headers.get("Content-Type", "").split(";", 1)[0].strip()
|
||||
if content_type != "application/json":
|
||||
raise ValueError("Content-Type must be application/json")
|
||||
return json.loads(self.rfile.read(length).decode("utf-8"))
|
||||
|
||||
def _security_headers(self) -> None:
|
||||
self.send_header("Cache-Control", "no-store")
|
||||
self.send_header("X-Content-Type-Options", "nosniff")
|
||||
self.send_header("X-Frame-Options", "DENY")
|
||||
self.send_header("Referrer-Policy", "no-referrer")
|
||||
self.send_header(
|
||||
"Content-Security-Policy",
|
||||
"default-src 'self'; style-src 'unsafe-inline'; script-src 'unsafe-inline'; connect-src 'self'",
|
||||
)
|
||||
|
||||
def _send_json(self, status_code: int, payload: Mapping[str, Any]) -> None:
|
||||
encoded = json.dumps(
|
||||
_json_value(payload), ensure_ascii=False, separators=(",", ":")
|
||||
).encode("utf-8")
|
||||
self.send_response(int(status_code))
|
||||
self.send_header("Content-Type", "application/json; charset=utf-8")
|
||||
self.send_header("Content-Length", str(len(encoded)))
|
||||
self._security_headers()
|
||||
self.end_headers()
|
||||
self.wfile.write(encoded)
|
||||
|
||||
def _send_console(self) -> None:
|
||||
encoded = CONSOLE_HTML.encode("utf-8")
|
||||
self.send_response(HTTPStatus.OK)
|
||||
self.send_header("Content-Type", "text/html; charset=utf-8")
|
||||
self.send_header("Content-Length", str(len(encoded)))
|
||||
self._security_headers()
|
||||
self.end_headers()
|
||||
self.wfile.write(encoded)
|
||||
|
||||
def _dispatch(self, method: str) -> None:
|
||||
path = urllib.parse.urlparse(self.path).path.rstrip("/") or "/"
|
||||
if method == "GET" and path in {"/", "/console"}:
|
||||
self._send_console()
|
||||
return
|
||||
try:
|
||||
body = self._read_body() if method == "POST" else {}
|
||||
status_code, payload = self.application.handle_json(
|
||||
method,
|
||||
self.path,
|
||||
{key: value for key, value in self.headers.items()},
|
||||
body,
|
||||
)
|
||||
except Exception as exc:
|
||||
status_code, payload = error_response(exc)
|
||||
self._send_json(status_code, payload)
|
||||
|
||||
def do_GET(self) -> None: # noqa: N802
|
||||
self._dispatch("GET")
|
||||
|
||||
def do_POST(self) -> None: # noqa: N802
|
||||
self._dispatch("POST")
|
||||
|
||||
|
||||
class CandidateHTTPServer(ThreadingHTTPServer):
|
||||
daemon_threads = True
|
||||
allow_reuse_address = True
|
||||
|
||||
def __init__(self, address: tuple[str, int], application: CandidateApplication) -> None:
|
||||
self.application = application
|
||||
super().__init__(address, CandidateRequestHandler)
|
||||
|
||||
|
||||
def build_application() -> CandidateApplication:
|
||||
state_dir = Path(os.getenv("AIOS_V2_STATE_DIR", "/var/lib/aios-v2")).resolve()
|
||||
state_dir.mkdir(parents=True, exist_ok=True)
|
||||
repository = SQLiteSnapshotRepository(state_dir / "control-plane.sqlite3")
|
||||
dispatch_repository = SQLiteDispatchRepository(state_dir / "dispatches.sqlite3")
|
||||
service = DurableControlPlaneService(repository)
|
||||
require_provenance = _enabled(os.getenv("AIOS_REQUIRE_RUN_PROVENANCE", "0"))
|
||||
provenance_writer = build_provenance_writer_from_env(
|
||||
state_dir=state_dir, required=require_provenance
|
||||
)
|
||||
tracker = ExecutionTracker(
|
||||
state_dir / "executions",
|
||||
provenance_writer=provenance_writer,
|
||||
require_provenance=require_provenance,
|
||||
)
|
||||
hermes = HermesAdapter(store=SQLiteHermesStore(state_dir / "hermes.sqlite3"))
|
||||
|
||||
openclaw_url = os.getenv("AIOS_OPENCLAW_URL", "").strip()
|
||||
signing_file = os.getenv("AIOS_OPENCLAW_SIGNING_MATERIAL_FILE", "").strip()
|
||||
signing_key_id = os.getenv(
|
||||
"AIOS_OPENCLAW_SIGNING_KEY_ID", "openclaw-v2r1-candidate-ed25519"
|
||||
).strip()
|
||||
openclaw = None
|
||||
resolver = None
|
||||
if openclaw_url and signing_file:
|
||||
resolver = FileCommandSignerResolver(
|
||||
signing_file,
|
||||
configured_key_id=signing_key_id,
|
||||
)
|
||||
transport = HTTPRuntimeTransport(
|
||||
openclaw_url,
|
||||
credential_ref=os.getenv("AIOS_OPENCLAW_CREDENTIAL_REF") or None,
|
||||
)
|
||||
openclaw = OpenClawAdapter(
|
||||
transport,
|
||||
resolver,
|
||||
callback_sink=AuditCallbackSink(ControlPlaneEventPublisher(service)),
|
||||
)
|
||||
|
||||
gateway = GatewayApplication(service)
|
||||
orchestrator = ExecutionOrchestrator(
|
||||
service,
|
||||
openclaw=openclaw,
|
||||
hermes=hermes,
|
||||
openclaw_signing_material_resolver=resolver,
|
||||
openclaw_key_id=signing_key_id,
|
||||
provenance_writer=provenance_writer,
|
||||
require_provenance=require_provenance,
|
||||
dispatch_repository=dispatch_repository,
|
||||
)
|
||||
return CandidateApplication(
|
||||
gateway,
|
||||
orchestrator,
|
||||
tracker,
|
||||
hermes,
|
||||
openclaw,
|
||||
hermes_lifecycle_api_enabled=_enabled(
|
||||
os.getenv("AIOS_HERMES_LIFECYCLE_API_ENABLED", "0")
|
||||
),
|
||||
)
|
||||
|
||||
|
||||
def main() -> None:
|
||||
host = os.getenv("AIOS_V2_HOST", "127.0.0.1")
|
||||
port = int(os.getenv("AIOS_V2_PORT", "18920"))
|
||||
server = CandidateHTTPServer((host, port), build_application())
|
||||
print(f"AIOS V2 candidate listening on {host}:{port}")
|
||||
server.serve_forever()
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@@ -1,83 +0,0 @@
|
||||
"""Dependency-free, role-aware AIOS unified portal.
|
||||
|
||||
The browser receives only server-authorized capabilities and tenant-scoped data.
|
||||
It never selects a tenant, signs Provenance, mutates Git tags, or calls Runtime
|
||||
services directly.
|
||||
"""
|
||||
|
||||
CONSOLE_HTML = r'''<!doctype html>
|
||||
<html lang="zh-CN">
|
||||
<head>
|
||||
<meta charset="utf-8">
|
||||
<meta name="viewport" content="width=device-width,initial-scale=1">
|
||||
<meta name="referrer" content="no-referrer">
|
||||
<title>AIOS Unified Portal</title>
|
||||
<style>
|
||||
:root{font-family:Inter,"PingFang SC","Microsoft YaHei",ui-sans-serif,system-ui,sans-serif;color:#172033;background:#eef2f7;--nav:#0f172a;--card:#fff;--line:#dfe6ef;--muted:#667085;--blue:#2563eb;--green:#047857;--red:#b42318;--amber:#b54708}
|
||||
*{box-sizing:border-box}body{margin:0;min-height:100vh}button,input,textarea,select{font:inherit}
|
||||
.shell{display:grid;grid-template-columns:250px minmax(0,1fr);min-height:100vh}.sidebar{background:var(--nav);color:#e2e8f0;padding:22px 16px;position:sticky;top:0;height:100vh;overflow:auto}.brand{font-weight:800;font-size:20px;letter-spacing:.2px}.version{font-size:12px;color:#94a3b8;margin:5px 0 22px}.identity{padding:12px;background:#182338;border:1px solid #2b3950;border-radius:12px;margin-bottom:18px}.identity strong{display:block;color:#fff}.identity span{font-size:12px;color:#aebbd0;display:block;margin-top:3px;overflow-wrap:anywhere}.nav button{width:100%;display:flex;gap:10px;align-items:center;border:0;background:transparent;color:#cbd5e1;padding:11px 12px;border-radius:9px;text-align:left;cursor:pointer;margin:2px 0}.nav button:hover,.nav button.active{background:#24324b;color:#fff}.nav .dot{width:8px;height:8px;border-radius:50%;background:#60a5fa}.main{min-width:0}.topbar{height:70px;background:#fff;border-bottom:1px solid var(--line);display:flex;align-items:center;justify-content:space-between;padding:0 26px;position:sticky;top:0;z-index:4}.topbar h1{font-size:19px;margin:0}.top-actions{display:flex;align-items:center;gap:10px}.timestamp{font-size:12px;color:var(--muted)}.content{padding:24px;max-width:1680px;margin:auto}.notice{background:#eff6ff;border:1px solid #bfdbfe;border-radius:12px;padding:12px 14px;color:#1e3a8a;font-size:13px;margin-bottom:18px}.error{background:#fef3f2;border:1px solid #fecdca;color:var(--red);border-radius:10px;padding:10px 12px;white-space:pre-wrap;margin-bottom:14px;display:none}.cards{display:grid;grid-template-columns:repeat(auto-fit,minmax(170px,1fr));gap:14px;margin-bottom:18px}.card,.panel{background:var(--card);border:1px solid var(--line);border-radius:14px;box-shadow:0 1px 3px rgba(16,24,40,.05)}.card{padding:16px}.card small{color:var(--muted);font-weight:600}.card b{display:block;font-size:28px;margin-top:7px}.panel{padding:17px;margin-bottom:16px;overflow:auto}.panel h2{font-size:16px;margin:0}.panel-head{display:flex;align-items:center;justify-content:space-between;gap:12px;margin-bottom:13px}.grid{display:grid;grid-template-columns:repeat(auto-fit,minmax(410px,1fr));gap:16px}.wide{grid-column:1/-1}.muted{color:var(--muted)}.good{color:var(--green);font-weight:700}.bad{color:var(--red);font-weight:700}.warn{color:var(--amber);font-weight:700}.pill{display:inline-block;border:1px solid #cbd5e1;border-radius:999px;padding:3px 8px;font-size:11px;margin:2px;background:#f8fafc}.pill.good{background:#ecfdf3;border-color:#a6f4c5}.pill.bad{background:#fef3f2;border-color:#fecdca}.toolbar{display:flex;gap:8px;align-items:center;flex-wrap:wrap}.btn{border:0;border-radius:9px;padding:9px 12px;background:var(--blue);color:#fff;cursor:pointer;font-weight:650}.btn.secondary{background:#fff;color:#344054;border:1px solid #d0d5dd}.btn.danger{background:#d92d20}.btn:disabled{opacity:.45;cursor:not-allowed}.icon-btn{padding:7px 10px}.view{display:none}.view.active{display:block}table{width:100%;border-collapse:collapse;font-size:12px}th,td{text-align:left;padding:9px 8px;border-bottom:1px solid #edf0f4;vertical-align:top}th{color:#667085;font-weight:700;white-space:nowrap}td{overflow-wrap:anywhere}.empty{padding:24px;text-align:center;color:var(--muted)}.timeline{border-left:2px solid #dbe4f0;margin-left:8px;padding-left:20px}.event{position:relative;padding:0 0 17px}.event:before{content:"";position:absolute;left:-27px;top:4px;width:11px;height:11px;border-radius:50%;background:#3b82f6;border:3px solid #fff;box-shadow:0 0 0 1px #93c5fd}.event strong{font-size:13px}.event p{margin:4px 0;color:var(--muted);font-size:12px}.chain{display:flex;align-items:stretch;gap:7px;overflow:auto;padding:5px 0}.chain-item{min-width:135px;border:1px solid var(--line);border-radius:10px;padding:10px;background:#f8fafc}.chain-arrow{display:flex;align-items:center;color:#94a3b8}.form-grid{display:grid;grid-template-columns:repeat(auto-fit,minmax(230px,1fr));gap:12px}.field label{font-size:12px;color:#475467;font-weight:650;display:block;margin-bottom:5px}.field input,.field textarea,.field select{width:100%;border:1px solid #d0d5dd;border-radius:9px;padding:9px;background:#fff}.field textarea{min-height:90px;resize:vertical}.dialog{border:0;border-radius:14px;padding:0;max-width:650px;width:calc(100% - 32px);box-shadow:0 20px 60px rgba(15,23,42,.28)}.dialog::backdrop{background:rgba(15,23,42,.6)}.dialog-head{padding:16px 18px;border-bottom:1px solid var(--line);font-weight:750}.dialog-body{padding:18px}.dialog-actions{padding:14px 18px;border-top:1px solid var(--line);display:flex;justify-content:flex-end;gap:8px}.kv{display:grid;grid-template-columns:150px minmax(0,1fr);gap:6px 12px;font-size:12px}.kv div:nth-child(odd){color:var(--muted)}pre{white-space:pre-wrap;word-break:break-word;font-size:11px;background:#0f172a;color:#dbeafe;border-radius:10px;padding:12px;max-height:300px;overflow:auto}
|
||||
@media(max-width:900px){.shell{grid-template-columns:1fr}.sidebar{height:auto;position:static}.nav{display:flex;overflow:auto}.nav button{min-width:max-content}.topbar{position:static}.grid{grid-template-columns:1fr}.content{padding:16px}}
|
||||
</style>
|
||||
</head>
|
||||
<body>
|
||||
<div class="shell">
|
||||
<aside class="sidebar">
|
||||
<div class="brand">AIOS Unified Portal</div><div class="version">V2R1C1 · Role-aware Control Plane</div>
|
||||
<div class="identity"><strong id="principal">加载身份…</strong><span id="tenant"></span><span id="roles"></span></div>
|
||||
<nav id="navigation" class="nav"></nav>
|
||||
</aside>
|
||||
<section class="main">
|
||||
<header class="topbar"><h1 id="pageTitle">系统总览</h1><div class="top-actions"><span id="updated" class="timestamp">尚未加载</span><button class="btn secondary icon-btn" id="refresh">刷新</button></div></header>
|
||||
<main class="content">
|
||||
<div class="notice">身份、租户和角色由可信反向代理注入。门户只调用 AIOS Control Plane；Provenance 签发、Tag、生产部署与 Runtime 权威状态仍由受控流程执行。</div>
|
||||
<div id="error" class="error"></div>
|
||||
<section id="overview" class="view active"></section>
|
||||
<section id="tasks" class="view"></section>
|
||||
<section id="authorization" class="view"></section>
|
||||
<section id="runtime" class="view"></section>
|
||||
<section id="evidence" class="view"></section>
|
||||
<section id="audit" class="view"></section>
|
||||
<section id="release" class="view"></section>
|
||||
</main>
|
||||
</section>
|
||||
</div>
|
||||
<dialog id="taskDialog" class="dialog">
|
||||
<div class="dialog-head">创建任务</div><form id="taskForm"><div class="dialog-body form-grid">
|
||||
<div class="field"><label>Agent ID</label><input name="agent_id" required></div>
|
||||
<div class="field"><label>Action</label><input name="action" required></div>
|
||||
<div class="field"><label>Idempotency Key</label><input name="idempotency_key" required></div>
|
||||
<div class="field wide"><label>Payload JSON</label><textarea name="payload">{}</textarea></div>
|
||||
</div><div class="dialog-actions"><button type="button" class="btn secondary" data-close="taskDialog">取消</button><button class="btn">创建</button></div></form>
|
||||
</dialog>
|
||||
<dialog id="confirmDialog" class="dialog"><div class="dialog-head" id="confirmTitle">确认操作</div><form id="confirmForm"><div class="dialog-body"><p id="confirmText"></p><div class="field"><label>原因</label><textarea id="confirmReason" required></textarea></div></div><div class="dialog-actions"><button type="button" class="btn secondary" data-close="confirmDialog">取消</button><button class="btn danger">确认</button></div></form></dialog>
|
||||
<script>
|
||||
const $=s=>document.querySelector(s), esc=v=>String(v??'').replace(/[&<>"']/g,c=>({'&':'&','<':'<','>':'>','"':'"',"'":'''}[c]));
|
||||
const state={identity:null,current:'overview',cache:{},confirm:null};
|
||||
const labels={overview:'系统总览',tasks:'任务中心',authorization:'授权中心',runtime:'运行与运维',evidence:'执行证据',audit:'审计中心',release:'GitOps 与发布'};
|
||||
function has(c){return !!state.identity?.capabilities?.includes(c)}
|
||||
async function api(path,options={}){const r=await fetch(path,{credentials:'same-origin',headers:{'Accept':'application/json','Content-Type':'application/json',...(options.headers||{})},...options});const d=await r.json().catch(()=>({}));if(!r.ok)throw new Error(`${r.status} ${d.message||d.error||path}`);return d}
|
||||
function err(e){const el=$('#error');el.textContent=e?.message||String(e);el.style.display='block'}function clearErr(){$('#error').style.display='none';$('#error').textContent=''}
|
||||
function pill(v){const s=String(v??'unknown'),c=/complete|pass|healthy|active|synced|approved|used/i.test(s)?'good':/fail|deny|reject|revoke|expire|cancel|unavailable/i.test(s)?'bad':'';return `<span class="pill ${c}">${esc(s)}</span>`}
|
||||
function table(cols,rows){if(!rows?.length)return '<div class="empty">暂无数据</div>';return `<table><thead><tr>${cols.map(x=>`<th>${esc(x[0])}</th>`).join('')}</tr></thead><tbody>${rows.map(r=>`<tr>${cols.map(x=>`<td>${x[1](r)}</td>`).join('')}</tr>`).join('')}</tbody></table>`}
|
||||
function card(label,value,detail=''){return `<div class="card"><small>${esc(label)}</small><b>${esc(value)}</b>${detail?`<span class="muted">${esc(detail)}</span>`:''}</div>`}
|
||||
function json(v){return `<pre>${esc(JSON.stringify(v,null,2))}</pre>`}
|
||||
function show(view){state.current=view;document.querySelectorAll('.view').forEach(x=>x.classList.toggle('active',x.id===view));document.querySelectorAll('.nav button').forEach(x=>x.classList.toggle('active',x.dataset.view===view));$('#pageTitle').textContent=labels[view]||view;load(view)}
|
||||
function navigation(){const nav=$('#navigation');nav.innerHTML=(state.identity.navigation||[]).map(x=>`<button data-view="${esc(x.id)}"><span class="dot"></span>${esc(x.label)}</button>`).join('');nav.querySelectorAll('button').forEach(b=>b.onclick=()=>show(b.dataset.view));}
|
||||
async function identity(){state.identity=await api('/api/v2/me/capabilities');$('#principal').textContent=state.identity.principal_id;$('#tenant').textContent=`租户：${state.identity.tenant_id}`;$('#roles').textContent=`角色：${state.identity.roles.join(', ')||'无'}`;navigation();if(!state.identity.navigation.some(x=>x.id===state.current))state.current=state.identity.navigation[0]?.id||'overview';show(state.current)}
|
||||
async function load(view){clearErr();try{if(view==='overview')await overview();if(view==='tasks')await tasks();if(view==='authorization')await authorizations();if(view==='runtime')await runtime();if(view==='evidence')await evidence();if(view==='audit')await audit();if(view==='release')await release();$('#updated').textContent=`更新于 ${new Date().toLocaleString()}`}catch(e){err(e)}}
|
||||
async function overview(){const d=await api('/api/v2/portal/overview');state.cache.overview=d;const s=d.summary||{},rt=d.sections?.runtime?.runtimes||[],rel=d.sections?.release||{};$('#overview').innerHTML=`<div class="cards">${card('任务',s.tasks||0)}${card('活动 Dispatch',s.active_dispatches||0,`总数 ${s.dispatches||0}`)}${card('执行证据',s.evidence||0)}${card('审计事件',s.audit_events||0)}${card('当前版本',rel.version||'—',rel.status||'')}${card('授权 Grant',d.sections?.authorization?.active_grants||0,`总数 ${d.sections?.authorization?.grants||0}`)}</div><div class="grid"><div class="panel"><div class="panel-head"><h2>Runtime 健康</h2></div>${table([['Runtime',x=>esc(x.name)],['状态',x=>pill(x.status)],['版本/详情',x=>esc(x.details?.version||x.details?.runtime_id||'—')]],rt)}</div><div class="panel"><div class="panel-head"><h2>任务状态</h2></div>${table([['状态',x=>pill(x[0])],['数量',x=>esc(x[1])]],Object.entries(s.task_states||{}))}</div><div class="panel wide"><div class="panel-head"><h2>最近任务</h2></div>${table([['任务',x=>esc(x.task_id)],['Agent',x=>esc(x.agent_id)],['动作',x=>esc(x.action)],['状态',x=>pill(x.state)],['更新时间',x=>esc(x.updated_at)]],d.recent?.tasks||[])}</div></div>`}
|
||||
async function tasks(){const d=await api('/api/v2/portal/tasks');state.cache.tasks=d.items||[];const create=has('task.create')?'<button class="btn" id="newTask">创建任务</button>':'';$('#tasks').innerHTML=`<div class="panel"><div class="panel-head"><h2>任务全链路</h2><div class="toolbar">${create}</div></div>${(d.items||[]).map(taskBlock).join('')||'<div class="empty">暂无任务</div>'}</div>`;$('#newTask')?.addEventListener('click',()=>$('#taskDialog').showModal());document.querySelectorAll('[data-task-action]').forEach(b=>b.onclick=()=>taskAction(b.dataset.taskId,b.dataset.taskAction,b.dataset.revision))}
|
||||
function taskBlock(x){const t=x.task||{},d=x.dispatch,e=x.evidence||[],a=x.audit||[],actions=(x.available_actions||[]).map(v=>`<button class="btn ${v==='cancel'?'danger':'secondary'}" data-task-action="${v}" data-task-id="${esc(t.task_id)}" data-revision="${esc(t.revision)}">${{approve:'审批',cancel:'取消',dispatch:'调度'}[v]||v}</button>`).join('');return `<div class="panel" style="background:#fbfcfe"><div class="panel-head"><h2>${esc(t.task_id)} · ${esc(t.action)}</h2><div class="toolbar">${pill(t.state)}${actions}</div></div><div class="chain"><div class="chain-item"><b>Task</b><div>${esc(t.agent_id)}</div><small>${esc(t.created_by)}</small></div><span class="chain-arrow">→</span><div class="chain-item"><b>Approval</b><div>${esc(t.approved_by||'待审批')}</div><small>revision ${esc(t.revision)}</small></div><span class="chain-arrow">→</span><div class="chain-item"><b>Provenance</b><div>${esc(d?.provenance_id||'未调度')}</div><small>${esc(d?.authorization_id||'')}</small></div><span class="chain-arrow">→</span><div class="chain-item"><b>Dispatch</b><div>${esc(d?.dispatch_id||'—')}</div><small>${pill(d?.state||'not_created')}</small></div><span class="chain-arrow">→</span><div class="chain-item"><b>Runtime</b><div>${esc(d?.runtime||'—')}</div><small>${esc(d?.runtime_execution_id||'')}</small></div><span class="chain-arrow">→</span><div class="chain-item"><b>Evidence</b><div>${e.length} 条</div><small>Audit ${a.length} 条</small></div></div></div>`}
|
||||
async function taskAction(id,action,revision){clearErr();try{let body={expected_revision:Number(revision)};if(action==='dispatch'){body={};const p=prompt('Provenance ID（生产调度必填）','');const r=prompt('Run ID（生产调度必填）','');if(p)body.provenance_id=p;if(r)body.run_id=r}await api(`/api/v2/portal/tasks/${encodeURIComponent(id)}/${action}`,{method:'POST',body:JSON.stringify(body)});await tasks()}catch(e){err(e)}}
|
||||
async function authorizations(){const d=await api('/api/v2/portal/authorizations');state.cache.authorization=d;const workflows=(d.workflows||[]),grants=(d.grants||[]);$('#authorization').innerHTML=`<div class="cards">${card('Workflow',d.summary?.workflows||0)}${card('Grant',d.summary?.grants||0)}${card('有效 Grant',d.summary?.active_grants||0)}${card('已撤销',d.summary?.revoked_grants||0)}</div><div class="panel"><div class="panel-head"><h2>Workflow Provenance</h2></div>${table([['ID',x=>esc(x.provenance_id)],['Run / Task',x=>`${esc(x.run_id)}<br>${esc(x.task_id)}`],['Principal / Agent',x=>`${esc(x.principal_id)}<br>${esc(x.agent_id)}`],['状态',x=>pill(x.status)],['有效期',x=>esc(x.expires_at)],['使用',x=>esc(x.usage_count)],['操作',x=>has('provenance.revoke')&&x.status!=='revoked'?`<button class="btn danger" data-revoke-workflow="${esc(x.provenance_id)}">撤销</button>`:'—']],workflows)}</div><div class="panel"><div class="panel-head"><h2>Child Grants</h2></div>${table([['Grant',x=>esc(x.grant_id)],['类型 / Scope',x=>`${esc(x.grant_type)}<br>${esc(x.execution_path)}`],['Git 操作',x=>esc((x.allowed_git_operations||[]).join(', ')||'—')],['状态',x=>pill(x.status)],['有效期',x=>esc(x.expires_at)],['使用',x=>esc(x.usage_count)],['操作',x=>has('provenance.revoke')&&x.status!=='revoked'?`<button class="btn danger" data-revoke-grant="${esc(x.grant_id)}">撤销</button>`:'—']],grants)}</div>`;document.querySelectorAll('[data-revoke-workflow]').forEach(b=>b.onclick=()=>confirmOp('撤销 Workflow',`撤销 ${b.dataset.revokeWorkflow} 将使所有子 Grant 失效。`,reason=>api(`/api/v2/portal/provenance/${encodeURIComponent(b.dataset.revokeWorkflow)}/revoke`,{method:'POST',body:JSON.stringify({reason})}).then(authorizations)));document.querySelectorAll('[data-revoke-grant]').forEach(b=>b.onclick=()=>confirmOp('撤销 Grant',`撤销 ${b.dataset.revokeGrant}。`,reason=>api(`/api/v2/portal/grants/${encodeURIComponent(b.dataset.revokeGrant)}/revoke`,{method:'POST',body:JSON.stringify({reason})}).then(authorizations)))}
|
||||
async function runtime(){const d=await api('/api/v2/portal/runtime');const runtimes=d.runtimes||[],dispatches=d.dispatches||[],jobs=d.hermes_jobs||[];$('#runtime').innerHTML=`<div class="grid"><div class="panel"><div class="panel-head"><h2>Runtime</h2></div>${table([['名称',x=>esc(x.name)],['状态',x=>pill(x.status)],['详情',x=>esc(JSON.stringify(x.details||{}))]],runtimes)}</div><div class="panel"><div class="panel-head"><h2>Hermes Queue / Lease</h2></div>${table([['Job',x=>esc(x.job_id)],['Cell / Profile',x=>`${esc(x.cell_id)} / ${esc(x.profile_id)}`],['Worker',x=>esc(x.assigned_worker_id||'—')],['状态',x=>pill(x.state)],['Lease',x=>esc(x.lease_expires_at||'—')]],jobs)}</div><div class="panel wide"><div class="panel-head"><h2>Dispatch</h2></div>${table([['Dispatch',x=>esc(x.dispatch_id)],['Task',x=>esc(x.task_id)],['Runtime',x=>esc(x.runtime)],['执行 ID',x=>esc(x.runtime_execution_id)],['Principal',x=>esc(x.principal_id)],['状态',x=>pill(x.state)]],dispatches)}</div></div>`}
|
||||
async function evidence(){const d=await api('/api/v2/portal/evidence');$('#evidence').innerHTML=`<div class="panel"><div class="panel-head"><h2>Execution Evidence</h2></div>${table([['Execution',x=>esc(x.execution_id)],['Task / Agent',x=>`${esc(x.task_id)}<br>${esc(x.agent_id)}`],['Executor',x=>esc(x.executor)],['状态',x=>pill(x.status)],['进度',x=>`${esc(x.progress_completed)}/${esc(x.progress_total)}`],['Test',x=>pill(x.test_status)],['Commit',x=>esc(x.last_commit||'—')],['授权',x=>esc(x.last_authorization_id||'—')]],d.executions||[])}</div>`}
|
||||
async function audit(){const d=await api('/api/v2/portal/audit');const events=(d.events||[]).slice().reverse();$('#audit').innerHTML=`<div class="panel"><div class="panel-head"><h2>统一审计时间线</h2></div><div class="timeline">${events.map(x=>`<div class="event"><strong>${esc(x.action)} · ${pill(x.outcome)}</strong><p>${esc(x.created_at)} · ${esc(x.principal_id)} · ${esc(x.resource_type)}/${esc(x.resource_id)}</p><div class="muted">Trace ${esc(x.trace_id)} · Policy ${esc(x.policy_version)}</div></div>`).join('')||'<div class="empty">暂无审计事件</div>'}</div></div>`}
|
||||
async function release(){const d=await api('/api/v2/portal/release');const g=d.gitops||{};$('#release').innerHTML=`<div class="cards">${card('版本',d.version||'—')}${card('Baseline',d.baseline||'—')}${card('发布状态',d.status||'—')}${card('Git 同步',g.sync_status||'unknown')}</div><div class="grid"><div class="panel"><div class="panel-head"><h2>当前 Release</h2></div><div class="kv"><div>Release OID</div><div>${esc(d.release_oid)}</div><div>Branch</div><div>${esc(g.workspace_branch||g.branch||'—')}</div><div>Workspace</div><div>${pill(g.workspace_clean===true?'clean':g.workspace_clean===false?'dirty':'unknown')}</div><div>Local Sync</div><div>${pill(g.local_sync||'unknown')}</div><div>Gitea Sync</div><div>${pill(g.gitea_sync||'unknown')}</div></div></div><div class="panel"><div class="panel-head"><h2>治理操作</h2></div><p class="muted">门户不直接移动 Tag、合并主线或部署生产。以下仅为可发起的 GitOps 请求目录。</p>${(d.operations||[]).map(x=>pill(x)).join('')||'<span class="muted">当前角色只读</span>'}</div><div class="panel wide"><div class="panel-head"><h2>原始 GitOps 状态</h2></div>${json(g)}</div></div>`}
|
||||
function confirmOp(title,text,fn){state.confirm=fn;$('#confirmTitle').textContent=title;$('#confirmText').textContent=text;$('#confirmReason').value='';$('#confirmDialog').showModal()}
|
||||
$('#taskForm').onsubmit=async e=>{e.preventDefault();clearErr();try{const fd=new FormData(e.target),payload=JSON.parse(fd.get('payload')||'{}');await api('/api/v2/portal/tasks',{method:'POST',body:JSON.stringify({agent_id:fd.get('agent_id'),action:fd.get('action'),idempotency_key:fd.get('idempotency_key'),payload})});$('#taskDialog').close();e.target.reset();await tasks()}catch(e){err(e)}};
|
||||
$('#confirmForm').onsubmit=async e=>{e.preventDefault();const fn=state.confirm;$('#confirmDialog').close();state.confirm=null;try{await fn?.($('#confirmReason').value)}catch(e){err(e)}};
|
||||
document.querySelectorAll('[data-close]').forEach(b=>b.onclick=()=>document.getElementById(b.dataset.close).close());$('#refresh').onclick=()=>load(state.current);
|
||||
identity().catch(err);setInterval(()=>load(state.current),30000);
|
||||
</script>
|
||||
</body></html>'''
|
||||
@@ -1,627 +0,0 @@
|
||||
"""Tenant-isolated AIOS V2 control-plane domain service.
|
||||
|
||||
This module deliberately contains no OpenClaw or Hermes implementation details.
|
||||
It owns authoritative tenant, agent, task-lifecycle, idempotency and audit state.
|
||||
Runtime adapters consume approved tasks through a separate boundary.
|
||||
"""
|
||||
from __future__ import annotations
|
||||
|
||||
import copy
|
||||
import hashlib
|
||||
import json
|
||||
import threading
|
||||
import uuid
|
||||
from dataclasses import dataclass, field
|
||||
from datetime import datetime, timezone
|
||||
from enum import Enum
|
||||
from typing import Any, Callable, Iterable, Mapping
|
||||
|
||||
|
||||
def _utc_now() -> str:
|
||||
return datetime.now(timezone.utc).isoformat().replace("+00:00", "Z")
|
||||
|
||||
|
||||
def _new_id(prefix: str) -> str:
|
||||
return f"{prefix}_{uuid.uuid4().hex}"
|
||||
|
||||
|
||||
def _canonical_digest(value: Mapping[str, Any]) -> str:
|
||||
encoded = json.dumps(
|
||||
value,
|
||||
ensure_ascii=False,
|
||||
sort_keys=True,
|
||||
separators=(",", ":"),
|
||||
default=str,
|
||||
).encode("utf-8")
|
||||
return hashlib.sha256(encoded).hexdigest()
|
||||
|
||||
|
||||
class ControlPlaneError(RuntimeError):
|
||||
"""Base error returned by the control-plane domain."""
|
||||
|
||||
|
||||
class Unauthorized(ControlPlaneError):
|
||||
"""The caller is not authenticated or lacks the required role."""
|
||||
|
||||
|
||||
class TenantIsolationError(ControlPlaneError):
|
||||
"""A request attempted to cross a tenant boundary."""
|
||||
|
||||
|
||||
class NotFound(ControlPlaneError):
|
||||
"""A tenant-scoped resource does not exist or is not visible."""
|
||||
|
||||
|
||||
class InvalidTransition(ControlPlaneError):
|
||||
"""A task state transition violates the lifecycle contract."""
|
||||
|
||||
|
||||
class IdempotencyConflict(ControlPlaneError):
|
||||
"""An idempotency key was reused for a different command."""
|
||||
|
||||
|
||||
class RevisionConflict(ControlPlaneError):
|
||||
"""Optimistic task revision does not match current state."""
|
||||
|
||||
|
||||
class PolicyDenied(ControlPlaneError):
|
||||
"""The policy gate denied a control-plane operation."""
|
||||
|
||||
|
||||
@dataclass(frozen=True)
|
||||
class RequestContext:
|
||||
"""Authenticated request identity propagated across all AIOS layers."""
|
||||
|
||||
tenant_id: str
|
||||
principal_id: str
|
||||
trace_id: str
|
||||
roles: frozenset[str] = field(default_factory=frozenset)
|
||||
session_id: str | None = None
|
||||
policy_version: str = "v1"
|
||||
|
||||
def __post_init__(self) -> None:
|
||||
for name in ("tenant_id", "principal_id", "trace_id"):
|
||||
if not str(getattr(self, name, "")).strip():
|
||||
raise ValueError(f"{name} is required")
|
||||
|
||||
@classmethod
|
||||
def create(
|
||||
cls,
|
||||
*,
|
||||
tenant_id: str,
|
||||
principal_id: str,
|
||||
roles: Iterable[str] = (),
|
||||
trace_id: str | None = None,
|
||||
session_id: str | None = None,
|
||||
policy_version: str = "v1",
|
||||
) -> "RequestContext":
|
||||
return cls(
|
||||
tenant_id=tenant_id.strip(),
|
||||
principal_id=principal_id.strip(),
|
||||
trace_id=trace_id or _new_id("trace"),
|
||||
roles=frozenset(str(role).strip() for role in roles if str(role).strip()),
|
||||
session_id=session_id,
|
||||
policy_version=policy_version,
|
||||
)
|
||||
|
||||
|
||||
@dataclass(frozen=True)
|
||||
class TenantRecord:
|
||||
tenant_id: str
|
||||
display_name: str
|
||||
status: str = "active"
|
||||
metadata: Mapping[str, Any] = field(default_factory=dict)
|
||||
created_at: str = field(default_factory=_utc_now)
|
||||
updated_at: str = field(default_factory=_utc_now)
|
||||
|
||||
|
||||
@dataclass(frozen=True)
|
||||
class AgentRecord:
|
||||
agent_id: str
|
||||
tenant_id: str
|
||||
display_name: str
|
||||
runtime: str
|
||||
capabilities: tuple[str, ...] = field(default_factory=tuple)
|
||||
enabled: bool = True
|
||||
metadata: Mapping[str, Any] = field(default_factory=dict)
|
||||
created_at: str = field(default_factory=_utc_now)
|
||||
updated_at: str = field(default_factory=_utc_now)
|
||||
|
||||
|
||||
class TaskState(str, Enum):
|
||||
CREATED = "CREATED"
|
||||
APPROVED = "APPROVED"
|
||||
RUNNING = "RUNNING"
|
||||
COMPLETED = "COMPLETED"
|
||||
FAILED = "FAILED"
|
||||
CANCELLED = "CANCELLED"
|
||||
|
||||
|
||||
TERMINAL_TASK_STATES = frozenset(
|
||||
{TaskState.COMPLETED, TaskState.FAILED, TaskState.CANCELLED}
|
||||
)
|
||||
|
||||
ALLOWED_TASK_TRANSITIONS: Mapping[TaskState, frozenset[TaskState]] = {
|
||||
TaskState.CREATED: frozenset({TaskState.APPROVED, TaskState.CANCELLED}),
|
||||
TaskState.APPROVED: frozenset({TaskState.RUNNING, TaskState.CANCELLED}),
|
||||
TaskState.RUNNING: frozenset(
|
||||
{TaskState.COMPLETED, TaskState.FAILED, TaskState.CANCELLED}
|
||||
),
|
||||
TaskState.COMPLETED: frozenset(),
|
||||
TaskState.FAILED: frozenset(),
|
||||
TaskState.CANCELLED: frozenset(),
|
||||
}
|
||||
|
||||
|
||||
@dataclass(frozen=True)
|
||||
class TaskRecord:
|
||||
task_id: str
|
||||
tenant_id: str
|
||||
agent_id: str
|
||||
action: str
|
||||
payload: Mapping[str, Any]
|
||||
state: TaskState = TaskState.CREATED
|
||||
revision: int = 1
|
||||
idempotency_key: str | None = None
|
||||
request_digest: str = ""
|
||||
result: Mapping[str, Any] | None = None
|
||||
error: Mapping[str, Any] | None = None
|
||||
created_by: str = ""
|
||||
approved_by: str | None = None
|
||||
created_at: str = field(default_factory=_utc_now)
|
||||
updated_at: str = field(default_factory=_utc_now)
|
||||
|
||||
|
||||
@dataclass(frozen=True)
|
||||
class AuditEvent:
|
||||
event_id: str
|
||||
tenant_id: str
|
||||
principal_id: str
|
||||
trace_id: str
|
||||
action: str
|
||||
resource_type: str
|
||||
resource_id: str
|
||||
outcome: str
|
||||
policy_version: str
|
||||
details: Mapping[str, Any] = field(default_factory=dict)
|
||||
created_at: str = field(default_factory=_utc_now)
|
||||
|
||||
|
||||
@dataclass(frozen=True)
|
||||
class PolicyDecision:
|
||||
allowed: bool
|
||||
reason: str
|
||||
policy_version: str
|
||||
|
||||
|
||||
PolicyEvaluator = Callable[[RequestContext, str, Mapping[str, Any]], PolicyDecision]
|
||||
|
||||
|
||||
class InMemoryControlPlaneStore:
|
||||
"""Thread-safe reference store used by tests and the first gateway slice.
|
||||
|
||||
Production backends must preserve the same tenant-scoped interface and add
|
||||
database row-level security, migrations, backup and HA evidence.
|
||||
"""
|
||||
|
||||
def __init__(self) -> None:
|
||||
self.lock = threading.RLock()
|
||||
self.tenants: dict[str, TenantRecord] = {}
|
||||
self.agents: dict[str, AgentRecord] = {}
|
||||
self.tasks: dict[str, TaskRecord] = {}
|
||||
self.idempotency: dict[tuple[str, str], tuple[str, str]] = {}
|
||||
self.audit_events: list[AuditEvent] = []
|
||||
|
||||
|
||||
class ControlPlaneService:
|
||||
"""Authoritative tenant, agent and task lifecycle service."""
|
||||
|
||||
def __init__(
|
||||
self,
|
||||
store: InMemoryControlPlaneStore | None = None,
|
||||
*,
|
||||
policy_evaluator: PolicyEvaluator | None = None,
|
||||
) -> None:
|
||||
self.store = store or InMemoryControlPlaneStore()
|
||||
self.policy_evaluator = policy_evaluator or self._default_policy
|
||||
|
||||
@staticmethod
|
||||
def _default_policy(
|
||||
context: RequestContext,
|
||||
action: str,
|
||||
resource: Mapping[str, Any],
|
||||
) -> PolicyDecision:
|
||||
del resource
|
||||
role_requirements = {
|
||||
"tenant.register": {"platform_admin"},
|
||||
"tenant.read": {"tenant_admin", "operator", "auditor", "platform_admin"},
|
||||
"agent.register": {"tenant_admin", "operator", "platform_admin"},
|
||||
"agent.read": {"tenant_admin", "operator", "auditor", "platform_admin"},
|
||||
"task.create": {"tenant_admin", "operator", "platform_admin"},
|
||||
"task.read": {"tenant_admin", "operator", "auditor", "platform_admin"},
|
||||
"task.approve": {"tenant_admin", "approver", "platform_admin"},
|
||||
"task.start": {"runtime", "operator", "platform_admin"},
|
||||
"task.complete": {"runtime", "operator", "platform_admin"},
|
||||
"task.fail": {"runtime", "operator", "platform_admin"},
|
||||
"task.cancel": {"tenant_admin", "operator", "approver", "platform_admin"},
|
||||
"audit.read": {"tenant_admin", "auditor", "platform_admin"},
|
||||
}
|
||||
required = role_requirements.get(action, {"platform_admin"})
|
||||
allowed = bool(context.roles.intersection(required))
|
||||
return PolicyDecision(
|
||||
allowed=allowed,
|
||||
reason="role_allowed" if allowed else "required_role_missing",
|
||||
policy_version=context.policy_version,
|
||||
)
|
||||
|
||||
def _require_context(self, context: RequestContext) -> None:
|
||||
if not context.principal_id or not context.tenant_id or not context.trace_id:
|
||||
raise Unauthorized("authenticated tenant context is required")
|
||||
|
||||
def _authorize(
|
||||
self,
|
||||
context: RequestContext,
|
||||
action: str,
|
||||
resource: Mapping[str, Any],
|
||||
) -> PolicyDecision:
|
||||
self._require_context(context)
|
||||
decision = self.policy_evaluator(context, action, resource)
|
||||
if not decision.allowed:
|
||||
self._audit(
|
||||
context,
|
||||
action=action,
|
||||
resource_type=str(resource.get("resource_type", "policy")),
|
||||
resource_id=str(resource.get("resource_id", "unknown")),
|
||||
outcome="denied",
|
||||
details={"reason": decision.reason},
|
||||
)
|
||||
raise PolicyDenied(f"{action} denied: {decision.reason}")
|
||||
return decision
|
||||
|
||||
@staticmethod
|
||||
def _assert_same_tenant(context: RequestContext, tenant_id: str) -> None:
|
||||
if context.tenant_id != tenant_id and "platform_admin" not in context.roles:
|
||||
raise TenantIsolationError("cross-tenant access denied")
|
||||
|
||||
def _audit(
|
||||
self,
|
||||
context: RequestContext,
|
||||
*,
|
||||
action: str,
|
||||
resource_type: str,
|
||||
resource_id: str,
|
||||
outcome: str,
|
||||
details: Mapping[str, Any] | None = None,
|
||||
) -> AuditEvent:
|
||||
event = AuditEvent(
|
||||
event_id=_new_id("audit"),
|
||||
tenant_id=context.tenant_id,
|
||||
principal_id=context.principal_id,
|
||||
trace_id=context.trace_id,
|
||||
action=action,
|
||||
resource_type=resource_type,
|
||||
resource_id=resource_id,
|
||||
outcome=outcome,
|
||||
policy_version=context.policy_version,
|
||||
details=copy.deepcopy(dict(details or {})),
|
||||
)
|
||||
self.store.audit_events.append(event)
|
||||
return event
|
||||
|
||||
def register_tenant(
|
||||
self,
|
||||
context: RequestContext,
|
||||
*,
|
||||
tenant_id: str,
|
||||
display_name: str,
|
||||
metadata: Mapping[str, Any] | None = None,
|
||||
) -> TenantRecord:
|
||||
tenant_id = tenant_id.strip()
|
||||
if not tenant_id or not display_name.strip():
|
||||
raise ValueError("tenant_id and display_name are required")
|
||||
self._authorize(
|
||||
context,
|
||||
"tenant.register",
|
||||
{"resource_type": "tenant", "resource_id": tenant_id},
|
||||
)
|
||||
self._assert_same_tenant(context, tenant_id)
|
||||
with self.store.lock:
|
||||
if tenant_id in self.store.tenants:
|
||||
raise ControlPlaneError(f"tenant already exists: {tenant_id}")
|
||||
tenant = TenantRecord(
|
||||
tenant_id=tenant_id,
|
||||
display_name=display_name.strip(),
|
||||
metadata=copy.deepcopy(dict(metadata or {})),
|
||||
)
|
||||
self.store.tenants[tenant_id] = tenant
|
||||
self._audit(
|
||||
context,
|
||||
action="tenant.register",
|
||||
resource_type="tenant",
|
||||
resource_id=tenant_id,
|
||||
outcome="allowed",
|
||||
)
|
||||
return tenant
|
||||
|
||||
def get_tenant(self, context: RequestContext, tenant_id: str | None = None) -> TenantRecord:
|
||||
tenant_id = tenant_id or context.tenant_id
|
||||
self._authorize(
|
||||
context,
|
||||
"tenant.read",
|
||||
{"resource_type": "tenant", "resource_id": tenant_id},
|
||||
)
|
||||
self._assert_same_tenant(context, tenant_id)
|
||||
with self.store.lock:
|
||||
tenant = self.store.tenants.get(tenant_id)
|
||||
if tenant is None:
|
||||
raise NotFound("tenant not found")
|
||||
return tenant
|
||||
|
||||
def register_agent(
|
||||
self,
|
||||
context: RequestContext,
|
||||
*,
|
||||
agent_id: str,
|
||||
display_name: str,
|
||||
runtime: str,
|
||||
capabilities: Iterable[str] = (),
|
||||
metadata: Mapping[str, Any] | None = None,
|
||||
) -> AgentRecord:
|
||||
self._authorize(
|
||||
context,
|
||||
"agent.register",
|
||||
{"resource_type": "agent", "resource_id": agent_id},
|
||||
)
|
||||
tenant = self.get_tenant(context)
|
||||
if tenant.status != "active":
|
||||
raise ControlPlaneError("tenant is not active")
|
||||
normalized_capabilities = tuple(
|
||||
sorted({str(item).strip() for item in capabilities if str(item).strip()})
|
||||
)
|
||||
if not agent_id.strip() or not display_name.strip() or not runtime.strip():
|
||||
raise ValueError("agent_id, display_name and runtime are required")
|
||||
with self.store.lock:
|
||||
existing = self.store.agents.get(agent_id)
|
||||
if existing is not None and existing.tenant_id != context.tenant_id:
|
||||
raise TenantIsolationError("agent id belongs to another tenant")
|
||||
if existing is not None:
|
||||
raise ControlPlaneError(f"agent already exists: {agent_id}")
|
||||
agent = AgentRecord(
|
||||
agent_id=agent_id.strip(),
|
||||
tenant_id=context.tenant_id,
|
||||
display_name=display_name.strip(),
|
||||
runtime=runtime.strip(),
|
||||
capabilities=normalized_capabilities,
|
||||
metadata=copy.deepcopy(dict(metadata or {})),
|
||||
)
|
||||
self.store.agents[agent.agent_id] = agent
|
||||
self._audit(
|
||||
context,
|
||||
action="agent.register",
|
||||
resource_type="agent",
|
||||
resource_id=agent.agent_id,
|
||||
outcome="allowed",
|
||||
details={"runtime": agent.runtime},
|
||||
)
|
||||
return agent
|
||||
|
||||
def get_agent(self, context: RequestContext, agent_id: str) -> AgentRecord:
|
||||
self._authorize(
|
||||
context,
|
||||
"agent.read",
|
||||
{"resource_type": "agent", "resource_id": agent_id},
|
||||
)
|
||||
with self.store.lock:
|
||||
agent = self.store.agents.get(agent_id)
|
||||
if agent is None:
|
||||
raise NotFound("agent not found")
|
||||
self._assert_same_tenant(context, agent.tenant_id)
|
||||
return agent
|
||||
|
||||
def list_agents(self, context: RequestContext) -> list[AgentRecord]:
|
||||
self._authorize(
|
||||
context,
|
||||
"agent.read",
|
||||
{"resource_type": "agent_collection", "resource_id": context.tenant_id},
|
||||
)
|
||||
with self.store.lock:
|
||||
return [
|
||||
agent
|
||||
for agent in self.store.agents.values()
|
||||
if agent.tenant_id == context.tenant_id
|
||||
]
|
||||
|
||||
def create_task(
|
||||
self,
|
||||
context: RequestContext,
|
||||
*,
|
||||
agent_id: str,
|
||||
action: str,
|
||||
payload: Mapping[str, Any] | None = None,
|
||||
idempotency_key: str | None = None,
|
||||
) -> TaskRecord:
|
||||
self._authorize(
|
||||
context,
|
||||
"task.create",
|
||||
{"resource_type": "task", "resource_id": idempotency_key or "new"},
|
||||
)
|
||||
agent = self.get_agent(context, agent_id)
|
||||
if not agent.enabled:
|
||||
raise ControlPlaneError("agent is disabled")
|
||||
if action not in agent.capabilities and "*" not in agent.capabilities:
|
||||
raise PolicyDenied(f"agent does not advertise capability: {action}")
|
||||
normalized_payload = copy.deepcopy(dict(payload or {}))
|
||||
request_digest = _canonical_digest(
|
||||
{"agent_id": agent_id, "action": action, "payload": normalized_payload}
|
||||
)
|
||||
normalized_key = idempotency_key.strip() if idempotency_key else None
|
||||
with self.store.lock:
|
||||
if normalized_key:
|
||||
idempotency_ref = (context.tenant_id, normalized_key)
|
||||
existing = self.store.idempotency.get(idempotency_ref)
|
||||
if existing is not None:
|
||||
existing_task_id, existing_digest = existing
|
||||
if existing_digest != request_digest:
|
||||
raise IdempotencyConflict(
|
||||
"idempotency key was reused with a different request"
|
||||
)
|
||||
return self.store.tasks[existing_task_id]
|
||||
task = TaskRecord(
|
||||
task_id=_new_id("task"),
|
||||
tenant_id=context.tenant_id,
|
||||
agent_id=agent_id,
|
||||
action=action,
|
||||
payload=normalized_payload,
|
||||
idempotency_key=normalized_key,
|
||||
request_digest=request_digest,
|
||||
created_by=context.principal_id,
|
||||
)
|
||||
self.store.tasks[task.task_id] = task
|
||||
if normalized_key:
|
||||
self.store.idempotency[(context.tenant_id, normalized_key)] = (
|
||||
task.task_id,
|
||||
request_digest,
|
||||
)
|
||||
self._audit(
|
||||
context,
|
||||
action="task.create",
|
||||
resource_type="task",
|
||||
resource_id=task.task_id,
|
||||
outcome="allowed",
|
||||
details={"agent_id": agent_id, "action": action},
|
||||
)
|
||||
return task
|
||||
|
||||
def get_task(self, context: RequestContext, task_id: str) -> TaskRecord:
|
||||
self._authorize(
|
||||
context,
|
||||
"task.read",
|
||||
{"resource_type": "task", "resource_id": task_id},
|
||||
)
|
||||
with self.store.lock:
|
||||
task = self.store.tasks.get(task_id)
|
||||
if task is None:
|
||||
raise NotFound("task not found")
|
||||
self._assert_same_tenant(context, task.tenant_id)
|
||||
return task
|
||||
|
||||
def list_tasks(
|
||||
self,
|
||||
context: RequestContext,
|
||||
*,
|
||||
states: Iterable[TaskState | str] | None = None,
|
||||
) -> list[TaskRecord]:
|
||||
self._authorize(
|
||||
context,
|
||||
"task.read",
|
||||
{"resource_type": "task_collection", "resource_id": context.tenant_id},
|
||||
)
|
||||
state_filter = (
|
||||
{TaskState(item) for item in states}
|
||||
if states is not None
|
||||
else None
|
||||
)
|
||||
with self.store.lock:
|
||||
return [
|
||||
task
|
||||
for task in self.store.tasks.values()
|
||||
if task.tenant_id == context.tenant_id
|
||||
and (state_filter is None or task.state in state_filter)
|
||||
]
|
||||
|
||||
def transition_task(
|
||||
self,
|
||||
context: RequestContext,
|
||||
*,
|
||||
task_id: str,
|
||||
target_state: TaskState | str,
|
||||
expected_revision: int | None = None,
|
||||
result: Mapping[str, Any] | None = None,
|
||||
error: Mapping[str, Any] | None = None,
|
||||
) -> TaskRecord:
|
||||
target = TaskState(target_state)
|
||||
action_name = {
|
||||
TaskState.APPROVED: "task.approve",
|
||||
TaskState.RUNNING: "task.start",
|
||||
TaskState.COMPLETED: "task.complete",
|
||||
TaskState.FAILED: "task.fail",
|
||||
TaskState.CANCELLED: "task.cancel",
|
||||
}.get(target)
|
||||
if action_name is None:
|
||||
raise InvalidTransition(f"cannot transition to {target.value}")
|
||||
self._authorize(
|
||||
context,
|
||||
action_name,
|
||||
{"resource_type": "task", "resource_id": task_id},
|
||||
)
|
||||
with self.store.lock:
|
||||
current = self.store.tasks.get(task_id)
|
||||
if current is None:
|
||||
raise NotFound("task not found")
|
||||
self._assert_same_tenant(context, current.tenant_id)
|
||||
if expected_revision is not None and current.revision != expected_revision:
|
||||
raise RevisionConflict(
|
||||
f"expected revision {expected_revision}, current {current.revision}"
|
||||
)
|
||||
if target not in ALLOWED_TASK_TRANSITIONS[current.state]:
|
||||
raise InvalidTransition(
|
||||
f"invalid transition {current.state.value} -> {target.value}"
|
||||
)
|
||||
if target == TaskState.COMPLETED and result is None:
|
||||
raise ValueError("completed task requires result")
|
||||
if target == TaskState.FAILED and error is None:
|
||||
raise ValueError("failed task requires error")
|
||||
updated = TaskRecord(
|
||||
task_id=current.task_id,
|
||||
tenant_id=current.tenant_id,
|
||||
agent_id=current.agent_id,
|
||||
action=current.action,
|
||||
payload=current.payload,
|
||||
state=target,
|
||||
revision=current.revision + 1,
|
||||
idempotency_key=current.idempotency_key,
|
||||
request_digest=current.request_digest,
|
||||
result=copy.deepcopy(dict(result)) if result is not None else current.result,
|
||||
error=copy.deepcopy(dict(error)) if error is not None else current.error,
|
||||
created_by=current.created_by,
|
||||
approved_by=(
|
||||
context.principal_id
|
||||
if target == TaskState.APPROVED
|
||||
else current.approved_by
|
||||
),
|
||||
created_at=current.created_at,
|
||||
updated_at=_utc_now(),
|
||||
)
|
||||
self.store.tasks[task_id] = updated
|
||||
self._audit(
|
||||
context,
|
||||
action=action_name,
|
||||
resource_type="task",
|
||||
resource_id=task_id,
|
||||
outcome="allowed",
|
||||
details={
|
||||
"from": current.state.value,
|
||||
"to": target.value,
|
||||
"revision": updated.revision,
|
||||
},
|
||||
)
|
||||
return updated
|
||||
|
||||
def list_audit_events(
|
||||
self,
|
||||
context: RequestContext,
|
||||
*,
|
||||
resource_id: str | None = None,
|
||||
) -> list[AuditEvent]:
|
||||
self._authorize(
|
||||
context,
|
||||
"audit.read",
|
||||
{"resource_type": "audit", "resource_id": resource_id or context.tenant_id},
|
||||
)
|
||||
with self.store.lock:
|
||||
return [
|
||||
event
|
||||
for event in self.store.audit_events
|
||||
if event.tenant_id == context.tenant_id
|
||||
and (resource_id is None or event.resource_id == resource_id)
|
||||
]
|
||||
@@ -1,379 +0,0 @@
|
||||
"""AIOS V2 持久化 Dispatch 记录。
|
||||
|
||||
Dispatch 是 AIOS Task 与 Runtime command/job 之间的唯一可信绑定。所有结果回写
|
||||
必须匹配 tenant/task/trace/runtime_execution/provenance/run/principal。
|
||||
"""
|
||||
from __future__ import annotations
|
||||
|
||||
import json
|
||||
import sqlite3
|
||||
import threading
|
||||
import uuid
|
||||
from dataclasses import asdict, dataclass, replace
|
||||
from datetime import datetime, timezone
|
||||
from enum import Enum
|
||||
from pathlib import Path
|
||||
from typing import Any, Mapping, Protocol
|
||||
|
||||
|
||||
def utc_now() -> str:
|
||||
return datetime.now(timezone.utc).isoformat().replace("+00:00", "Z")
|
||||
|
||||
|
||||
def _required(value: str, label: str) -> str:
|
||||
normalized = str(value or "").strip()
|
||||
if not normalized:
|
||||
raise ValueError(f"{label} is required")
|
||||
return normalized
|
||||
|
||||
|
||||
class DispatchState(str, Enum):
|
||||
PREPARED = "PREPARED"
|
||||
RUNNING = "RUNNING"
|
||||
QUEUED = "QUEUED"
|
||||
COMPLETED = "COMPLETED"
|
||||
FAILED = "FAILED"
|
||||
CANCELLED = "CANCELLED"
|
||||
|
||||
|
||||
TERMINAL_DISPATCH_STATES = frozenset(
|
||||
{DispatchState.COMPLETED, DispatchState.FAILED, DispatchState.CANCELLED}
|
||||
)
|
||||
|
||||
|
||||
@dataclass(frozen=True)
|
||||
class DispatchRecord:
|
||||
dispatch_id: str
|
||||
tenant_id: str
|
||||
task_id: str
|
||||
agent_id: str
|
||||
principal_id: str
|
||||
runtime: str
|
||||
runtime_execution_id: str
|
||||
trace_id: str
|
||||
provenance_id: str
|
||||
run_id: str
|
||||
authorization_id: str
|
||||
state: DispatchState = DispatchState.PREPARED
|
||||
expected_worker_id: str | None = None
|
||||
result_digest: str | None = None
|
||||
created_at: str = ""
|
||||
updated_at: str = ""
|
||||
completed_at: str | None = None
|
||||
|
||||
def __post_init__(self) -> None:
|
||||
for name in (
|
||||
"dispatch_id",
|
||||
"tenant_id",
|
||||
"task_id",
|
||||
"agent_id",
|
||||
"principal_id",
|
||||
"runtime",
|
||||
"runtime_execution_id",
|
||||
"trace_id",
|
||||
"provenance_id",
|
||||
"run_id",
|
||||
"authorization_id",
|
||||
):
|
||||
object.__setattr__(self, name, _required(getattr(self, name), name))
|
||||
object.__setattr__(self, "state", DispatchState(self.state))
|
||||
now = utc_now()
|
||||
object.__setattr__(self, "created_at", self.created_at or now)
|
||||
object.__setattr__(self, "updated_at", self.updated_at or now)
|
||||
if self.expected_worker_id is not None:
|
||||
object.__setattr__(
|
||||
self,
|
||||
"expected_worker_id",
|
||||
_required(self.expected_worker_id, "expected_worker_id"),
|
||||
)
|
||||
|
||||
@classmethod
|
||||
def create(
|
||||
cls,
|
||||
*,
|
||||
tenant_id: str,
|
||||
task_id: str,
|
||||
agent_id: str,
|
||||
principal_id: str,
|
||||
runtime: str,
|
||||
runtime_execution_id: str,
|
||||
trace_id: str,
|
||||
provenance_id: str,
|
||||
run_id: str,
|
||||
authorization_id: str,
|
||||
) -> "DispatchRecord":
|
||||
return cls(
|
||||
dispatch_id=f"dispatch_{uuid.uuid4().hex}",
|
||||
tenant_id=tenant_id,
|
||||
task_id=task_id,
|
||||
agent_id=agent_id,
|
||||
principal_id=principal_id,
|
||||
runtime=runtime,
|
||||
runtime_execution_id=runtime_execution_id,
|
||||
trace_id=trace_id,
|
||||
provenance_id=provenance_id,
|
||||
run_id=run_id,
|
||||
authorization_id=authorization_id,
|
||||
)
|
||||
|
||||
def as_dict(self) -> dict[str, Any]:
|
||||
value = asdict(self)
|
||||
value["state"] = self.state.value
|
||||
return value
|
||||
|
||||
@classmethod
|
||||
def from_dict(cls, value: Mapping[str, Any]) -> "DispatchRecord":
|
||||
return cls(**dict(value))
|
||||
|
||||
|
||||
class DispatchConflict(RuntimeError):
|
||||
pass
|
||||
|
||||
|
||||
class DispatchNotFound(RuntimeError):
|
||||
pass
|
||||
|
||||
|
||||
class DispatchRepository(Protocol):
|
||||
def create(self, record: DispatchRecord) -> DispatchRecord: ...
|
||||
def get(self, dispatch_id: str, *, tenant_id: str) -> DispatchRecord: ...
|
||||
def get_by_task(self, task_id: str, *, tenant_id: str) -> DispatchRecord | None: ...
|
||||
def get_by_runtime_execution(
|
||||
self, runtime_execution_id: str, *, tenant_id: str
|
||||
) -> DispatchRecord | None: ...
|
||||
def update(
|
||||
self,
|
||||
dispatch_id: str,
|
||||
*,
|
||||
tenant_id: str,
|
||||
state: DispatchState | str | None = None,
|
||||
expected_worker_id: str | None = None,
|
||||
result_digest: str | None = None,
|
||||
) -> DispatchRecord: ...
|
||||
def list(self, *, tenant_id: str) -> list[DispatchRecord]: ...
|
||||
|
||||
|
||||
class InMemoryDispatchRepository:
|
||||
def __init__(self) -> None:
|
||||
self._lock = threading.RLock()
|
||||
self._records: dict[str, DispatchRecord] = {}
|
||||
self._by_task: dict[tuple[str, str], str] = {}
|
||||
self._by_runtime: dict[tuple[str, str], str] = {}
|
||||
|
||||
def create(self, record: DispatchRecord) -> DispatchRecord:
|
||||
with self._lock:
|
||||
task_ref = (record.tenant_id, record.task_id)
|
||||
runtime_ref = (record.tenant_id, record.runtime_execution_id)
|
||||
if task_ref in self._by_task or runtime_ref in self._by_runtime:
|
||||
existing = self.get_by_task(record.task_id, tenant_id=record.tenant_id)
|
||||
if existing == record:
|
||||
return record
|
||||
raise DispatchConflict("task or runtime execution already has a dispatch")
|
||||
self._records[record.dispatch_id] = record
|
||||
self._by_task[task_ref] = record.dispatch_id
|
||||
self._by_runtime[runtime_ref] = record.dispatch_id
|
||||
return record
|
||||
|
||||
def get(self, dispatch_id: str, *, tenant_id: str) -> DispatchRecord:
|
||||
with self._lock:
|
||||
record = self._records.get(dispatch_id)
|
||||
if record is None or record.tenant_id != tenant_id:
|
||||
raise DispatchNotFound("dispatch not found")
|
||||
return record
|
||||
|
||||
def get_by_task(self, task_id: str, *, tenant_id: str) -> DispatchRecord | None:
|
||||
with self._lock:
|
||||
dispatch_id = self._by_task.get((tenant_id, task_id))
|
||||
return self._records.get(dispatch_id) if dispatch_id else None
|
||||
|
||||
def get_by_runtime_execution(
|
||||
self, runtime_execution_id: str, *, tenant_id: str
|
||||
) -> DispatchRecord | None:
|
||||
with self._lock:
|
||||
dispatch_id = self._by_runtime.get((tenant_id, runtime_execution_id))
|
||||
return self._records.get(dispatch_id) if dispatch_id else None
|
||||
|
||||
def update(
|
||||
self,
|
||||
dispatch_id: str,
|
||||
*,
|
||||
tenant_id: str,
|
||||
state: DispatchState | str | None = None,
|
||||
expected_worker_id: str | None = None,
|
||||
result_digest: str | None = None,
|
||||
) -> DispatchRecord:
|
||||
with self._lock:
|
||||
current = self.get(dispatch_id, tenant_id=tenant_id)
|
||||
target = DispatchState(state) if state is not None else current.state
|
||||
if current.state in TERMINAL_DISPATCH_STATES and target != current.state:
|
||||
raise DispatchConflict("terminal dispatch cannot transition")
|
||||
updated = replace(
|
||||
current,
|
||||
state=target,
|
||||
expected_worker_id=(
|
||||
expected_worker_id
|
||||
if expected_worker_id is not None
|
||||
else current.expected_worker_id
|
||||
),
|
||||
result_digest=result_digest or current.result_digest,
|
||||
updated_at=utc_now(),
|
||||
completed_at=(utc_now() if target in TERMINAL_DISPATCH_STATES else None),
|
||||
)
|
||||
self._records[dispatch_id] = updated
|
||||
return updated
|
||||
|
||||
def list(self, *, tenant_id: str) -> list[DispatchRecord]:
|
||||
with self._lock:
|
||||
return sorted(
|
||||
[item for item in self._records.values() if item.tenant_id == tenant_id],
|
||||
key=lambda item: (item.created_at, item.dispatch_id),
|
||||
)
|
||||
|
||||
|
||||
class SQLiteDispatchRepository:
|
||||
SCHEMA_VERSION = 1
|
||||
|
||||
def __init__(self, path: str | Path) -> None:
|
||||
self.path = Path(path).resolve()
|
||||
self.path.parent.mkdir(parents=True, exist_ok=True)
|
||||
self._lock = threading.RLock()
|
||||
with self._connect() as connection:
|
||||
connection.executescript(
|
||||
"""
|
||||
CREATE TABLE IF NOT EXISTS dispatch_records (
|
||||
dispatch_id TEXT PRIMARY KEY,
|
||||
tenant_id TEXT NOT NULL,
|
||||
task_id TEXT NOT NULL,
|
||||
runtime_execution_id TEXT NOT NULL,
|
||||
payload_json TEXT NOT NULL,
|
||||
state TEXT NOT NULL,
|
||||
updated_at TEXT NOT NULL,
|
||||
UNIQUE(tenant_id, task_id),
|
||||
UNIQUE(tenant_id, runtime_execution_id)
|
||||
);
|
||||
CREATE INDEX IF NOT EXISTS idx_dispatch_tenant_state
|
||||
ON dispatch_records(tenant_id, state, updated_at);
|
||||
"""
|
||||
)
|
||||
|
||||
def _connect(self) -> sqlite3.Connection:
|
||||
connection = sqlite3.connect(str(self.path), timeout=30.0)
|
||||
connection.row_factory = sqlite3.Row
|
||||
connection.execute("PRAGMA journal_mode=WAL")
|
||||
connection.execute("PRAGMA synchronous=FULL")
|
||||
return connection
|
||||
|
||||
@staticmethod
|
||||
def _encode(record: DispatchRecord) -> str:
|
||||
return json.dumps(
|
||||
record.as_dict(), ensure_ascii=False, sort_keys=True, separators=(",", ":")
|
||||
)
|
||||
|
||||
@staticmethod
|
||||
def _decode(row: sqlite3.Row) -> DispatchRecord:
|
||||
value = json.loads(row["payload_json"])
|
||||
if not isinstance(value, Mapping):
|
||||
raise RuntimeError("invalid dispatch record")
|
||||
return DispatchRecord.from_dict(value)
|
||||
|
||||
def create(self, record: DispatchRecord) -> DispatchRecord:
|
||||
with self._lock, self._connect() as connection:
|
||||
connection.execute("BEGIN IMMEDIATE")
|
||||
try:
|
||||
connection.execute(
|
||||
"INSERT INTO dispatch_records VALUES (?, ?, ?, ?, ?, ?, ?)",
|
||||
(
|
||||
record.dispatch_id,
|
||||
record.tenant_id,
|
||||
record.task_id,
|
||||
record.runtime_execution_id,
|
||||
self._encode(record),
|
||||
record.state.value,
|
||||
record.updated_at,
|
||||
),
|
||||
)
|
||||
connection.commit()
|
||||
return record
|
||||
except sqlite3.IntegrityError as exc:
|
||||
connection.rollback()
|
||||
existing = self.get_by_task(record.task_id, tenant_id=record.tenant_id)
|
||||
if existing is not None and existing == record:
|
||||
return existing
|
||||
raise DispatchConflict("task or runtime execution already has a dispatch") from exc
|
||||
|
||||
def get(self, dispatch_id: str, *, tenant_id: str) -> DispatchRecord:
|
||||
with self._lock, self._connect() as connection:
|
||||
row = connection.execute(
|
||||
"SELECT payload_json FROM dispatch_records WHERE dispatch_id = ? AND tenant_id = ?",
|
||||
(_required(dispatch_id, "dispatch_id"), _required(tenant_id, "tenant_id")),
|
||||
).fetchone()
|
||||
if row is None:
|
||||
raise DispatchNotFound("dispatch not found")
|
||||
return self._decode(row)
|
||||
|
||||
def get_by_task(self, task_id: str, *, tenant_id: str) -> DispatchRecord | None:
|
||||
with self._lock, self._connect() as connection:
|
||||
row = connection.execute(
|
||||
"SELECT payload_json FROM dispatch_records WHERE task_id = ? AND tenant_id = ?",
|
||||
(_required(task_id, "task_id"), _required(tenant_id, "tenant_id")),
|
||||
).fetchone()
|
||||
return self._decode(row) if row is not None else None
|
||||
|
||||
def get_by_runtime_execution(
|
||||
self, runtime_execution_id: str, *, tenant_id: str
|
||||
) -> DispatchRecord | None:
|
||||
with self._lock, self._connect() as connection:
|
||||
row = connection.execute(
|
||||
"SELECT payload_json FROM dispatch_records WHERE runtime_execution_id = ? AND tenant_id = ?",
|
||||
(
|
||||
_required(runtime_execution_id, "runtime_execution_id"),
|
||||
_required(tenant_id, "tenant_id"),
|
||||
),
|
||||
).fetchone()
|
||||
return self._decode(row) if row is not None else None
|
||||
|
||||
def update(
|
||||
self,
|
||||
dispatch_id: str,
|
||||
*,
|
||||
tenant_id: str,
|
||||
state: DispatchState | str | None = None,
|
||||
expected_worker_id: str | None = None,
|
||||
result_digest: str | None = None,
|
||||
) -> DispatchRecord:
|
||||
current = self.get(dispatch_id, tenant_id=tenant_id)
|
||||
target = DispatchState(state) if state is not None else current.state
|
||||
if current.state in TERMINAL_DISPATCH_STATES and target != current.state:
|
||||
raise DispatchConflict("terminal dispatch cannot transition")
|
||||
updated = replace(
|
||||
current,
|
||||
state=target,
|
||||
expected_worker_id=(
|
||||
expected_worker_id if expected_worker_id is not None else current.expected_worker_id
|
||||
),
|
||||
result_digest=result_digest or current.result_digest,
|
||||
updated_at=utc_now(),
|
||||
completed_at=(utc_now() if target in TERMINAL_DISPATCH_STATES else None),
|
||||
)
|
||||
with self._lock, self._connect() as connection:
|
||||
connection.execute("BEGIN IMMEDIATE")
|
||||
connection.execute(
|
||||
"UPDATE dispatch_records SET payload_json = ?, state = ?, updated_at = ? WHERE dispatch_id = ? AND tenant_id = ?",
|
||||
(
|
||||
self._encode(updated),
|
||||
updated.state.value,
|
||||
updated.updated_at,
|
||||
updated.dispatch_id,
|
||||
updated.tenant_id,
|
||||
),
|
||||
)
|
||||
connection.commit()
|
||||
return updated
|
||||
|
||||
def list(self, *, tenant_id: str) -> list[DispatchRecord]:
|
||||
with self._lock, self._connect() as connection:
|
||||
rows = connection.execute(
|
||||
"SELECT payload_json FROM dispatch_records WHERE tenant_id = ? ORDER BY updated_at, dispatch_id",
|
||||
(_required(tenant_id, "tenant_id"),),
|
||||
).fetchall()
|
||||
return [self._decode(row) for row in rows]
|
||||
@@ -1,543 +0,0 @@
|
||||
"""Portable multi-provider execution plans and aggregate release gates.
|
||||
|
||||
A plan is a DAG of executor-neutral stages. Only root stages are declared at
|
||||
plan creation. A dependent stage is declared atomically after every dependency
|
||||
passes its Truth + notification gate, so its start deadline cannot expire while
|
||||
it is legitimately waiting for upstream work.
|
||||
"""
|
||||
from __future__ import annotations
|
||||
|
||||
import json
|
||||
import sqlite3
|
||||
import threading
|
||||
from dataclasses import asdict, dataclass, field
|
||||
from pathlib import Path
|
||||
from typing import Any, Mapping, Sequence
|
||||
|
||||
from .executor_protocol import ExecutorProviderRegistry, normalize_executor
|
||||
from .external_task_control import ExternalTaskCoordinator
|
||||
from .external_task_query import list_records
|
||||
from .task_execution_registry import (
|
||||
ExecutionTaskManifest,
|
||||
ExecutionTruthRecord,
|
||||
ExecutionTruthState,
|
||||
required,
|
||||
utc_now,
|
||||
)
|
||||
|
||||
PLAN_SCHEMA_VERSION = "aios.execution-plan.v2"
|
||||
WAITING_DEPENDENCY = "WAITING_DEPENDENCY"
|
||||
|
||||
|
||||
@dataclass(frozen=True)
|
||||
class ExecutionStageManifest:
|
||||
stage_id: str
|
||||
task_id: str
|
||||
executor_type: str
|
||||
role: str
|
||||
steps: Sequence[str]
|
||||
depends_on: Sequence[str] = ()
|
||||
required_evidence: Sequence[str] = ()
|
||||
notification_events: Sequence[str] = ("STARTED", "SUCCEEDED", "FAILED")
|
||||
owner_notification_ref: str = "AIOS_OWNER_WECHAT_TARGET_REF"
|
||||
start_deadline_seconds: int = 300
|
||||
heartbeat_timeout_seconds: int = 180
|
||||
required: bool = True
|
||||
metadata: Mapping[str, Any] = field(default_factory=dict)
|
||||
|
||||
def __post_init__(self) -> None:
|
||||
for name in ("stage_id", "task_id", "role", "owner_notification_ref"):
|
||||
object.__setattr__(self, name, required(getattr(self, name), name))
|
||||
object.__setattr__(self, "executor_type", normalize_executor(self.executor_type))
|
||||
steps = tuple(required(item, "step") for item in self.steps)
|
||||
if not steps:
|
||||
raise ValueError("execution stage requires at least one step")
|
||||
object.__setattr__(self, "steps", steps)
|
||||
object.__setattr__(
|
||||
self,
|
||||
"depends_on",
|
||||
tuple(sorted({required(item, "depends_on") for item in self.depends_on})),
|
||||
)
|
||||
object.__setattr__(
|
||||
self,
|
||||
"required_evidence",
|
||||
tuple(sorted({required(item, "required_evidence") for item in self.required_evidence})),
|
||||
)
|
||||
object.__setattr__(
|
||||
self,
|
||||
"notification_events",
|
||||
tuple(sorted({required(item, "notification_event") for item in self.notification_events})),
|
||||
)
|
||||
if self.start_deadline_seconds < 1 or self.heartbeat_timeout_seconds < 1:
|
||||
raise ValueError("stage deadlines must be positive")
|
||||
object.__setattr__(
|
||||
self,
|
||||
"metadata",
|
||||
json.loads(json.dumps(dict(self.metadata), ensure_ascii=False, default=str)),
|
||||
)
|
||||
|
||||
def as_dict(self) -> dict[str, Any]:
|
||||
value = asdict(self)
|
||||
value["steps"] = list(self.steps)
|
||||
value["depends_on"] = list(self.depends_on)
|
||||
value["required_evidence"] = list(self.required_evidence)
|
||||
value["notification_events"] = list(self.notification_events)
|
||||
return value
|
||||
|
||||
@classmethod
|
||||
def from_dict(cls, value: Mapping[str, Any]) -> "ExecutionStageManifest":
|
||||
return cls(**dict(value))
|
||||
|
||||
|
||||
@dataclass(frozen=True)
|
||||
class ExecutionPlanManifest:
|
||||
plan_id: str
|
||||
source_branch: str
|
||||
source_oid: str
|
||||
target_version: str
|
||||
stages: Sequence[ExecutionStageManifest]
|
||||
release_gate_policy: str = "all_required_stages"
|
||||
schema_version: str = PLAN_SCHEMA_VERSION
|
||||
metadata: Mapping[str, Any] = field(default_factory=dict)
|
||||
|
||||
def __post_init__(self) -> None:
|
||||
for name in ("plan_id", "source_branch", "source_oid", "target_version"):
|
||||
object.__setattr__(self, name, required(getattr(self, name), name))
|
||||
if self.schema_version != PLAN_SCHEMA_VERSION:
|
||||
raise ValueError("unsupported execution plan schema")
|
||||
if self.release_gate_policy != "all_required_stages":
|
||||
raise ValueError("unsupported release gate policy")
|
||||
stages = tuple(self.stages)
|
||||
if not stages:
|
||||
raise ValueError("execution plan requires stages")
|
||||
stage_ids = [item.stage_id for item in stages]
|
||||
task_ids = [item.task_id for item in stages]
|
||||
if len(stage_ids) != len(set(stage_ids)):
|
||||
raise ValueError("execution plan stage_id values must be unique")
|
||||
if len(task_ids) != len(set(task_ids)):
|
||||
raise ValueError("execution plan task_id values must be unique")
|
||||
known = set(stage_ids)
|
||||
for stage in stages:
|
||||
unknown = sorted(set(stage.depends_on) - known)
|
||||
if unknown:
|
||||
raise ValueError(f"stage {stage.stage_id} has unknown dependencies: {unknown}")
|
||||
if stage.stage_id in stage.depends_on:
|
||||
raise ValueError("stage cannot depend on itself")
|
||||
self._assert_acyclic(stages)
|
||||
object.__setattr__(self, "stages", stages)
|
||||
object.__setattr__(
|
||||
self,
|
||||
"metadata",
|
||||
json.loads(json.dumps(dict(self.metadata), ensure_ascii=False, default=str)),
|
||||
)
|
||||
|
||||
@staticmethod
|
||||
def _assert_acyclic(stages: Sequence[ExecutionStageManifest]) -> None:
|
||||
dependencies = {item.stage_id: set(item.depends_on) for item in stages}
|
||||
resolved: set[str] = set()
|
||||
while len(resolved) < len(stages):
|
||||
ready = {
|
||||
stage_id
|
||||
for stage_id, deps in dependencies.items()
|
||||
if stage_id not in resolved and deps.issubset(resolved)
|
||||
}
|
||||
if not ready:
|
||||
raise ValueError("execution plan contains a dependency cycle")
|
||||
resolved.update(ready)
|
||||
|
||||
def as_dict(self) -> dict[str, Any]:
|
||||
return {
|
||||
"schema_version": self.schema_version,
|
||||
"plan_id": self.plan_id,
|
||||
"source_branch": self.source_branch,
|
||||
"source_oid": self.source_oid,
|
||||
"target_version": self.target_version,
|
||||
"release_gate_policy": self.release_gate_policy,
|
||||
"stages": [item.as_dict() for item in self.stages],
|
||||
"metadata": dict(self.metadata),
|
||||
}
|
||||
|
||||
@classmethod
|
||||
def from_dict(cls, value: Mapping[str, Any]) -> "ExecutionPlanManifest":
|
||||
raw = dict(value)
|
||||
raw["stages"] = tuple(
|
||||
ExecutionStageManifest.from_dict(item) for item in raw.get("stages") or ()
|
||||
)
|
||||
return cls(**raw)
|
||||
|
||||
def stage(self, stage_id: str) -> ExecutionStageManifest:
|
||||
normalized = required(stage_id, "stage_id")
|
||||
for stage in self.stages:
|
||||
if stage.stage_id == normalized:
|
||||
return stage
|
||||
raise KeyError(f"execution stage not found: {normalized}")
|
||||
|
||||
|
||||
class SQLiteExecutionPlanStore:
|
||||
"""Durable plan declarations; stage state remains in Truth Registry."""
|
||||
|
||||
def __init__(self, path: str | Path) -> None:
|
||||
self.path = Path(path).resolve()
|
||||
self.path.parent.mkdir(parents=True, exist_ok=True)
|
||||
self._lock = threading.RLock()
|
||||
with self._connect() as connection:
|
||||
connection.executescript(
|
||||
"""
|
||||
CREATE TABLE IF NOT EXISTS execution_plans (
|
||||
plan_id TEXT PRIMARY KEY,
|
||||
manifest_json TEXT NOT NULL,
|
||||
created_at TEXT NOT NULL,
|
||||
updated_at TEXT NOT NULL
|
||||
);
|
||||
"""
|
||||
)
|
||||
|
||||
def _connect(self) -> sqlite3.Connection:
|
||||
connection = sqlite3.connect(str(self.path), timeout=30.0)
|
||||
connection.row_factory = sqlite3.Row
|
||||
connection.execute("PRAGMA journal_mode=WAL")
|
||||
connection.execute("PRAGMA synchronous=FULL")
|
||||
return connection
|
||||
|
||||
@staticmethod
|
||||
def _encode(plan: ExecutionPlanManifest) -> str:
|
||||
return json.dumps(
|
||||
plan.as_dict(),
|
||||
ensure_ascii=False,
|
||||
sort_keys=True,
|
||||
separators=(",", ":"),
|
||||
)
|
||||
|
||||
def save(
|
||||
self,
|
||||
plan: ExecutionPlanManifest,
|
||||
*,
|
||||
allow_source_oid_supersession: bool = False,
|
||||
) -> None:
|
||||
payload = self._encode(plan)
|
||||
now = utc_now()
|
||||
with self._lock, self._connect() as connection:
|
||||
connection.execute("BEGIN IMMEDIATE")
|
||||
existing = connection.execute(
|
||||
"SELECT manifest_json FROM execution_plans WHERE plan_id = ?",
|
||||
(plan.plan_id,),
|
||||
).fetchone()
|
||||
if existing is not None:
|
||||
if existing["manifest_json"] != payload:
|
||||
previous = json.loads(existing["manifest_json"])
|
||||
replacement = plan.as_dict()
|
||||
previous_oid = previous.pop("source_oid", None)
|
||||
replacement_oid = replacement.pop("source_oid", None)
|
||||
if (
|
||||
not allow_source_oid_supersession
|
||||
or previous != replacement
|
||||
or previous_oid == replacement_oid
|
||||
):
|
||||
connection.rollback()
|
||||
raise RuntimeError(
|
||||
"plan_id already exists with another manifest"
|
||||
)
|
||||
connection.execute(
|
||||
"UPDATE execution_plans SET manifest_json = ?, updated_at = ? WHERE plan_id = ?",
|
||||
(payload, now, plan.plan_id),
|
||||
)
|
||||
connection.commit()
|
||||
return
|
||||
connection.rollback()
|
||||
return
|
||||
connection.execute(
|
||||
"INSERT INTO execution_plans VALUES (?, ?, ?, ?)",
|
||||
(plan.plan_id, payload, now, now),
|
||||
)
|
||||
connection.commit()
|
||||
|
||||
def get(self, plan_id: str) -> ExecutionPlanManifest:
|
||||
with self._lock, self._connect() as connection:
|
||||
row = connection.execute(
|
||||
"SELECT manifest_json FROM execution_plans WHERE plan_id = ?",
|
||||
(required(plan_id, "plan_id"),),
|
||||
).fetchone()
|
||||
if row is None:
|
||||
raise KeyError("execution plan not found")
|
||||
value = json.loads(row["manifest_json"])
|
||||
if not isinstance(value, Mapping):
|
||||
raise ValueError("stored execution plan is invalid")
|
||||
return ExecutionPlanManifest.from_dict(value)
|
||||
|
||||
def list(self) -> list[ExecutionPlanManifest]:
|
||||
with self._lock, self._connect() as connection:
|
||||
rows = connection.execute(
|
||||
"SELECT manifest_json FROM execution_plans ORDER BY created_at, plan_id"
|
||||
).fetchall()
|
||||
return [
|
||||
ExecutionPlanManifest.from_dict(json.loads(row["manifest_json"]))
|
||||
for row in rows
|
||||
]
|
||||
|
||||
|
||||
class ExecutionPlanCoordinator:
|
||||
"""Declares dependency-ready stages and evaluates aggregate release gates."""
|
||||
|
||||
def __init__(
|
||||
self,
|
||||
*,
|
||||
task_coordinator: ExternalTaskCoordinator,
|
||||
plan_store: SQLiteExecutionPlanStore,
|
||||
providers: ExecutorProviderRegistry,
|
||||
) -> None:
|
||||
self.task_coordinator = task_coordinator
|
||||
self.plan_store = plan_store
|
||||
self.providers = providers
|
||||
|
||||
@classmethod
|
||||
def from_file(
|
||||
cls,
|
||||
path: str | Path,
|
||||
*,
|
||||
providers: ExecutorProviderRegistry,
|
||||
) -> "ExecutionPlanCoordinator":
|
||||
return cls(
|
||||
task_coordinator=ExternalTaskCoordinator.from_file(path),
|
||||
plan_store=SQLiteExecutionPlanStore(path),
|
||||
providers=providers,
|
||||
)
|
||||
|
||||
@staticmethod
|
||||
def _task_manifest(
|
||||
plan: ExecutionPlanManifest,
|
||||
stage: ExecutionStageManifest,
|
||||
) -> ExecutionTaskManifest:
|
||||
return ExecutionTaskManifest(
|
||||
task_id=stage.task_id,
|
||||
executor=stage.executor_type,
|
||||
source_branch=plan.source_branch,
|
||||
source_oid=plan.source_oid,
|
||||
target_version=plan.target_version,
|
||||
steps=stage.steps,
|
||||
start_deadline_seconds=stage.start_deadline_seconds,
|
||||
heartbeat_timeout_seconds=stage.heartbeat_timeout_seconds,
|
||||
required_evidence=stage.required_evidence,
|
||||
notification_events=stage.notification_events,
|
||||
owner_notification_ref=stage.owner_notification_ref,
|
||||
manifest_version="aios.external-task.v2",
|
||||
)
|
||||
|
||||
def _record(self, task_id: str) -> ExecutionTruthRecord | None:
|
||||
try:
|
||||
return self.task_coordinator.registry.get(task_id)
|
||||
except KeyError:
|
||||
return None
|
||||
|
||||
def _declare_stage(
|
||||
self,
|
||||
plan: ExecutionPlanManifest,
|
||||
stage: ExecutionStageManifest,
|
||||
) -> ExecutionTruthRecord:
|
||||
self.providers.validate_manifest(self._task_manifest(plan, stage))
|
||||
return self.task_coordinator.declare(self._task_manifest(plan, stage))
|
||||
|
||||
def declare(self, plan: ExecutionPlanManifest) -> Mapping[str, Any]:
|
||||
for stage in plan.stages:
|
||||
self.providers.get(stage.executor_type)
|
||||
allow_source_oid_supersession = False
|
||||
try:
|
||||
previous = self.plan_store.get(plan.plan_id)
|
||||
except KeyError:
|
||||
previous = None
|
||||
if previous is not None and previous.source_oid != plan.source_oid:
|
||||
previous_value = previous.as_dict()
|
||||
replacement_value = plan.as_dict()
|
||||
previous_value.pop("source_oid")
|
||||
replacement_value.pop("source_oid")
|
||||
root_records = [
|
||||
self._record(stage.task_id)
|
||||
for stage in previous.stages
|
||||
if not stage.depends_on
|
||||
]
|
||||
allow_source_oid_supersession = bool(
|
||||
previous_value == replacement_value
|
||||
and root_records
|
||||
and all(
|
||||
record is not None
|
||||
and record.state == ExecutionTruthState.NOT_STARTED
|
||||
for record in root_records
|
||||
)
|
||||
)
|
||||
self.plan_store.save(
|
||||
plan,
|
||||
allow_source_oid_supersession=allow_source_oid_supersession,
|
||||
)
|
||||
for stage in plan.stages:
|
||||
if not stage.depends_on:
|
||||
self._declare_stage(plan, stage)
|
||||
return self.snapshot(plan.plan_id)
|
||||
|
||||
def declare_file(self, path: str | Path) -> Mapping[str, Any]:
|
||||
value = json.loads(Path(path).read_text(encoding="utf-8"))
|
||||
if not isinstance(value, Mapping):
|
||||
raise ValueError("execution plan file must contain a JSON object")
|
||||
return self.declare(ExecutionPlanManifest.from_dict(value))
|
||||
|
||||
def dependency_gate(self, plan_id: str, stage_id: str) -> Mapping[str, Any]:
|
||||
plan = self.plan_store.get(plan_id)
|
||||
stage = plan.stage(stage_id)
|
||||
dependencies: list[Mapping[str, Any]] = []
|
||||
passed = True
|
||||
for dependency_id in stage.depends_on:
|
||||
dependency = plan.stage(dependency_id)
|
||||
record = self._record(dependency.task_id)
|
||||
if record is None:
|
||||
gate: Mapping[str, Any] = {
|
||||
"task_id": dependency.task_id,
|
||||
"state": WAITING_DEPENDENCY,
|
||||
"passed": False,
|
||||
"release_blocking": True,
|
||||
}
|
||||
else:
|
||||
gate = self.task_coordinator.gate(dependency.task_id)
|
||||
dependencies.append(
|
||||
{
|
||||
"stage_id": dependency.stage_id,
|
||||
"task_id": dependency.task_id,
|
||||
"gate": gate,
|
||||
}
|
||||
)
|
||||
if not gate["passed"]:
|
||||
passed = False
|
||||
return {
|
||||
"plan_id": plan.plan_id,
|
||||
"stage_id": stage.stage_id,
|
||||
"passed": passed,
|
||||
"release_blocking": not passed,
|
||||
"dependencies": dependencies,
|
||||
}
|
||||
|
||||
def activate_ready(self, plan_id: str) -> list[Mapping[str, Any]]:
|
||||
plan = self.plan_store.get(plan_id)
|
||||
activated: list[Mapping[str, Any]] = []
|
||||
for stage in plan.stages:
|
||||
if self._record(stage.task_id) is not None:
|
||||
continue
|
||||
dependency = self.dependency_gate(plan.plan_id, stage.stage_id)
|
||||
if not dependency["passed"]:
|
||||
continue
|
||||
record = self._declare_stage(plan, stage)
|
||||
activated.append(
|
||||
{
|
||||
"stage_id": stage.stage_id,
|
||||
"task_id": record.task_id,
|
||||
"executor_type": stage.executor_type,
|
||||
"state": record.state.value,
|
||||
}
|
||||
)
|
||||
return activated
|
||||
|
||||
def discover_ready(
|
||||
self,
|
||||
*,
|
||||
plan_id: str,
|
||||
executor_type: str,
|
||||
) -> list[Mapping[str, Any]]:
|
||||
plan = self.plan_store.get(plan_id)
|
||||
self.activate_ready(plan.plan_id)
|
||||
normalized = normalize_executor(executor_type)
|
||||
records = {
|
||||
item.task_id: item
|
||||
for item in list_records(
|
||||
self.task_coordinator.registry.path,
|
||||
executor=normalized,
|
||||
states=(
|
||||
ExecutionTruthState.DECLARED.value,
|
||||
ExecutionTruthState.REGISTERED.value,
|
||||
),
|
||||
)
|
||||
}
|
||||
ready: list[Mapping[str, Any]] = []
|
||||
for stage in plan.stages:
|
||||
if stage.executor_type != normalized or stage.task_id not in records:
|
||||
continue
|
||||
dependency = self.dependency_gate(plan.plan_id, stage.stage_id)
|
||||
if dependency["passed"]:
|
||||
ready.append(
|
||||
{
|
||||
"plan_id": plan.plan_id,
|
||||
"stage": stage.as_dict(),
|
||||
"record": records[stage.task_id].as_dict(),
|
||||
}
|
||||
)
|
||||
return ready
|
||||
|
||||
def snapshot(self, plan_id: str) -> Mapping[str, Any]:
|
||||
plan = self.plan_store.get(plan_id)
|
||||
stages: list[Mapping[str, Any]] = []
|
||||
for stage in plan.stages:
|
||||
record = self._record(stage.task_id)
|
||||
dependency = self.dependency_gate(plan.plan_id, stage.stage_id)
|
||||
if record is None:
|
||||
truth: Mapping[str, Any] = {
|
||||
"task_id": stage.task_id,
|
||||
"state": WAITING_DEPENDENCY,
|
||||
"passed": False,
|
||||
"release_blocking": True,
|
||||
"executor_run_id": None,
|
||||
"executor_id": None,
|
||||
"current_step": 0,
|
||||
"total_steps": len(stage.steps),
|
||||
"evidence": {},
|
||||
"error": {},
|
||||
"notifications": [],
|
||||
}
|
||||
else:
|
||||
truth = self.task_coordinator.status(stage.task_id)
|
||||
stages.append(
|
||||
{
|
||||
"stage": stage.as_dict(),
|
||||
"dependency_gate": dependency,
|
||||
"truth": truth,
|
||||
}
|
||||
)
|
||||
return {
|
||||
"manifest": plan.as_dict(),
|
||||
"stages": stages,
|
||||
}
|
||||
|
||||
def gate(self, plan_id: str) -> Mapping[str, Any]:
|
||||
plan = self.plan_store.get(plan_id)
|
||||
self.activate_ready(plan.plan_id)
|
||||
stages: list[Mapping[str, Any]] = []
|
||||
required_passed = True
|
||||
for stage in plan.stages:
|
||||
dependency = self.dependency_gate(plan.plan_id, stage.stage_id)
|
||||
record = self._record(stage.task_id)
|
||||
if record is None:
|
||||
truth_gate: Mapping[str, Any] = {
|
||||
"task_id": stage.task_id,
|
||||
"state": WAITING_DEPENDENCY,
|
||||
"passed": False,
|
||||
"release_blocking": True,
|
||||
}
|
||||
else:
|
||||
truth_gate = self.task_coordinator.gate(stage.task_id)
|
||||
stage_passed = bool(truth_gate["passed"] and dependency["passed"])
|
||||
if stage.required and not stage_passed:
|
||||
required_passed = False
|
||||
stages.append(
|
||||
{
|
||||
"stage_id": stage.stage_id,
|
||||
"task_id": stage.task_id,
|
||||
"executor_type": stage.executor_type,
|
||||
"role": stage.role,
|
||||
"required": stage.required,
|
||||
"passed": stage_passed,
|
||||
"truth_gate": truth_gate,
|
||||
"dependency_gate": dependency,
|
||||
}
|
||||
)
|
||||
return {
|
||||
"plan_id": plan.plan_id,
|
||||
"target_version": plan.target_version,
|
||||
"policy": plan.release_gate_policy,
|
||||
"passed": required_passed,
|
||||
"release_blocking": not required_passed,
|
||||
"stages": stages,
|
||||
}
|
||||
@@ -1,323 +0,0 @@
|
||||
"""AIOS V2 Agent 执行证据。
|
||||
|
||||
Evidence 按租户隔离并使用原子 JSON 写入。生产模式下，claim、heartbeat
|
||||
和 complete 在落盘前必须通过最小权限 Evidence Grant 授权。
|
||||
"""
|
||||
from __future__ import annotations
|
||||
|
||||
import json
|
||||
import os
|
||||
import threading
|
||||
from dataclasses import asdict, dataclass, field, replace
|
||||
from datetime import datetime, timezone
|
||||
from pathlib import Path
|
||||
from typing import Any, Mapping, Protocol
|
||||
|
||||
from .provenance import ProvenanceDenied, digest_payload
|
||||
|
||||
|
||||
class EvidenceAuthorizationWriter(Protocol):
|
||||
def authorize_evidence_write(self, **values: Any) -> Any: ...
|
||||
|
||||
|
||||
def utc_now() -> str:
|
||||
return datetime.now(timezone.utc).isoformat().replace("+00:00", "Z")
|
||||
|
||||
|
||||
def _required(value: str, label: str) -> str:
|
||||
normalized = str(value or "").strip()
|
||||
if not normalized:
|
||||
raise ValueError(f"{label} is required")
|
||||
return normalized
|
||||
|
||||
|
||||
def _safe(value: Mapping[str, Any] | None) -> dict[str, Any]:
|
||||
return json.loads(json.dumps(dict(value or {}), ensure_ascii=False, default=str))
|
||||
|
||||
|
||||
@dataclass(frozen=True)
|
||||
class ExecutionEvidence:
|
||||
execution_id: str
|
||||
tenant_id: str
|
||||
task_id: str
|
||||
agent_id: str
|
||||
executor: str
|
||||
branch: str
|
||||
status: str = "claimed"
|
||||
progress_completed: int = 0
|
||||
progress_total: int = 1
|
||||
current_step: str = "claim"
|
||||
last_commit: str | None = None
|
||||
test_status: str = "not_run"
|
||||
test_summary: Mapping[str, Any] = field(default_factory=dict)
|
||||
result_summary: Mapping[str, Any] = field(default_factory=dict)
|
||||
claimed_at: str = field(default_factory=utc_now)
|
||||
heartbeat_at: str = field(default_factory=utc_now)
|
||||
completed_at: str | None = None
|
||||
provenance_id: str | None = None
|
||||
run_id: str | None = None
|
||||
last_authorization_id: str | None = None
|
||||
|
||||
def __post_init__(self) -> None:
|
||||
for name in (
|
||||
"execution_id",
|
||||
"tenant_id",
|
||||
"task_id",
|
||||
"agent_id",
|
||||
"executor",
|
||||
"branch",
|
||||
"status",
|
||||
"current_step",
|
||||
"claimed_at",
|
||||
"heartbeat_at",
|
||||
):
|
||||
object.__setattr__(self, name, _required(getattr(self, name), name))
|
||||
if self.progress_completed < 0 or self.progress_total < 1:
|
||||
raise ValueError("invalid progress values")
|
||||
if self.progress_completed > self.progress_total:
|
||||
raise ValueError("progress_completed cannot exceed progress_total")
|
||||
object.__setattr__(self, "test_summary", _safe(self.test_summary))
|
||||
object.__setattr__(self, "result_summary", _safe(self.result_summary))
|
||||
for optional in ("provenance_id", "run_id", "last_authorization_id"):
|
||||
value = getattr(self, optional)
|
||||
object.__setattr__(self, optional, str(value).strip() if value else None)
|
||||
|
||||
|
||||
class ExecutionTracker:
|
||||
"""每个租户、每次执行持久保存一份证据记录。"""
|
||||
|
||||
def __init__(
|
||||
self,
|
||||
root: str | Path,
|
||||
*,
|
||||
provenance_writer: EvidenceAuthorizationWriter | None = None,
|
||||
require_provenance: bool = False,
|
||||
) -> None:
|
||||
self.root = Path(root).resolve()
|
||||
self.root.mkdir(parents=True, exist_ok=True)
|
||||
self.provenance_writer = provenance_writer
|
||||
self.require_provenance = bool(require_provenance)
|
||||
if self.require_provenance and self.provenance_writer is None:
|
||||
raise ValueError("production evidence tracking requires a provenance writer")
|
||||
self._lock = threading.RLock()
|
||||
|
||||
@staticmethod
|
||||
def _component(value: str) -> str:
|
||||
normalized = _required(value, "path component")
|
||||
if normalized in {".", ".."} or "/" in normalized or "\\" in normalized:
|
||||
raise ValueError("invalid evidence path component")
|
||||
return normalized
|
||||
|
||||
def _path(self, tenant_id: str, execution_id: str) -> Path:
|
||||
tenant = self._component(tenant_id)
|
||||
execution = self._component(execution_id)
|
||||
return self.root / tenant / f"{execution}.json"
|
||||
|
||||
def _authorize(
|
||||
self,
|
||||
evidence: ExecutionEvidence,
|
||||
*,
|
||||
operation: str,
|
||||
principal_id: str | None,
|
||||
provenance_id: str | None,
|
||||
run_id: str | None,
|
||||
changes: Mapping[str, Any],
|
||||
) -> str | None:
|
||||
if not self.require_provenance:
|
||||
return None
|
||||
if self.provenance_writer is None:
|
||||
raise RuntimeError("Run Provenance writer is not configured")
|
||||
effective_provenance = provenance_id or evidence.provenance_id
|
||||
effective_run = run_id or evidence.run_id
|
||||
if not effective_provenance or not effective_run or not principal_id:
|
||||
raise RuntimeError(
|
||||
"production evidence write requires provenance_id, run_id and principal_id"
|
||||
)
|
||||
request_digest = digest_payload(
|
||||
{
|
||||
"operation": operation,
|
||||
"execution_id": evidence.execution_id,
|
||||
"tenant_id": evidence.tenant_id,
|
||||
"task_id": evidence.task_id,
|
||||
"agent_id": evidence.agent_id,
|
||||
"executor": evidence.executor,
|
||||
"branch": evidence.branch,
|
||||
"changes": dict(changes),
|
||||
}
|
||||
)
|
||||
try:
|
||||
authorization = self.provenance_writer.authorize_evidence_write(
|
||||
provenance_id=effective_provenance,
|
||||
run_id=effective_run,
|
||||
tenant_id=evidence.tenant_id,
|
||||
task_id=evidence.task_id,
|
||||
agent_id=evidence.agent_id,
|
||||
principal_id=principal_id,
|
||||
request_digest=request_digest,
|
||||
)
|
||||
except ProvenanceDenied as exc:
|
||||
raise RuntimeError(f"Run Provenance denied evidence write: {exc}") from exc
|
||||
return authorization.authorization_id
|
||||
|
||||
def claim(
|
||||
self,
|
||||
evidence: ExecutionEvidence,
|
||||
*,
|
||||
principal_id: str | None = None,
|
||||
provenance_id: str | None = None,
|
||||
run_id: str | None = None,
|
||||
) -> ExecutionEvidence:
|
||||
path = self._path(evidence.tenant_id, evidence.execution_id)
|
||||
with self._lock:
|
||||
if path.exists():
|
||||
current = self._read(path)
|
||||
if current.task_id != evidence.task_id or current.agent_id != evidence.agent_id:
|
||||
raise RuntimeError("execution_id already belongs to another task")
|
||||
if self.require_provenance and (
|
||||
current.provenance_id != (provenance_id or evidence.provenance_id)
|
||||
or current.run_id != (run_id or evidence.run_id)
|
||||
):
|
||||
raise RuntimeError(
|
||||
"execution_id already belongs to another provenance context"
|
||||
)
|
||||
return current
|
||||
effective_provenance = provenance_id or evidence.provenance_id
|
||||
effective_run = run_id or evidence.run_id
|
||||
authorization_id = self._authorize(
|
||||
evidence,
|
||||
operation="claim",
|
||||
principal_id=principal_id,
|
||||
provenance_id=effective_provenance,
|
||||
run_id=effective_run,
|
||||
changes={"status": evidence.status, "current_step": evidence.current_step},
|
||||
)
|
||||
persisted = replace(
|
||||
evidence,
|
||||
provenance_id=effective_provenance,
|
||||
run_id=effective_run,
|
||||
last_authorization_id=authorization_id,
|
||||
)
|
||||
self._write(path, persisted)
|
||||
return persisted
|
||||
|
||||
def heartbeat(
|
||||
self,
|
||||
*,
|
||||
tenant_id: str,
|
||||
execution_id: str,
|
||||
status: str | None = None,
|
||||
current_step: str | None = None,
|
||||
progress_completed: int | None = None,
|
||||
progress_total: int | None = None,
|
||||
last_commit: str | None = None,
|
||||
principal_id: str | None = None,
|
||||
provenance_id: str | None = None,
|
||||
run_id: str | None = None,
|
||||
) -> ExecutionEvidence:
|
||||
path = self._path(tenant_id, execution_id)
|
||||
with self._lock:
|
||||
current = self._read(path)
|
||||
changes = {
|
||||
"status": status or current.status,
|
||||
"current_step": current_step or current.current_step,
|
||||
"progress_completed": (
|
||||
progress_completed
|
||||
if progress_completed is not None
|
||||
else current.progress_completed
|
||||
),
|
||||
"progress_total": (
|
||||
progress_total if progress_total is not None else current.progress_total
|
||||
),
|
||||
"last_commit": last_commit or current.last_commit,
|
||||
}
|
||||
authorization_id = self._authorize(
|
||||
current,
|
||||
operation="heartbeat",
|
||||
principal_id=principal_id,
|
||||
provenance_id=provenance_id,
|
||||
run_id=run_id,
|
||||
changes=changes,
|
||||
)
|
||||
updated = replace(
|
||||
current,
|
||||
**changes,
|
||||
last_authorization_id=authorization_id or current.last_authorization_id,
|
||||
heartbeat_at=utc_now(),
|
||||
)
|
||||
self._write(path, updated)
|
||||
return updated
|
||||
|
||||
def complete(
|
||||
self,
|
||||
*,
|
||||
tenant_id: str,
|
||||
execution_id: str,
|
||||
status: str,
|
||||
test_status: str,
|
||||
test_summary: Mapping[str, Any] | None = None,
|
||||
result_summary: Mapping[str, Any] | None = None,
|
||||
last_commit: str | None = None,
|
||||
principal_id: str | None = None,
|
||||
provenance_id: str | None = None,
|
||||
run_id: str | None = None,
|
||||
) -> ExecutionEvidence:
|
||||
path = self._path(tenant_id, execution_id)
|
||||
with self._lock:
|
||||
current = self._read(path)
|
||||
changes = {
|
||||
"status": _required(status, "status"),
|
||||
"current_step": "complete",
|
||||
"progress_completed": current.progress_total,
|
||||
"last_commit": last_commit or current.last_commit,
|
||||
"test_status": _required(test_status, "test_status"),
|
||||
"test_summary": _safe(test_summary),
|
||||
"result_summary": _safe(result_summary),
|
||||
}
|
||||
authorization_id = self._authorize(
|
||||
current,
|
||||
operation="complete",
|
||||
principal_id=principal_id,
|
||||
provenance_id=provenance_id,
|
||||
run_id=run_id,
|
||||
changes=changes,
|
||||
)
|
||||
updated = replace(
|
||||
current,
|
||||
**changes,
|
||||
last_authorization_id=authorization_id or current.last_authorization_id,
|
||||
heartbeat_at=utc_now(),
|
||||
completed_at=utc_now(),
|
||||
)
|
||||
self._write(path, updated)
|
||||
return updated
|
||||
|
||||
def get(self, *, tenant_id: str, execution_id: str) -> ExecutionEvidence:
|
||||
return self._read(self._path(tenant_id, execution_id))
|
||||
|
||||
def list(self, *, tenant_id: str) -> list[ExecutionEvidence]:
|
||||
tenant_dir = self.root / self._component(tenant_id)
|
||||
if not tenant_dir.exists():
|
||||
return []
|
||||
records = [self._read(path) for path in tenant_dir.glob("*.json")]
|
||||
return sorted(records, key=lambda item: (item.heartbeat_at, item.execution_id), reverse=True)
|
||||
|
||||
@staticmethod
|
||||
def _read(path: Path) -> ExecutionEvidence:
|
||||
try:
|
||||
value = json.loads(path.read_text(encoding="utf-8"))
|
||||
except FileNotFoundError as exc:
|
||||
raise KeyError("execution evidence not found") from exc
|
||||
if not isinstance(value, Mapping):
|
||||
raise RuntimeError("invalid execution evidence file")
|
||||
return ExecutionEvidence(**dict(value))
|
||||
|
||||
@staticmethod
|
||||
def _write(path: Path, evidence: ExecutionEvidence) -> None:
|
||||
path.parent.mkdir(parents=True, exist_ok=True)
|
||||
temporary = path.with_suffix(f".tmp-{os.getpid()}")
|
||||
temporary.write_text(
|
||||
json.dumps(asdict(evidence), ensure_ascii=False, sort_keys=True, indent=2) + "\n",
|
||||
encoding="utf-8",
|
||||
)
|
||||
os.chmod(temporary, 0o640)
|
||||
os.replace(temporary, path)
|
||||
@@ -1,204 +0,0 @@
|
||||
"""Persistent and portable AIOS executor provider catalog.
|
||||
|
||||
The catalog contains descriptors only: provider names, protocol/adapter versions,
|
||||
trust roles, capabilities and configuration schema identifiers. Credentials,
|
||||
endpoints and runtime secrets are intentionally excluded and must be resolved in
|
||||
the destination environment.
|
||||
"""
|
||||
from __future__ import annotations
|
||||
|
||||
import hashlib
|
||||
import json
|
||||
import os
|
||||
import threading
|
||||
from dataclasses import dataclass
|
||||
from pathlib import Path
|
||||
from typing import Any, Mapping, Sequence
|
||||
|
||||
from .executor_protocol import (
|
||||
EXECUTOR_PROTOCOL_VERSION,
|
||||
DescriptorOnlyProvider,
|
||||
ExecutorProvider,
|
||||
ExecutorProviderDescriptor,
|
||||
ExecutorProviderRegistry,
|
||||
default_provider_registry,
|
||||
)
|
||||
|
||||
CATALOG_SCHEMA_VERSION = "aios.executor.catalog.v1"
|
||||
MIGRATION_SCHEMA_VERSION = "aios.executor.migration.v1"
|
||||
|
||||
|
||||
def canonical_json_bytes(value: Mapping[str, Any]) -> bytes:
|
||||
return json.dumps(
|
||||
dict(value),
|
||||
ensure_ascii=False,
|
||||
sort_keys=True,
|
||||
separators=(",", ":"),
|
||||
default=str,
|
||||
).encode("utf-8")
|
||||
|
||||
|
||||
def sha256_payload(value: Mapping[str, Any]) -> str:
|
||||
return hashlib.sha256(canonical_json_bytes(value)).hexdigest()
|
||||
|
||||
|
||||
@dataclass(frozen=True)
|
||||
class ExecutorCatalogSnapshot:
|
||||
catalog: Mapping[str, Any]
|
||||
catalog_sha256: str
|
||||
path: str
|
||||
|
||||
def as_dict(self) -> dict[str, Any]:
|
||||
return {
|
||||
"catalog": dict(self.catalog),
|
||||
"catalog_sha256": self.catalog_sha256,
|
||||
"path": self.path,
|
||||
}
|
||||
|
||||
|
||||
class FileExecutorCatalogStore:
|
||||
"""Atomic file store for provider descriptors and migration packages."""
|
||||
|
||||
def __init__(self, path: str | Path) -> None:
|
||||
self.path = Path(path).resolve()
|
||||
self.path.parent.mkdir(parents=True, exist_ok=True)
|
||||
self._lock = threading.RLock()
|
||||
|
||||
@staticmethod
|
||||
def _validate_catalog(value: Mapping[str, Any]) -> ExecutorProviderRegistry:
|
||||
if value.get("schema_version") != CATALOG_SCHEMA_VERSION:
|
||||
raise ValueError("unsupported executor catalog schema")
|
||||
if value.get("protocol_version") != EXECUTOR_PROTOCOL_VERSION:
|
||||
raise ValueError("executor catalog protocol mismatch")
|
||||
providers = value.get("providers")
|
||||
if not isinstance(providers, Sequence) or isinstance(providers, (str, bytes)):
|
||||
raise ValueError("executor catalog providers must be an array")
|
||||
return ExecutorProviderRegistry.import_catalog(value)
|
||||
|
||||
def initialize_defaults(self) -> ExecutorCatalogSnapshot:
|
||||
with self._lock:
|
||||
if self.path.exists():
|
||||
return self.load()
|
||||
return self.save(default_provider_registry())
|
||||
|
||||
def load(self) -> ExecutorCatalogSnapshot:
|
||||
with self._lock:
|
||||
value = json.loads(self.path.read_text(encoding="utf-8"))
|
||||
if not isinstance(value, Mapping):
|
||||
raise ValueError("executor catalog must contain a JSON object")
|
||||
registry = self._validate_catalog(value)
|
||||
normalized = registry.export_catalog()
|
||||
return ExecutorCatalogSnapshot(
|
||||
catalog=normalized,
|
||||
catalog_sha256=sha256_payload(normalized),
|
||||
path=str(self.path),
|
||||
)
|
||||
|
||||
def registry(
|
||||
self,
|
||||
*,
|
||||
provider_factories: Mapping[str, ExecutorProvider] | None = None,
|
||||
) -> ExecutorProviderRegistry:
|
||||
snapshot = self.load()
|
||||
return ExecutorProviderRegistry.import_catalog(
|
||||
snapshot.catalog,
|
||||
provider_factories=provider_factories,
|
||||
)
|
||||
|
||||
def save(self, registry: ExecutorProviderRegistry) -> ExecutorCatalogSnapshot:
|
||||
catalog = registry.export_catalog()
|
||||
self._validate_catalog(catalog)
|
||||
encoded = json.dumps(
|
||||
catalog,
|
||||
ensure_ascii=False,
|
||||
sort_keys=True,
|
||||
indent=2,
|
||||
) + "\n"
|
||||
with self._lock:
|
||||
temporary = self.path.with_suffix(f".tmp-{os.getpid()}")
|
||||
temporary.write_text(encoded, encoding="utf-8")
|
||||
os.chmod(temporary, 0o640)
|
||||
os.replace(temporary, self.path)
|
||||
return ExecutorCatalogSnapshot(
|
||||
catalog=catalog,
|
||||
catalog_sha256=sha256_payload(catalog),
|
||||
path=str(self.path),
|
||||
)
|
||||
|
||||
def upsert_descriptor(
|
||||
self,
|
||||
descriptor: ExecutorProviderDescriptor,
|
||||
) -> ExecutorCatalogSnapshot:
|
||||
with self._lock:
|
||||
if self.path.exists():
|
||||
registry = self.registry()
|
||||
else:
|
||||
registry = default_provider_registry()
|
||||
try:
|
||||
registry.register(DescriptorOnlyProvider(descriptor), replace=True)
|
||||
except KeyError:
|
||||
registry.register(DescriptorOnlyProvider(descriptor))
|
||||
return self.save(registry)
|
||||
|
||||
def export_migration_package(
|
||||
self,
|
||||
*,
|
||||
source_environment: str,
|
||||
required_executor_types: Sequence[str] = (),
|
||||
) -> Mapping[str, Any]:
|
||||
snapshot = self.load()
|
||||
registry = ExecutorProviderRegistry.import_catalog(snapshot.catalog)
|
||||
required = tuple(sorted({str(item).strip().lower() for item in required_executor_types if str(item).strip()}))
|
||||
if required:
|
||||
available = {item.executor_type for item in registry.list_descriptors()}
|
||||
missing = sorted(set(required) - available)
|
||||
if missing:
|
||||
raise ValueError(f"migration package is missing providers: {missing}")
|
||||
package = {
|
||||
"schema_version": MIGRATION_SCHEMA_VERSION,
|
||||
"source_environment": str(source_environment or "").strip(),
|
||||
"catalog": snapshot.catalog,
|
||||
"catalog_sha256": snapshot.catalog_sha256,
|
||||
"required_executor_types": list(required),
|
||||
"secret_values_included": False,
|
||||
}
|
||||
if not package["source_environment"]:
|
||||
raise ValueError("source_environment is required")
|
||||
return {
|
||||
**package,
|
||||
"package_sha256": sha256_payload(package),
|
||||
}
|
||||
|
||||
@classmethod
|
||||
def import_migration_package(
|
||||
cls,
|
||||
value: Mapping[str, Any],
|
||||
*,
|
||||
destination_path: str | Path,
|
||||
destination_environment: str,
|
||||
provider_factories: Mapping[str, ExecutorProvider] | None = None,
|
||||
) -> ExecutorCatalogSnapshot:
|
||||
if value.get("schema_version") != MIGRATION_SCHEMA_VERSION:
|
||||
raise ValueError("unsupported executor migration schema")
|
||||
if value.get("secret_values_included") is not False:
|
||||
raise ValueError("executor migration package must not contain secrets")
|
||||
package_without_hash = {key: item for key, item in value.items() if key != "package_sha256"}
|
||||
if sha256_payload(package_without_hash) != value.get("package_sha256"):
|
||||
raise ValueError("executor migration package hash mismatch")
|
||||
catalog = value.get("catalog")
|
||||
if not isinstance(catalog, Mapping):
|
||||
raise ValueError("executor migration package has no catalog")
|
||||
if sha256_payload(catalog) != value.get("catalog_sha256"):
|
||||
raise ValueError("executor catalog hash mismatch")
|
||||
registry = ExecutorProviderRegistry.import_catalog(
|
||||
catalog,
|
||||
provider_factories=provider_factories,
|
||||
)
|
||||
required = tuple(value.get("required_executor_types") or ())
|
||||
available = {item.executor_type for item in registry.list_descriptors()}
|
||||
missing = sorted(set(required) - available)
|
||||
if missing:
|
||||
raise ValueError(f"destination provider factories are missing: {missing}")
|
||||
if not str(destination_environment or "").strip():
|
||||
raise ValueError("destination_environment is required")
|
||||
return cls(destination_path).save(registry)
|
||||
@@ -1,441 +0,0 @@
|
||||
"""Versioned, extensible executor protocol for AIOS external tasks.
|
||||
|
||||
The core lifecycle is executor-neutral. OpenClaw, Hermes, Codex and the scoped
|
||||
ChatGPT supervisor are built-in
|
||||
providers, not hard-coded protocol branches. Future providers register a
|
||||
versioned descriptor and use the same Truth Registry, evidence, notification
|
||||
and release-gate mechanisms without modifying the lifecycle state machine.
|
||||
"""
|
||||
from __future__ import annotations
|
||||
|
||||
import json
|
||||
import re
|
||||
import threading
|
||||
from dataclasses import asdict, dataclass, field
|
||||
from typing import Any, Mapping, Protocol, Sequence
|
||||
|
||||
from .external_task_control import ExternalTaskCoordinator
|
||||
from .task_execution_registry import ExecutionTaskManifest, ExecutionTruthRecord
|
||||
|
||||
EXECUTOR_PROTOCOL_VERSION = "aios.executor.v1"
|
||||
_PROVIDER_NAME = re.compile(r"^[a-z][a-z0-9._-]{1,63}$")
|
||||
_VERSION = re.compile(r"^[0-9]+(?:\.[0-9]+){0,2}(?:[-+][A-Za-z0-9._-]+)?$")
|
||||
DISCOVERABLE_STATES: Sequence[str] = ("DECLARED", "REGISTERED")
|
||||
|
||||
|
||||
def normalize_executor(value: str) -> str:
|
||||
normalized = str(value or "").strip().lower()
|
||||
if not _PROVIDER_NAME.fullmatch(normalized):
|
||||
raise ValueError("executor type must be a lowercase provider identifier")
|
||||
return normalized
|
||||
|
||||
|
||||
def _major(version: str) -> int:
|
||||
normalized = str(version or "").strip()
|
||||
if not _VERSION.fullmatch(normalized):
|
||||
raise ValueError(f"invalid version: {version}")
|
||||
return int(normalized.split(".", 1)[0])
|
||||
|
||||
|
||||
@dataclass(frozen=True)
|
||||
class ExecutorProviderDescriptor:
|
||||
"""Portable provider metadata stored without credentials or runtime secrets."""
|
||||
|
||||
executor_type: str
|
||||
adapter_version: str
|
||||
protocol_version: str = EXECUTOR_PROTOCOL_VERSION
|
||||
trust_roles: Sequence[str] = ()
|
||||
capabilities: Sequence[str] = ()
|
||||
configuration_schema: str = "aios.executor.config.v1"
|
||||
portable: bool = True
|
||||
metadata: Mapping[str, Any] = field(default_factory=dict)
|
||||
|
||||
def __post_init__(self) -> None:
|
||||
object.__setattr__(self, "executor_type", normalize_executor(self.executor_type))
|
||||
adapter_version = str(self.adapter_version or "").strip()
|
||||
if not _VERSION.fullmatch(adapter_version):
|
||||
raise ValueError("adapter_version must be version-like")
|
||||
object.__setattr__(self, "adapter_version", adapter_version)
|
||||
protocol_version = str(self.protocol_version or "").strip()
|
||||
if not protocol_version.startswith("aios.executor.v"):
|
||||
raise ValueError("unsupported executor protocol namespace")
|
||||
int(protocol_version.rsplit("v", 1)[1])
|
||||
object.__setattr__(self, "protocol_version", protocol_version)
|
||||
roles = tuple(sorted({str(item).strip() for item in self.trust_roles if str(item).strip()}))
|
||||
if not roles:
|
||||
raise ValueError("provider must declare at least one trust role")
|
||||
capabilities = tuple(
|
||||
sorted({str(item).strip() for item in self.capabilities if str(item).strip()})
|
||||
)
|
||||
object.__setattr__(self, "trust_roles", roles)
|
||||
object.__setattr__(self, "capabilities", capabilities)
|
||||
object.__setattr__(
|
||||
self,
|
||||
"configuration_schema",
|
||||
str(self.configuration_schema or "").strip(),
|
||||
)
|
||||
object.__setattr__(
|
||||
self,
|
||||
"metadata",
|
||||
json.loads(json.dumps(dict(self.metadata), ensure_ascii=False, default=str)),
|
||||
)
|
||||
|
||||
def as_dict(self) -> dict[str, Any]:
|
||||
value = asdict(self)
|
||||
value["trust_roles"] = list(self.trust_roles)
|
||||
value["capabilities"] = list(self.capabilities)
|
||||
return value
|
||||
|
||||
@classmethod
|
||||
def from_dict(cls, value: Mapping[str, Any]) -> "ExecutorProviderDescriptor":
|
||||
return cls(**dict(value))
|
||||
|
||||
def protocol_compatible_with(self, other: "ExecutorProviderDescriptor") -> bool:
|
||||
return (
|
||||
self.executor_type == other.executor_type
|
||||
and self.protocol_version == other.protocol_version
|
||||
and _major(self.adapter_version) == _major(other.adapter_version)
|
||||
)
|
||||
|
||||
|
||||
class ExternalExecutorAdapter(Protocol):
|
||||
"""Runtime-specific implementation behind the common lifecycle."""
|
||||
|
||||
descriptor: ExecutorProviderDescriptor
|
||||
|
||||
def discover(self) -> Sequence[ExecutionTruthRecord]: ...
|
||||
def execute(self, manifest: ExecutionTaskManifest) -> Mapping[str, Any]: ...
|
||||
def notify_owner(self, payload: Mapping[str, Any]) -> str: ...
|
||||
|
||||
|
||||
class ExecutorProvider(Protocol):
|
||||
descriptor: ExecutorProviderDescriptor
|
||||
|
||||
def validate_manifest(self, manifest: ExecutionTaskManifest) -> None: ...
|
||||
def build_adapter(self, configuration: Mapping[str, Any]) -> ExternalExecutorAdapter: ...
|
||||
|
||||
|
||||
class DescriptorOnlyProvider:
|
||||
"""Default provider used when lifecycle integration is supplied externally."""
|
||||
|
||||
def __init__(self, descriptor: ExecutorProviderDescriptor) -> None:
|
||||
self.descriptor = descriptor
|
||||
|
||||
def validate_manifest(self, manifest: ExecutionTaskManifest) -> None:
|
||||
if normalize_executor(manifest.executor) != self.descriptor.executor_type:
|
||||
raise ValueError("manifest executor does not match provider")
|
||||
|
||||
def build_adapter(self, configuration: Mapping[str, Any]) -> ExternalExecutorAdapter:
|
||||
raise RuntimeError(
|
||||
f"provider {self.descriptor.executor_type} requires an external adapter factory"
|
||||
)
|
||||
|
||||
|
||||
class ExecutorProviderRegistry:
|
||||
"""Thread-safe registry supporting runtime registration and catalog migration."""
|
||||
|
||||
def __init__(self, providers: Sequence[ExecutorProvider] = ()) -> None:
|
||||
self._lock = threading.RLock()
|
||||
self._providers: dict[str, ExecutorProvider] = {}
|
||||
for provider in providers:
|
||||
self.register(provider)
|
||||
|
||||
def register(self, provider: ExecutorProvider, *, replace: bool = False) -> None:
|
||||
descriptor = provider.descriptor
|
||||
key = normalize_executor(descriptor.executor_type)
|
||||
with self._lock:
|
||||
current = self._providers.get(key)
|
||||
if current is not None and not replace:
|
||||
raise ValueError(f"executor provider already registered: {key}")
|
||||
if current is not None and not descriptor.protocol_compatible_with(
|
||||
current.descriptor
|
||||
):
|
||||
raise ValueError(
|
||||
f"replacement provider is incompatible with registered provider: {key}"
|
||||
)
|
||||
self._providers[key] = provider
|
||||
|
||||
def unregister(self, executor_type: str) -> ExecutorProvider:
|
||||
key = normalize_executor(executor_type)
|
||||
with self._lock:
|
||||
try:
|
||||
return self._providers.pop(key)
|
||||
except KeyError as exc:
|
||||
raise KeyError(f"executor provider is not registered: {key}") from exc
|
||||
|
||||
def get(self, executor_type: str) -> ExecutorProvider:
|
||||
key = normalize_executor(executor_type)
|
||||
with self._lock:
|
||||
provider = self._providers.get(key)
|
||||
if provider is None:
|
||||
raise KeyError(f"executor provider is not registered: {key}")
|
||||
return provider
|
||||
|
||||
def descriptor(self, executor_type: str) -> ExecutorProviderDescriptor:
|
||||
return self.get(executor_type).descriptor
|
||||
|
||||
def validate_manifest(self, manifest: ExecutionTaskManifest) -> None:
|
||||
self.get(manifest.executor).validate_manifest(manifest)
|
||||
|
||||
def trusted(
|
||||
self,
|
||||
*,
|
||||
executor_type: str,
|
||||
roles: Sequence[str],
|
||||
platform_admin: bool = False,
|
||||
) -> bool:
|
||||
if platform_admin or "platform_admin" in set(roles):
|
||||
return True
|
||||
descriptor = self.descriptor(executor_type)
|
||||
return bool(set(descriptor.trust_roles).intersection(set(roles)))
|
||||
|
||||
def list_descriptors(self) -> tuple[ExecutorProviderDescriptor, ...]:
|
||||
with self._lock:
|
||||
return tuple(
|
||||
self._providers[key].descriptor for key in sorted(self._providers)
|
||||
)
|
||||
|
||||
def export_catalog(self) -> Mapping[str, Any]:
|
||||
return {
|
||||
"schema_version": "aios.executor.catalog.v1",
|
||||
"protocol_version": EXECUTOR_PROTOCOL_VERSION,
|
||||
"providers": [item.as_dict() for item in self.list_descriptors()],
|
||||
}
|
||||
|
||||
@classmethod
|
||||
def import_catalog(
|
||||
cls,
|
||||
value: Mapping[str, Any],
|
||||
*,
|
||||
provider_factories: Mapping[str, ExecutorProvider] | None = None,
|
||||
) -> "ExecutorProviderRegistry":
|
||||
if value.get("schema_version") != "aios.executor.catalog.v1":
|
||||
raise ValueError("unsupported executor catalog schema")
|
||||
if value.get("protocol_version") != EXECUTOR_PROTOCOL_VERSION:
|
||||
raise ValueError("executor catalog protocol mismatch")
|
||||
factories = dict(provider_factories or {})
|
||||
providers: list[ExecutorProvider] = []
|
||||
for raw in value.get("providers") or ():
|
||||
descriptor = ExecutorProviderDescriptor.from_dict(raw)
|
||||
provider = factories.get(descriptor.executor_type)
|
||||
if provider is not None:
|
||||
if not provider.descriptor.protocol_compatible_with(descriptor):
|
||||
raise ValueError(
|
||||
f"provider factory does not match imported descriptor: {descriptor.executor_type}"
|
||||
)
|
||||
providers.append(provider)
|
||||
else:
|
||||
providers.append(DescriptorOnlyProvider(descriptor))
|
||||
return cls(providers)
|
||||
|
||||
|
||||
BUILTIN_PROVIDER_DESCRIPTORS: Sequence[ExecutorProviderDescriptor] = (
|
||||
ExecutorProviderDescriptor(
|
||||
executor_type="openclaw",
|
||||
adapter_version="2.1.0",
|
||||
trust_roles=("runtime", "openclaw_executor"),
|
||||
capabilities=(
|
||||
"deploy",
|
||||
"http_runtime",
|
||||
"owner_notification",
|
||||
"healthcheck",
|
||||
"rollback",
|
||||
),
|
||||
configuration_schema="aios.executor.openclaw.config.v1",
|
||||
metadata={"official": True},
|
||||
),
|
||||
ExecutorProviderDescriptor(
|
||||
executor_type="hermes",
|
||||
adapter_version="2.1.0",
|
||||
trust_roles=("runtime", "hermes_executor"),
|
||||
capabilities=(
|
||||
"queue",
|
||||
"lease",
|
||||
"worker",
|
||||
"runtime_validation",
|
||||
"restart_recovery",
|
||||
),
|
||||
configuration_schema="aios.executor.hermes.config.v1",
|
||||
metadata={"official": True},
|
||||
),
|
||||
ExecutorProviderDescriptor(
|
||||
executor_type="codex",
|
||||
adapter_version="2.1.0",
|
||||
trust_roles=("codex", "codex_executor"),
|
||||
capabilities=("code", "test", "docs", "gitops_patch", "security_review"),
|
||||
configuration_schema="aios.executor.codex.config.v1",
|
||||
metadata={"official": True},
|
||||
),
|
||||
ExecutorProviderDescriptor(
|
||||
executor_type="chatgpt-supervisor",
|
||||
adapter_version="2.1.0",
|
||||
trust_roles=("chatgpt_supervisor",),
|
||||
capabilities=(
|
||||
"acceptance",
|
||||
"deploy",
|
||||
"evidence",
|
||||
"healthcheck",
|
||||
"rollback",
|
||||
"wechat_simulation",
|
||||
),
|
||||
configuration_schema="aios.executor.chatgpt-supervisor.config.v1",
|
||||
metadata={"official": True, "production_mutation_allowed": False},
|
||||
),
|
||||
)
|
||||
|
||||
|
||||
def default_provider_registry() -> ExecutorProviderRegistry:
|
||||
return ExecutorProviderRegistry(
|
||||
[DescriptorOnlyProvider(item) for item in BUILTIN_PROVIDER_DESCRIPTORS]
|
||||
)
|
||||
|
||||
|
||||
def trusted_for_executor(
|
||||
*,
|
||||
executor: str,
|
||||
roles: Sequence[str],
|
||||
platform_admin: bool = False,
|
||||
registry: ExecutorProviderRegistry | None = None,
|
||||
) -> bool:
|
||||
return (registry or default_provider_registry()).trusted(
|
||||
executor_type=executor,
|
||||
roles=roles,
|
||||
platform_admin=platform_admin,
|
||||
)
|
||||
|
||||
|
||||
@dataclass(frozen=True)
|
||||
class ExecutorIdentity:
|
||||
executor_type: str
|
||||
executor_id: str
|
||||
executor_run_id: str
|
||||
protocol_version: str = EXECUTOR_PROTOCOL_VERSION
|
||||
|
||||
def __post_init__(self) -> None:
|
||||
object.__setattr__(self, "executor_type", normalize_executor(self.executor_type))
|
||||
for name in ("executor_id", "executor_run_id"):
|
||||
value = str(getattr(self, name) or "").strip()
|
||||
if not value:
|
||||
raise ValueError(f"{name} is required")
|
||||
object.__setattr__(self, name, value)
|
||||
if self.protocol_version != EXECUTOR_PROTOCOL_VERSION:
|
||||
raise ValueError("executor identity protocol mismatch")
|
||||
|
||||
|
||||
class ExecutorLifecycleSession:
|
||||
"""Executor-neutral lifecycle facade used by every registered provider."""
|
||||
|
||||
def __init__(
|
||||
self,
|
||||
coordinator: ExternalTaskCoordinator,
|
||||
identity: ExecutorIdentity,
|
||||
*,
|
||||
registry: ExecutorProviderRegistry | None = None,
|
||||
) -> None:
|
||||
self.coordinator = coordinator
|
||||
self.identity = identity
|
||||
self.registry = registry or default_provider_registry()
|
||||
self.registry.get(identity.executor_type)
|
||||
|
||||
def _assert_manifest(self, task_id: str) -> ExecutionTaskManifest:
|
||||
record = self.coordinator.registry.get(task_id)
|
||||
manifest = record.manifest
|
||||
self.registry.validate_manifest(manifest)
|
||||
if normalize_executor(manifest.executor) != self.identity.executor_type:
|
||||
raise PermissionError(
|
||||
f"task executor is {manifest.executor}, not {self.identity.executor_type}"
|
||||
)
|
||||
return manifest
|
||||
|
||||
def register(self, task_id: str) -> ExecutionTruthRecord:
|
||||
self._assert_manifest(task_id)
|
||||
return self.coordinator.register(
|
||||
task_id,
|
||||
executor_run_id=self.identity.executor_run_id,
|
||||
)
|
||||
|
||||
def retry_not_started(self, task_id: str) -> ExecutionTruthRecord:
|
||||
self._assert_manifest(task_id)
|
||||
return self.coordinator.retry_not_started(
|
||||
task_id,
|
||||
executor_run_id=self.identity.executor_run_id,
|
||||
)
|
||||
|
||||
def claim(self, task_id: str) -> ExecutionTruthRecord:
|
||||
self._assert_manifest(task_id)
|
||||
return self.coordinator.claim(
|
||||
task_id,
|
||||
executor_run_id=self.identity.executor_run_id,
|
||||
executor_id=self.identity.executor_id,
|
||||
)
|
||||
|
||||
def start(self, task_id: str) -> ExecutionTruthRecord:
|
||||
self._assert_manifest(task_id)
|
||||
return self.coordinator.start(
|
||||
task_id,
|
||||
executor_run_id=self.identity.executor_run_id,
|
||||
executor_id=self.identity.executor_id,
|
||||
)
|
||||
|
||||
def heartbeat(self, task_id: str, *, current_step: int) -> ExecutionTruthRecord:
|
||||
self._assert_manifest(task_id)
|
||||
return self.coordinator.heartbeat(
|
||||
task_id,
|
||||
executor_run_id=self.identity.executor_run_id,
|
||||
executor_id=self.identity.executor_id,
|
||||
current_step=current_step,
|
||||
)
|
||||
|
||||
def succeed(
|
||||
self,
|
||||
task_id: str,
|
||||
*,
|
||||
evidence: Mapping[str, str],
|
||||
) -> ExecutionTruthRecord:
|
||||
self._assert_manifest(task_id)
|
||||
return self.coordinator.succeed(
|
||||
task_id,
|
||||
executor_run_id=self.identity.executor_run_id,
|
||||
executor_id=self.identity.executor_id,
|
||||
evidence=evidence,
|
||||
)
|
||||
|
||||
def fail(
|
||||
self,
|
||||
task_id: str,
|
||||
*,
|
||||
error: Mapping[str, Any],
|
||||
evidence: Mapping[str, str] | None = None,
|
||||
) -> ExecutionTruthRecord:
|
||||
self._assert_manifest(task_id)
|
||||
return self.coordinator.fail(
|
||||
task_id,
|
||||
executor_run_id=self.identity.executor_run_id,
|
||||
executor_id=self.identity.executor_id,
|
||||
error=error,
|
||||
evidence=evidence,
|
||||
)
|
||||
|
||||
|
||||
class OpenClawExecutorSession(ExecutorLifecycleSession):
|
||||
def __init__(self, coordinator: ExternalTaskCoordinator, *, executor_id: str, executor_run_id: str) -> None:
|
||||
super().__init__(
|
||||
coordinator,
|
||||
ExecutorIdentity("openclaw", executor_id, executor_run_id),
|
||||
)
|
||||
|
||||
|
||||
class HermesExecutorSession(ExecutorLifecycleSession):
|
||||
def __init__(self, coordinator: ExternalTaskCoordinator, *, executor_id: str, executor_run_id: str) -> None:
|
||||
super().__init__(
|
||||
coordinator,
|
||||
ExecutorIdentity("hermes", executor_id, executor_run_id),
|
||||
)
|
||||
|
||||
|
||||
class CodexExecutorSession(ExecutorLifecycleSession):
|
||||
def __init__(self, coordinator: ExternalTaskCoordinator, *, executor_id: str, executor_run_id: str) -> None:
|
||||
super().__init__(
|
||||
coordinator,
|
||||
ExecutorIdentity("codex", executor_id, executor_run_id),
|
||||
)
|
||||
@@ -1,313 +0,0 @@
|
||||
"""Provider-neutral worker runtime for AIOS external executors.
|
||||
|
||||
Providers implement only step execution and notification delivery. Discovery,
|
||||
dependency gates, lifecycle truth, heartbeat, evidence validation and durable
|
||||
notification acknowledgement are identical for every current and future
|
||||
executor Provider.
|
||||
"""
|
||||
from __future__ import annotations
|
||||
|
||||
import hashlib
|
||||
import json
|
||||
import uuid
|
||||
from dataclasses import dataclass, field
|
||||
from typing import Any, Mapping, Protocol, Sequence
|
||||
|
||||
from .execution_plan import ExecutionPlanCoordinator, ExecutionStageManifest
|
||||
from .executor_protocol import (
|
||||
ExecutorIdentity,
|
||||
ExecutorLifecycleSession,
|
||||
ExecutorProviderRegistry,
|
||||
normalize_executor,
|
||||
)
|
||||
from .external_task_control import ExternalTaskCoordinator, NotificationRecord
|
||||
from .task_execution_registry import ExecutionTruthState
|
||||
|
||||
|
||||
class StepRunner(Protocol):
|
||||
def run_step(
|
||||
self,
|
||||
*,
|
||||
plan_id: str,
|
||||
stage: ExecutionStageManifest,
|
||||
step: str,
|
||||
step_number: int,
|
||||
executor_id: str,
|
||||
executor_run_id: str,
|
||||
) -> Mapping[str, str]: ...
|
||||
|
||||
|
||||
class NotificationSender(Protocol):
|
||||
def send(self, notification: NotificationRecord) -> str: ...
|
||||
|
||||
|
||||
@dataclass(frozen=True)
|
||||
class StageRunResult:
|
||||
plan_id: str
|
||||
stage_id: str
|
||||
task_id: str
|
||||
executor_type: str
|
||||
executor_id: str
|
||||
executor_run_id: str
|
||||
state: str
|
||||
evidence: Mapping[str, str] = field(default_factory=dict)
|
||||
error: Mapping[str, Any] = field(default_factory=dict)
|
||||
delivered_notifications: Sequence[str] = ()
|
||||
|
||||
def as_dict(self) -> dict[str, Any]:
|
||||
return {
|
||||
"plan_id": self.plan_id,
|
||||
"stage_id": self.stage_id,
|
||||
"task_id": self.task_id,
|
||||
"executor_type": self.executor_type,
|
||||
"executor_id": self.executor_id,
|
||||
"executor_run_id": self.executor_run_id,
|
||||
"state": self.state,
|
||||
"evidence": dict(self.evidence),
|
||||
"error": dict(self.error),
|
||||
"delivered_notifications": list(self.delivered_notifications),
|
||||
}
|
||||
|
||||
|
||||
class UnifiedExecutorWorker:
|
||||
"""Dependency-aware worker shared by every registered Provider."""
|
||||
|
||||
def __init__(
|
||||
self,
|
||||
*,
|
||||
plan_coordinator: ExecutionPlanCoordinator,
|
||||
task_coordinator: ExternalTaskCoordinator,
|
||||
providers: ExecutorProviderRegistry,
|
||||
executor_type: str,
|
||||
executor_id: str,
|
||||
step_runner: StepRunner,
|
||||
notification_sender: NotificationSender,
|
||||
) -> None:
|
||||
self.plan_coordinator = plan_coordinator
|
||||
self.task_coordinator = task_coordinator
|
||||
self.providers = providers
|
||||
self.executor_type = normalize_executor(executor_type)
|
||||
self.executor_id = str(executor_id or "").strip()
|
||||
if not self.executor_id:
|
||||
raise ValueError("executor_id is required")
|
||||
self.providers.get(self.executor_type)
|
||||
self.step_runner = step_runner
|
||||
self.notification_sender = notification_sender
|
||||
|
||||
def _session(self, executor_run_id: str) -> ExecutorLifecycleSession:
|
||||
return ExecutorLifecycleSession(
|
||||
self.task_coordinator,
|
||||
ExecutorIdentity(
|
||||
executor_type=self.executor_type,
|
||||
executor_id=self.executor_id,
|
||||
executor_run_id=executor_run_id,
|
||||
),
|
||||
registry=self.providers,
|
||||
)
|
||||
|
||||
def _notification_candidates(self, task_id: str) -> tuple[NotificationRecord, ...]:
|
||||
"""Return idempotent delivery candidates, including prior failures.
|
||||
|
||||
The outbox has a unique ``(task_id, event_type)`` key. Retrying therefore
|
||||
reuses the same notification ID and cannot create duplicate STARTED or
|
||||
SUCCEEDED events. A later successful acknowledgement replaces FAILED
|
||||
with DELIVERED and records the receipt hash.
|
||||
"""
|
||||
candidates: dict[str, NotificationRecord] = {}
|
||||
for status in ("PENDING", "FAILED"):
|
||||
for item in self.task_coordinator.notifications.list(
|
||||
task_id=task_id,
|
||||
status=status,
|
||||
):
|
||||
candidates[item.notification_id] = item
|
||||
return tuple(
|
||||
candidates[key]
|
||||
for key in sorted(
|
||||
candidates,
|
||||
key=lambda item: (
|
||||
candidates[item].created_at,
|
||||
candidates[item].notification_id,
|
||||
),
|
||||
)
|
||||
)
|
||||
|
||||
def _deliver_notifications(self, task_id: str) -> tuple[str, ...]:
|
||||
delivered: list[str] = []
|
||||
for item in self._notification_candidates(task_id):
|
||||
try:
|
||||
receipt = self.notification_sender.send(item)
|
||||
acknowledged = self.task_coordinator.notifications.acknowledge(
|
||||
item.notification_id,
|
||||
receipt_sha256=receipt,
|
||||
)
|
||||
delivered.append(acknowledged.event_type)
|
||||
except Exception as exc:
|
||||
self.task_coordinator.notifications.fail(
|
||||
item.notification_id,
|
||||
error=f"{type(exc).__name__}: {exc}",
|
||||
)
|
||||
return tuple(sorted(set(delivered)))
|
||||
|
||||
def retry_failed_notifications(self, *, task_id: str) -> tuple[str, ...]:
|
||||
"""Retry failed owner notifications without changing task truth."""
|
||||
return self._deliver_notifications(task_id)
|
||||
|
||||
def run_ready(
|
||||
self,
|
||||
*,
|
||||
plan_id: str,
|
||||
max_stages: int = 1,
|
||||
) -> list[StageRunResult]:
|
||||
if max_stages < 1:
|
||||
raise ValueError("max_stages must be positive")
|
||||
ready = self.plan_coordinator.discover_ready(
|
||||
plan_id=plan_id,
|
||||
executor_type=self.executor_type,
|
||||
)[:max_stages]
|
||||
return [
|
||||
self.run_stage(
|
||||
plan_id=plan_id,
|
||||
stage_id=item["stage"]["stage_id"],
|
||||
)
|
||||
for item in ready
|
||||
]
|
||||
|
||||
def run_stage(
|
||||
self,
|
||||
*,
|
||||
plan_id: str,
|
||||
stage_id: str,
|
||||
executor_run_id: str | None = None,
|
||||
) -> StageRunResult:
|
||||
plan = self.plan_coordinator.plan_store.get(plan_id)
|
||||
stage = plan.stage(stage_id)
|
||||
if stage.executor_type != self.executor_type:
|
||||
raise PermissionError(
|
||||
f"stage executor is {stage.executor_type}, not {self.executor_type}"
|
||||
)
|
||||
dependency = self.plan_coordinator.dependency_gate(plan_id, stage_id)
|
||||
if not dependency["passed"]:
|
||||
raise RuntimeError("stage dependencies are not satisfied")
|
||||
|
||||
run_id = executor_run_id or f"{self.executor_type}_run_{uuid.uuid4().hex}"
|
||||
session = self._session(run_id)
|
||||
record = self.task_coordinator.registry.get(stage.task_id)
|
||||
evidence: dict[str, str] = dict(record.evidence)
|
||||
delivered: list[str] = []
|
||||
try:
|
||||
if record.state == ExecutionTruthState.DECLARED:
|
||||
record = session.register(stage.task_id)
|
||||
if record.state == ExecutionTruthState.REGISTERED:
|
||||
record = session.claim(stage.task_id)
|
||||
if record.state == ExecutionTruthState.CLAIMED:
|
||||
record = session.start(stage.task_id)
|
||||
delivered.extend(self._deliver_notifications(stage.task_id))
|
||||
if record.state != ExecutionTruthState.RUNNING:
|
||||
raise RuntimeError(
|
||||
f"stage cannot execute from state {record.state.value}"
|
||||
)
|
||||
|
||||
# Re-running the current step is intentional: Provider steps must be
|
||||
# idempotent and a crash between side effect and heartbeat cannot be
|
||||
# safely interpreted as completed work.
|
||||
start_step = max(1, record.current_step)
|
||||
for number, step in enumerate(stage.steps, start=1):
|
||||
if number < start_step:
|
||||
continue
|
||||
produced = self.step_runner.run_step(
|
||||
plan_id=plan_id,
|
||||
stage=stage,
|
||||
step=step,
|
||||
step_number=number,
|
||||
executor_id=self.executor_id,
|
||||
executor_run_id=run_id,
|
||||
)
|
||||
if not isinstance(produced, Mapping):
|
||||
raise TypeError("step runner must return an evidence mapping")
|
||||
evidence.update(
|
||||
{
|
||||
str(key).strip(): str(value).strip().lower()
|
||||
for key, value in produced.items()
|
||||
}
|
||||
)
|
||||
record = session.heartbeat(stage.task_id, current_step=number)
|
||||
|
||||
record = session.succeed(stage.task_id, evidence=evidence)
|
||||
delivered.extend(self._deliver_notifications(stage.task_id))
|
||||
return StageRunResult(
|
||||
plan_id=plan_id,
|
||||
stage_id=stage.stage_id,
|
||||
task_id=stage.task_id,
|
||||
executor_type=self.executor_type,
|
||||
executor_id=self.executor_id,
|
||||
executor_run_id=run_id,
|
||||
state=record.state.value,
|
||||
evidence=dict(record.evidence),
|
||||
delivered_notifications=tuple(sorted(set(delivered))),
|
||||
)
|
||||
except Exception as exc:
|
||||
current = self.task_coordinator.registry.get(stage.task_id)
|
||||
if current.state in {
|
||||
ExecutionTruthState.REGISTERED,
|
||||
ExecutionTruthState.CLAIMED,
|
||||
ExecutionTruthState.RUNNING,
|
||||
}:
|
||||
current = session.fail(
|
||||
stage.task_id,
|
||||
error={
|
||||
"code": "executor_stage_failed",
|
||||
"error_type": type(exc).__name__,
|
||||
"message": str(exc),
|
||||
},
|
||||
evidence=evidence or None,
|
||||
)
|
||||
delivered.extend(self._deliver_notifications(stage.task_id))
|
||||
return StageRunResult(
|
||||
plan_id=plan_id,
|
||||
stage_id=stage.stage_id,
|
||||
task_id=stage.task_id,
|
||||
executor_type=self.executor_type,
|
||||
executor_id=self.executor_id,
|
||||
executor_run_id=run_id,
|
||||
state=current.state.value,
|
||||
evidence=dict(current.evidence),
|
||||
error=dict(current.error),
|
||||
delivered_notifications=tuple(sorted(set(delivered))),
|
||||
)
|
||||
|
||||
|
||||
class JsonEvidenceStepRunner:
|
||||
"""Adapter for handlers returning evidence-name to SHA256 mappings."""
|
||||
|
||||
def __init__(self, handler) -> None:
|
||||
self.handler = handler
|
||||
|
||||
def run_step(self, **values: Any) -> Mapping[str, str]:
|
||||
result = self.handler(**values)
|
||||
if not isinstance(result, Mapping):
|
||||
raise TypeError("step handler must return a mapping")
|
||||
return {str(key): str(value) for key, value in result.items()}
|
||||
|
||||
|
||||
class JsonReceiptNotificationSender:
|
||||
"""Adapter for senders returning a SHA256 or receipt JSON object."""
|
||||
|
||||
def __init__(self, sender) -> None:
|
||||
self.sender = sender
|
||||
|
||||
def send(self, notification: NotificationRecord) -> str:
|
||||
result = self.sender(notification.as_dict())
|
||||
if isinstance(result, str):
|
||||
return result
|
||||
if not isinstance(result, Mapping):
|
||||
raise TypeError(
|
||||
"notification sender must return SHA256 or a receipt object"
|
||||
)
|
||||
encoded = json.dumps(
|
||||
dict(result),
|
||||
ensure_ascii=False,
|
||||
sort_keys=True,
|
||||
separators=(",", ":"),
|
||||
default=str,
|
||||
).encode("utf-8")
|
||||
return hashlib.sha256(encoded).hexdigest()
|
||||
@@ -1,266 +0,0 @@
|
||||
#!/usr/bin/env python3
|
||||
"""CLI for durable external-task truth and notification receipts.
|
||||
|
||||
The CLI is suitable for OpenClaw workers, systemd jobs and release gates. It
|
||||
never infers execution from the presence of a manifest: each lifecycle action
|
||||
must be recorded explicitly in the shared SQLite registry.
|
||||
"""
|
||||
from __future__ import annotations
|
||||
|
||||
import argparse
|
||||
import json
|
||||
import os
|
||||
import sys
|
||||
from pathlib import Path
|
||||
from typing import Any, Mapping, Sequence
|
||||
|
||||
from .external_task_control import ExternalTaskCoordinator
|
||||
from .external_task_query import list_records
|
||||
|
||||
|
||||
def _json_mapping(value: str | None, path: str | None) -> Mapping[str, Any]:
|
||||
if value and path:
|
||||
raise ValueError("inline JSON and JSON file are mutually exclusive")
|
||||
if path:
|
||||
parsed = json.loads(Path(path).read_text(encoding="utf-8"))
|
||||
else:
|
||||
parsed = json.loads(value or "{}")
|
||||
if not isinstance(parsed, Mapping):
|
||||
raise ValueError("JSON value must be an object")
|
||||
return dict(parsed)
|
||||
|
||||
|
||||
def _coordinator(args: argparse.Namespace) -> ExternalTaskCoordinator:
|
||||
return ExternalTaskCoordinator.from_file(args.store_file)
|
||||
|
||||
|
||||
def _print(value: Any) -> None:
|
||||
print(json.dumps(value, ensure_ascii=False, sort_keys=True, indent=2, default=str))
|
||||
|
||||
|
||||
def cmd_declare(args: argparse.Namespace) -> int:
|
||||
record = _coordinator(args).declare_file(args.manifest)
|
||||
_print(record.as_dict())
|
||||
return 0
|
||||
|
||||
|
||||
def cmd_discover(args: argparse.Namespace) -> int:
|
||||
records = list_records(
|
||||
args.store_file,
|
||||
executor=args.executor,
|
||||
states=tuple(args.state or ()),
|
||||
)
|
||||
_print({"count": len(records), "items": [item.as_dict() for item in records]})
|
||||
return 0
|
||||
|
||||
|
||||
def cmd_register(args: argparse.Namespace) -> int:
|
||||
_print(_coordinator(args).register(args.task_id, executor_run_id=args.executor_run_id).as_dict())
|
||||
return 0
|
||||
|
||||
|
||||
def cmd_claim(args: argparse.Namespace) -> int:
|
||||
_print(
|
||||
_coordinator(args).claim(
|
||||
args.task_id,
|
||||
executor_run_id=args.executor_run_id,
|
||||
executor_id=args.executor_id,
|
||||
).as_dict()
|
||||
)
|
||||
return 0
|
||||
|
||||
|
||||
def cmd_start(args: argparse.Namespace) -> int:
|
||||
_print(
|
||||
_coordinator(args).start(
|
||||
args.task_id,
|
||||
executor_run_id=args.executor_run_id,
|
||||
executor_id=args.executor_id,
|
||||
).as_dict()
|
||||
)
|
||||
return 0
|
||||
|
||||
|
||||
def cmd_heartbeat(args: argparse.Namespace) -> int:
|
||||
_print(
|
||||
_coordinator(args).heartbeat(
|
||||
args.task_id,
|
||||
executor_run_id=args.executor_run_id,
|
||||
executor_id=args.executor_id,
|
||||
current_step=args.current_step,
|
||||
).as_dict()
|
||||
)
|
||||
return 0
|
||||
|
||||
|
||||
def cmd_succeed(args: argparse.Namespace) -> int:
|
||||
evidence = _json_mapping(args.evidence_json, args.evidence_file)
|
||||
_print(
|
||||
_coordinator(args).succeed(
|
||||
args.task_id,
|
||||
executor_run_id=args.executor_run_id,
|
||||
executor_id=args.executor_id,
|
||||
evidence={str(key): str(value) for key, value in evidence.items()},
|
||||
).as_dict()
|
||||
)
|
||||
return 0
|
||||
|
||||
|
||||
def cmd_fail(args: argparse.Namespace) -> int:
|
||||
error = _json_mapping(args.error_json, args.error_file)
|
||||
evidence = None
|
||||
if args.evidence_json or args.evidence_file:
|
||||
evidence_value = _json_mapping(args.evidence_json, args.evidence_file)
|
||||
evidence = {str(key): str(value) for key, value in evidence_value.items()}
|
||||
_print(
|
||||
_coordinator(args).fail(
|
||||
args.task_id,
|
||||
executor_run_id=args.executor_run_id,
|
||||
executor_id=args.executor_id,
|
||||
error=error,
|
||||
evidence=evidence,
|
||||
).as_dict()
|
||||
)
|
||||
return 0
|
||||
|
||||
|
||||
def cmd_status(args: argparse.Namespace) -> int:
|
||||
_print(_coordinator(args).status(args.task_id))
|
||||
return 0
|
||||
|
||||
|
||||
def cmd_gate(args: argparse.Namespace) -> int:
|
||||
value = _coordinator(args).gate(args.task_id)
|
||||
_print(value)
|
||||
return 0 if value["passed"] else 3
|
||||
|
||||
|
||||
def cmd_notifications(args: argparse.Namespace) -> int:
|
||||
items = _coordinator(args).notifications.list(task_id=args.task_id, status=args.status)
|
||||
_print({"count": len(items), "items": [item.as_dict() for item in items]})
|
||||
return 0
|
||||
|
||||
|
||||
def cmd_ack(args: argparse.Namespace) -> int:
|
||||
_print(
|
||||
_coordinator(args).notifications.acknowledge(
|
||||
args.notification_id,
|
||||
receipt_sha256=args.receipt_sha256,
|
||||
).as_dict()
|
||||
)
|
||||
return 0
|
||||
|
||||
|
||||
def common(parser: argparse.ArgumentParser) -> None:
|
||||
parser.add_argument(
|
||||
"--store-file",
|
||||
default=os.getenv(
|
||||
"AIOS_EXTERNAL_TASK_STORE_FILE",
|
||||
"/var/lib/aios-v2/external-task-truth.sqlite3",
|
||||
),
|
||||
)
|
||||
|
||||
|
||||
def lifecycle(parser: argparse.ArgumentParser) -> None:
|
||||
parser.add_argument("--task-id", required=True)
|
||||
parser.add_argument("--executor-run-id", required=True)
|
||||
parser.add_argument("--executor-id", required=True)
|
||||
|
||||
|
||||
def build_parser() -> argparse.ArgumentParser:
|
||||
parser = argparse.ArgumentParser(description="AIOS external task truth CLI")
|
||||
commands = parser.add_subparsers(dest="command", required=True)
|
||||
|
||||
declare = commands.add_parser("declare")
|
||||
common(declare)
|
||||
declare.add_argument("--manifest", required=True)
|
||||
declare.set_defaults(handler=cmd_declare)
|
||||
|
||||
discover = commands.add_parser("discover")
|
||||
common(discover)
|
||||
discover.add_argument("--executor", default="openclaw")
|
||||
discover.add_argument("--state", action="append")
|
||||
discover.set_defaults(handler=cmd_discover)
|
||||
|
||||
register = commands.add_parser("register")
|
||||
common(register)
|
||||
register.add_argument("--task-id", required=True)
|
||||
register.add_argument("--executor-run-id", required=True)
|
||||
register.set_defaults(handler=cmd_register)
|
||||
|
||||
claim = commands.add_parser("claim")
|
||||
common(claim)
|
||||
lifecycle(claim)
|
||||
claim.set_defaults(handler=cmd_claim)
|
||||
|
||||
start = commands.add_parser("start")
|
||||
common(start)
|
||||
lifecycle(start)
|
||||
start.set_defaults(handler=cmd_start)
|
||||
|
||||
heartbeat = commands.add_parser("heartbeat")
|
||||
common(heartbeat)
|
||||
lifecycle(heartbeat)
|
||||
heartbeat.add_argument("--current-step", type=int, required=True)
|
||||
heartbeat.set_defaults(handler=cmd_heartbeat)
|
||||
|
||||
succeed = commands.add_parser("succeed")
|
||||
common(succeed)
|
||||
lifecycle(succeed)
|
||||
evidence = succeed.add_mutually_exclusive_group(required=True)
|
||||
evidence.add_argument("--evidence-json")
|
||||
evidence.add_argument("--evidence-file")
|
||||
succeed.set_defaults(handler=cmd_succeed)
|
||||
|
||||
fail = commands.add_parser("fail")
|
||||
common(fail)
|
||||
lifecycle(fail)
|
||||
error = fail.add_mutually_exclusive_group(required=True)
|
||||
error.add_argument("--error-json")
|
||||
error.add_argument("--error-file")
|
||||
fail_evidence = fail.add_mutually_exclusive_group()
|
||||
fail_evidence.add_argument("--evidence-json")
|
||||
fail_evidence.add_argument("--evidence-file")
|
||||
fail.set_defaults(handler=cmd_fail)
|
||||
|
||||
status = commands.add_parser("status")
|
||||
common(status)
|
||||
status.add_argument("--task-id", required=True)
|
||||
status.set_defaults(handler=cmd_status)
|
||||
|
||||
gate = commands.add_parser("gate")
|
||||
common(gate)
|
||||
gate.add_argument("--task-id", required=True)
|
||||
gate.set_defaults(handler=cmd_gate)
|
||||
|
||||
notifications = commands.add_parser("notifications")
|
||||
common(notifications)
|
||||
notifications.add_argument("--task-id")
|
||||
notifications.add_argument("--status")
|
||||
notifications.set_defaults(handler=cmd_notifications)
|
||||
|
||||
ack = commands.add_parser("ack-notification")
|
||||
common(ack)
|
||||
ack.add_argument("--notification-id", required=True)
|
||||
ack.add_argument("--receipt-sha256", required=True)
|
||||
ack.set_defaults(handler=cmd_ack)
|
||||
return parser
|
||||
|
||||
|
||||
def main(argv: Sequence[str] | None = None) -> int:
|
||||
args = build_parser().parse_args(argv)
|
||||
try:
|
||||
return int(args.handler(args))
|
||||
except Exception as exc:
|
||||
print(
|
||||
json.dumps(
|
||||
{"status": "error", "error": type(exc).__name__, "message": str(exc)},
|
||||
ensure_ascii=False,
|
||||
),
|
||||
file=sys.stderr,
|
||||
)
|
||||
return 1
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
raise SystemExit(main())
|
||||
@@ -1,420 +0,0 @@
|
||||
"""External executor coordination, notification outbox and release truth gate.
|
||||
|
||||
OpenClaw/Codex task declarations are not execution evidence. This module wraps
|
||||
``SQLiteExecutionTruthRegistry`` with a durable notification outbox. A successful
|
||||
release gate requires both terminal task evidence and acknowledged STARTED /
|
||||
SUCCEEDED owner notifications when those events are required by the manifest.
|
||||
"""
|
||||
from __future__ import annotations
|
||||
|
||||
import hashlib
|
||||
import json
|
||||
import re
|
||||
import sqlite3
|
||||
import threading
|
||||
import uuid
|
||||
from dataclasses import asdict, dataclass
|
||||
from pathlib import Path
|
||||
from typing import Any, Mapping, Sequence
|
||||
|
||||
from .task_execution_registry import (
|
||||
ExecutionTaskManifest,
|
||||
ExecutionTruthRecord,
|
||||
ExecutionTruthState,
|
||||
SQLiteExecutionTruthRegistry,
|
||||
utc_now,
|
||||
)
|
||||
|
||||
_SHA256 = re.compile(r"^[0-9a-f]{64}$")
|
||||
|
||||
|
||||
def sha256_value(value: str, label: str) -> str:
|
||||
normalized = str(value or "").strip().lower()
|
||||
if not _SHA256.fullmatch(normalized):
|
||||
raise ValueError(f"{label} must be a lowercase SHA256 hex digest")
|
||||
return normalized
|
||||
|
||||
|
||||
@dataclass(frozen=True)
|
||||
class NotificationRecord:
|
||||
notification_id: str
|
||||
task_id: str
|
||||
event_type: str
|
||||
target_ref: str
|
||||
payload: Mapping[str, Any]
|
||||
status: str
|
||||
created_at: str
|
||||
delivered_at: str | None = None
|
||||
receipt_sha256: str | None = None
|
||||
error: str | None = None
|
||||
|
||||
def as_dict(self) -> dict[str, Any]:
|
||||
return asdict(self)
|
||||
|
||||
|
||||
class SQLiteNotificationOutbox:
|
||||
"""Durable owner-notification delivery and acknowledgement records."""
|
||||
|
||||
def __init__(self, path: str | Path) -> None:
|
||||
self.path = Path(path).resolve()
|
||||
self.path.parent.mkdir(parents=True, exist_ok=True)
|
||||
self._lock = threading.RLock()
|
||||
with self._connect() as connection:
|
||||
connection.executescript(
|
||||
"""
|
||||
CREATE TABLE IF NOT EXISTS external_task_notifications (
|
||||
notification_id TEXT PRIMARY KEY,
|
||||
task_id TEXT NOT NULL,
|
||||
event_type TEXT NOT NULL,
|
||||
target_ref TEXT NOT NULL,
|
||||
payload_json TEXT NOT NULL,
|
||||
status TEXT NOT NULL,
|
||||
created_at TEXT NOT NULL,
|
||||
delivered_at TEXT,
|
||||
receipt_sha256 TEXT,
|
||||
error TEXT,
|
||||
UNIQUE(task_id, event_type)
|
||||
);
|
||||
CREATE INDEX IF NOT EXISTS idx_external_notification_status
|
||||
ON external_task_notifications(status, created_at);
|
||||
"""
|
||||
)
|
||||
|
||||
def _connect(self) -> sqlite3.Connection:
|
||||
connection = sqlite3.connect(str(self.path), timeout=30.0)
|
||||
connection.row_factory = sqlite3.Row
|
||||
connection.execute("PRAGMA journal_mode=WAL")
|
||||
connection.execute("PRAGMA synchronous=FULL")
|
||||
return connection
|
||||
|
||||
@staticmethod
|
||||
def _decode(row: sqlite3.Row) -> NotificationRecord:
|
||||
return NotificationRecord(
|
||||
notification_id=row["notification_id"],
|
||||
task_id=row["task_id"],
|
||||
event_type=row["event_type"],
|
||||
target_ref=row["target_ref"],
|
||||
payload=json.loads(row["payload_json"]),
|
||||
status=row["status"],
|
||||
created_at=row["created_at"],
|
||||
delivered_at=row["delivered_at"],
|
||||
receipt_sha256=row["receipt_sha256"],
|
||||
error=row["error"],
|
||||
)
|
||||
|
||||
def enqueue(
|
||||
self,
|
||||
*,
|
||||
task_id: str,
|
||||
event_type: str,
|
||||
target_ref: str,
|
||||
payload: Mapping[str, Any],
|
||||
) -> NotificationRecord:
|
||||
now = utc_now()
|
||||
record = NotificationRecord(
|
||||
notification_id=f"notify_{uuid.uuid4().hex}",
|
||||
task_id=str(task_id).strip(),
|
||||
event_type=str(event_type).strip().upper(),
|
||||
target_ref=str(target_ref).strip(),
|
||||
payload=json.loads(json.dumps(dict(payload), ensure_ascii=False, default=str)),
|
||||
status="PENDING",
|
||||
created_at=now,
|
||||
)
|
||||
if not record.task_id or not record.event_type or not record.target_ref:
|
||||
raise ValueError("task_id, event_type and target_ref are required")
|
||||
with self._lock, self._connect() as connection:
|
||||
connection.execute("BEGIN IMMEDIATE")
|
||||
existing = connection.execute(
|
||||
"SELECT * FROM external_task_notifications WHERE task_id = ? AND event_type = ?",
|
||||
(record.task_id, record.event_type),
|
||||
).fetchone()
|
||||
if existing is not None:
|
||||
connection.rollback()
|
||||
return self._decode(existing)
|
||||
connection.execute(
|
||||
"""
|
||||
INSERT INTO external_task_notifications
|
||||
(notification_id, task_id, event_type, target_ref, payload_json,
|
||||
status, created_at, delivered_at, receipt_sha256, error)
|
||||
VALUES (?, ?, ?, ?, ?, ?, ?, NULL, NULL, NULL)
|
||||
""",
|
||||
(
|
||||
record.notification_id,
|
||||
record.task_id,
|
||||
record.event_type,
|
||||
record.target_ref,
|
||||
json.dumps(record.payload, ensure_ascii=False, sort_keys=True, separators=(",", ":")),
|
||||
record.status,
|
||||
record.created_at,
|
||||
),
|
||||
)
|
||||
connection.commit()
|
||||
return record
|
||||
|
||||
def get(self, notification_id: str) -> NotificationRecord:
|
||||
with self._lock, self._connect() as connection:
|
||||
row = connection.execute(
|
||||
"SELECT * FROM external_task_notifications WHERE notification_id = ?",
|
||||
(str(notification_id).strip(),),
|
||||
).fetchone()
|
||||
if row is None:
|
||||
raise KeyError("notification not found")
|
||||
return self._decode(row)
|
||||
|
||||
def acknowledge(self, notification_id: str, *, receipt_sha256: str) -> NotificationRecord:
|
||||
digest = sha256_value(receipt_sha256, "receipt_sha256")
|
||||
with self._lock, self._connect() as connection:
|
||||
connection.execute("BEGIN IMMEDIATE")
|
||||
row = connection.execute(
|
||||
"SELECT * FROM external_task_notifications WHERE notification_id = ?",
|
||||
(str(notification_id).strip(),),
|
||||
).fetchone()
|
||||
if row is None:
|
||||
connection.rollback()
|
||||
raise KeyError("notification not found")
|
||||
current = self._decode(row)
|
||||
if current.status == "DELIVERED":
|
||||
if current.receipt_sha256 != digest:
|
||||
connection.rollback()
|
||||
raise RuntimeError("notification already acknowledged with another receipt")
|
||||
connection.rollback()
|
||||
return current
|
||||
delivered_at = utc_now()
|
||||
connection.execute(
|
||||
"""
|
||||
UPDATE external_task_notifications
|
||||
SET status = 'DELIVERED', delivered_at = ?, receipt_sha256 = ?, error = NULL
|
||||
WHERE notification_id = ?
|
||||
""",
|
||||
(delivered_at, digest, current.notification_id),
|
||||
)
|
||||
connection.commit()
|
||||
return self.get(current.notification_id)
|
||||
|
||||
def fail(self, notification_id: str, *, error: str) -> NotificationRecord:
|
||||
message = str(error or "").strip()
|
||||
if not message:
|
||||
raise ValueError("notification error is required")
|
||||
with self._lock, self._connect() as connection:
|
||||
connection.execute(
|
||||
"UPDATE external_task_notifications SET status = 'FAILED', error = ? WHERE notification_id = ?",
|
||||
(message, str(notification_id).strip()),
|
||||
)
|
||||
connection.commit()
|
||||
return self.get(notification_id)
|
||||
|
||||
def list(
|
||||
self,
|
||||
*,
|
||||
task_id: str | None = None,
|
||||
status: str | None = None,
|
||||
) -> list[NotificationRecord]:
|
||||
conditions: list[str] = []
|
||||
values: list[str] = []
|
||||
if task_id:
|
||||
conditions.append("task_id = ?")
|
||||
values.append(str(task_id).strip())
|
||||
if status:
|
||||
conditions.append("status = ?")
|
||||
values.append(str(status).strip().upper())
|
||||
where = f" WHERE {' AND '.join(conditions)}" if conditions else ""
|
||||
with self._lock, self._connect() as connection:
|
||||
rows = connection.execute(
|
||||
f"SELECT * FROM external_task_notifications{where} ORDER BY created_at, notification_id",
|
||||
tuple(values),
|
||||
).fetchall()
|
||||
return [self._decode(row) for row in rows]
|
||||
|
||||
|
||||
class ExternalTaskCoordinator:
|
||||
"""Single safe lifecycle used by external executors and release gates."""
|
||||
|
||||
def __init__(
|
||||
self,
|
||||
registry: SQLiteExecutionTruthRegistry,
|
||||
notifications: SQLiteNotificationOutbox,
|
||||
) -> None:
|
||||
self.registry = registry
|
||||
self.notifications = notifications
|
||||
|
||||
@classmethod
|
||||
def from_file(cls, path: str | Path) -> "ExternalTaskCoordinator":
|
||||
return cls(
|
||||
SQLiteExecutionTruthRegistry(path),
|
||||
SQLiteNotificationOutbox(path),
|
||||
)
|
||||
|
||||
def declare(self, manifest: ExecutionTaskManifest) -> ExecutionTruthRecord:
|
||||
return self.registry.declare(manifest)
|
||||
|
||||
def declare_file(self, path: str | Path) -> ExecutionTruthRecord:
|
||||
value = json.loads(Path(path).read_text(encoding="utf-8"))
|
||||
if not isinstance(value, Mapping):
|
||||
raise ValueError("external task manifest must be a JSON object")
|
||||
return self.declare(ExecutionTaskManifest.from_dict(value))
|
||||
|
||||
def register(self, task_id: str, *, executor_run_id: str) -> ExecutionTruthRecord:
|
||||
return self.registry.register(task_id, executor_run_id=executor_run_id)
|
||||
|
||||
def retry_not_started(
|
||||
self,
|
||||
task_id: str,
|
||||
*,
|
||||
executor_run_id: str,
|
||||
) -> ExecutionTruthRecord:
|
||||
return self.registry.retry_not_started(
|
||||
task_id,
|
||||
executor_run_id=executor_run_id,
|
||||
)
|
||||
|
||||
def claim(
|
||||
self,
|
||||
task_id: str,
|
||||
*,
|
||||
executor_run_id: str,
|
||||
executor_id: str,
|
||||
) -> ExecutionTruthRecord:
|
||||
return self.registry.claim(
|
||||
task_id,
|
||||
executor_run_id=executor_run_id,
|
||||
executor_id=executor_id,
|
||||
)
|
||||
|
||||
def _notify(self, record: ExecutionTruthRecord, event_type: str) -> NotificationRecord | None:
|
||||
event = event_type.upper()
|
||||
if event not in set(record.manifest.notification_events):
|
||||
return None
|
||||
return self.notifications.enqueue(
|
||||
task_id=record.task_id,
|
||||
event_type=event,
|
||||
target_ref=record.manifest.owner_notification_ref,
|
||||
payload={
|
||||
"task_id": record.task_id,
|
||||
"target_version": record.manifest.target_version,
|
||||
"executor": record.manifest.executor,
|
||||
"executor_id": record.executor_id,
|
||||
"executor_run_id": record.executor_run_id,
|
||||
"state": record.state.value,
|
||||
"current_step": record.current_step,
|
||||
"total_steps": len(record.manifest.steps),
|
||||
"timestamp": utc_now(),
|
||||
},
|
||||
)
|
||||
|
||||
def start(
|
||||
self,
|
||||
task_id: str,
|
||||
*,
|
||||
executor_run_id: str,
|
||||
executor_id: str,
|
||||
) -> ExecutionTruthRecord:
|
||||
record = self.registry.start(
|
||||
task_id,
|
||||
executor_run_id=executor_run_id,
|
||||
executor_id=executor_id,
|
||||
)
|
||||
self._notify(record, "STARTED")
|
||||
return record
|
||||
|
||||
def heartbeat(
|
||||
self,
|
||||
task_id: str,
|
||||
*,
|
||||
executor_run_id: str,
|
||||
executor_id: str,
|
||||
current_step: int,
|
||||
) -> ExecutionTruthRecord:
|
||||
return self.registry.heartbeat(
|
||||
task_id,
|
||||
executor_run_id=executor_run_id,
|
||||
executor_id=executor_id,
|
||||
current_step=current_step,
|
||||
)
|
||||
|
||||
def succeed(
|
||||
self,
|
||||
task_id: str,
|
||||
*,
|
||||
executor_run_id: str,
|
||||
executor_id: str,
|
||||
evidence: Mapping[str, str],
|
||||
) -> ExecutionTruthRecord:
|
||||
normalized = {
|
||||
str(key).strip(): sha256_value(value, f"evidence[{key}]")
|
||||
for key, value in evidence.items()
|
||||
}
|
||||
record = self.registry.succeed(
|
||||
task_id,
|
||||
executor_run_id=executor_run_id,
|
||||
executor_id=executor_id,
|
||||
evidence=normalized,
|
||||
)
|
||||
self._notify(record, "SUCCEEDED")
|
||||
return record
|
||||
|
||||
def fail(
|
||||
self,
|
||||
task_id: str,
|
||||
*,
|
||||
executor_run_id: str,
|
||||
executor_id: str,
|
||||
error: Mapping[str, Any],
|
||||
evidence: Mapping[str, str] | None = None,
|
||||
) -> ExecutionTruthRecord:
|
||||
normalized = None
|
||||
if evidence is not None:
|
||||
normalized = {
|
||||
str(key).strip(): sha256_value(value, f"evidence[{key}]")
|
||||
for key, value in evidence.items()
|
||||
}
|
||||
record = self.registry.fail(
|
||||
task_id,
|
||||
executor_run_id=executor_run_id,
|
||||
executor_id=executor_id,
|
||||
error=error,
|
||||
evidence=normalized,
|
||||
)
|
||||
self._notify(record, "FAILED")
|
||||
return record
|
||||
|
||||
def gate(self, task_id: str) -> Mapping[str, Any]:
|
||||
before = self.registry.get(task_id)
|
||||
truth = self.registry.gate(task_id)
|
||||
after = self.registry.get(task_id)
|
||||
if after.state != before.state and after.state in {
|
||||
ExecutionTruthState.NOT_STARTED,
|
||||
ExecutionTruthState.STALLED,
|
||||
}:
|
||||
self._notify(after, after.state.value)
|
||||
notifications = self.notifications.list(task_id=task_id)
|
||||
delivered = {item.event_type for item in notifications if item.status == "DELIVERED"}
|
||||
required_success_notifications = {
|
||||
item
|
||||
for item in ("STARTED", "SUCCEEDED")
|
||||
if item in set(after.manifest.notification_events)
|
||||
}
|
||||
notification_complete = required_success_notifications.issubset(delivered)
|
||||
passed = bool(truth["passed"] and notification_complete)
|
||||
return {
|
||||
**dict(truth),
|
||||
"passed": passed,
|
||||
"release_blocking": not passed,
|
||||
"notification_complete": notification_complete,
|
||||
"required_success_notifications": sorted(required_success_notifications),
|
||||
"delivered_notifications": sorted(delivered),
|
||||
"notifications": [item.as_dict() for item in notifications],
|
||||
}
|
||||
|
||||
def status(self, task_id: str) -> Mapping[str, Any]:
|
||||
gate = self.gate(task_id)
|
||||
record = self.registry.get(task_id)
|
||||
return {
|
||||
"record": record.as_dict(),
|
||||
"gate": gate,
|
||||
"events": self.registry.events(task_id),
|
||||
}
|
||||
|
||||
@staticmethod
|
||||
def content_receipt(value: Mapping[str, Any]) -> str:
|
||||
encoded = json.dumps(dict(value), ensure_ascii=False, sort_keys=True, separators=(",", ":"), default=str).encode("utf-8")
|
||||
return hashlib.sha256(encoded).hexdigest()
|
||||
@@ -1,51 +0,0 @@
|
||||
"""Read models for the durable external-task truth registry."""
|
||||
from __future__ import annotations
|
||||
|
||||
import json
|
||||
import sqlite3
|
||||
from pathlib import Path
|
||||
from typing import Sequence
|
||||
|
||||
from .task_execution_registry import ExecutionTruthRecord, ExecutionTruthState
|
||||
|
||||
|
||||
def _decode(value: str) -> ExecutionTruthRecord:
|
||||
payload = json.loads(value)
|
||||
payload["state"] = ExecutionTruthState(payload["state"])
|
||||
payload["evidence"] = dict(payload.get("evidence") or {})
|
||||
payload["error"] = dict(payload.get("error") or {})
|
||||
return ExecutionTruthRecord(**payload)
|
||||
|
||||
|
||||
def list_records(
|
||||
path: str | Path,
|
||||
*,
|
||||
executor: str | None = None,
|
||||
states: Sequence[str] = (),
|
||||
) -> list[ExecutionTruthRecord]:
|
||||
database = Path(path).resolve()
|
||||
if not database.exists():
|
||||
return []
|
||||
conditions: list[str] = []
|
||||
values: list[str] = []
|
||||
normalized_states = tuple(sorted({ExecutionTruthState(item).value for item in states}))
|
||||
if normalized_states:
|
||||
conditions.append(f"state IN ({','.join('?' for _ in normalized_states)})")
|
||||
values.extend(normalized_states)
|
||||
where = f" WHERE {' AND '.join(conditions)}" if conditions else ""
|
||||
connection = sqlite3.connect(f"file:{database}?mode=ro", uri=True, timeout=10.0)
|
||||
connection.row_factory = sqlite3.Row
|
||||
try:
|
||||
rows = connection.execute(
|
||||
f"SELECT record_json FROM execution_truth{where} ORDER BY updated_at, task_id",
|
||||
tuple(values),
|
||||
).fetchall()
|
||||
except sqlite3.OperationalError:
|
||||
return []
|
||||
finally:
|
||||
connection.close()
|
||||
records = [_decode(row["record_json"]) for row in rows]
|
||||
if executor:
|
||||
normalized = str(executor).strip().lower()
|
||||
records = [item for item in records if item.manifest.executor.lower() == normalized]
|
||||
return records
|
||||
@@ -1,353 +0,0 @@
|
||||
"""HTTP/JSON gateway for the AIOS V2 control plane.
|
||||
|
||||
The public gateway owns user-facing control operations only. Runtime lifecycle
|
||||
transitions are deliberately absent: external callers cannot directly move a
|
||||
task to RUNNING, COMPLETED or FAILED. Those transitions are available only
|
||||
through the provenance-protected orchestrator and internal reconciliation API.
|
||||
"""
|
||||
from __future__ import annotations
|
||||
|
||||
import dataclasses
|
||||
import json
|
||||
import os
|
||||
import re
|
||||
import urllib.parse
|
||||
from enum import Enum
|
||||
from http import HTTPStatus
|
||||
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
|
||||
from typing import Any, Mapping
|
||||
|
||||
from aios_hermes import HermesConflict, HermesNotFound
|
||||
|
||||
from .control_plane import (
|
||||
ControlPlaneError,
|
||||
ControlPlaneService,
|
||||
IdempotencyConflict,
|
||||
InvalidTransition,
|
||||
NotFound,
|
||||
PolicyDenied,
|
||||
RequestContext,
|
||||
RevisionConflict,
|
||||
TaskState,
|
||||
TenantIsolationError,
|
||||
Unauthorized,
|
||||
)
|
||||
from .dispatch_store import DispatchConflict, DispatchNotFound
|
||||
from .orchestrator import OrchestrationError
|
||||
from .provenance import ProvenanceDenied, ProvenanceReplay
|
||||
|
||||
TENANT_HEADER = "X-AIOS-Tenant-ID"
|
||||
PRINCIPAL_HEADER = "X-AIOS-Principal-ID"
|
||||
ROLES_HEADER = "X-AIOS-Roles"
|
||||
TRACE_HEADER = "X-AIOS-Trace-ID"
|
||||
SESSION_HEADER = "X-AIOS-Session-ID"
|
||||
POLICY_HEADER = "X-AIOS-Policy-Version"
|
||||
AUTHENTICATED_HEADER = "X-AIOS-Authenticated"
|
||||
|
||||
_RESOURCE_ID_RE = re.compile(r"^[A-Za-z0-9][A-Za-z0-9._:-]{0,191}$")
|
||||
|
||||
|
||||
def _json_value(value: Any) -> Any:
|
||||
if dataclasses.is_dataclass(value):
|
||||
return {
|
||||
field.name: _json_value(getattr(value, field.name))
|
||||
for field in dataclasses.fields(value)
|
||||
}
|
||||
if isinstance(value, Enum):
|
||||
return value.value
|
||||
if isinstance(value, Mapping):
|
||||
return {str(key): _json_value(item) for key, item in value.items()}
|
||||
if isinstance(value, (list, tuple, set, frozenset)):
|
||||
return [_json_value(item) for item in value]
|
||||
return value
|
||||
|
||||
|
||||
def _require_mapping(value: Any, *, label: str = "JSON body") -> Mapping[str, Any]:
|
||||
if not isinstance(value, Mapping):
|
||||
raise ValueError(f"{label} must be an object")
|
||||
return value
|
||||
|
||||
|
||||
def _require_resource_id(value: Any, *, label: str) -> str:
|
||||
normalized = str(value or "").strip()
|
||||
if not _RESOURCE_ID_RE.fullmatch(normalized):
|
||||
raise ValueError(f"invalid {label}")
|
||||
return normalized
|
||||
|
||||
|
||||
class GatewayApplication:
|
||||
"""Pure user-facing request router that can be tested without a socket."""
|
||||
|
||||
def __init__(self, service: ControlPlaneService | None = None) -> None:
|
||||
self.service = service or ControlPlaneService()
|
||||
|
||||
@staticmethod
|
||||
def context_from_headers(headers: Mapping[str, str]) -> RequestContext:
|
||||
normalized_headers = {
|
||||
str(key).strip().lower(): value for key, value in headers.items()
|
||||
}
|
||||
|
||||
def header(name: str, default: str = "") -> str:
|
||||
return str(normalized_headers.get(name.lower(), default))
|
||||
|
||||
authenticated = header(AUTHENTICATED_HEADER).strip().lower()
|
||||
if authenticated not in {"1", "true", "yes"}:
|
||||
raise Unauthorized("trusted authentication assertion is required")
|
||||
roles = [
|
||||
role.strip()
|
||||
for role in header(ROLES_HEADER).split(",")
|
||||
if role.strip()
|
||||
]
|
||||
return RequestContext.create(
|
||||
tenant_id=header(TENANT_HEADER),
|
||||
principal_id=header(PRINCIPAL_HEADER),
|
||||
trace_id=header(TRACE_HEADER).strip() or None,
|
||||
session_id=header(SESSION_HEADER).strip() or None,
|
||||
policy_version=header(POLICY_HEADER, "v1").strip() or "v1",
|
||||
roles=roles,
|
||||
)
|
||||
|
||||
def handle(
|
||||
self,
|
||||
method: str,
|
||||
raw_path: str,
|
||||
headers: Mapping[str, str],
|
||||
body: Any = None,
|
||||
) -> tuple[int, Mapping[str, Any]]:
|
||||
parsed = urllib.parse.urlparse(raw_path)
|
||||
path = parsed.path.rstrip("/") or "/"
|
||||
query = urllib.parse.parse_qs(parsed.query, keep_blank_values=False)
|
||||
method = method.upper()
|
||||
|
||||
if method == "GET" and path in {"/healthz", "/api/v2/health"}:
|
||||
return HTTPStatus.OK, {
|
||||
"service": "aios-v2-control-plane",
|
||||
"status": "ok",
|
||||
"store": type(self.service.store).__name__,
|
||||
}
|
||||
|
||||
context = self.context_from_headers(headers)
|
||||
payload = _require_mapping(body or {})
|
||||
|
||||
if method == "POST" and path == "/api/v2/tenants":
|
||||
tenant = self.service.register_tenant(
|
||||
context,
|
||||
tenant_id=_require_resource_id(payload.get("tenant_id"), label="tenant_id"),
|
||||
display_name=str(payload.get("display_name", "")),
|
||||
metadata=_require_mapping(payload.get("metadata", {}), label="metadata"),
|
||||
)
|
||||
return HTTPStatus.CREATED, {"tenant": _json_value(tenant)}
|
||||
|
||||
if method == "GET" and path == "/api/v2/tenants/current":
|
||||
return HTTPStatus.OK, {"tenant": _json_value(self.service.get_tenant(context))}
|
||||
|
||||
if method == "POST" and path == "/api/v2/agents":
|
||||
agent = self.service.register_agent(
|
||||
context,
|
||||
agent_id=_require_resource_id(payload.get("agent_id"), label="agent_id"),
|
||||
display_name=str(payload.get("display_name", "")),
|
||||
runtime=str(payload.get("runtime", "")),
|
||||
capabilities=payload.get("capabilities", ()),
|
||||
metadata=_require_mapping(payload.get("metadata", {}), label="metadata"),
|
||||
)
|
||||
return HTTPStatus.CREATED, {"agent": _json_value(agent)}
|
||||
|
||||
if method == "GET" and path == "/api/v2/agents":
|
||||
return HTTPStatus.OK, {"agents": _json_value(self.service.list_agents(context))}
|
||||
|
||||
agent_match = re.fullmatch(r"/api/v2/agents/([^/]+)", path)
|
||||
if method == "GET" and agent_match:
|
||||
agent_id = _require_resource_id(
|
||||
urllib.parse.unquote(agent_match.group(1)), label="agent_id"
|
||||
)
|
||||
return HTTPStatus.OK, {
|
||||
"agent": _json_value(self.service.get_agent(context, agent_id))
|
||||
}
|
||||
|
||||
if method == "POST" and path == "/api/v2/tasks":
|
||||
task = self.service.create_task(
|
||||
context,
|
||||
agent_id=_require_resource_id(payload.get("agent_id"), label="agent_id"),
|
||||
action=str(payload.get("action", "")).strip(),
|
||||
payload=_require_mapping(payload.get("payload", {}), label="payload"),
|
||||
idempotency_key=(
|
||||
str(payload["idempotency_key"]).strip()
|
||||
if payload.get("idempotency_key") is not None
|
||||
else None
|
||||
),
|
||||
)
|
||||
return HTTPStatus.CREATED, {"task": _json_value(task)}
|
||||
|
||||
if method == "GET" and path == "/api/v2/tasks":
|
||||
tasks = self.service.list_tasks(context, states=query.get("state"))
|
||||
return HTTPStatus.OK, {"tasks": _json_value(tasks)}
|
||||
|
||||
task_match = re.fullmatch(r"/api/v2/tasks/([^/]+)", path)
|
||||
if method == "GET" and task_match:
|
||||
task_id = _require_resource_id(
|
||||
urllib.parse.unquote(task_match.group(1)), label="task_id"
|
||||
)
|
||||
return HTTPStatus.OK, {
|
||||
"task": _json_value(self.service.get_task(context, task_id))
|
||||
}
|
||||
|
||||
bypass_match = re.fullmatch(
|
||||
r"/api/v2/tasks/([^/]+)/(start|complete|fail)", path
|
||||
)
|
||||
if method == "POST" and bypass_match:
|
||||
return HTTPStatus.FORBIDDEN, {
|
||||
"error": "RuntimeLifecycleBypassDenied",
|
||||
"message": (
|
||||
"RUNNING, COMPLETED and FAILED transitions are internal; "
|
||||
"use the provenance-protected dispatch/reconcile flow"
|
||||
),
|
||||
}
|
||||
|
||||
transition_match = re.fullmatch(
|
||||
r"/api/v2/tasks/([^/]+)/(approve|cancel)", path
|
||||
)
|
||||
if method == "POST" and transition_match:
|
||||
task_id = _require_resource_id(
|
||||
urllib.parse.unquote(transition_match.group(1)), label="task_id"
|
||||
)
|
||||
target = (
|
||||
TaskState.APPROVED
|
||||
if transition_match.group(2) == "approve"
|
||||
else TaskState.CANCELLED
|
||||
)
|
||||
expected_revision = payload.get("expected_revision")
|
||||
task = self.service.transition_task(
|
||||
context,
|
||||
task_id=task_id,
|
||||
target_state=target,
|
||||
expected_revision=(
|
||||
int(expected_revision) if expected_revision is not None else None
|
||||
),
|
||||
)
|
||||
return HTTPStatus.OK, {"task": _json_value(task)}
|
||||
|
||||
if method == "GET" and path == "/api/v2/audit":
|
||||
resource_id = query.get("resource_id", [None])[0]
|
||||
events = self.service.list_audit_events(
|
||||
context,
|
||||
resource_id=(
|
||||
_require_resource_id(resource_id, label="resource_id")
|
||||
if resource_id
|
||||
else None
|
||||
),
|
||||
)
|
||||
return HTTPStatus.OK, {"events": _json_value(events)}
|
||||
|
||||
return HTTPStatus.NOT_FOUND, {
|
||||
"error": "not_found",
|
||||
"message": "route not found",
|
||||
}
|
||||
|
||||
|
||||
_ERROR_STATUS: tuple[tuple[type[BaseException], HTTPStatus], ...] = (
|
||||
(Unauthorized, HTTPStatus.UNAUTHORIZED),
|
||||
(PolicyDenied, HTTPStatus.FORBIDDEN),
|
||||
(ProvenanceDenied, HTTPStatus.FORBIDDEN),
|
||||
(TenantIsolationError, HTTPStatus.NOT_FOUND),
|
||||
(NotFound, HTTPStatus.NOT_FOUND),
|
||||
(DispatchNotFound, HTTPStatus.NOT_FOUND),
|
||||
(HermesNotFound, HTTPStatus.NOT_FOUND),
|
||||
(ProvenanceReplay, HTTPStatus.CONFLICT),
|
||||
(IdempotencyConflict, HTTPStatus.CONFLICT),
|
||||
(RevisionConflict, HTTPStatus.CONFLICT),
|
||||
(InvalidTransition, HTTPStatus.CONFLICT),
|
||||
(DispatchConflict, HTTPStatus.CONFLICT),
|
||||
(HermesConflict, HTTPStatus.CONFLICT),
|
||||
(OrchestrationError, HTTPStatus.CONFLICT),
|
||||
(ValueError, HTTPStatus.BAD_REQUEST),
|
||||
(ControlPlaneError, HTTPStatus.BAD_REQUEST),
|
||||
)
|
||||
|
||||
|
||||
def error_response(exc: BaseException) -> tuple[int, Mapping[str, Any]]:
|
||||
for error_type, status in _ERROR_STATUS:
|
||||
if isinstance(exc, error_type):
|
||||
return status, {"error": error_type.__name__, "message": str(exc)}
|
||||
return HTTPStatus.INTERNAL_SERVER_ERROR, {
|
||||
"error": "InternalServerError",
|
||||
"message": "internal server error",
|
||||
}
|
||||
|
||||
|
||||
class GatewayRequestHandler(BaseHTTPRequestHandler):
|
||||
server_version = "AIOSV2Gateway/1.0"
|
||||
max_body_bytes = 1_048_576
|
||||
|
||||
@property
|
||||
def application(self) -> GatewayApplication:
|
||||
return self.server.application # type: ignore[attr-defined]
|
||||
|
||||
def _read_body(self) -> Any:
|
||||
length = int(self.headers.get("Content-Length", "0") or "0")
|
||||
if length < 0 or length > self.max_body_bytes:
|
||||
raise ValueError("request body is too large")
|
||||
if length == 0:
|
||||
return {}
|
||||
content_type = self.headers.get("Content-Type", "").split(";", 1)[0].strip()
|
||||
if content_type != "application/json":
|
||||
raise ValueError("Content-Type must be application/json")
|
||||
return json.loads(self.rfile.read(length).decode("utf-8"))
|
||||
|
||||
def _send_json(self, status: int, payload: Mapping[str, Any]) -> None:
|
||||
encoded = json.dumps(
|
||||
_json_value(payload), ensure_ascii=False, separators=(",", ":")
|
||||
).encode("utf-8")
|
||||
self.send_response(int(status))
|
||||
self.send_header("Content-Type", "application/json; charset=utf-8")
|
||||
self.send_header("Content-Length", str(len(encoded)))
|
||||
self.send_header("Cache-Control", "no-store")
|
||||
self.send_header("X-Content-Type-Options", "nosniff")
|
||||
self.end_headers()
|
||||
self.wfile.write(encoded)
|
||||
|
||||
def _dispatch(self, method: str) -> None:
|
||||
try:
|
||||
body = self._read_body() if method in {"POST", "PUT", "PATCH"} else {}
|
||||
status, payload = self.application.handle(
|
||||
method,
|
||||
self.path,
|
||||
{key: value for key, value in self.headers.items()},
|
||||
body,
|
||||
)
|
||||
except Exception as exc:
|
||||
status, payload = error_response(exc)
|
||||
self._send_json(status, payload)
|
||||
|
||||
def do_GET(self) -> None: # noqa: N802
|
||||
self._dispatch("GET")
|
||||
|
||||
def do_POST(self) -> None: # noqa: N802
|
||||
self._dispatch("POST")
|
||||
|
||||
def log_message(self, format: str, *args: Any) -> None:
|
||||
super().log_message(format, *args)
|
||||
|
||||
|
||||
class GatewayHTTPServer(ThreadingHTTPServer):
|
||||
daemon_threads = True
|
||||
allow_reuse_address = True
|
||||
|
||||
def __init__(
|
||||
self,
|
||||
server_address: tuple[str, int],
|
||||
application: GatewayApplication,
|
||||
) -> None:
|
||||
self.application = application
|
||||
super().__init__(server_address, GatewayRequestHandler)
|
||||
|
||||
|
||||
def main() -> None:
|
||||
host = os.getenv("AIOS_V2_GATEWAY_HOST", "127.0.0.1")
|
||||
port = int(os.getenv("AIOS_V2_GATEWAY_PORT", "18920"))
|
||||
server = GatewayHTTPServer((host, port), GatewayApplication())
|
||||
print(f"AIOS V2 control-plane gateway listening on {host}:{port}")
|
||||
server.serve_forever()
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@@ -1,123 +0,0 @@
|
||||
"""Sanitized GitOps runtime status for the AIOS Web control plane."""
|
||||
from __future__ import annotations
|
||||
|
||||
import os
|
||||
import subprocess
|
||||
from dataclasses import dataclass, asdict
|
||||
from pathlib import Path
|
||||
from typing import Any, Mapping
|
||||
|
||||
|
||||
@dataclass(frozen=True)
|
||||
class GitOpsStatus:
|
||||
available: bool
|
||||
service_status: str
|
||||
workspace_mode: str
|
||||
workspace_branch: str | None
|
||||
workspace_ref: str | None
|
||||
workspace_dirty: bool | None
|
||||
candidate_branch: str
|
||||
release_channel: str
|
||||
release_version: str
|
||||
sync_status: str
|
||||
details: Mapping[str, Any]
|
||||
|
||||
def as_dict(self) -> dict[str, Any]:
|
||||
return asdict(self)
|
||||
|
||||
|
||||
def _run_git(worktree: Path, *args: str) -> tuple[int, str, str]:
|
||||
process = subprocess.run(
|
||||
["git", "-C", str(worktree), *args],
|
||||
text=True,
|
||||
capture_output=True,
|
||||
timeout=5,
|
||||
)
|
||||
return process.returncode, process.stdout.strip(), process.stderr.strip()
|
||||
|
||||
|
||||
def collect_gitops_status() -> GitOpsStatus:
|
||||
"""Return only non-sensitive Git/workspace metadata.
|
||||
|
||||
Remote URLs, environment values, credentials, filesystem contents and
|
||||
command stderr are deliberately excluded from the Web response.
|
||||
"""
|
||||
|
||||
candidate_branch = os.getenv(
|
||||
"AIOS_CANDIDATE_BRANCH",
|
||||
"integration/aios-v2r1-cto-production-candidate-20260720",
|
||||
)
|
||||
release_channel = os.getenv("AIOS_RELEASE_CHANNEL", "candidate")
|
||||
release_version = os.getenv("AIOS_RELEASE_VERSION", "V2R1C0-candidate")
|
||||
sync_status = os.getenv("AIOS_GITOPS_SYNC_STATUS", "unknown")
|
||||
worktree = Path(
|
||||
os.getenv(
|
||||
"AIOS_GITOPS_CONTROLLER_WORKTREE",
|
||||
"/data/aios-gitops/worktrees/controller",
|
||||
)
|
||||
)
|
||||
|
||||
if not worktree.is_dir():
|
||||
return GitOpsStatus(
|
||||
available=False,
|
||||
service_status="unknown",
|
||||
workspace_mode="unavailable",
|
||||
workspace_branch=None,
|
||||
workspace_ref=None,
|
||||
workspace_dirty=None,
|
||||
candidate_branch=candidate_branch,
|
||||
release_channel=release_channel,
|
||||
release_version=release_version,
|
||||
sync_status=sync_status,
|
||||
details={"reason": "controller_worktree_unavailable"},
|
||||
)
|
||||
|
||||
inside_code, inside, _ = _run_git(worktree, "rev-parse", "--is-inside-work-tree")
|
||||
if inside_code != 0 or inside != "true":
|
||||
return GitOpsStatus(
|
||||
available=False,
|
||||
service_status="unknown",
|
||||
workspace_mode="invalid",
|
||||
workspace_branch=None,
|
||||
workspace_ref=None,
|
||||
workspace_dirty=None,
|
||||
candidate_branch=candidate_branch,
|
||||
release_channel=release_channel,
|
||||
release_version=release_version,
|
||||
sync_status=sync_status,
|
||||
details={"reason": "controller_worktree_invalid"},
|
||||
)
|
||||
|
||||
branch_code, branch, _ = _run_git(worktree, "branch", "--show-current")
|
||||
ref_code, ref_value, _ = _run_git(worktree, "rev-parse", "HEAD")
|
||||
dirty_code, dirty_value, _ = _run_git(worktree, "status", "--porcelain=v1")
|
||||
|
||||
service_status = "unknown"
|
||||
try:
|
||||
process = subprocess.run(
|
||||
["systemctl", "is-active", "aios-gitops-model-api"],
|
||||
text=True,
|
||||
capture_output=True,
|
||||
timeout=3,
|
||||
)
|
||||
service_status = process.stdout.strip() or "inactive"
|
||||
except (FileNotFoundError, subprocess.TimeoutExpired):
|
||||
service_status = "unavailable"
|
||||
|
||||
branch_value = branch if branch_code == 0 and branch else None
|
||||
return GitOpsStatus(
|
||||
available=True,
|
||||
service_status=service_status,
|
||||
workspace_mode="branch" if branch_value else "detached",
|
||||
workspace_branch=branch_value,
|
||||
workspace_ref=ref_value if ref_code == 0 else None,
|
||||
workspace_dirty=bool(dirty_value) if dirty_code == 0 else None,
|
||||
candidate_branch=candidate_branch,
|
||||
release_channel=release_channel,
|
||||
release_version=release_version,
|
||||
sync_status=sync_status,
|
||||
details={
|
||||
"controller_clean": dirty_code == 0 and not dirty_value,
|
||||
"controller_detached": branch_code == 0 and not branch,
|
||||
},
|
||||
)
|
||||
@@ -1,238 +0,0 @@
|
||||
"""Official AIOS executor providers built on the portable provider protocol.
|
||||
|
||||
The official providers contain no lifecycle implementation. They validate their
|
||||
manifests, resolve a generic ``UnifiedExecutorWorker`` from runtime-supplied
|
||||
boundaries and expose the same adapter contract. Future providers can use
|
||||
``ConfiguredExecutorProvider`` directly without changing AIOS core modules.
|
||||
"""
|
||||
from __future__ import annotations
|
||||
|
||||
from dataclasses import dataclass
|
||||
from typing import Any, Mapping, Sequence
|
||||
|
||||
from .execution_plan import ExecutionPlanCoordinator, ExecutionStageManifest
|
||||
from .executor_protocol import (
|
||||
EXECUTOR_PROTOCOL_VERSION,
|
||||
ExternalExecutorAdapter,
|
||||
ExecutorProviderDescriptor,
|
||||
normalize_executor,
|
||||
)
|
||||
from .executor_worker import NotificationSender, StepRunner, UnifiedExecutorWorker
|
||||
from .external_task_control import ExternalTaskCoordinator
|
||||
from .task_execution_registry import ExecutionTaskManifest, ExecutionTruthRecord
|
||||
|
||||
|
||||
@dataclass(frozen=True)
|
||||
class ProviderRuntimeConfiguration:
|
||||
plan_id: str
|
||||
executor_id: str
|
||||
plan_coordinator: ExecutionPlanCoordinator
|
||||
task_coordinator: ExternalTaskCoordinator
|
||||
providers: Any
|
||||
step_runner: StepRunner
|
||||
notification_sender: NotificationSender
|
||||
|
||||
@classmethod
|
||||
def from_mapping(cls, value: Mapping[str, Any]) -> "ProviderRuntimeConfiguration":
|
||||
required = (
|
||||
"plan_id",
|
||||
"executor_id",
|
||||
"plan_coordinator",
|
||||
"task_coordinator",
|
||||
"providers",
|
||||
"step_runner",
|
||||
"notification_sender",
|
||||
)
|
||||
missing = [name for name in required if value.get(name) is None]
|
||||
if missing:
|
||||
raise ValueError(f"provider runtime configuration is missing: {missing}")
|
||||
return cls(**{name: value[name] for name in required})
|
||||
|
||||
|
||||
class ConfiguredExecutorAdapter:
|
||||
"""Generic adapter produced by every official or third-party provider."""
|
||||
|
||||
def __init__(
|
||||
self,
|
||||
descriptor: ExecutorProviderDescriptor,
|
||||
configuration: ProviderRuntimeConfiguration,
|
||||
) -> None:
|
||||
self.descriptor = descriptor
|
||||
self.configuration = configuration
|
||||
self.worker = UnifiedExecutorWorker(
|
||||
plan_coordinator=configuration.plan_coordinator,
|
||||
task_coordinator=configuration.task_coordinator,
|
||||
providers=configuration.providers,
|
||||
executor_type=descriptor.executor_type,
|
||||
executor_id=configuration.executor_id,
|
||||
step_runner=configuration.step_runner,
|
||||
notification_sender=configuration.notification_sender,
|
||||
)
|
||||
|
||||
def discover(self) -> Sequence[ExecutionTruthRecord]:
|
||||
ready = self.configuration.plan_coordinator.discover_ready(
|
||||
plan_id=self.configuration.plan_id,
|
||||
executor_type=self.descriptor.executor_type,
|
||||
)
|
||||
return tuple(item["record"] for item in ready)
|
||||
|
||||
def execute(self, manifest: ExecutionTaskManifest) -> Mapping[str, Any]:
|
||||
if normalize_executor(manifest.executor) != self.descriptor.executor_type:
|
||||
raise PermissionError("manifest executor does not match adapter provider")
|
||||
plan = self.configuration.plan_coordinator.plan_store.get(
|
||||
self.configuration.plan_id
|
||||
)
|
||||
stage: ExecutionStageManifest | None = None
|
||||
for item in plan.stages:
|
||||
if item.task_id == manifest.task_id:
|
||||
stage = item
|
||||
break
|
||||
if stage is None:
|
||||
raise KeyError("manifest task is not part of configured execution plan")
|
||||
return self.worker.run_stage(
|
||||
plan_id=plan.plan_id,
|
||||
stage_id=stage.stage_id,
|
||||
).as_dict()
|
||||
|
||||
def notify_owner(self, payload: Mapping[str, Any]) -> str:
|
||||
# External callers normally use the durable NotificationOutbox. This
|
||||
# method remains part of the portable adapter contract for providers
|
||||
# that need to send a standalone operational notice.
|
||||
from .external_task_control import NotificationRecord
|
||||
from .task_execution_registry import utc_now
|
||||
|
||||
notification = NotificationRecord(
|
||||
notification_id="provider_direct_notice",
|
||||
task_id=str(payload.get("task_id") or "provider-notice"),
|
||||
event_type=str(payload.get("event_type") or "INFO"),
|
||||
target_ref=str(
|
||||
payload.get("target_ref") or "AIOS_OWNER_WECHAT_TARGET_REF"
|
||||
),
|
||||
payload=dict(payload),
|
||||
status="PENDING",
|
||||
created_at=utc_now(),
|
||||
)
|
||||
return self.configuration.notification_sender.send(notification)
|
||||
|
||||
|
||||
class ConfiguredExecutorProvider:
|
||||
"""Reusable provider implementation for current and future executors."""
|
||||
|
||||
descriptor: ExecutorProviderDescriptor
|
||||
|
||||
def __init__(self, descriptor: ExecutorProviderDescriptor) -> None:
|
||||
self.descriptor = descriptor
|
||||
|
||||
def validate_manifest(self, manifest: ExecutionTaskManifest) -> None:
|
||||
if normalize_executor(manifest.executor) != self.descriptor.executor_type:
|
||||
raise ValueError("manifest executor does not match provider")
|
||||
if manifest.manifest_version not in {
|
||||
"aios.external-task.v1",
|
||||
"aios.external-task.v2",
|
||||
}:
|
||||
raise ValueError("unsupported external task manifest version")
|
||||
if not manifest.steps:
|
||||
raise ValueError("executor manifest has no steps")
|
||||
|
||||
def build_adapter(self, configuration: Mapping[str, Any]) -> ExternalExecutorAdapter:
|
||||
return ConfiguredExecutorAdapter(
|
||||
self.descriptor,
|
||||
ProviderRuntimeConfiguration.from_mapping(configuration),
|
||||
)
|
||||
|
||||
|
||||
class OpenClawProvider(ConfiguredExecutorProvider):
|
||||
def __init__(self) -> None:
|
||||
super().__init__(
|
||||
ExecutorProviderDescriptor(
|
||||
executor_type="openclaw",
|
||||
adapter_version="2.1.0",
|
||||
protocol_version=EXECUTOR_PROTOCOL_VERSION,
|
||||
trust_roles=("runtime", "openclaw_executor"),
|
||||
capabilities=(
|
||||
"deploy",
|
||||
"http_runtime",
|
||||
"owner_notification",
|
||||
"healthcheck",
|
||||
"rollback",
|
||||
),
|
||||
configuration_schema="aios.executor.openclaw.config.v1",
|
||||
metadata={"official": True},
|
||||
)
|
||||
)
|
||||
|
||||
|
||||
class HermesProvider(ConfiguredExecutorProvider):
|
||||
def __init__(self) -> None:
|
||||
super().__init__(
|
||||
ExecutorProviderDescriptor(
|
||||
executor_type="hermes",
|
||||
adapter_version="2.1.0",
|
||||
protocol_version=EXECUTOR_PROTOCOL_VERSION,
|
||||
trust_roles=("runtime", "hermes_executor"),
|
||||
capabilities=(
|
||||
"queue",
|
||||
"lease",
|
||||
"worker",
|
||||
"runtime_validation",
|
||||
"restart_recovery",
|
||||
),
|
||||
configuration_schema="aios.executor.hermes.config.v1",
|
||||
metadata={"official": True},
|
||||
)
|
||||
)
|
||||
|
||||
|
||||
class CodexProvider(ConfiguredExecutorProvider):
|
||||
def __init__(self) -> None:
|
||||
super().__init__(
|
||||
ExecutorProviderDescriptor(
|
||||
executor_type="codex",
|
||||
adapter_version="2.1.0",
|
||||
protocol_version=EXECUTOR_PROTOCOL_VERSION,
|
||||
trust_roles=("codex", "codex_executor"),
|
||||
capabilities=(
|
||||
"code",
|
||||
"test",
|
||||
"docs",
|
||||
"gitops_patch",
|
||||
"security_review",
|
||||
),
|
||||
configuration_schema="aios.executor.codex.config.v1",
|
||||
metadata={"official": True},
|
||||
)
|
||||
)
|
||||
|
||||
|
||||
class ChatGPTSupervisorProvider(ConfiguredExecutorProvider):
|
||||
"""Explicit takeover provider; it does not inherit Codex permissions."""
|
||||
|
||||
def __init__(self) -> None:
|
||||
super().__init__(
|
||||
ExecutorProviderDescriptor(
|
||||
executor_type="chatgpt-supervisor",
|
||||
adapter_version="2.1.0",
|
||||
protocol_version=EXECUTOR_PROTOCOL_VERSION,
|
||||
trust_roles=("chatgpt_supervisor",),
|
||||
capabilities=(
|
||||
"acceptance",
|
||||
"deploy",
|
||||
"evidence",
|
||||
"healthcheck",
|
||||
"rollback",
|
||||
"wechat_simulation",
|
||||
),
|
||||
configuration_schema="aios.executor.chatgpt-supervisor.config.v1",
|
||||
metadata={"official": True, "production_mutation_allowed": False},
|
||||
)
|
||||
)
|
||||
|
||||
|
||||
def official_provider_factories() -> Mapping[str, ConfiguredExecutorProvider]:
|
||||
providers = (
|
||||
OpenClawProvider(),
|
||||
HermesProvider(),
|
||||
CodexProvider(),
|
||||
ChatGPTSupervisorProvider(),
|
||||
)
|
||||
return {item.descriptor.executor_type: item for item in providers}
|
||||
@@ -1,599 +0,0 @@
|
||||
"""AIOS V2 execution orchestrator.
|
||||
|
||||
The orchestrator is the only component allowed to translate an approved AIOS
|
||||
Task into an OpenClaw command or Hermes job. Every dispatch is persisted before
|
||||
Runtime side effects. Runtime results must bind to the exact dispatch,
|
||||
command/job, tenant, task, trace, principal and provenance context.
|
||||
"""
|
||||
from __future__ import annotations
|
||||
|
||||
from typing import Any, Mapping, Protocol
|
||||
|
||||
from aios_hermes import HermesAdapter, HermesJob, HermesJobState, HermesResult
|
||||
from aios_openclaw import (
|
||||
CommandState,
|
||||
OpenClawAdapter,
|
||||
OpenClawCommand,
|
||||
OpenClawResult,
|
||||
sign_command,
|
||||
)
|
||||
|
||||
from .control_plane import (
|
||||
AgentRecord,
|
||||
ControlPlaneService,
|
||||
RequestContext,
|
||||
TaskRecord,
|
||||
TaskState,
|
||||
)
|
||||
from .dispatch_store import (
|
||||
DispatchConflict,
|
||||
DispatchRecord,
|
||||
DispatchRepository,
|
||||
DispatchState,
|
||||
InMemoryDispatchRepository,
|
||||
TERMINAL_DISPATCH_STATES,
|
||||
)
|
||||
from .provenance import ProvenanceDenied, digest_payload
|
||||
|
||||
|
||||
class RuntimeAuthorizationWriter(Protocol):
|
||||
def authorize_runtime_execute(self, **values: Any) -> Any: ...
|
||||
|
||||
|
||||
class OrchestrationError(RuntimeError):
|
||||
"""AIOS failed to dispatch or reconcile a runtime execution."""
|
||||
|
||||
|
||||
class ExecutionOrchestrator:
|
||||
"""Dispatch approved AIOS tasks and strictly reconcile Runtime results."""
|
||||
|
||||
def __init__(
|
||||
self,
|
||||
control_plane: ControlPlaneService,
|
||||
*,
|
||||
openclaw: OpenClawAdapter | None = None,
|
||||
hermes: HermesAdapter | None = None,
|
||||
openclaw_signing_material_resolver=None,
|
||||
openclaw_key_id: str = "default",
|
||||
default_cell_id: str = "default",
|
||||
default_profile_id: str = "default",
|
||||
provenance_writer: RuntimeAuthorizationWriter | None = None,
|
||||
require_provenance: bool = False,
|
||||
dispatch_repository: DispatchRepository | None = None,
|
||||
) -> None:
|
||||
self.control_plane = control_plane
|
||||
self.openclaw = openclaw
|
||||
self.hermes = hermes
|
||||
self.openclaw_signing_material_resolver = openclaw_signing_material_resolver
|
||||
self.openclaw_key_id = str(openclaw_key_id or "").strip() or "default"
|
||||
self.default_cell_id = default_cell_id
|
||||
self.default_profile_id = default_profile_id
|
||||
self.provenance_writer = provenance_writer
|
||||
self.require_provenance = bool(require_provenance)
|
||||
self.dispatch_repository = dispatch_repository or InMemoryDispatchRepository()
|
||||
if self.require_provenance and self.provenance_writer is None:
|
||||
raise ValueError("production orchestration requires a provenance writer")
|
||||
|
||||
@staticmethod
|
||||
def _record_provenance(value: str | None, *, required: bool, label: str) -> str:
|
||||
normalized = str(value or "").strip()
|
||||
if required and not normalized:
|
||||
raise OrchestrationError(f"production dispatch requires {label}")
|
||||
return normalized or f"{label}-not-required"
|
||||
|
||||
def _authorize_dispatch(
|
||||
self,
|
||||
context: RequestContext,
|
||||
*,
|
||||
task: TaskRecord,
|
||||
agent: AgentRecord,
|
||||
provenance_id: str | None,
|
||||
run_id: str | None,
|
||||
timeout_seconds: float | None,
|
||||
) -> str:
|
||||
if not self.require_provenance:
|
||||
return "authorization-not-required"
|
||||
if self.provenance_writer is None:
|
||||
raise OrchestrationError("Run Provenance writer is not configured")
|
||||
if not provenance_id or not run_id:
|
||||
raise OrchestrationError(
|
||||
"production dispatch requires provenance_id and run_id"
|
||||
)
|
||||
request_digest = digest_payload(
|
||||
{
|
||||
"operation": "dispatch",
|
||||
"tenant_id": task.tenant_id,
|
||||
"task_id": task.task_id,
|
||||
"agent_id": agent.agent_id,
|
||||
"principal_id": context.principal_id,
|
||||
"runtime": agent.runtime.strip().lower(),
|
||||
"action": task.action,
|
||||
"payload": task.payload,
|
||||
"trace_id": context.trace_id,
|
||||
"timeout_seconds": timeout_seconds,
|
||||
"task_revision": task.revision,
|
||||
}
|
||||
)
|
||||
try:
|
||||
authorization = self.provenance_writer.authorize_runtime_execute(
|
||||
provenance_id=provenance_id,
|
||||
run_id=run_id,
|
||||
tenant_id=task.tenant_id,
|
||||
task_id=task.task_id,
|
||||
agent_id=agent.agent_id,
|
||||
principal_id=context.principal_id,
|
||||
request_digest=request_digest,
|
||||
)
|
||||
return authorization.authorization_id
|
||||
except ProvenanceDenied as exc:
|
||||
raise OrchestrationError(f"Run Provenance denied dispatch: {exc}") from exc
|
||||
|
||||
def dispatch(
|
||||
self,
|
||||
context: RequestContext,
|
||||
*,
|
||||
task_id: str,
|
||||
timeout_seconds: float | None = None,
|
||||
provenance_id: str | None = None,
|
||||
run_id: str | None = None,
|
||||
) -> DispatchRecord:
|
||||
task = self.control_plane.get_task(context, task_id)
|
||||
agent = self.control_plane.get_agent(context, task.agent_id)
|
||||
persisted_provenance = self._record_provenance(
|
||||
provenance_id, required=self.require_provenance, label="provenance_id"
|
||||
)
|
||||
persisted_run = self._record_provenance(
|
||||
run_id, required=self.require_provenance, label="run_id"
|
||||
)
|
||||
|
||||
existing = self.dispatch_repository.get_by_task(
|
||||
task.task_id, tenant_id=task.tenant_id
|
||||
)
|
||||
if existing is not None:
|
||||
if (
|
||||
existing.provenance_id != persisted_provenance
|
||||
or existing.run_id != persisted_run
|
||||
or existing.principal_id != context.principal_id
|
||||
):
|
||||
raise OrchestrationError(
|
||||
"existing dispatch belongs to another provenance or principal context"
|
||||
)
|
||||
return existing
|
||||
|
||||
if task.state != TaskState.APPROVED:
|
||||
raise OrchestrationError("only APPROVED tasks may be dispatched")
|
||||
|
||||
authorization_id = self._authorize_dispatch(
|
||||
context,
|
||||
task=task,
|
||||
agent=agent,
|
||||
provenance_id=provenance_id,
|
||||
run_id=run_id,
|
||||
timeout_seconds=timeout_seconds,
|
||||
)
|
||||
runtime = agent.runtime.strip().lower()
|
||||
prepared: DispatchRecord | None = None
|
||||
|
||||
try:
|
||||
if runtime == "openclaw":
|
||||
command = self._create_openclaw_command(context, task)
|
||||
prepared = self.dispatch_repository.create(
|
||||
DispatchRecord.create(
|
||||
tenant_id=task.tenant_id,
|
||||
task_id=task.task_id,
|
||||
agent_id=agent.agent_id,
|
||||
principal_id=context.principal_id,
|
||||
runtime="openclaw",
|
||||
runtime_execution_id=command.command_id,
|
||||
trace_id=context.trace_id,
|
||||
provenance_id=persisted_provenance,
|
||||
run_id=persisted_run,
|
||||
authorization_id=authorization_id,
|
||||
)
|
||||
)
|
||||
self.control_plane.transition_task(
|
||||
context,
|
||||
task_id=task.task_id,
|
||||
target_state=TaskState.RUNNING,
|
||||
expected_revision=task.revision,
|
||||
)
|
||||
self.dispatch_repository.update(
|
||||
prepared.dispatch_id,
|
||||
tenant_id=prepared.tenant_id,
|
||||
state=DispatchState.RUNNING,
|
||||
)
|
||||
if self.openclaw is None:
|
||||
raise OrchestrationError("OpenClaw runtime is not configured")
|
||||
result = self.openclaw.execute(
|
||||
command, timeout_seconds=timeout_seconds
|
||||
)
|
||||
self.reconcile_openclaw(
|
||||
context,
|
||||
result,
|
||||
dispatch_id=prepared.dispatch_id,
|
||||
provenance_id=persisted_provenance,
|
||||
run_id=persisted_run,
|
||||
)
|
||||
return self.dispatch_repository.get(
|
||||
prepared.dispatch_id, tenant_id=prepared.tenant_id
|
||||
)
|
||||
|
||||
if runtime == "hermes":
|
||||
if self.hermes is None:
|
||||
raise OrchestrationError("Hermes runtime is not configured")
|
||||
job = self._create_hermes_job(context, agent, task)
|
||||
prepared = self.dispatch_repository.create(
|
||||
DispatchRecord.create(
|
||||
tenant_id=task.tenant_id,
|
||||
task_id=task.task_id,
|
||||
agent_id=agent.agent_id,
|
||||
principal_id=context.principal_id,
|
||||
runtime="hermes",
|
||||
runtime_execution_id=job.job_id,
|
||||
trace_id=context.trace_id,
|
||||
provenance_id=persisted_provenance,
|
||||
run_id=persisted_run,
|
||||
authorization_id=authorization_id,
|
||||
)
|
||||
)
|
||||
self.control_plane.transition_task(
|
||||
context,
|
||||
task_id=task.task_id,
|
||||
target_state=TaskState.RUNNING,
|
||||
expected_revision=task.revision,
|
||||
)
|
||||
queued = self.hermes.enqueue(job)
|
||||
return self.dispatch_repository.update(
|
||||
prepared.dispatch_id,
|
||||
tenant_id=prepared.tenant_id,
|
||||
state=DispatchState.QUEUED,
|
||||
result_digest=digest_payload(
|
||||
{
|
||||
"queued_job_id": queued.job_id,
|
||||
"state": queued.state.value,
|
||||
"revision": queued.revision,
|
||||
}
|
||||
),
|
||||
)
|
||||
|
||||
raise OrchestrationError(f"unsupported runtime: {agent.runtime}")
|
||||
except Exception as exc:
|
||||
if prepared is not None:
|
||||
try:
|
||||
self.dispatch_repository.update(
|
||||
prepared.dispatch_id,
|
||||
tenant_id=prepared.tenant_id,
|
||||
state=DispatchState.FAILED,
|
||||
result_digest=digest_payload(
|
||||
{
|
||||
"code": "dispatch_failed",
|
||||
"error_type": type(exc).__name__,
|
||||
"message": str(exc),
|
||||
}
|
||||
),
|
||||
)
|
||||
except Exception:
|
||||
pass
|
||||
current = self.control_plane.get_task(context, task.task_id)
|
||||
if current.state == TaskState.RUNNING:
|
||||
self.control_plane.transition_task(
|
||||
context,
|
||||
task_id=task.task_id,
|
||||
target_state=TaskState.FAILED,
|
||||
expected_revision=current.revision,
|
||||
error={"code": "dispatch_failed", "message": str(exc)},
|
||||
)
|
||||
raise
|
||||
|
||||
def _create_openclaw_command(
|
||||
self,
|
||||
context: RequestContext,
|
||||
task: TaskRecord,
|
||||
) -> OpenClawCommand:
|
||||
if self.openclaw_signing_material_resolver is None:
|
||||
raise OrchestrationError("OpenClaw signing material is not configured")
|
||||
key_material = self.openclaw_signing_material_resolver(
|
||||
task.tenant_id,
|
||||
self.openclaw_key_id,
|
||||
)
|
||||
command = OpenClawCommand.create(
|
||||
tenant_id=task.tenant_id,
|
||||
task_id=task.task_id,
|
||||
trace_id=context.trace_id,
|
||||
action=task.action,
|
||||
payload=task.payload,
|
||||
idempotency_key=task.idempotency_key or task.task_id,
|
||||
key_id=self.openclaw_key_id,
|
||||
)
|
||||
return sign_command(command, key_material)
|
||||
|
||||
def _create_hermes_job(
|
||||
self,
|
||||
context: RequestContext,
|
||||
agent: AgentRecord,
|
||||
task: TaskRecord,
|
||||
) -> HermesJob:
|
||||
metadata = dict(agent.metadata)
|
||||
return HermesJob.create(
|
||||
tenant_id=task.tenant_id,
|
||||
cell_id=str(metadata.get("cell_id") or self.default_cell_id),
|
||||
profile_id=str(metadata.get("profile_id") or self.default_profile_id),
|
||||
task_id=task.task_id,
|
||||
trace_id=context.trace_id,
|
||||
action=task.action,
|
||||
payload=task.payload,
|
||||
idempotency_key=task.idempotency_key or task.task_id,
|
||||
priority=int(metadata.get("priority", 100)),
|
||||
)
|
||||
|
||||
@staticmethod
|
||||
def _assert_dispatch_context(
|
||||
dispatch: DispatchRecord,
|
||||
*,
|
||||
runtime: str,
|
||||
runtime_execution_id: str,
|
||||
tenant_id: str,
|
||||
task_id: str,
|
||||
trace_id: str,
|
||||
principal_id: str,
|
||||
provenance_id: str,
|
||||
run_id: str,
|
||||
) -> None:
|
||||
expected = {
|
||||
"runtime": runtime,
|
||||
"runtime_execution_id": runtime_execution_id,
|
||||
"tenant_id": tenant_id,
|
||||
"task_id": task_id,
|
||||
"trace_id": trace_id,
|
||||
"principal_id": principal_id,
|
||||
"provenance_id": provenance_id,
|
||||
"run_id": run_id,
|
||||
}
|
||||
for field_name, expected_value in expected.items():
|
||||
if getattr(dispatch, field_name) != expected_value:
|
||||
raise OrchestrationError(f"dispatch {field_name} mismatch")
|
||||
|
||||
def hermes_lifecycle_context(
|
||||
self,
|
||||
context: RequestContext,
|
||||
*,
|
||||
dispatch_id: str,
|
||||
job_id: str,
|
||||
tenant_id: str,
|
||||
task_id: str,
|
||||
trace_id: str,
|
||||
principal_id: str,
|
||||
provenance_id: str,
|
||||
run_id: str,
|
||||
) -> tuple[DispatchRecord, HermesJob]:
|
||||
"""Resolve a runtime lifecycle request against its durable dispatch."""
|
||||
dispatch = self.dispatch_repository.get(
|
||||
dispatch_id, tenant_id=context.tenant_id
|
||||
)
|
||||
self._assert_dispatch_context(
|
||||
dispatch,
|
||||
runtime="hermes",
|
||||
runtime_execution_id=job_id,
|
||||
tenant_id=tenant_id,
|
||||
task_id=task_id,
|
||||
trace_id=trace_id,
|
||||
principal_id=principal_id,
|
||||
provenance_id=provenance_id,
|
||||
run_id=run_id,
|
||||
)
|
||||
if context.tenant_id != tenant_id:
|
||||
raise OrchestrationError("runtime context tenant_id mismatch")
|
||||
if context.principal_id != principal_id:
|
||||
raise OrchestrationError("runtime context principal_id mismatch")
|
||||
if context.trace_id != trace_id:
|
||||
raise OrchestrationError("runtime context trace_id mismatch")
|
||||
if self.hermes is None:
|
||||
raise OrchestrationError("Hermes runtime is not configured")
|
||||
job = self.hermes.get(job_id, tenant_id=tenant_id)
|
||||
if job.task_id != task_id or job.trace_id != trace_id:
|
||||
raise OrchestrationError("Hermes job identity mismatch")
|
||||
return dispatch, job
|
||||
|
||||
def bind_hermes_worker(
|
||||
self,
|
||||
context: RequestContext,
|
||||
job: HermesJob,
|
||||
*,
|
||||
dispatch_id: str,
|
||||
provenance_id: str,
|
||||
run_id: str,
|
||||
worker_id: str,
|
||||
) -> DispatchRecord:
|
||||
dispatch, current = self.hermes_lifecycle_context(
|
||||
context,
|
||||
dispatch_id=dispatch_id,
|
||||
job_id=job.job_id,
|
||||
tenant_id=job.tenant_id,
|
||||
task_id=job.task_id,
|
||||
trace_id=job.trace_id,
|
||||
principal_id=context.principal_id,
|
||||
provenance_id=provenance_id,
|
||||
run_id=run_id,
|
||||
)
|
||||
if current.assigned_worker_id != worker_id:
|
||||
raise OrchestrationError("Hermes worker does not own claimed job")
|
||||
return self.dispatch_repository.update(
|
||||
dispatch.dispatch_id,
|
||||
tenant_id=dispatch.tenant_id,
|
||||
expected_worker_id=worker_id,
|
||||
)
|
||||
|
||||
def reconcile_openclaw(
|
||||
self,
|
||||
context: RequestContext,
|
||||
result: OpenClawResult,
|
||||
*,
|
||||
dispatch_id: str,
|
||||
provenance_id: str,
|
||||
run_id: str,
|
||||
) -> TaskRecord:
|
||||
dispatch = self.dispatch_repository.get(
|
||||
dispatch_id, tenant_id=context.tenant_id
|
||||
)
|
||||
self._assert_dispatch_context(
|
||||
dispatch,
|
||||
runtime="openclaw",
|
||||
runtime_execution_id=result.command_id,
|
||||
tenant_id=result.tenant_id,
|
||||
task_id=result.task_id,
|
||||
trace_id=result.trace_id,
|
||||
principal_id=context.principal_id,
|
||||
provenance_id=provenance_id,
|
||||
run_id=run_id,
|
||||
)
|
||||
result_digest = digest_payload(
|
||||
{
|
||||
"command_id": result.command_id,
|
||||
"state": result.state.value,
|
||||
"output": result.output,
|
||||
"error": result.error,
|
||||
"runtime_id": result.runtime_id,
|
||||
"attempts": result.attempts,
|
||||
"finished_at": result.finished_at,
|
||||
}
|
||||
)
|
||||
if dispatch.state in TERMINAL_DISPATCH_STATES:
|
||||
if dispatch.result_digest != result_digest:
|
||||
raise DispatchConflict("terminal dispatch received a different result")
|
||||
return self.control_plane.get_task(context, dispatch.task_id)
|
||||
|
||||
task = self.control_plane.get_task(context, dispatch.task_id)
|
||||
if task.state != TaskState.RUNNING:
|
||||
raise OrchestrationError("task is not RUNNING for active dispatch")
|
||||
if result.state == CommandState.COMPLETED:
|
||||
target = TaskState.COMPLETED
|
||||
values = {"result": result.output or {}}
|
||||
dispatch_state = DispatchState.COMPLETED
|
||||
elif result.state in {
|
||||
CommandState.FAILED,
|
||||
CommandState.TIMED_OUT,
|
||||
CommandState.REJECTED,
|
||||
}:
|
||||
target = TaskState.FAILED
|
||||
values = {
|
||||
"error": result.error or {"code": result.state.value.lower()}
|
||||
}
|
||||
dispatch_state = DispatchState.FAILED
|
||||
elif result.state == CommandState.CANCELLED:
|
||||
target = TaskState.CANCELLED
|
||||
values = {}
|
||||
dispatch_state = DispatchState.CANCELLED
|
||||
else:
|
||||
self.dispatch_repository.update(
|
||||
dispatch.dispatch_id,
|
||||
tenant_id=dispatch.tenant_id,
|
||||
state=DispatchState.RUNNING,
|
||||
result_digest=result_digest,
|
||||
)
|
||||
return task
|
||||
|
||||
updated_task = self.control_plane.transition_task(
|
||||
context,
|
||||
task_id=task.task_id,
|
||||
target_state=target,
|
||||
expected_revision=task.revision,
|
||||
**values,
|
||||
)
|
||||
self.dispatch_repository.update(
|
||||
dispatch.dispatch_id,
|
||||
tenant_id=dispatch.tenant_id,
|
||||
state=dispatch_state,
|
||||
result_digest=result_digest,
|
||||
)
|
||||
return updated_task
|
||||
|
||||
def reconcile_hermes(
|
||||
self,
|
||||
context: RequestContext,
|
||||
result: HermesResult,
|
||||
*,
|
||||
dispatch_id: str,
|
||||
provenance_id: str,
|
||||
run_id: str,
|
||||
) -> TaskRecord:
|
||||
dispatch = self.dispatch_repository.get(
|
||||
dispatch_id, tenant_id=context.tenant_id
|
||||
)
|
||||
self._assert_dispatch_context(
|
||||
dispatch,
|
||||
runtime="hermes",
|
||||
runtime_execution_id=result.job_id,
|
||||
tenant_id=result.tenant_id,
|
||||
task_id=result.task_id,
|
||||
trace_id=result.trace_id,
|
||||
principal_id=context.principal_id,
|
||||
provenance_id=provenance_id,
|
||||
run_id=run_id,
|
||||
)
|
||||
if self.hermes is None:
|
||||
raise OrchestrationError("Hermes runtime is not configured")
|
||||
job = self.hermes.get(result.job_id, tenant_id=result.tenant_id)
|
||||
if result.state in {HermesJobState.COMPLETED, HermesJobState.FAILED}:
|
||||
if not result.worker_id:
|
||||
raise OrchestrationError("terminal Hermes result requires worker_id")
|
||||
if job.assigned_worker_id != result.worker_id:
|
||||
raise OrchestrationError("Hermes result worker does not own job lease")
|
||||
if (
|
||||
dispatch.expected_worker_id is not None
|
||||
and dispatch.expected_worker_id != result.worker_id
|
||||
):
|
||||
raise OrchestrationError("Hermes result worker mismatch")
|
||||
result_digest = digest_payload(
|
||||
{
|
||||
"job_id": result.job_id,
|
||||
"worker_id": result.worker_id,
|
||||
"state": result.state.value,
|
||||
"output": result.output,
|
||||
"error": result.error,
|
||||
"finished_at": result.finished_at,
|
||||
}
|
||||
)
|
||||
if dispatch.state in TERMINAL_DISPATCH_STATES:
|
||||
if dispatch.result_digest != result_digest:
|
||||
raise DispatchConflict("terminal dispatch received a different result")
|
||||
return self.control_plane.get_task(context, dispatch.task_id)
|
||||
|
||||
task = self.control_plane.get_task(context, dispatch.task_id)
|
||||
if task.state != TaskState.RUNNING:
|
||||
raise OrchestrationError("task is not RUNNING for active dispatch")
|
||||
if result.state == HermesJobState.COMPLETED:
|
||||
target = TaskState.COMPLETED
|
||||
values = {"result": result.output or {}}
|
||||
dispatch_state = DispatchState.COMPLETED
|
||||
elif result.state == HermesJobState.FAILED:
|
||||
target = TaskState.FAILED
|
||||
values = {"error": result.error or {"code": "hermes_failed"}}
|
||||
dispatch_state = DispatchState.FAILED
|
||||
elif result.state == HermesJobState.CANCELLED:
|
||||
target = TaskState.CANCELLED
|
||||
values = {}
|
||||
dispatch_state = DispatchState.CANCELLED
|
||||
else:
|
||||
raise OrchestrationError("Hermes reconcile only accepts terminal results")
|
||||
|
||||
updated_task = self.control_plane.transition_task(
|
||||
context,
|
||||
task_id=task.task_id,
|
||||
target_state=target,
|
||||
expected_revision=task.revision,
|
||||
**values,
|
||||
)
|
||||
self.dispatch_repository.update(
|
||||
dispatch.dispatch_id,
|
||||
tenant_id=dispatch.tenant_id,
|
||||
state=dispatch_state,
|
||||
expected_worker_id=result.worker_id,
|
||||
result_digest=result_digest,
|
||||
)
|
||||
return updated_task
|
||||
|
||||
def dispatch_snapshot(self, *, tenant_id: str) -> Mapping[str, DispatchRecord]:
|
||||
return {
|
||||
item.task_id: item
|
||||
for item in self.dispatch_repository.list(tenant_id=tenant_id)
|
||||
}
|
||||
@@ -1,181 +0,0 @@
|
||||
"""Durable single-process persistence for the AIOS V2 control plane.
|
||||
|
||||
The candidate uses an atomic SQLite snapshot so a gateway restart does not lose
|
||||
tenants, agents, task state, idempotency records, or audit events. The domain
|
||||
service remains storage-agnostic; a later HA backend can replace this module
|
||||
without changing API or runtime-adapter contracts.
|
||||
"""
|
||||
from __future__ import annotations
|
||||
|
||||
import json
|
||||
import sqlite3
|
||||
import threading
|
||||
from dataclasses import asdict
|
||||
from pathlib import Path
|
||||
from typing import Any, Callable
|
||||
|
||||
from .control_plane import (
|
||||
AgentRecord,
|
||||
AuditEvent,
|
||||
ControlPlaneService,
|
||||
InMemoryControlPlaneStore,
|
||||
TaskRecord,
|
||||
TaskState,
|
||||
TenantRecord,
|
||||
)
|
||||
|
||||
|
||||
class SQLiteSnapshotRepository:
|
||||
"""Store one versioned control-plane snapshot in SQLite."""
|
||||
|
||||
SCHEMA_VERSION = 1
|
||||
|
||||
def __init__(self, path: str | Path) -> None:
|
||||
self.path = Path(path).resolve()
|
||||
self.path.parent.mkdir(parents=True, exist_ok=True)
|
||||
self._lock = threading.RLock()
|
||||
self._initialize()
|
||||
|
||||
def _connect(self) -> sqlite3.Connection:
|
||||
connection = sqlite3.connect(self.path, timeout=30.0)
|
||||
connection.execute("PRAGMA journal_mode=WAL")
|
||||
connection.execute("PRAGMA synchronous=FULL")
|
||||
connection.execute("PRAGMA foreign_keys=ON")
|
||||
return connection
|
||||
|
||||
def _initialize(self) -> None:
|
||||
with self._connect() as connection:
|
||||
connection.execute(
|
||||
"""
|
||||
CREATE TABLE IF NOT EXISTS control_plane_snapshot (
|
||||
singleton_id INTEGER PRIMARY KEY CHECK (singleton_id = 1),
|
||||
schema_version INTEGER NOT NULL,
|
||||
payload_json TEXT NOT NULL,
|
||||
updated_at TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP
|
||||
)
|
||||
"""
|
||||
)
|
||||
|
||||
def load(self) -> dict[str, Any] | None:
|
||||
with self._lock, self._connect() as connection:
|
||||
row = connection.execute(
|
||||
"SELECT schema_version, payload_json FROM control_plane_snapshot WHERE singleton_id = 1"
|
||||
).fetchone()
|
||||
if row is None:
|
||||
return None
|
||||
schema_version, payload_json = row
|
||||
if int(schema_version) != self.SCHEMA_VERSION:
|
||||
raise RuntimeError(
|
||||
f"unsupported control-plane snapshot version: {schema_version}"
|
||||
)
|
||||
decoded = json.loads(str(payload_json))
|
||||
if not isinstance(decoded, dict):
|
||||
raise RuntimeError("invalid control-plane snapshot")
|
||||
return decoded
|
||||
|
||||
def save(self, payload: dict[str, Any]) -> None:
|
||||
encoded = json.dumps(
|
||||
payload,
|
||||
ensure_ascii=False,
|
||||
sort_keys=True,
|
||||
separators=(",", ":"),
|
||||
default=str,
|
||||
)
|
||||
with self._lock, self._connect() as connection:
|
||||
connection.execute("BEGIN IMMEDIATE")
|
||||
connection.execute(
|
||||
"""
|
||||
INSERT INTO control_plane_snapshot (
|
||||
singleton_id, schema_version, payload_json, updated_at
|
||||
) VALUES (1, ?, ?, CURRENT_TIMESTAMP)
|
||||
ON CONFLICT(singleton_id) DO UPDATE SET
|
||||
schema_version = excluded.schema_version,
|
||||
payload_json = excluded.payload_json,
|
||||
updated_at = CURRENT_TIMESTAMP
|
||||
""",
|
||||
(self.SCHEMA_VERSION, encoded),
|
||||
)
|
||||
connection.commit()
|
||||
|
||||
|
||||
class DurableControlPlaneService(ControlPlaneService):
|
||||
"""Control-plane service that persists after every successful mutation."""
|
||||
|
||||
def __init__(
|
||||
self,
|
||||
repository: SQLiteSnapshotRepository,
|
||||
*,
|
||||
policy_evaluator=None,
|
||||
) -> None:
|
||||
self.repository = repository
|
||||
store = InMemoryControlPlaneStore()
|
||||
self._restore(store, repository.load())
|
||||
super().__init__(store, policy_evaluator=policy_evaluator)
|
||||
|
||||
@staticmethod
|
||||
def _restore(
|
||||
store: InMemoryControlPlaneStore,
|
||||
snapshot: dict[str, Any] | None,
|
||||
) -> None:
|
||||
if not snapshot:
|
||||
return
|
||||
for item in snapshot.get("tenants", []):
|
||||
record = TenantRecord(**item)
|
||||
store.tenants[record.tenant_id] = record
|
||||
for item in snapshot.get("agents", []):
|
||||
normalized = dict(item)
|
||||
normalized["capabilities"] = tuple(normalized.get("capabilities", ()))
|
||||
record = AgentRecord(**normalized)
|
||||
store.agents[record.agent_id] = record
|
||||
for item in snapshot.get("tasks", []):
|
||||
normalized = dict(item)
|
||||
normalized["state"] = TaskState(normalized["state"])
|
||||
record = TaskRecord(**normalized)
|
||||
store.tasks[record.task_id] = record
|
||||
store.audit_events.extend(AuditEvent(**item) for item in snapshot.get("audit", []))
|
||||
for item in snapshot.get("idempotency", []):
|
||||
store.idempotency[(item["tenant_id"], item["key"])] = (
|
||||
item["task_id"],
|
||||
item["digest"],
|
||||
)
|
||||
|
||||
def _snapshot(self) -> dict[str, Any]:
|
||||
with self.store.lock:
|
||||
return {
|
||||
"schema_version": self.repository.SCHEMA_VERSION,
|
||||
"tenants": [asdict(item) for item in self.store.tenants.values()],
|
||||
"agents": [asdict(item) for item in self.store.agents.values()],
|
||||
"tasks": [
|
||||
{**asdict(item), "state": item.state.value}
|
||||
for item in self.store.tasks.values()
|
||||
],
|
||||
"audit": [asdict(item) for item in self.store.audit_events],
|
||||
"idempotency": [
|
||||
{
|
||||
"tenant_id": tenant_id,
|
||||
"key": key,
|
||||
"task_id": task_id,
|
||||
"digest": digest,
|
||||
}
|
||||
for (tenant_id, key), (task_id, digest)
|
||||
in self.store.idempotency.items()
|
||||
],
|
||||
}
|
||||
|
||||
def _mutate(self, operation: Callable[[], Any]) -> Any:
|
||||
with self.store.lock:
|
||||
result = operation()
|
||||
self.repository.save(self._snapshot())
|
||||
return result
|
||||
|
||||
def register_tenant(self, *args, **kwargs):
|
||||
return self._mutate(lambda: super(DurableControlPlaneService, self).register_tenant(*args, **kwargs))
|
||||
|
||||
def register_agent(self, *args, **kwargs):
|
||||
return self._mutate(lambda: super(DurableControlPlaneService, self).register_agent(*args, **kwargs))
|
||||
|
||||
def create_task(self, *args, **kwargs):
|
||||
return self._mutate(lambda: super(DurableControlPlaneService, self).create_task(*args, **kwargs))
|
||||
|
||||
def transition_task(self, *args, **kwargs):
|
||||
return self._mutate(lambda: super(DurableControlPlaneService, self).transition_task(*args, **kwargs))
|
||||
@@ -1,831 +0,0 @@
|
||||
"""AIOS V2 可信 Run Provenance 签发、持久化与受控写入。
|
||||
|
||||
生产策略要求 Provenance 同时覆盖七类路径：代码变更、Git 操作、部署、
|
||||
Runtime 执行、Evidence 写入、回滚和审计。任何缺失、篡改、过期、撤销、
|
||||
重放或上下文不匹配都默认拒绝。
|
||||
"""
|
||||
from __future__ import annotations
|
||||
|
||||
import base64
|
||||
import hashlib
|
||||
import json
|
||||
import os
|
||||
import sqlite3
|
||||
import stat
|
||||
import threading
|
||||
import uuid
|
||||
from dataclasses import asdict, dataclass, field, replace
|
||||
from datetime import datetime, timedelta, timezone
|
||||
from enum import Enum
|
||||
from pathlib import Path
|
||||
from typing import Any, Mapping, Protocol, Sequence
|
||||
|
||||
PROVENANCE_VERSION = "aios.v2.run-provenance.v1"
|
||||
PRODUCTION_POLICY_VERSION = "aios.v2.production.v1"
|
||||
|
||||
|
||||
def utc_now() -> str:
|
||||
return datetime.now(timezone.utc).isoformat().replace("+00:00", "Z")
|
||||
|
||||
|
||||
def parse_timestamp(value: str) -> datetime:
|
||||
normalized = str(value or "").strip()
|
||||
if not normalized:
|
||||
raise ValueError("timestamp is required")
|
||||
if normalized.endswith("Z"):
|
||||
normalized = normalized[:-1] + "+00:00"
|
||||
parsed = datetime.fromisoformat(normalized)
|
||||
if parsed.tzinfo is None:
|
||||
raise ValueError("timestamp must include timezone")
|
||||
return parsed.astimezone(timezone.utc)
|
||||
|
||||
|
||||
def required(value: str, label: str) -> str:
|
||||
normalized = str(value or "").strip()
|
||||
if not normalized:
|
||||
raise ValueError(f"{label} is required")
|
||||
return normalized
|
||||
|
||||
|
||||
def canonical_json_bytes(value: Mapping[str, Any]) -> bytes:
|
||||
return json.dumps(
|
||||
dict(value),
|
||||
ensure_ascii=False,
|
||||
sort_keys=True,
|
||||
separators=(",", ":"),
|
||||
default=str,
|
||||
).encode("utf-8")
|
||||
|
||||
|
||||
def digest_payload(value: Mapping[str, Any]) -> str:
|
||||
return hashlib.sha256(canonical_json_bytes(value)).hexdigest()
|
||||
|
||||
|
||||
def _validate_digest(value: str) -> str:
|
||||
normalized = required(value, "request_digest").lower()
|
||||
if len(normalized) != 64 or any(ch not in "0123456789abcdef" for ch in normalized):
|
||||
raise ValueError("request_digest must be a SHA-256 hexadecimal digest")
|
||||
return normalized
|
||||
|
||||
|
||||
class ExecutionPath(str, Enum):
|
||||
CODE_CHANGE = "code_change"
|
||||
GIT_OPERATION = "git_operation"
|
||||
DEPLOYMENT = "deployment"
|
||||
RUNTIME_EXECUTE = "runtime_execute"
|
||||
EVIDENCE_WRITE = "evidence_write"
|
||||
ROLLBACK = "rollback"
|
||||
AUDIT = "audit"
|
||||
|
||||
|
||||
REQUIRED_PRODUCTION_PATHS = frozenset(item.value for item in ExecutionPath)
|
||||
|
||||
|
||||
class GitOperation(str, Enum):
|
||||
READ_REF = "read_ref"
|
||||
FETCH = "fetch"
|
||||
CREATE_BRANCH = "create_branch"
|
||||
COMMIT = "commit"
|
||||
MERGE = "merge"
|
||||
PUSH = "push"
|
||||
UPDATE_EVIDENCE = "update_evidence"
|
||||
|
||||
|
||||
class ProvenanceStatus(str, Enum):
|
||||
ISSUED = "issued"
|
||||
VERIFIED = "verified"
|
||||
USED = "used"
|
||||
EXPIRED = "expired"
|
||||
REVOKED = "revoked"
|
||||
|
||||
|
||||
class ProvenanceError(RuntimeError):
|
||||
"""Run Provenance 基础错误。"""
|
||||
|
||||
|
||||
class ProvenanceDenied(ProvenanceError):
|
||||
"""策略拒绝当前操作。"""
|
||||
|
||||
|
||||
class ProvenanceNotFound(ProvenanceDenied):
|
||||
"""未找到 Provenance。"""
|
||||
|
||||
|
||||
class ProvenanceSignatureError(ProvenanceDenied):
|
||||
"""签名无效。"""
|
||||
|
||||
|
||||
class ProvenanceExpired(ProvenanceDenied):
|
||||
"""Provenance 已过期。"""
|
||||
|
||||
|
||||
class ProvenanceRevoked(ProvenanceDenied):
|
||||
"""Provenance 已撤销。"""
|
||||
|
||||
|
||||
class ProvenanceReplay(ProvenanceDenied):
|
||||
"""检测到相同授权摘要重放。"""
|
||||
|
||||
|
||||
class Signer(Protocol):
|
||||
key_id: str
|
||||
|
||||
def sign(self, payload: bytes) -> str: ...
|
||||
|
||||
|
||||
class SignatureVerifier(Protocol):
|
||||
key_id: str
|
||||
fingerprint: str
|
||||
|
||||
def verify(self, payload: bytes, signature: str) -> bool: ...
|
||||
|
||||
|
||||
def _load_crypto() -> tuple[Any, Any, Any]:
|
||||
try:
|
||||
from cryptography.hazmat.primitives import serialization
|
||||
from cryptography.hazmat.primitives.asymmetric.ed25519 import (
|
||||
Ed25519PrivateKey,
|
||||
Ed25519PublicKey,
|
||||
)
|
||||
except ImportError as exc: # pragma: no cover - depends on deployment image
|
||||
raise RuntimeError(
|
||||
"cryptography package with Ed25519 support is required"
|
||||
) from exc
|
||||
return serialization, Ed25519PrivateKey, Ed25519PublicKey
|
||||
|
||||
|
||||
def _check_private_key_file(path: Path) -> bytes:
|
||||
resolved = path.resolve()
|
||||
metadata = resolved.stat()
|
||||
if not stat.S_ISREG(metadata.st_mode):
|
||||
raise RuntimeError("private key reference is not a regular file")
|
||||
if metadata.st_mode & 0o077:
|
||||
raise RuntimeError("private key file permissions must be 0600 or stricter")
|
||||
return resolved.read_bytes()
|
||||
|
||||
|
||||
def _check_public_key_file(path: Path) -> bytes:
|
||||
resolved = path.resolve()
|
||||
metadata = resolved.stat()
|
||||
if not stat.S_ISREG(metadata.st_mode):
|
||||
raise RuntimeError("public key reference is not a regular file")
|
||||
if metadata.st_mode & 0o022:
|
||||
raise RuntimeError("public key file must not be group/world writable")
|
||||
return resolved.read_bytes()
|
||||
|
||||
|
||||
class Ed25519PrivateKeySigner:
|
||||
"""Ed25519 Owner/Control Plane 签发器。"""
|
||||
|
||||
def __init__(self, private_key: Any, *, key_id: str) -> None:
|
||||
self.private_key = private_key
|
||||
self.key_id = required(key_id, "key_id")
|
||||
|
||||
@classmethod
|
||||
def from_file(cls, path: str | Path, *, key_id: str) -> "Ed25519PrivateKeySigner":
|
||||
serialization, private_cls, _ = _load_crypto()
|
||||
value = _check_private_key_file(Path(path))
|
||||
if value.startswith(b"-----BEGIN"):
|
||||
key = serialization.load_pem_private_key(value, password=None)
|
||||
elif len(value) == 32:
|
||||
key = private_cls.from_private_bytes(value)
|
||||
else:
|
||||
raise RuntimeError("private key must be PEM or a raw 32-byte Ed25519 seed")
|
||||
if not isinstance(key, private_cls):
|
||||
raise RuntimeError("private key is not Ed25519")
|
||||
return cls(key, key_id=key_id)
|
||||
|
||||
def sign(self, payload: bytes) -> str:
|
||||
return base64.b64encode(self.private_key.sign(bytes(payload))).decode("ascii")
|
||||
|
||||
def public_verifier(self) -> "Ed25519PublicKeyVerifier":
|
||||
return Ed25519PublicKeyVerifier(self.private_key.public_key(), key_id=self.key_id)
|
||||
|
||||
|
||||
class Ed25519PublicKeyVerifier:
|
||||
"""Ed25519 签名验证器。"""
|
||||
|
||||
def __init__(self, public_key: Any, *, key_id: str) -> None:
|
||||
serialization, _, public_cls = _load_crypto()
|
||||
if not isinstance(public_key, public_cls):
|
||||
raise RuntimeError("public key is not Ed25519")
|
||||
self.public_key = public_key
|
||||
self.key_id = required(key_id, "key_id")
|
||||
raw = public_key.public_bytes(
|
||||
encoding=serialization.Encoding.Raw,
|
||||
format=serialization.PublicFormat.Raw,
|
||||
)
|
||||
self.fingerprint = hashlib.sha256(raw).hexdigest()
|
||||
|
||||
@classmethod
|
||||
def from_file(cls, path: str | Path, *, key_id: str) -> "Ed25519PublicKeyVerifier":
|
||||
serialization, _, public_cls = _load_crypto()
|
||||
value = _check_public_key_file(Path(path))
|
||||
if value.startswith(b"-----BEGIN"):
|
||||
key = serialization.load_pem_public_key(value)
|
||||
elif len(value) == 32:
|
||||
key = public_cls.from_public_bytes(value)
|
||||
else:
|
||||
raise RuntimeError("public key must be PEM or raw 32-byte Ed25519 key")
|
||||
if not isinstance(key, public_cls):
|
||||
raise RuntimeError("public key is not Ed25519")
|
||||
return cls(key, key_id=key_id)
|
||||
|
||||
def verify(self, payload: bytes, signature: str) -> bool:
|
||||
try:
|
||||
decoded = base64.b64decode(required(signature, "signature"), validate=True)
|
||||
self.public_key.verify(decoded, bytes(payload))
|
||||
return True
|
||||
except Exception:
|
||||
return False
|
||||
|
||||
|
||||
@dataclass(frozen=True)
|
||||
class RunProvenance:
|
||||
provenance_id: str
|
||||
run_id: str
|
||||
issuer: str
|
||||
tenant_id: str
|
||||
task_id: str
|
||||
agent_id: str
|
||||
principal_id: str
|
||||
allowed_paths: Sequence[str]
|
||||
allowed_git_operations: Sequence[str]
|
||||
issued_at: str
|
||||
expires_at: str
|
||||
policy_version: str
|
||||
key_id: str
|
||||
nonce: str
|
||||
signature: str = ""
|
||||
schema_version: str = PROVENANCE_VERSION
|
||||
|
||||
def __post_init__(self) -> None:
|
||||
for name in (
|
||||
"provenance_id",
|
||||
"run_id",
|
||||
"issuer",
|
||||
"tenant_id",
|
||||
"task_id",
|
||||
"agent_id",
|
||||
"principal_id",
|
||||
"issued_at",
|
||||
"expires_at",
|
||||
"policy_version",
|
||||
"key_id",
|
||||
"nonce",
|
||||
"schema_version",
|
||||
):
|
||||
object.__setattr__(self, name, required(getattr(self, name), name))
|
||||
if self.schema_version != PROVENANCE_VERSION:
|
||||
raise ValueError(f"unsupported schema_version: {self.schema_version}")
|
||||
issued = parse_timestamp(self.issued_at)
|
||||
expires = parse_timestamp(self.expires_at)
|
||||
if expires <= issued:
|
||||
raise ValueError("expires_at must be later than issued_at")
|
||||
paths = tuple(sorted({ExecutionPath(item).value for item in self.allowed_paths}))
|
||||
operations = tuple(
|
||||
sorted({GitOperation(item).value for item in self.allowed_git_operations})
|
||||
)
|
||||
object.__setattr__(self, "allowed_paths", paths)
|
||||
object.__setattr__(self, "allowed_git_operations", operations)
|
||||
object.__setattr__(self, "signature", str(self.signature or "").strip())
|
||||
|
||||
def unsigned_dict(self) -> dict[str, Any]:
|
||||
return {
|
||||
"schema_version": self.schema_version,
|
||||
"provenance_id": self.provenance_id,
|
||||
"run_id": self.run_id,
|
||||
"issuer": self.issuer,
|
||||
"tenant_id": self.tenant_id,
|
||||
"task_id": self.task_id,
|
||||
"agent_id": self.agent_id,
|
||||
"principal_id": self.principal_id,
|
||||
"allowed_paths": list(self.allowed_paths),
|
||||
"allowed_git_operations": list(self.allowed_git_operations),
|
||||
"issued_at": self.issued_at,
|
||||
"expires_at": self.expires_at,
|
||||
"policy_version": self.policy_version,
|
||||
"key_id": self.key_id,
|
||||
"nonce": self.nonce,
|
||||
}
|
||||
|
||||
def canonical_bytes(self) -> bytes:
|
||||
return canonical_json_bytes(self.unsigned_dict())
|
||||
|
||||
def as_dict(self) -> dict[str, Any]:
|
||||
value = self.unsigned_dict()
|
||||
value["signature"] = self.signature
|
||||
return value
|
||||
|
||||
@classmethod
|
||||
def from_dict(cls, value: Mapping[str, Any]) -> "RunProvenance":
|
||||
return cls(**dict(value))
|
||||
|
||||
|
||||
class ProvenanceIssuer:
|
||||
"""只由 Owner 或 AIOS Control Plane 持有的签发服务。"""
|
||||
|
||||
def __init__(self, signer: Signer, store: "SQLiteProvenanceStore") -> None:
|
||||
self.signer = signer
|
||||
self.store = store
|
||||
|
||||
def issue(
|
||||
self,
|
||||
*,
|
||||
run_id: str,
|
||||
issuer: str,
|
||||
tenant_id: str,
|
||||
task_id: str,
|
||||
agent_id: str,
|
||||
principal_id: str,
|
||||
allowed_paths: Sequence[str] = tuple(REQUIRED_PRODUCTION_PATHS),
|
||||
allowed_git_operations: Sequence[str] = tuple(item.value for item in GitOperation),
|
||||
ttl_seconds: int = 3600,
|
||||
policy_version: str = PRODUCTION_POLICY_VERSION,
|
||||
provenance_id: str | None = None,
|
||||
nonce: str | None = None,
|
||||
now: datetime | None = None,
|
||||
) -> RunProvenance:
|
||||
if ttl_seconds <= 0:
|
||||
raise ValueError("ttl_seconds must be positive")
|
||||
normalized_paths = frozenset(ExecutionPath(item).value for item in allowed_paths)
|
||||
if policy_version == PRODUCTION_POLICY_VERSION and normalized_paths != REQUIRED_PRODUCTION_PATHS:
|
||||
missing = sorted(REQUIRED_PRODUCTION_PATHS - normalized_paths)
|
||||
extra = sorted(normalized_paths - REQUIRED_PRODUCTION_PATHS)
|
||||
raise ProvenanceDenied(
|
||||
f"production provenance must cover exactly seven paths; missing={missing}, extra={extra}"
|
||||
)
|
||||
normalized_operations = tuple(
|
||||
sorted({GitOperation(item).value for item in allowed_git_operations})
|
||||
)
|
||||
if ExecutionPath.GIT_OPERATION.value in normalized_paths and not normalized_operations:
|
||||
raise ProvenanceDenied("git_operation path requires explicit allowed Git operations")
|
||||
issued = (now or datetime.now(timezone.utc)).astimezone(timezone.utc)
|
||||
unsigned = RunProvenance(
|
||||
provenance_id=provenance_id or f"prov_{uuid.uuid4().hex}",
|
||||
run_id=run_id,
|
||||
issuer=issuer,
|
||||
tenant_id=tenant_id,
|
||||
task_id=task_id,
|
||||
agent_id=agent_id,
|
||||
principal_id=principal_id,
|
||||
allowed_paths=tuple(normalized_paths),
|
||||
allowed_git_operations=normalized_operations,
|
||||
issued_at=issued.isoformat().replace("+00:00", "Z"),
|
||||
expires_at=(issued + timedelta(seconds=ttl_seconds))
|
||||
.isoformat()
|
||||
.replace("+00:00", "Z"),
|
||||
policy_version=policy_version,
|
||||
key_id=self.signer.key_id,
|
||||
nonce=nonce or uuid.uuid4().hex,
|
||||
)
|
||||
signed = replace(unsigned, signature=self.signer.sign(unsigned.canonical_bytes()))
|
||||
self.store.save_issued(signed)
|
||||
return signed
|
||||
|
||||
|
||||
@dataclass(frozen=True)
|
||||
class ProvenanceAuthorization:
|
||||
authorization_id: str
|
||||
provenance_id: str
|
||||
run_id: str
|
||||
tenant_id: str
|
||||
task_id: str
|
||||
agent_id: str
|
||||
principal_id: str
|
||||
execution_path: str
|
||||
git_operation: str | None
|
||||
request_digest: str
|
||||
policy_version: str
|
||||
key_id: str
|
||||
public_key_fingerprint: str
|
||||
authorized_at: str = field(default_factory=utc_now)
|
||||
|
||||
def as_dict(self) -> dict[str, Any]:
|
||||
return asdict(self)
|
||||
|
||||
|
||||
class SQLiteProvenanceStore:
|
||||
"""持久化 Provenance、状态、授权使用和不可变事件。"""
|
||||
|
||||
def __init__(self, path: str | Path) -> None:
|
||||
self.path = Path(path).resolve()
|
||||
self.path.parent.mkdir(parents=True, exist_ok=True)
|
||||
self._lock = threading.RLock()
|
||||
self._connection = sqlite3.connect(
|
||||
str(self.path), timeout=30.0, check_same_thread=False
|
||||
)
|
||||
self._connection.row_factory = sqlite3.Row
|
||||
with self._lock:
|
||||
self._connection.execute("PRAGMA journal_mode=WAL")
|
||||
self._connection.execute("PRAGMA synchronous=FULL")
|
||||
self._connection.execute("PRAGMA foreign_keys=ON")
|
||||
self._connection.executescript(
|
||||
"""
|
||||
CREATE TABLE IF NOT EXISTS provenance_records (
|
||||
provenance_id TEXT PRIMARY KEY,
|
||||
payload_json TEXT NOT NULL,
|
||||
status TEXT NOT NULL,
|
||||
signature_verified INTEGER NOT NULL DEFAULT 0,
|
||||
created_at TEXT NOT NULL,
|
||||
updated_at TEXT NOT NULL
|
||||
);
|
||||
CREATE TABLE IF NOT EXISTS provenance_usage (
|
||||
authorization_id TEXT PRIMARY KEY,
|
||||
provenance_id TEXT NOT NULL,
|
||||
execution_path TEXT NOT NULL,
|
||||
git_operation TEXT NOT NULL DEFAULT '',
|
||||
request_digest TEXT NOT NULL,
|
||||
authorized_at TEXT NOT NULL,
|
||||
receipt_json TEXT NOT NULL,
|
||||
UNIQUE(provenance_id, execution_path, git_operation, request_digest),
|
||||
FOREIGN KEY(provenance_id) REFERENCES provenance_records(provenance_id)
|
||||
);
|
||||
CREATE TABLE IF NOT EXISTS provenance_events (
|
||||
event_id TEXT PRIMARY KEY,
|
||||
provenance_id TEXT NOT NULL,
|
||||
event_type TEXT NOT NULL,
|
||||
details_json TEXT NOT NULL,
|
||||
created_at TEXT NOT NULL,
|
||||
FOREIGN KEY(provenance_id) REFERENCES provenance_records(provenance_id)
|
||||
);
|
||||
CREATE INDEX IF NOT EXISTS idx_provenance_usage_id
|
||||
ON provenance_usage(provenance_id, authorized_at);
|
||||
CREATE INDEX IF NOT EXISTS idx_provenance_events_id
|
||||
ON provenance_events(provenance_id, created_at);
|
||||
"""
|
||||
)
|
||||
self._connection.commit()
|
||||
|
||||
def close(self) -> None:
|
||||
with self._lock:
|
||||
self._connection.close()
|
||||
|
||||
def _event(
|
||||
self,
|
||||
provenance_id: str,
|
||||
event_type: str,
|
||||
details: Mapping[str, Any] | None = None,
|
||||
) -> None:
|
||||
self._connection.execute(
|
||||
"INSERT INTO provenance_events VALUES (?, ?, ?, ?, ?)",
|
||||
(
|
||||
f"pevt_{uuid.uuid4().hex}",
|
||||
provenance_id,
|
||||
event_type,
|
||||
json.dumps(dict(details or {}), ensure_ascii=False, sort_keys=True),
|
||||
utc_now(),
|
||||
),
|
||||
)
|
||||
|
||||
def save_issued(self, provenance: RunProvenance) -> None:
|
||||
payload = json.dumps(
|
||||
provenance.as_dict(), ensure_ascii=False, sort_keys=True, separators=(",", ":")
|
||||
)
|
||||
now = utc_now()
|
||||
with self._lock:
|
||||
self._connection.execute("BEGIN IMMEDIATE")
|
||||
try:
|
||||
prior = self._connection.execute(
|
||||
"SELECT payload_json FROM provenance_records WHERE provenance_id = ?",
|
||||
(provenance.provenance_id,),
|
||||
).fetchone()
|
||||
if prior is not None:
|
||||
if prior["payload_json"] != payload:
|
||||
raise ProvenanceDenied("provenance_id reused with different payload")
|
||||
self._connection.rollback()
|
||||
return
|
||||
self._connection.execute(
|
||||
"INSERT INTO provenance_records VALUES (?, ?, ?, 0, ?, ?)",
|
||||
(
|
||||
provenance.provenance_id,
|
||||
payload,
|
||||
ProvenanceStatus.ISSUED.value,
|
||||
now,
|
||||
now,
|
||||
),
|
||||
)
|
||||
self._event(provenance.provenance_id, "issued")
|
||||
self._connection.commit()
|
||||
except Exception:
|
||||
self._connection.rollback()
|
||||
raise
|
||||
|
||||
def get(self, provenance_id: str) -> RunProvenance:
|
||||
with self._lock:
|
||||
row = self._connection.execute(
|
||||
"SELECT payload_json FROM provenance_records WHERE provenance_id = ?",
|
||||
(required(provenance_id, "provenance_id"),),
|
||||
).fetchone()
|
||||
if row is None:
|
||||
raise ProvenanceNotFound("provenance not found")
|
||||
value = json.loads(row["payload_json"])
|
||||
if not isinstance(value, Mapping):
|
||||
raise ProvenanceError("stored provenance payload is invalid")
|
||||
return RunProvenance.from_dict(value)
|
||||
|
||||
def status(self, provenance_id: str) -> ProvenanceStatus:
|
||||
with self._lock:
|
||||
row = self._connection.execute(
|
||||
"SELECT status FROM provenance_records WHERE provenance_id = ?",
|
||||
(required(provenance_id, "provenance_id"),),
|
||||
).fetchone()
|
||||
if row is None:
|
||||
raise ProvenanceNotFound("provenance not found")
|
||||
return ProvenanceStatus(row["status"])
|
||||
|
||||
def mark_verified(self, provenance_id: str, *, fingerprint: str) -> None:
|
||||
with self._lock:
|
||||
self._connection.execute("BEGIN IMMEDIATE")
|
||||
try:
|
||||
current = self.status(provenance_id)
|
||||
if current in {ProvenanceStatus.REVOKED, ProvenanceStatus.EXPIRED}:
|
||||
raise ProvenanceDenied(f"cannot verify provenance in state {current.value}")
|
||||
next_status = (
|
||||
ProvenanceStatus.USED.value
|
||||
if current == ProvenanceStatus.USED
|
||||
else ProvenanceStatus.VERIFIED.value
|
||||
)
|
||||
self._connection.execute(
|
||||
"UPDATE provenance_records SET status = ?, signature_verified = 1, updated_at = ? WHERE provenance_id = ?",
|
||||
(next_status, utc_now(), provenance_id),
|
||||
)
|
||||
self._event(
|
||||
provenance_id,
|
||||
"verified",
|
||||
{"public_key_fingerprint": fingerprint},
|
||||
)
|
||||
self._connection.commit()
|
||||
except Exception:
|
||||
self._connection.rollback()
|
||||
raise
|
||||
|
||||
def mark_expired(self, provenance_id: str) -> None:
|
||||
with self._lock:
|
||||
self._connection.execute("BEGIN IMMEDIATE")
|
||||
try:
|
||||
current = self.status(provenance_id)
|
||||
if current == ProvenanceStatus.REVOKED:
|
||||
self._connection.rollback()
|
||||
return
|
||||
self._connection.execute(
|
||||
"UPDATE provenance_records SET status = ?, updated_at = ? WHERE provenance_id = ?",
|
||||
(ProvenanceStatus.EXPIRED.value, utc_now(), provenance_id),
|
||||
)
|
||||
self._event(provenance_id, "expired")
|
||||
self._connection.commit()
|
||||
except Exception:
|
||||
self._connection.rollback()
|
||||
raise
|
||||
|
||||
def revoke(self, provenance_id: str, *, reason: str, principal_id: str) -> None:
|
||||
with self._lock:
|
||||
self._connection.execute("BEGIN IMMEDIATE")
|
||||
try:
|
||||
self.get(provenance_id)
|
||||
self._connection.execute(
|
||||
"UPDATE provenance_records SET status = ?, updated_at = ? WHERE provenance_id = ?",
|
||||
(ProvenanceStatus.REVOKED.value, utc_now(), provenance_id),
|
||||
)
|
||||
self._event(
|
||||
provenance_id,
|
||||
"revoked",
|
||||
{
|
||||
"reason": required(reason, "reason"),
|
||||
"principal_id": required(principal_id, "principal_id"),
|
||||
},
|
||||
)
|
||||
self._connection.commit()
|
||||
except Exception:
|
||||
self._connection.rollback()
|
||||
raise
|
||||
|
||||
def record_authorization(self, authorization: ProvenanceAuthorization) -> None:
|
||||
receipt = json.dumps(
|
||||
authorization.as_dict(), ensure_ascii=False, sort_keys=True, separators=(",", ":")
|
||||
)
|
||||
with self._lock:
|
||||
self._connection.execute("BEGIN IMMEDIATE")
|
||||
try:
|
||||
current = self.status(authorization.provenance_id)
|
||||
if current in {ProvenanceStatus.REVOKED, ProvenanceStatus.EXPIRED}:
|
||||
raise ProvenanceDenied(f"provenance state is {current.value}")
|
||||
try:
|
||||
self._connection.execute(
|
||||
"INSERT INTO provenance_usage VALUES (?, ?, ?, ?, ?, ?, ?)",
|
||||
(
|
||||
authorization.authorization_id,
|
||||
authorization.provenance_id,
|
||||
authorization.execution_path,
|
||||
authorization.git_operation or "",
|
||||
authorization.request_digest,
|
||||
authorization.authorized_at,
|
||||
receipt,
|
||||
),
|
||||
)
|
||||
except sqlite3.IntegrityError as exc:
|
||||
raise ProvenanceReplay(
|
||||
"identical provenance path/operation/request digest already used"
|
||||
) from exc
|
||||
self._connection.execute(
|
||||
"UPDATE provenance_records SET status = ?, updated_at = ? WHERE provenance_id = ?",
|
||||
(
|
||||
ProvenanceStatus.USED.value,
|
||||
authorization.authorized_at,
|
||||
authorization.provenance_id,
|
||||
),
|
||||
)
|
||||
self._event(
|
||||
authorization.provenance_id,
|
||||
"used",
|
||||
{
|
||||
"authorization_id": authorization.authorization_id,
|
||||
"execution_path": authorization.execution_path,
|
||||
"git_operation": authorization.git_operation,
|
||||
"request_digest": authorization.request_digest,
|
||||
},
|
||||
)
|
||||
self._connection.commit()
|
||||
except Exception:
|
||||
self._connection.rollback()
|
||||
raise
|
||||
|
||||
def authorization_count(self, provenance_id: str) -> int:
|
||||
with self._lock:
|
||||
row = self._connection.execute(
|
||||
"SELECT COUNT(*) AS total FROM provenance_usage WHERE provenance_id = ?",
|
||||
(required(provenance_id, "provenance_id"),),
|
||||
).fetchone()
|
||||
return int(row["total"])
|
||||
|
||||
def events(self, provenance_id: str) -> list[dict[str, Any]]:
|
||||
with self._lock:
|
||||
rows = self._connection.execute(
|
||||
"SELECT event_type, details_json, created_at FROM provenance_events WHERE provenance_id = ? ORDER BY created_at, event_id",
|
||||
(required(provenance_id, "provenance_id"),),
|
||||
).fetchall()
|
||||
return [
|
||||
{
|
||||
"event_type": row["event_type"],
|
||||
"details": json.loads(row["details_json"]),
|
||||
"created_at": row["created_at"],
|
||||
}
|
||||
for row in rows
|
||||
]
|
||||
|
||||
|
||||
class ProvenanceVerifier:
|
||||
"""验证 Owner 签名、上下文、路径、Git 操作、时效和重放。"""
|
||||
|
||||
def __init__(
|
||||
self,
|
||||
store: SQLiteProvenanceStore,
|
||||
verifiers: Mapping[str, SignatureVerifier],
|
||||
) -> None:
|
||||
if not verifiers:
|
||||
raise ValueError("at least one public key verifier is required")
|
||||
self.store = store
|
||||
self.verifiers = {required(key, "key_id"): value for key, value in verifiers.items()}
|
||||
|
||||
def authorize(
|
||||
self,
|
||||
*,
|
||||
provenance_id: str,
|
||||
run_id: str,
|
||||
tenant_id: str,
|
||||
task_id: str,
|
||||
agent_id: str,
|
||||
principal_id: str,
|
||||
execution_path: str,
|
||||
request_digest: str,
|
||||
git_operation: str | None = None,
|
||||
now: datetime | None = None,
|
||||
) -> ProvenanceAuthorization:
|
||||
provenance = self.store.get(provenance_id)
|
||||
status = self.store.status(provenance.provenance_id)
|
||||
if status == ProvenanceStatus.REVOKED:
|
||||
raise ProvenanceRevoked("provenance is revoked")
|
||||
current = (now or datetime.now(timezone.utc)).astimezone(timezone.utc)
|
||||
if current >= parse_timestamp(provenance.expires_at):
|
||||
self.store.mark_expired(provenance.provenance_id)
|
||||
raise ProvenanceExpired("provenance is expired")
|
||||
verifier = self.verifiers.get(provenance.key_id)
|
||||
if verifier is None:
|
||||
raise ProvenanceSignatureError("no trusted public key for provenance key_id")
|
||||
if not provenance.signature or not verifier.verify(
|
||||
provenance.canonical_bytes(), provenance.signature
|
||||
):
|
||||
raise ProvenanceSignatureError("invalid provenance signature")
|
||||
expected = {
|
||||
"run_id": required(run_id, "run_id"),
|
||||
"tenant_id": required(tenant_id, "tenant_id"),
|
||||
"task_id": required(task_id, "task_id"),
|
||||
"agent_id": required(agent_id, "agent_id"),
|
||||
"principal_id": required(principal_id, "principal_id"),
|
||||
}
|
||||
for field_name, expected_value in expected.items():
|
||||
if getattr(provenance, field_name) != expected_value:
|
||||
raise ProvenanceDenied(f"provenance {field_name} mismatch")
|
||||
path = ExecutionPath(execution_path).value
|
||||
if path not in provenance.allowed_paths:
|
||||
raise ProvenanceDenied(f"execution path is not allowed: {path}")
|
||||
operation: str | None = None
|
||||
if path == ExecutionPath.GIT_OPERATION.value:
|
||||
if git_operation is None:
|
||||
raise ProvenanceDenied("git operation is required for git_operation path")
|
||||
operation = GitOperation(git_operation).value
|
||||
if operation not in provenance.allowed_git_operations:
|
||||
raise ProvenanceDenied(f"Git operation is not allowed: {operation}")
|
||||
elif git_operation is not None:
|
||||
raise ProvenanceDenied("git_operation is only valid for git_operation path")
|
||||
digest = _validate_digest(request_digest)
|
||||
self.store.mark_verified(
|
||||
provenance.provenance_id, fingerprint=verifier.fingerprint
|
||||
)
|
||||
authorization = ProvenanceAuthorization(
|
||||
authorization_id=f"pauth_{uuid.uuid4().hex}",
|
||||
provenance_id=provenance.provenance_id,
|
||||
run_id=provenance.run_id,
|
||||
tenant_id=provenance.tenant_id,
|
||||
task_id=provenance.task_id,
|
||||
agent_id=provenance.agent_id,
|
||||
principal_id=provenance.principal_id,
|
||||
execution_path=path,
|
||||
git_operation=operation,
|
||||
request_digest=digest,
|
||||
policy_version=provenance.policy_version,
|
||||
key_id=provenance.key_id,
|
||||
public_key_fingerprint=verifier.fingerprint,
|
||||
)
|
||||
self.store.record_authorization(authorization)
|
||||
return authorization
|
||||
|
||||
|
||||
class ProvenanceControlledWriter:
|
||||
"""七路径统一策略入口并持久写入授权回执。"""
|
||||
|
||||
def __init__(
|
||||
self,
|
||||
verifier: ProvenanceVerifier,
|
||||
receipt_root: str | Path,
|
||||
*,
|
||||
writer_id: str = "aios-v2-provenance-writer",
|
||||
) -> None:
|
||||
self.verifier = verifier
|
||||
self.receipt_root = Path(receipt_root).resolve()
|
||||
self.receipt_root.mkdir(parents=True, exist_ok=True)
|
||||
self.writer_id = required(writer_id, "writer_id")
|
||||
self._lock = threading.RLock()
|
||||
|
||||
@staticmethod
|
||||
def _component(value: str) -> str:
|
||||
normalized = required(value, "path component")
|
||||
if normalized in {".", ".."} or "/" in normalized or "\\" in normalized:
|
||||
raise ProvenanceDenied("invalid receipt path component")
|
||||
return normalized
|
||||
|
||||
def authorize(self, **values: Any) -> ProvenanceAuthorization:
|
||||
authorization = self.verifier.authorize(**values)
|
||||
tenant = self._component(authorization.tenant_id)
|
||||
provenance_id = self._component(authorization.provenance_id)
|
||||
target_dir = self.receipt_root / tenant / provenance_id
|
||||
target = target_dir / f"{authorization.authorization_id}.json"
|
||||
payload = authorization.as_dict()
|
||||
payload["writer_id"] = self.writer_id
|
||||
with self._lock:
|
||||
target_dir.mkdir(parents=True, exist_ok=True)
|
||||
temporary = target.with_suffix(f".tmp-{os.getpid()}")
|
||||
temporary.write_text(
|
||||
json.dumps(payload, ensure_ascii=False, sort_keys=True, indent=2) + "\n",
|
||||
encoding="utf-8",
|
||||
)
|
||||
os.chmod(temporary, 0o640)
|
||||
os.replace(temporary, target)
|
||||
return authorization
|
||||
|
||||
def authorize_code_change(self, **values: Any) -> ProvenanceAuthorization:
|
||||
return self.authorize(execution_path=ExecutionPath.CODE_CHANGE.value, **values)
|
||||
|
||||
def authorize_git_operation(
|
||||
self, *, git_operation: str, **values: Any
|
||||
) -> ProvenanceAuthorization:
|
||||
return self.authorize(
|
||||
execution_path=ExecutionPath.GIT_OPERATION.value,
|
||||
git_operation=git_operation,
|
||||
**values,
|
||||
)
|
||||
|
||||
def authorize_deployment(self, **values: Any) -> ProvenanceAuthorization:
|
||||
return self.authorize(execution_path=ExecutionPath.DEPLOYMENT.value, **values)
|
||||
|
||||
def authorize_runtime_execute(self, **values: Any) -> ProvenanceAuthorization:
|
||||
return self.authorize(execution_path=ExecutionPath.RUNTIME_EXECUTE.value, **values)
|
||||
|
||||
def authorize_evidence_write(self, **values: Any) -> ProvenanceAuthorization:
|
||||
return self.authorize(execution_path=ExecutionPath.EVIDENCE_WRITE.value, **values)
|
||||
|
||||
def authorize_rollback(self, **values: Any) -> ProvenanceAuthorization:
|
||||
return self.authorize(execution_path=ExecutionPath.ROLLBACK.value, **values)
|
||||
|
||||
def authorize_audit(self, **values: Any) -> ProvenanceAuthorization:
|
||||
return self.authorize(execution_path=ExecutionPath.AUDIT.value, **values)
|
||||
@@ -1,381 +0,0 @@
|
||||
#!/usr/bin/env python3
|
||||
"""AIOS V2 Run Provenance 与最小权限 Grant 运维 CLI。
|
||||
|
||||
私钥只用于签发；授权命令只加载一个与 ``--path`` 对应的 Grant。所有输出均为
|
||||
不含 Secret 的 JSON。旧 ``issue`` 仅为候选兼容，生产必须使用
|
||||
``issue-workflow`` 与 ``issue-grant``。
|
||||
"""
|
||||
from __future__ import annotations
|
||||
|
||||
import argparse
|
||||
import json
|
||||
import os
|
||||
import sys
|
||||
from pathlib import Path
|
||||
from typing import Any, Mapping, Sequence
|
||||
|
||||
from .provenance import (
|
||||
Ed25519PrivateKeySigner,
|
||||
Ed25519PublicKeyVerifier,
|
||||
ExecutionPath,
|
||||
GitOperation,
|
||||
ProvenanceIssuer,
|
||||
SQLiteProvenanceStore,
|
||||
)
|
||||
from .provenance_grants import (
|
||||
GrantIssuer,
|
||||
GrantType,
|
||||
GrantVerifier,
|
||||
SQLiteGrantStore,
|
||||
WorkflowProvenanceIssuer,
|
||||
)
|
||||
from .provenance_operations import (
|
||||
OperationContext,
|
||||
ProvenanceOperationGate,
|
||||
context_from_environment,
|
||||
load_request_file,
|
||||
)
|
||||
from .provenance_scoped import ScopedLeastPrivilegeProvenanceWriter
|
||||
|
||||
|
||||
def _json_object(value: str | None, file_path: str | None) -> Mapping[str, Any]:
|
||||
if value and file_path:
|
||||
raise ValueError("request-json and request-file are mutually exclusive")
|
||||
if file_path:
|
||||
return load_request_file(file_path)
|
||||
parsed = json.loads(value or "{}")
|
||||
if not isinstance(parsed, Mapping):
|
||||
raise ValueError("request JSON must be an object")
|
||||
return dict(parsed)
|
||||
|
||||
|
||||
def _csv(value: str | None) -> tuple[str, ...]:
|
||||
return tuple(item.strip() for item in str(value or "").split(",") if item.strip())
|
||||
|
||||
|
||||
def _write_json(path: str | None, payload: Mapping[str, Any]) -> None:
|
||||
encoded = json.dumps(dict(payload), ensure_ascii=False, sort_keys=True, indent=2) + "\n"
|
||||
if path:
|
||||
target = Path(path).resolve()
|
||||
target.parent.mkdir(parents=True, exist_ok=True)
|
||||
temporary = target.with_suffix(f".tmp-{os.getpid()}")
|
||||
temporary.write_text(encoded, encoding="utf-8")
|
||||
os.chmod(temporary, 0o640)
|
||||
os.replace(temporary, target)
|
||||
print(encoded, end="")
|
||||
|
||||
|
||||
def _parent_store(args: argparse.Namespace) -> SQLiteProvenanceStore:
|
||||
return SQLiteProvenanceStore(args.store_file)
|
||||
|
||||
|
||||
def _grant_store(args: argparse.Namespace) -> SQLiteGrantStore:
|
||||
return SQLiteGrantStore(args.store_file)
|
||||
|
||||
|
||||
def _context(args: argparse.Namespace) -> OperationContext:
|
||||
if args.context_from_env:
|
||||
return context_from_environment()
|
||||
values = {
|
||||
"provenance_id": args.provenance_id,
|
||||
"run_id": args.run_id,
|
||||
"tenant_id": args.tenant_id,
|
||||
"task_id": args.task_id,
|
||||
"agent_id": args.agent_id,
|
||||
"principal_id": args.principal_id,
|
||||
}
|
||||
missing = [name for name, value in values.items() if not str(value or "").strip()]
|
||||
if missing:
|
||||
raise ValueError(f"missing context arguments: {missing}")
|
||||
return OperationContext(**{name: str(value).strip() for name, value in values.items()})
|
||||
|
||||
|
||||
def command_issue_legacy(args: argparse.Namespace) -> int:
|
||||
store = _parent_store(args)
|
||||
signer = Ed25519PrivateKeySigner.from_file(args.private_key_file, key_id=args.key_id)
|
||||
provenance = ProvenanceIssuer(signer, store).issue(
|
||||
run_id=args.run_id,
|
||||
issuer=args.issuer,
|
||||
tenant_id=args.tenant_id,
|
||||
task_id=args.task_id,
|
||||
agent_id=args.agent_id,
|
||||
principal_id=args.principal_id,
|
||||
allowed_paths=_csv(args.allowed_paths) or tuple(item.value for item in ExecutionPath),
|
||||
allowed_git_operations=_csv(args.allowed_git_operations)
|
||||
or tuple(item.value for item in GitOperation),
|
||||
ttl_seconds=args.ttl_seconds,
|
||||
policy_version=args.policy_version,
|
||||
)
|
||||
_write_json(
|
||||
args.output,
|
||||
{
|
||||
"mode": "legacy-full-rights-candidate-only",
|
||||
"provenance": provenance.as_dict(),
|
||||
"status": store.status(provenance.provenance_id).value,
|
||||
"secret_value_stored": False,
|
||||
},
|
||||
)
|
||||
return 0
|
||||
|
||||
|
||||
def command_issue_workflow(args: argparse.Namespace) -> int:
|
||||
store = _parent_store(args)
|
||||
signer = Ed25519PrivateKeySigner.from_file(args.private_key_file, key_id=args.key_id)
|
||||
workflow = WorkflowProvenanceIssuer(signer, store).issue(
|
||||
run_id=args.run_id,
|
||||
issuer=args.issuer,
|
||||
tenant_id=args.tenant_id,
|
||||
task_id=args.task_id,
|
||||
agent_id=args.agent_id,
|
||||
principal_id=args.principal_id,
|
||||
ttl_seconds=args.ttl_seconds,
|
||||
)
|
||||
_write_json(
|
||||
args.output,
|
||||
{
|
||||
"mode": "least-privilege-workflow",
|
||||
"workflow_provenance": workflow.as_dict(),
|
||||
"status": store.status(workflow.provenance_id).value,
|
||||
"secret_value_stored": False,
|
||||
},
|
||||
)
|
||||
return 0
|
||||
|
||||
|
||||
def command_issue_grant(args: argparse.Namespace) -> int:
|
||||
parent_store = _parent_store(args)
|
||||
grant_store = _grant_store(args)
|
||||
signer = Ed25519PrivateKeySigner.from_file(args.private_key_file, key_id=args.key_id)
|
||||
grant = GrantIssuer(signer, parent_store, grant_store).issue(
|
||||
parent_provenance_id=args.parent_provenance_id,
|
||||
grant_type=GrantType(args.grant_type),
|
||||
ttl_seconds=args.ttl_seconds,
|
||||
allowed_git_operations=_csv(args.allowed_git_operations),
|
||||
)
|
||||
_write_json(
|
||||
args.output,
|
||||
{
|
||||
"grant": grant.as_dict(),
|
||||
"status": grant_store.status(grant.grant_id).value,
|
||||
"secret_value_stored": False,
|
||||
},
|
||||
)
|
||||
return 0
|
||||
|
||||
|
||||
def _single_scope_writer(args: argparse.Namespace) -> ScopedLeastPrivilegeProvenanceWriter:
|
||||
path = ExecutionPath(args.path).value
|
||||
parent_store = _parent_store(args)
|
||||
grant_store = _grant_store(args)
|
||||
verifier = Ed25519PublicKeyVerifier.from_file(args.public_key_file, key_id=args.key_id)
|
||||
trusted = GrantVerifier(parent_store, grant_store, {args.key_id: verifier})
|
||||
return ScopedLeastPrivilegeProvenanceWriter(
|
||||
trusted,
|
||||
args.receipt_dir,
|
||||
{path: args.grant_id},
|
||||
required_paths=(path,),
|
||||
writer_id=f"aios-v2-cli-{path}",
|
||||
)
|
||||
|
||||
|
||||
def command_authorize(args: argparse.Namespace) -> int:
|
||||
writer = _single_scope_writer(args)
|
||||
context = _context(args)
|
||||
receipt = ProvenanceOperationGate(writer).authorize(
|
||||
context,
|
||||
execution_path=args.path,
|
||||
operation=args.operation,
|
||||
request=_json_object(args.request_json, args.request_file),
|
||||
)
|
||||
_write_json(args.output, {"authorization": receipt.as_dict()})
|
||||
return 0
|
||||
|
||||
|
||||
def command_revoke(args: argparse.Namespace) -> int:
|
||||
store = _parent_store(args)
|
||||
store.revoke(args.provenance_id, reason=args.reason, principal_id=args.principal_id)
|
||||
_write_json(
|
||||
args.output,
|
||||
{"provenance_id": args.provenance_id, "status": store.status(args.provenance_id).value},
|
||||
)
|
||||
return 0
|
||||
|
||||
|
||||
def command_status(args: argparse.Namespace) -> int:
|
||||
store = _parent_store(args)
|
||||
provenance = store.get(args.provenance_id)
|
||||
grant_store = _grant_store(args)
|
||||
_write_json(
|
||||
args.output,
|
||||
{
|
||||
"provenance": provenance.as_dict(),
|
||||
"status": store.status(args.provenance_id).value,
|
||||
"authorization_count": store.authorization_count(args.provenance_id),
|
||||
"events": store.events(args.provenance_id),
|
||||
"grants": [item.as_dict() for item in grant_store.list_for_parent(args.provenance_id)],
|
||||
},
|
||||
)
|
||||
return 0
|
||||
|
||||
|
||||
def command_grant_revoke(args: argparse.Namespace) -> int:
|
||||
store = _grant_store(args)
|
||||
store.revoke(args.grant_id, reason=args.reason, principal_id=args.principal_id)
|
||||
_write_json(
|
||||
args.output,
|
||||
{"grant_id": args.grant_id, "status": store.status(args.grant_id).value},
|
||||
)
|
||||
return 0
|
||||
|
||||
|
||||
def command_grant_status(args: argparse.Namespace) -> int:
|
||||
store = _grant_store(args)
|
||||
grant = store.get(args.grant_id)
|
||||
_write_json(
|
||||
args.output,
|
||||
{"grant": grant.as_dict(), "status": store.status(args.grant_id).value},
|
||||
)
|
||||
return 0
|
||||
|
||||
|
||||
def add_common_store(parser: argparse.ArgumentParser) -> None:
|
||||
parser.add_argument(
|
||||
"--store-file",
|
||||
default=os.getenv(
|
||||
"AIOS_PROVENANCE_STORE_FILE",
|
||||
"/var/lib/aios-v2/run-provenance.sqlite3",
|
||||
),
|
||||
)
|
||||
parser.add_argument("--output", default=None)
|
||||
|
||||
|
||||
def add_signing_context(parser: argparse.ArgumentParser) -> None:
|
||||
parser.add_argument("--private-key-file", required=True)
|
||||
parser.add_argument("--key-id", required=True)
|
||||
|
||||
|
||||
def add_workflow_identity(parser: argparse.ArgumentParser) -> None:
|
||||
parser.add_argument("--run-id", required=True)
|
||||
parser.add_argument("--issuer", required=True)
|
||||
parser.add_argument("--tenant-id", required=True)
|
||||
parser.add_argument("--task-id", required=True)
|
||||
parser.add_argument("--agent-id", required=True)
|
||||
parser.add_argument("--principal-id", required=True)
|
||||
|
||||
|
||||
def add_context(parser: argparse.ArgumentParser) -> None:
|
||||
parser.add_argument("--context-from-env", action="store_true")
|
||||
parser.add_argument("--provenance-id")
|
||||
parser.add_argument("--run-id")
|
||||
parser.add_argument("--tenant-id")
|
||||
parser.add_argument("--task-id")
|
||||
parser.add_argument("--agent-id")
|
||||
parser.add_argument("--principal-id")
|
||||
|
||||
|
||||
def build_parser() -> argparse.ArgumentParser:
|
||||
parser = argparse.ArgumentParser(description="AIOS V2 Run Provenance CLI")
|
||||
subcommands = parser.add_subparsers(dest="command", required=True)
|
||||
|
||||
issue = subcommands.add_parser("issue", help="候选兼容：签发全权限 Provenance；生产禁止")
|
||||
add_common_store(issue)
|
||||
add_signing_context(issue)
|
||||
add_workflow_identity(issue)
|
||||
issue.add_argument("--allowed-paths")
|
||||
issue.add_argument("--allowed-git-operations")
|
||||
issue.add_argument("--ttl-seconds", type=int, default=3600)
|
||||
issue.add_argument("--policy-version", default="aios.v2.candidate.legacy")
|
||||
issue.set_defaults(handler=command_issue_legacy)
|
||||
|
||||
workflow = subcommands.add_parser(
|
||||
"issue-workflow", help="签发不含操作权限的父 Workflow Provenance"
|
||||
)
|
||||
add_common_store(workflow)
|
||||
add_signing_context(workflow)
|
||||
add_workflow_identity(workflow)
|
||||
workflow.add_argument("--ttl-seconds", type=int, default=14400)
|
||||
workflow.set_defaults(handler=command_issue_workflow)
|
||||
|
||||
grant = subcommands.add_parser("issue-grant", help="签发单一路径最小权限 Grant")
|
||||
add_common_store(grant)
|
||||
add_signing_context(grant)
|
||||
grant.add_argument("--parent-provenance-id", required=True)
|
||||
grant.add_argument("--grant-type", choices=[item.value for item in GrantType], required=True)
|
||||
grant.add_argument("--allowed-git-operations")
|
||||
grant.add_argument("--ttl-seconds", type=int, default=900)
|
||||
grant.set_defaults(handler=command_issue_grant)
|
||||
|
||||
authorize = subcommands.add_parser("authorize", help="使用单一子 Grant 授权一次运维操作")
|
||||
add_common_store(authorize)
|
||||
add_context(authorize)
|
||||
authorize.add_argument("--public-key-file", required=True)
|
||||
authorize.add_argument("--key-id", required=True)
|
||||
authorize.add_argument("--grant-id", required=True)
|
||||
authorize.add_argument(
|
||||
"--receipt-dir",
|
||||
default=os.getenv(
|
||||
"AIOS_PROVENANCE_RECEIPT_DIR",
|
||||
"/var/lib/aios-v2/provenance-receipts",
|
||||
),
|
||||
)
|
||||
authorize.add_argument(
|
||||
"--path",
|
||||
required=True,
|
||||
choices=[
|
||||
ExecutionPath.CODE_CHANGE.value,
|
||||
ExecutionPath.DEPLOYMENT.value,
|
||||
ExecutionPath.RUNTIME_EXECUTE.value,
|
||||
ExecutionPath.EVIDENCE_WRITE.value,
|
||||
ExecutionPath.ROLLBACK.value,
|
||||
ExecutionPath.AUDIT.value,
|
||||
],
|
||||
)
|
||||
authorize.add_argument("--operation", required=True)
|
||||
request_group = authorize.add_mutually_exclusive_group()
|
||||
request_group.add_argument("--request-json")
|
||||
request_group.add_argument("--request-file")
|
||||
authorize.set_defaults(handler=command_authorize)
|
||||
|
||||
revoke = subcommands.add_parser("revoke", help="撤销父 Workflow Provenance")
|
||||
add_common_store(revoke)
|
||||
revoke.add_argument("--provenance-id", required=True)
|
||||
revoke.add_argument("--reason", required=True)
|
||||
revoke.add_argument("--principal-id", required=True)
|
||||
revoke.set_defaults(handler=command_revoke)
|
||||
|
||||
status = subcommands.add_parser("status", help="查询父 Workflow 与子 Grant")
|
||||
add_common_store(status)
|
||||
status.add_argument("--provenance-id", required=True)
|
||||
status.set_defaults(handler=command_status)
|
||||
|
||||
grant_revoke = subcommands.add_parser("grant-revoke", help="单独撤销子 Grant")
|
||||
add_common_store(grant_revoke)
|
||||
grant_revoke.add_argument("--grant-id", required=True)
|
||||
grant_revoke.add_argument("--reason", required=True)
|
||||
grant_revoke.add_argument("--principal-id", required=True)
|
||||
grant_revoke.set_defaults(handler=command_grant_revoke)
|
||||
|
||||
grant_status = subcommands.add_parser("grant-status", help="查询子 Grant 状态")
|
||||
add_common_store(grant_status)
|
||||
grant_status.add_argument("--grant-id", required=True)
|
||||
grant_status.set_defaults(handler=command_grant_status)
|
||||
return parser
|
||||
|
||||
|
||||
def main(argv: Sequence[str] | None = None) -> int:
|
||||
args = build_parser().parse_args(argv)
|
||||
try:
|
||||
return int(args.handler(args))
|
||||
except Exception as exc:
|
||||
print(
|
||||
json.dumps(
|
||||
{"status": "denied", "error": type(exc).__name__, "message": str(exc)},
|
||||
ensure_ascii=False,
|
||||
),
|
||||
file=sys.stderr,
|
||||
)
|
||||
return 1
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
raise SystemExit(main())
|
||||
@@ -1,416 +0,0 @@
|
||||
"""受最小权限 Run Provenance Grant 约束的 Git 写入器。
|
||||
|
||||
所有 Git 操作都使用参数数组执行。对于 Commit 和 Evidence Commit，先计算
|
||||
工作树内容摘要并完成 Provenance 授权，之后才允许执行 ``git add``，避免未授权
|
||||
请求改变 Git Index。
|
||||
"""
|
||||
from __future__ import annotations
|
||||
|
||||
import hashlib
|
||||
import os
|
||||
import re
|
||||
import subprocess
|
||||
import uuid
|
||||
from dataclasses import asdict, dataclass
|
||||
from pathlib import Path
|
||||
from typing import Any, Mapping, Protocol, Sequence
|
||||
|
||||
from .provenance import GitOperation, ProvenanceDenied, digest_payload, utc_now
|
||||
|
||||
_BRANCH_PATTERN = re.compile(r"^(?![-./])(?!.*\.\.)(?!.*//)[A-Za-z0-9._/-]{1,240}$")
|
||||
_SECRET_URL = re.compile(r"(?i)(https?://)([^/@\s]+)@")
|
||||
_TOKENISH = re.compile(r"(?i)(token|password|secret|authorization)([=:]\s*)([^\s]+)")
|
||||
|
||||
|
||||
class GitAuthorizationWriter(Protocol):
|
||||
def authorize_code_change(self, **values: Any) -> Any: ...
|
||||
|
||||
def authorize_git_operation(self, *, git_operation: str, **values: Any) -> Any: ...
|
||||
|
||||
|
||||
class ProvenanceGitError(RuntimeError):
|
||||
"""Git 操作被拒绝或执行失败。"""
|
||||
|
||||
|
||||
@dataclass(frozen=True)
|
||||
class GitExecutionContext:
|
||||
provenance_id: str
|
||||
run_id: str
|
||||
tenant_id: str
|
||||
task_id: str
|
||||
agent_id: str
|
||||
principal_id: str
|
||||
|
||||
|
||||
@dataclass(frozen=True)
|
||||
class GitCommandResult:
|
||||
operation_id: str
|
||||
operation: str
|
||||
authorization_ids: Sequence[str]
|
||||
command: Sequence[str]
|
||||
exit_code: int
|
||||
stdout: str
|
||||
stderr: str
|
||||
head_before: str | None
|
||||
head_after: str | None
|
||||
started_at: str
|
||||
completed_at: str
|
||||
|
||||
def as_dict(self) -> dict[str, Any]:
|
||||
return asdict(self)
|
||||
|
||||
|
||||
class ProvenanceGitWriter:
|
||||
"""执行经过单路径 Grant 授权的窄范围 Git 操作。"""
|
||||
|
||||
def __init__(
|
||||
self,
|
||||
repo: str | Path,
|
||||
writer: GitAuthorizationWriter,
|
||||
*,
|
||||
timeout_seconds: float = 120.0,
|
||||
output_limit: int = 16000,
|
||||
) -> None:
|
||||
self.repo = Path(repo).resolve()
|
||||
self.writer = writer
|
||||
self.timeout_seconds = float(timeout_seconds)
|
||||
self.output_limit = int(output_limit)
|
||||
if self.timeout_seconds <= 0 or self.output_limit < 1024:
|
||||
raise ValueError("invalid Git writer limits")
|
||||
self._run_raw(["rev-parse", "--is-inside-work-tree"], check=True)
|
||||
|
||||
@staticmethod
|
||||
def _validate_branch(branch: str) -> str:
|
||||
normalized = str(branch or "").strip()
|
||||
if not _BRANCH_PATTERN.fullmatch(normalized) or normalized.endswith((".", "/")):
|
||||
raise ProvenanceGitError("invalid Git branch name")
|
||||
if normalized in {"main", "master"}:
|
||||
raise ProvenanceGitError("direct main/master operation is prohibited")
|
||||
return normalized
|
||||
|
||||
def _validate_path(self, value: str | Path) -> str:
|
||||
raw = Path(value)
|
||||
candidate = (self.repo / raw).resolve() if not raw.is_absolute() else raw.resolve()
|
||||
try:
|
||||
relative = candidate.relative_to(self.repo)
|
||||
except ValueError as exc:
|
||||
raise ProvenanceGitError("Git path escapes repository") from exc
|
||||
if str(relative) in {"", "."}:
|
||||
raise ProvenanceGitError("repository root is not a valid file path")
|
||||
return relative.as_posix()
|
||||
|
||||
@staticmethod
|
||||
def _redact(value: str, limit: int) -> str:
|
||||
text = _SECRET_URL.sub(r"\1***@", str(value or ""))
|
||||
text = _TOKENISH.sub(r"\1\2***", text)
|
||||
if len(text) > limit:
|
||||
return text[:limit] + "\n...[truncated]"
|
||||
return text
|
||||
|
||||
def _head(self) -> str | None:
|
||||
process = self._run_raw(["rev-parse", "HEAD"], check=False)
|
||||
return process.stdout.strip() if process.returncode == 0 else None
|
||||
|
||||
def _run_raw(
|
||||
self,
|
||||
args: Sequence[str],
|
||||
*,
|
||||
check: bool,
|
||||
env: Mapping[str, str] | None = None,
|
||||
) -> subprocess.CompletedProcess[str]:
|
||||
command = ["git", "-C", str(self.repo), *[str(item) for item in args]]
|
||||
safe_env = {
|
||||
**os.environ,
|
||||
"GIT_TERMINAL_PROMPT": "0",
|
||||
"GIT_CONFIG_NOSYSTEM": os.environ.get("GIT_CONFIG_NOSYSTEM", "1"),
|
||||
}
|
||||
if env:
|
||||
safe_env.update({str(key): str(value) for key, value in env.items()})
|
||||
process = subprocess.run(
|
||||
command,
|
||||
text=True,
|
||||
capture_output=True,
|
||||
timeout=self.timeout_seconds,
|
||||
env=safe_env,
|
||||
)
|
||||
if check and process.returncode != 0:
|
||||
raise ProvenanceGitError(
|
||||
self._redact(process.stderr or process.stdout, self.output_limit)
|
||||
or f"Git command failed with exit code {process.returncode}"
|
||||
)
|
||||
return process
|
||||
|
||||
def _path_digest(self, relative: str) -> str:
|
||||
target = self.repo / relative
|
||||
if target.exists():
|
||||
if not target.is_file():
|
||||
raise ProvenanceGitError("Git writer accepts file paths only")
|
||||
hasher = hashlib.sha256()
|
||||
with target.open("rb") as handle:
|
||||
while True:
|
||||
block = handle.read(65536)
|
||||
if not block:
|
||||
break
|
||||
hasher.update(block)
|
||||
return hasher.hexdigest()
|
||||
tracked = self._run_raw(["ls-files", "--error-unmatch", "--", relative], check=False)
|
||||
if tracked.returncode != 0:
|
||||
raise ProvenanceGitError(f"path does not exist and is not tracked: {relative}")
|
||||
return "deleted"
|
||||
|
||||
def _content_manifest(self, paths: Sequence[str]) -> Mapping[str, str]:
|
||||
return {path: self._path_digest(path) for path in sorted(set(paths))}
|
||||
|
||||
def _authorize(
|
||||
self,
|
||||
context: GitExecutionContext,
|
||||
*,
|
||||
operation: GitOperation,
|
||||
request: Mapping[str, Any],
|
||||
code_change: bool,
|
||||
) -> list[str]:
|
||||
request_digest = digest_payload(
|
||||
{
|
||||
"operation": operation.value,
|
||||
"repo": self.repo.name,
|
||||
"request": dict(request),
|
||||
"head": self._head(),
|
||||
}
|
||||
)
|
||||
ids: list[str] = []
|
||||
try:
|
||||
if code_change:
|
||||
code_authorization = self.writer.authorize_code_change(
|
||||
provenance_id=context.provenance_id,
|
||||
run_id=context.run_id,
|
||||
tenant_id=context.tenant_id,
|
||||
task_id=context.task_id,
|
||||
agent_id=context.agent_id,
|
||||
principal_id=context.principal_id,
|
||||
request_digest=digest_payload(
|
||||
{
|
||||
"git_operation": operation.value,
|
||||
"request_digest": request_digest,
|
||||
}
|
||||
),
|
||||
)
|
||||
ids.append(code_authorization.authorization_id)
|
||||
git_authorization = self.writer.authorize_git_operation(
|
||||
provenance_id=context.provenance_id,
|
||||
run_id=context.run_id,
|
||||
tenant_id=context.tenant_id,
|
||||
task_id=context.task_id,
|
||||
agent_id=context.agent_id,
|
||||
principal_id=context.principal_id,
|
||||
git_operation=operation.value,
|
||||
request_digest=request_digest,
|
||||
)
|
||||
ids.append(git_authorization.authorization_id)
|
||||
return ids
|
||||
except ProvenanceDenied as exc:
|
||||
raise ProvenanceGitError(f"Run Provenance denied Git operation: {exc}") from exc
|
||||
|
||||
def _run_authorized(
|
||||
self,
|
||||
*,
|
||||
operation: GitOperation,
|
||||
args: Sequence[str],
|
||||
authorization_ids: Sequence[str],
|
||||
) -> GitCommandResult:
|
||||
started = utc_now()
|
||||
before = self._head()
|
||||
process = self._run_raw(args, check=False)
|
||||
after = self._head()
|
||||
result = GitCommandResult(
|
||||
operation_id=f"gitop_{uuid.uuid4().hex}",
|
||||
operation=operation.value,
|
||||
authorization_ids=tuple(authorization_ids),
|
||||
command=tuple(["git", "-C", "<repo>", *[str(item) for item in args]]),
|
||||
exit_code=int(process.returncode),
|
||||
stdout=self._redact(process.stdout, self.output_limit),
|
||||
stderr=self._redact(process.stderr, self.output_limit),
|
||||
head_before=before,
|
||||
head_after=after,
|
||||
started_at=started,
|
||||
completed_at=utc_now(),
|
||||
)
|
||||
if process.returncode != 0:
|
||||
raise ProvenanceGitError(
|
||||
result.stderr or result.stdout or f"Git {operation.value} failed"
|
||||
)
|
||||
return result
|
||||
|
||||
def _execute(
|
||||
self,
|
||||
context: GitExecutionContext,
|
||||
*,
|
||||
operation: GitOperation,
|
||||
args: Sequence[str],
|
||||
request: Mapping[str, Any],
|
||||
code_change: bool,
|
||||
) -> GitCommandResult:
|
||||
authorization_ids = self._authorize(
|
||||
context,
|
||||
operation=operation,
|
||||
request=request,
|
||||
code_change=code_change,
|
||||
)
|
||||
return self._run_authorized(
|
||||
operation=operation,
|
||||
args=args,
|
||||
authorization_ids=authorization_ids,
|
||||
)
|
||||
|
||||
def read_ref(self, context: GitExecutionContext, ref: str) -> GitCommandResult:
|
||||
normalized = str(ref or "").strip()
|
||||
if not normalized or any(ch.isspace() for ch in normalized):
|
||||
raise ProvenanceGitError("invalid Git ref")
|
||||
return self._execute(
|
||||
context,
|
||||
operation=GitOperation.READ_REF,
|
||||
args=["rev-parse", "--verify", normalized],
|
||||
request={"ref": normalized},
|
||||
code_change=False,
|
||||
)
|
||||
|
||||
def fetch(
|
||||
self,
|
||||
context: GitExecutionContext,
|
||||
*,
|
||||
remote: str,
|
||||
refspecs: Sequence[str],
|
||||
) -> GitCommandResult:
|
||||
normalized_remote = str(remote or "").strip()
|
||||
normalized_refspecs = tuple(str(item).strip() for item in refspecs if str(item).strip())
|
||||
if not normalized_remote or not normalized_refspecs:
|
||||
raise ProvenanceGitError("remote and refspecs are required")
|
||||
if any(item.startswith("+") and ":refs/heads/" in item for item in normalized_refspecs):
|
||||
raise ProvenanceGitError(
|
||||
"fetching directly into local branch refs is prohibited; use remote-tracking refs"
|
||||
)
|
||||
return self._execute(
|
||||
context,
|
||||
operation=GitOperation.FETCH,
|
||||
args=["fetch", "--prune", normalized_remote, *normalized_refspecs],
|
||||
request={"remote": normalized_remote, "refspecs": normalized_refspecs},
|
||||
code_change=False,
|
||||
)
|
||||
|
||||
def create_branch(
|
||||
self,
|
||||
context: GitExecutionContext,
|
||||
*,
|
||||
branch: str,
|
||||
start_point: str,
|
||||
) -> GitCommandResult:
|
||||
normalized = self._validate_branch(branch)
|
||||
start = str(start_point or "").strip()
|
||||
if not start:
|
||||
raise ProvenanceGitError("start_point is required")
|
||||
return self._execute(
|
||||
context,
|
||||
operation=GitOperation.CREATE_BRANCH,
|
||||
args=["branch", normalized, start],
|
||||
request={"branch": normalized, "start_point": start},
|
||||
code_change=False,
|
||||
)
|
||||
|
||||
def commit(
|
||||
self,
|
||||
context: GitExecutionContext,
|
||||
*,
|
||||
paths: Sequence[str | Path],
|
||||
message: str,
|
||||
) -> GitCommandResult:
|
||||
normalized_paths = tuple(self._validate_path(item) for item in paths)
|
||||
normalized_message = str(message or "").strip()
|
||||
if not normalized_paths or not normalized_message:
|
||||
raise ProvenanceGitError("commit paths and message are required")
|
||||
if len(normalized_message) > 500:
|
||||
raise ProvenanceGitError("commit message is too long")
|
||||
request = {
|
||||
"paths": normalized_paths,
|
||||
"message": normalized_message,
|
||||
"content_manifest": self._content_manifest(normalized_paths),
|
||||
}
|
||||
authorization_ids = self._authorize(
|
||||
context,
|
||||
operation=GitOperation.COMMIT,
|
||||
request=request,
|
||||
code_change=True,
|
||||
)
|
||||
self._run_raw(["add", "--", *normalized_paths], check=True)
|
||||
return self._run_authorized(
|
||||
operation=GitOperation.COMMIT,
|
||||
args=["commit", "--no-gpg-sign", "-m", normalized_message, "--", *normalized_paths],
|
||||
authorization_ids=authorization_ids,
|
||||
)
|
||||
|
||||
def merge(
|
||||
self,
|
||||
context: GitExecutionContext,
|
||||
*,
|
||||
source_ref: str,
|
||||
message: str,
|
||||
) -> GitCommandResult:
|
||||
source = str(source_ref or "").strip()
|
||||
normalized_message = str(message or "").strip()
|
||||
if not source or not normalized_message:
|
||||
raise ProvenanceGitError("source_ref and message are required")
|
||||
return self._execute(
|
||||
context,
|
||||
operation=GitOperation.MERGE,
|
||||
args=["merge", "--no-ff", "--no-edit", "-m", normalized_message, source],
|
||||
request={"source_ref": source, "message": normalized_message},
|
||||
code_change=True,
|
||||
)
|
||||
|
||||
def push(
|
||||
self,
|
||||
context: GitExecutionContext,
|
||||
*,
|
||||
remote: str,
|
||||
branch: str,
|
||||
) -> GitCommandResult:
|
||||
normalized_remote = str(remote or "").strip()
|
||||
normalized_branch = self._validate_branch(branch)
|
||||
if not normalized_remote:
|
||||
raise ProvenanceGitError("remote is required")
|
||||
return self._execute(
|
||||
context,
|
||||
operation=GitOperation.PUSH,
|
||||
args=["push", normalized_remote, f"refs/heads/{normalized_branch}:refs/heads/{normalized_branch}"],
|
||||
request={"remote": normalized_remote, "branch": normalized_branch},
|
||||
code_change=False,
|
||||
)
|
||||
|
||||
def update_evidence(
|
||||
self,
|
||||
context: GitExecutionContext,
|
||||
*,
|
||||
paths: Sequence[str | Path],
|
||||
message: str,
|
||||
) -> GitCommandResult:
|
||||
normalized_paths = tuple(self._validate_path(item) for item in paths)
|
||||
normalized_message = str(message or "").strip()
|
||||
if not normalized_paths or not normalized_message:
|
||||
raise ProvenanceGitError("evidence paths and message are required")
|
||||
if any(not path.startswith(".agent/") for path in normalized_paths):
|
||||
raise ProvenanceGitError("UPDATE_EVIDENCE may only commit .agent/ paths")
|
||||
request = {
|
||||
"paths": normalized_paths,
|
||||
"message": normalized_message,
|
||||
"content_manifest": self._content_manifest(normalized_paths),
|
||||
}
|
||||
authorization_ids = self._authorize(
|
||||
context,
|
||||
operation=GitOperation.UPDATE_EVIDENCE,
|
||||
request=request,
|
||||
code_change=False,
|
||||
)
|
||||
self._run_raw(["add", "--", *normalized_paths], check=True)
|
||||
return self._run_authorized(
|
||||
operation=GitOperation.UPDATE_EVIDENCE,
|
||||
args=["commit", "--no-gpg-sign", "-m", normalized_message, "--", *normalized_paths],
|
||||
authorization_ids=authorization_ids,
|
||||
)
|
||||
@@ -1,744 +0,0 @@
|
||||
"""AIOS V2 最小权限 Run Provenance 子 Grant。
|
||||
|
||||
父 Workflow Provenance 只绑定 run/tenant/task/agent/principal 身份，不直接授予
|
||||
操作权限。每个子 Grant 只允许一个 ExecutionPath；Git Grant 还必须限定具体
|
||||
GitOperation。子 Grant 具备独立 TTL、nonce、状态、撤销和重放防护。
|
||||
"""
|
||||
from __future__ import annotations
|
||||
|
||||
import json
|
||||
import os
|
||||
import sqlite3
|
||||
import threading
|
||||
import uuid
|
||||
from dataclasses import asdict, dataclass, field, replace
|
||||
from datetime import datetime, timedelta, timezone
|
||||
from enum import Enum
|
||||
from pathlib import Path
|
||||
from typing import Any, Mapping, Sequence
|
||||
|
||||
from .provenance import (
|
||||
ExecutionPath,
|
||||
GitOperation,
|
||||
ProvenanceDenied,
|
||||
ProvenanceExpired,
|
||||
ProvenanceIssuer,
|
||||
ProvenanceNotFound,
|
||||
ProvenanceReplay,
|
||||
ProvenanceRevoked,
|
||||
ProvenanceSignatureError,
|
||||
ProvenanceStatus,
|
||||
ProvenanceVerifier,
|
||||
RunProvenance,
|
||||
SQLiteProvenanceStore,
|
||||
Signer,
|
||||
SignatureVerifier,
|
||||
_validate_digest,
|
||||
canonical_json_bytes,
|
||||
parse_timestamp,
|
||||
required,
|
||||
utc_now,
|
||||
)
|
||||
|
||||
WORKFLOW_POLICY_VERSION = "aios.v2.workflow.v1"
|
||||
GRANT_SCHEMA_VERSION = "aios.v2.provenance-grant.v1"
|
||||
|
||||
|
||||
class GrantType(str, Enum):
|
||||
CODE_CHANGE = "code_change"
|
||||
GIT = "git"
|
||||
DEPLOYMENT = "deployment"
|
||||
RUNTIME = "runtime"
|
||||
EVIDENCE = "evidence"
|
||||
ROLLBACK = "rollback"
|
||||
AUDIT = "audit"
|
||||
|
||||
|
||||
GRANT_PATHS: Mapping[GrantType, ExecutionPath] = {
|
||||
GrantType.CODE_CHANGE: ExecutionPath.CODE_CHANGE,
|
||||
GrantType.GIT: ExecutionPath.GIT_OPERATION,
|
||||
GrantType.DEPLOYMENT: ExecutionPath.DEPLOYMENT,
|
||||
GrantType.RUNTIME: ExecutionPath.RUNTIME_EXECUTE,
|
||||
GrantType.EVIDENCE: ExecutionPath.EVIDENCE_WRITE,
|
||||
GrantType.ROLLBACK: ExecutionPath.ROLLBACK,
|
||||
GrantType.AUDIT: ExecutionPath.AUDIT,
|
||||
}
|
||||
|
||||
|
||||
class GrantStatus(str, Enum):
|
||||
ISSUED = "issued"
|
||||
VERIFIED = "verified"
|
||||
USED = "used"
|
||||
EXPIRED = "expired"
|
||||
REVOKED = "revoked"
|
||||
|
||||
|
||||
@dataclass(frozen=True)
|
||||
class ProvenanceGrant:
|
||||
grant_id: str
|
||||
parent_provenance_id: str
|
||||
grant_type: GrantType
|
||||
execution_path: ExecutionPath
|
||||
run_id: str
|
||||
issuer: str
|
||||
tenant_id: str
|
||||
task_id: str
|
||||
agent_id: str
|
||||
principal_id: str
|
||||
allowed_git_operations: Sequence[str]
|
||||
issued_at: str
|
||||
expires_at: str
|
||||
policy_version: str
|
||||
key_id: str
|
||||
nonce: str
|
||||
signature: str = ""
|
||||
schema_version: str = GRANT_SCHEMA_VERSION
|
||||
|
||||
def __post_init__(self) -> None:
|
||||
for name in (
|
||||
"grant_id",
|
||||
"parent_provenance_id",
|
||||
"run_id",
|
||||
"issuer",
|
||||
"tenant_id",
|
||||
"task_id",
|
||||
"agent_id",
|
||||
"principal_id",
|
||||
"issued_at",
|
||||
"expires_at",
|
||||
"policy_version",
|
||||
"key_id",
|
||||
"nonce",
|
||||
"schema_version",
|
||||
):
|
||||
object.__setattr__(self, name, required(getattr(self, name), name))
|
||||
if self.schema_version != GRANT_SCHEMA_VERSION:
|
||||
raise ValueError(f"unsupported grant schema: {self.schema_version}")
|
||||
grant_type = GrantType(self.grant_type)
|
||||
path = ExecutionPath(self.execution_path)
|
||||
if GRANT_PATHS[grant_type] != path:
|
||||
raise ValueError("grant_type does not match execution_path")
|
||||
object.__setattr__(self, "grant_type", grant_type)
|
||||
object.__setattr__(self, "execution_path", path)
|
||||
operations = tuple(
|
||||
sorted({GitOperation(item).value for item in self.allowed_git_operations})
|
||||
)
|
||||
if grant_type == GrantType.GIT and not operations:
|
||||
raise ValueError("Git Grant requires explicit Git operations")
|
||||
if grant_type != GrantType.GIT and operations:
|
||||
raise ValueError("only Git Grant may contain Git operations")
|
||||
object.__setattr__(self, "allowed_git_operations", operations)
|
||||
issued = parse_timestamp(self.issued_at)
|
||||
expires = parse_timestamp(self.expires_at)
|
||||
if expires <= issued:
|
||||
raise ValueError("grant expires_at must be later than issued_at")
|
||||
object.__setattr__(self, "signature", str(self.signature or "").strip())
|
||||
|
||||
def unsigned_dict(self) -> dict[str, Any]:
|
||||
return {
|
||||
"schema_version": self.schema_version,
|
||||
"grant_id": self.grant_id,
|
||||
"parent_provenance_id": self.parent_provenance_id,
|
||||
"grant_type": self.grant_type.value,
|
||||
"execution_path": self.execution_path.value,
|
||||
"run_id": self.run_id,
|
||||
"issuer": self.issuer,
|
||||
"tenant_id": self.tenant_id,
|
||||
"task_id": self.task_id,
|
||||
"agent_id": self.agent_id,
|
||||
"principal_id": self.principal_id,
|
||||
"allowed_git_operations": list(self.allowed_git_operations),
|
||||
"issued_at": self.issued_at,
|
||||
"expires_at": self.expires_at,
|
||||
"policy_version": self.policy_version,
|
||||
"key_id": self.key_id,
|
||||
"nonce": self.nonce,
|
||||
}
|
||||
|
||||
def canonical_bytes(self) -> bytes:
|
||||
return canonical_json_bytes(self.unsigned_dict())
|
||||
|
||||
def as_dict(self) -> dict[str, Any]:
|
||||
value = self.unsigned_dict()
|
||||
value["signature"] = self.signature
|
||||
return value
|
||||
|
||||
@classmethod
|
||||
def from_dict(cls, value: Mapping[str, Any]) -> "ProvenanceGrant":
|
||||
return cls(**dict(value))
|
||||
|
||||
|
||||
@dataclass(frozen=True)
|
||||
class GrantAuthorization:
|
||||
authorization_id: str
|
||||
grant_id: str
|
||||
parent_provenance_id: str
|
||||
run_id: str
|
||||
tenant_id: str
|
||||
task_id: str
|
||||
agent_id: str
|
||||
principal_id: str
|
||||
execution_path: str
|
||||
git_operation: str | None
|
||||
request_digest: str
|
||||
policy_version: str
|
||||
key_id: str
|
||||
public_key_fingerprint: str
|
||||
authorized_at: str = field(default_factory=utc_now)
|
||||
|
||||
@property
|
||||
def provenance_id(self) -> str:
|
||||
return self.parent_provenance_id
|
||||
|
||||
def as_dict(self) -> dict[str, Any]:
|
||||
return asdict(self)
|
||||
|
||||
|
||||
class WorkflowProvenanceIssuer:
|
||||
"""签发不携带操作权限的父 Workflow Provenance。"""
|
||||
|
||||
def __init__(self, signer: Signer, store: SQLiteProvenanceStore) -> None:
|
||||
self._issuer = ProvenanceIssuer(signer, store)
|
||||
|
||||
def issue(
|
||||
self,
|
||||
*,
|
||||
run_id: str,
|
||||
issuer: str,
|
||||
tenant_id: str,
|
||||
task_id: str,
|
||||
agent_id: str,
|
||||
principal_id: str,
|
||||
ttl_seconds: int = 14400,
|
||||
provenance_id: str | None = None,
|
||||
nonce: str | None = None,
|
||||
now: datetime | None = None,
|
||||
) -> RunProvenance:
|
||||
return self._issuer.issue(
|
||||
run_id=run_id,
|
||||
issuer=issuer,
|
||||
tenant_id=tenant_id,
|
||||
task_id=task_id,
|
||||
agent_id=agent_id,
|
||||
principal_id=principal_id,
|
||||
allowed_paths=(),
|
||||
allowed_git_operations=(),
|
||||
ttl_seconds=ttl_seconds,
|
||||
policy_version=WORKFLOW_POLICY_VERSION,
|
||||
provenance_id=provenance_id,
|
||||
nonce=nonce,
|
||||
now=now,
|
||||
)
|
||||
|
||||
|
||||
class SQLiteGrantStore:
|
||||
"""在 Provenance SQLite 数据库中持久化子 Grant 与使用记录。"""
|
||||
|
||||
def __init__(self, path: str | Path) -> None:
|
||||
self.path = Path(path).resolve()
|
||||
self.path.parent.mkdir(parents=True, exist_ok=True)
|
||||
self._lock = threading.RLock()
|
||||
self._connection = sqlite3.connect(
|
||||
str(self.path), timeout=30.0, check_same_thread=False
|
||||
)
|
||||
self._connection.row_factory = sqlite3.Row
|
||||
with self._lock:
|
||||
self._connection.execute("PRAGMA journal_mode=WAL")
|
||||
self._connection.execute("PRAGMA synchronous=FULL")
|
||||
self._connection.execute("PRAGMA foreign_keys=ON")
|
||||
self._connection.executescript(
|
||||
"""
|
||||
CREATE TABLE IF NOT EXISTS provenance_grants (
|
||||
grant_id TEXT PRIMARY KEY,
|
||||
parent_provenance_id TEXT NOT NULL,
|
||||
grant_type TEXT NOT NULL,
|
||||
execution_path TEXT NOT NULL,
|
||||
payload_json TEXT NOT NULL,
|
||||
status TEXT NOT NULL,
|
||||
signature_verified INTEGER NOT NULL DEFAULT 0,
|
||||
created_at TEXT NOT NULL,
|
||||
updated_at TEXT NOT NULL
|
||||
);
|
||||
CREATE INDEX IF NOT EXISTS idx_grants_parent
|
||||
ON provenance_grants(parent_provenance_id, grant_type, status);
|
||||
CREATE TABLE IF NOT EXISTS provenance_grant_usage (
|
||||
authorization_id TEXT PRIMARY KEY,
|
||||
grant_id TEXT NOT NULL,
|
||||
execution_path TEXT NOT NULL,
|
||||
git_operation TEXT NOT NULL DEFAULT '',
|
||||
request_digest TEXT NOT NULL,
|
||||
authorized_at TEXT NOT NULL,
|
||||
receipt_json TEXT NOT NULL,
|
||||
UNIQUE(grant_id, execution_path, git_operation, request_digest),
|
||||
FOREIGN KEY(grant_id) REFERENCES provenance_grants(grant_id)
|
||||
);
|
||||
CREATE TABLE IF NOT EXISTS provenance_grant_events (
|
||||
event_id TEXT PRIMARY KEY,
|
||||
grant_id TEXT NOT NULL,
|
||||
event_type TEXT NOT NULL,
|
||||
details_json TEXT NOT NULL,
|
||||
created_at TEXT NOT NULL,
|
||||
FOREIGN KEY(grant_id) REFERENCES provenance_grants(grant_id)
|
||||
);
|
||||
"""
|
||||
)
|
||||
self._connection.commit()
|
||||
|
||||
def close(self) -> None:
|
||||
with self._lock:
|
||||
self._connection.close()
|
||||
|
||||
def _event(
|
||||
self,
|
||||
grant_id: str,
|
||||
event_type: str,
|
||||
details: Mapping[str, Any] | None = None,
|
||||
) -> None:
|
||||
self._connection.execute(
|
||||
"INSERT INTO provenance_grant_events VALUES (?, ?, ?, ?, ?)",
|
||||
(
|
||||
f"gevt_{uuid.uuid4().hex}",
|
||||
grant_id,
|
||||
event_type,
|
||||
json.dumps(dict(details or {}), ensure_ascii=False, sort_keys=True),
|
||||
utc_now(),
|
||||
),
|
||||
)
|
||||
|
||||
def save_issued(self, grant: ProvenanceGrant) -> None:
|
||||
payload = json.dumps(
|
||||
grant.as_dict(), ensure_ascii=False, sort_keys=True, separators=(",", ":")
|
||||
)
|
||||
now = utc_now()
|
||||
with self._lock:
|
||||
self._connection.execute("BEGIN IMMEDIATE")
|
||||
try:
|
||||
self._connection.execute(
|
||||
"INSERT INTO provenance_grants VALUES (?, ?, ?, ?, ?, ?, 0, ?, ?)",
|
||||
(
|
||||
grant.grant_id,
|
||||
grant.parent_provenance_id,
|
||||
grant.grant_type.value,
|
||||
grant.execution_path.value,
|
||||
payload,
|
||||
GrantStatus.ISSUED.value,
|
||||
now,
|
||||
now,
|
||||
),
|
||||
)
|
||||
self._event(grant.grant_id, "issued")
|
||||
self._connection.commit()
|
||||
except sqlite3.IntegrityError as exc:
|
||||
self._connection.rollback()
|
||||
raise ProvenanceDenied("grant_id already exists") from exc
|
||||
except Exception:
|
||||
self._connection.rollback()
|
||||
raise
|
||||
|
||||
def get(self, grant_id: str) -> ProvenanceGrant:
|
||||
with self._lock:
|
||||
row = self._connection.execute(
|
||||
"SELECT payload_json FROM provenance_grants WHERE grant_id = ?",
|
||||
(required(grant_id, "grant_id"),),
|
||||
).fetchone()
|
||||
if row is None:
|
||||
raise ProvenanceNotFound("provenance grant not found")
|
||||
value = json.loads(row["payload_json"])
|
||||
if not isinstance(value, Mapping):
|
||||
raise ProvenanceDenied("stored grant is invalid")
|
||||
return ProvenanceGrant.from_dict(value)
|
||||
|
||||
def status(self, grant_id: str) -> GrantStatus:
|
||||
with self._lock:
|
||||
row = self._connection.execute(
|
||||
"SELECT status FROM provenance_grants WHERE grant_id = ?",
|
||||
(required(grant_id, "grant_id"),),
|
||||
).fetchone()
|
||||
if row is None:
|
||||
raise ProvenanceNotFound("provenance grant not found")
|
||||
return GrantStatus(row["status"])
|
||||
|
||||
def mark_verified(self, grant_id: str, *, fingerprint: str) -> None:
|
||||
with self._lock:
|
||||
self._connection.execute("BEGIN IMMEDIATE")
|
||||
try:
|
||||
current = self.status(grant_id)
|
||||
if current in {GrantStatus.REVOKED, GrantStatus.EXPIRED}:
|
||||
raise ProvenanceDenied(f"cannot verify grant in state {current.value}")
|
||||
next_status = (
|
||||
GrantStatus.USED.value
|
||||
if current == GrantStatus.USED
|
||||
else GrantStatus.VERIFIED.value
|
||||
)
|
||||
self._connection.execute(
|
||||
"UPDATE provenance_grants SET status = ?, signature_verified = 1, updated_at = ? WHERE grant_id = ?",
|
||||
(next_status, utc_now(), grant_id),
|
||||
)
|
||||
self._event(
|
||||
grant_id,
|
||||
"verified",
|
||||
{"public_key_fingerprint": fingerprint},
|
||||
)
|
||||
self._connection.commit()
|
||||
except Exception:
|
||||
self._connection.rollback()
|
||||
raise
|
||||
|
||||
def mark_expired(self, grant_id: str) -> None:
|
||||
with self._lock:
|
||||
self._connection.execute("BEGIN IMMEDIATE")
|
||||
try:
|
||||
if self.status(grant_id) == GrantStatus.REVOKED:
|
||||
self._connection.rollback()
|
||||
return
|
||||
self._connection.execute(
|
||||
"UPDATE provenance_grants SET status = ?, updated_at = ? WHERE grant_id = ?",
|
||||
(GrantStatus.EXPIRED.value, utc_now(), grant_id),
|
||||
)
|
||||
self._event(grant_id, "expired")
|
||||
self._connection.commit()
|
||||
except Exception:
|
||||
self._connection.rollback()
|
||||
raise
|
||||
|
||||
def revoke(self, grant_id: str, *, reason: str, principal_id: str) -> None:
|
||||
with self._lock:
|
||||
self._connection.execute("BEGIN IMMEDIATE")
|
||||
try:
|
||||
self.get(grant_id)
|
||||
self._connection.execute(
|
||||
"UPDATE provenance_grants SET status = ?, updated_at = ? WHERE grant_id = ?",
|
||||
(GrantStatus.REVOKED.value, utc_now(), grant_id),
|
||||
)
|
||||
self._event(
|
||||
grant_id,
|
||||
"revoked",
|
||||
{
|
||||
"reason": required(reason, "reason"),
|
||||
"principal_id": required(principal_id, "principal_id"),
|
||||
},
|
||||
)
|
||||
self._connection.commit()
|
||||
except Exception:
|
||||
self._connection.rollback()
|
||||
raise
|
||||
|
||||
def record_authorization(self, authorization: GrantAuthorization) -> None:
|
||||
receipt = json.dumps(
|
||||
authorization.as_dict(), ensure_ascii=False, sort_keys=True, separators=(",", ":")
|
||||
)
|
||||
with self._lock:
|
||||
self._connection.execute("BEGIN IMMEDIATE")
|
||||
try:
|
||||
current = self.status(authorization.grant_id)
|
||||
if current in {GrantStatus.REVOKED, GrantStatus.EXPIRED}:
|
||||
raise ProvenanceDenied(f"grant state is {current.value}")
|
||||
try:
|
||||
self._connection.execute(
|
||||
"INSERT INTO provenance_grant_usage VALUES (?, ?, ?, ?, ?, ?, ?)",
|
||||
(
|
||||
authorization.authorization_id,
|
||||
authorization.grant_id,
|
||||
authorization.execution_path,
|
||||
authorization.git_operation or "",
|
||||
authorization.request_digest,
|
||||
authorization.authorized_at,
|
||||
receipt,
|
||||
),
|
||||
)
|
||||
except sqlite3.IntegrityError as exc:
|
||||
raise ProvenanceReplay(
|
||||
"identical grant path/operation/request digest already used"
|
||||
) from exc
|
||||
self._connection.execute(
|
||||
"UPDATE provenance_grants SET status = ?, updated_at = ? WHERE grant_id = ?",
|
||||
(GrantStatus.USED.value, authorization.authorized_at, authorization.grant_id),
|
||||
)
|
||||
self._event(
|
||||
authorization.grant_id,
|
||||
"used",
|
||||
{
|
||||
"authorization_id": authorization.authorization_id,
|
||||
"execution_path": authorization.execution_path,
|
||||
"git_operation": authorization.git_operation,
|
||||
"request_digest": authorization.request_digest,
|
||||
},
|
||||
)
|
||||
self._connection.commit()
|
||||
except Exception:
|
||||
self._connection.rollback()
|
||||
raise
|
||||
|
||||
def list_for_parent(self, parent_provenance_id: str) -> list[ProvenanceGrant]:
|
||||
with self._lock:
|
||||
rows = self._connection.execute(
|
||||
"SELECT payload_json FROM provenance_grants WHERE parent_provenance_id = ? ORDER BY grant_type, grant_id",
|
||||
(required(parent_provenance_id, "parent_provenance_id"),),
|
||||
).fetchall()
|
||||
return [ProvenanceGrant.from_dict(json.loads(row["payload_json"])) for row in rows]
|
||||
|
||||
|
||||
class GrantIssuer:
|
||||
"""从父 Workflow Provenance 派生单一路径最小权限 Grant。"""
|
||||
|
||||
def __init__(
|
||||
self,
|
||||
signer: Signer,
|
||||
parent_store: SQLiteProvenanceStore,
|
||||
grant_store: SQLiteGrantStore,
|
||||
) -> None:
|
||||
self.signer = signer
|
||||
self.parent_store = parent_store
|
||||
self.grant_store = grant_store
|
||||
|
||||
def issue(
|
||||
self,
|
||||
*,
|
||||
parent_provenance_id: str,
|
||||
grant_type: GrantType | str,
|
||||
ttl_seconds: int = 900,
|
||||
allowed_git_operations: Sequence[str] = (),
|
||||
grant_id: str | None = None,
|
||||
nonce: str | None = None,
|
||||
now: datetime | None = None,
|
||||
) -> ProvenanceGrant:
|
||||
if ttl_seconds <= 0:
|
||||
raise ValueError("grant ttl_seconds must be positive")
|
||||
parent = self.parent_store.get(parent_provenance_id)
|
||||
if parent.policy_version != WORKFLOW_POLICY_VERSION:
|
||||
raise ProvenanceDenied("child grants require a workflow provenance parent")
|
||||
if parent.allowed_paths or parent.allowed_git_operations:
|
||||
raise ProvenanceDenied("workflow provenance parent must not contain operation rights")
|
||||
parent_status = self.parent_store.status(parent.provenance_id)
|
||||
if parent_status == ProvenanceStatus.REVOKED:
|
||||
raise ProvenanceRevoked("workflow provenance is revoked")
|
||||
issued = (now or datetime.now(timezone.utc)).astimezone(timezone.utc)
|
||||
parent_expiry = parse_timestamp(parent.expires_at)
|
||||
expires = min(issued + timedelta(seconds=ttl_seconds), parent_expiry)
|
||||
if expires <= issued:
|
||||
raise ProvenanceExpired("workflow provenance has expired")
|
||||
normalized_type = GrantType(grant_type)
|
||||
operations = tuple(allowed_git_operations)
|
||||
unsigned = ProvenanceGrant(
|
||||
grant_id=grant_id or f"grant_{uuid.uuid4().hex}",
|
||||
parent_provenance_id=parent.provenance_id,
|
||||
grant_type=normalized_type,
|
||||
execution_path=GRANT_PATHS[normalized_type],
|
||||
run_id=parent.run_id,
|
||||
issuer=parent.issuer,
|
||||
tenant_id=parent.tenant_id,
|
||||
task_id=parent.task_id,
|
||||
agent_id=parent.agent_id,
|
||||
principal_id=parent.principal_id,
|
||||
allowed_git_operations=operations,
|
||||
issued_at=issued.isoformat().replace("+00:00", "Z"),
|
||||
expires_at=expires.isoformat().replace("+00:00", "Z"),
|
||||
policy_version=f"{WORKFLOW_POLICY_VERSION}.{normalized_type.value}",
|
||||
key_id=self.signer.key_id,
|
||||
nonce=nonce or uuid.uuid4().hex,
|
||||
)
|
||||
signed = replace(unsigned, signature=self.signer.sign(unsigned.canonical_bytes()))
|
||||
self.grant_store.save_issued(signed)
|
||||
return signed
|
||||
|
||||
|
||||
class GrantVerifier:
|
||||
"""验证父 Workflow 与子 Grant，确保单一路径最小权限。"""
|
||||
|
||||
def __init__(
|
||||
self,
|
||||
parent_store: SQLiteProvenanceStore,
|
||||
grant_store: SQLiteGrantStore,
|
||||
verifiers: Mapping[str, SignatureVerifier],
|
||||
) -> None:
|
||||
if not verifiers:
|
||||
raise ValueError("at least one trusted verifier is required")
|
||||
self.parent_store = parent_store
|
||||
self.grant_store = grant_store
|
||||
self.verifiers = {required(key, "key_id"): value for key, value in verifiers.items()}
|
||||
|
||||
def _verify_parent(self, parent: RunProvenance, *, now: datetime) -> SignatureVerifier:
|
||||
status = self.parent_store.status(parent.provenance_id)
|
||||
if status == ProvenanceStatus.REVOKED:
|
||||
raise ProvenanceRevoked("workflow provenance is revoked")
|
||||
if now >= parse_timestamp(parent.expires_at):
|
||||
self.parent_store.mark_expired(parent.provenance_id)
|
||||
raise ProvenanceExpired("workflow provenance is expired")
|
||||
verifier = self.verifiers.get(parent.key_id)
|
||||
if verifier is None or not parent.signature or not verifier.verify(
|
||||
parent.canonical_bytes(), parent.signature
|
||||
):
|
||||
raise ProvenanceSignatureError("invalid workflow provenance signature")
|
||||
if parent.policy_version != WORKFLOW_POLICY_VERSION:
|
||||
raise ProvenanceDenied("parent is not a workflow provenance")
|
||||
if parent.allowed_paths or parent.allowed_git_operations:
|
||||
raise ProvenanceDenied("workflow provenance must not contain operation rights")
|
||||
return verifier
|
||||
|
||||
def authorize(
|
||||
self,
|
||||
*,
|
||||
grant_id: str,
|
||||
parent_provenance_id: str,
|
||||
run_id: str,
|
||||
tenant_id: str,
|
||||
task_id: str,
|
||||
agent_id: str,
|
||||
principal_id: str,
|
||||
execution_path: str,
|
||||
request_digest: str,
|
||||
git_operation: str | None = None,
|
||||
now: datetime | None = None,
|
||||
) -> GrantAuthorization:
|
||||
current = (now or datetime.now(timezone.utc)).astimezone(timezone.utc)
|
||||
parent = self.parent_store.get(parent_provenance_id)
|
||||
self._verify_parent(parent, now=current)
|
||||
grant = self.grant_store.get(grant_id)
|
||||
grant_status = self.grant_store.status(grant.grant_id)
|
||||
if grant_status == GrantStatus.REVOKED:
|
||||
raise ProvenanceRevoked("provenance grant is revoked")
|
||||
if current >= parse_timestamp(grant.expires_at):
|
||||
self.grant_store.mark_expired(grant.grant_id)
|
||||
raise ProvenanceExpired("provenance grant is expired")
|
||||
verifier = self.verifiers.get(grant.key_id)
|
||||
if verifier is None or not grant.signature or not verifier.verify(
|
||||
grant.canonical_bytes(), grant.signature
|
||||
):
|
||||
raise ProvenanceSignatureError("invalid provenance grant signature")
|
||||
expected = {
|
||||
"parent_provenance_id": parent.provenance_id,
|
||||
"run_id": required(run_id, "run_id"),
|
||||
"tenant_id": required(tenant_id, "tenant_id"),
|
||||
"task_id": required(task_id, "task_id"),
|
||||
"agent_id": required(agent_id, "agent_id"),
|
||||
"principal_id": required(principal_id, "principal_id"),
|
||||
}
|
||||
for field_name, expected_value in expected.items():
|
||||
if getattr(grant, field_name) != expected_value:
|
||||
raise ProvenanceDenied(f"grant {field_name} mismatch")
|
||||
if field_name != "parent_provenance_id" and getattr(parent, field_name) != expected_value:
|
||||
raise ProvenanceDenied(f"workflow {field_name} mismatch")
|
||||
path = ExecutionPath(execution_path)
|
||||
if grant.execution_path != path:
|
||||
raise ProvenanceDenied(
|
||||
f"grant permits {grant.execution_path.value}, not {path.value}"
|
||||
)
|
||||
operation: str | None = None
|
||||
if path == ExecutionPath.GIT_OPERATION:
|
||||
if git_operation is None:
|
||||
raise ProvenanceDenied("Git operation is required")
|
||||
operation = GitOperation(git_operation).value
|
||||
if operation not in grant.allowed_git_operations:
|
||||
raise ProvenanceDenied(f"Git operation is not allowed: {operation}")
|
||||
elif git_operation is not None:
|
||||
raise ProvenanceDenied("git_operation is only valid for a Git Grant")
|
||||
digest = _validate_digest(request_digest)
|
||||
self.grant_store.mark_verified(grant.grant_id, fingerprint=verifier.fingerprint)
|
||||
authorization = GrantAuthorization(
|
||||
authorization_id=f"gauth_{uuid.uuid4().hex}",
|
||||
grant_id=grant.grant_id,
|
||||
parent_provenance_id=parent.provenance_id,
|
||||
run_id=grant.run_id,
|
||||
tenant_id=grant.tenant_id,
|
||||
task_id=grant.task_id,
|
||||
agent_id=grant.agent_id,
|
||||
principal_id=grant.principal_id,
|
||||
execution_path=path.value,
|
||||
git_operation=operation,
|
||||
request_digest=digest,
|
||||
policy_version=grant.policy_version,
|
||||
key_id=grant.key_id,
|
||||
public_key_fingerprint=verifier.fingerprint,
|
||||
)
|
||||
self.grant_store.record_authorization(authorization)
|
||||
return authorization
|
||||
|
||||
|
||||
class LeastPrivilegeProvenanceWriter:
|
||||
"""按路径选择独立子 Grant 的生产 Writer。
|
||||
|
||||
``provenance_id`` 参数始终指父 Workflow Provenance；Grant ID 来自受保护
|
||||
配置映射，调用方无法通过请求体临时扩大权限。
|
||||
"""
|
||||
|
||||
def __init__(
|
||||
self,
|
||||
verifier: GrantVerifier,
|
||||
receipt_root: str | Path,
|
||||
grant_ids: Mapping[str, str],
|
||||
*,
|
||||
writer_id: str = "aios-v2-least-privilege-writer",
|
||||
) -> None:
|
||||
self.verifier = verifier
|
||||
self.receipt_root = Path(receipt_root).resolve()
|
||||
self.receipt_root.mkdir(parents=True, exist_ok=True)
|
||||
self.grant_ids = {
|
||||
ExecutionPath(path).value: required(grant_id, f"grant_id[{path}]")
|
||||
for path, grant_id in grant_ids.items()
|
||||
}
|
||||
missing = sorted(path.value for path in ExecutionPath if path.value not in self.grant_ids)
|
||||
if missing:
|
||||
raise ValueError(f"missing least-privilege Grant mappings: {missing}")
|
||||
self.writer_id = required(writer_id, "writer_id")
|
||||
self._lock = threading.RLock()
|
||||
|
||||
@staticmethod
|
||||
def _component(value: str) -> str:
|
||||
normalized = required(value, "path component")
|
||||
if normalized in {".", ".."} or "/" in normalized or "\\" in normalized:
|
||||
raise ProvenanceDenied("invalid receipt path component")
|
||||
return normalized
|
||||
|
||||
def authorize(self, **values: Any) -> GrantAuthorization:
|
||||
path = ExecutionPath(values["execution_path"]).value
|
||||
grant_id = self.grant_ids[path]
|
||||
parent_provenance_id = values.pop("provenance_id")
|
||||
authorization = self.verifier.authorize(
|
||||
grant_id=grant_id,
|
||||
parent_provenance_id=parent_provenance_id,
|
||||
**values,
|
||||
)
|
||||
tenant = self._component(authorization.tenant_id)
|
||||
parent = self._component(authorization.parent_provenance_id)
|
||||
grant = self._component(authorization.grant_id)
|
||||
target_dir = self.receipt_root / tenant / parent / grant
|
||||
target = target_dir / f"{authorization.authorization_id}.json"
|
||||
payload = authorization.as_dict()
|
||||
payload["writer_id"] = self.writer_id
|
||||
with self._lock:
|
||||
target_dir.mkdir(parents=True, exist_ok=True)
|
||||
temporary = target.with_suffix(f".tmp-{os.getpid()}")
|
||||
temporary.write_text(
|
||||
json.dumps(payload, ensure_ascii=False, sort_keys=True, indent=2) + "\n",
|
||||
encoding="utf-8",
|
||||
)
|
||||
os.chmod(temporary, 0o640)
|
||||
os.replace(temporary, target)
|
||||
return authorization
|
||||
|
||||
def authorize_code_change(self, **values: Any) -> GrantAuthorization:
|
||||
return self.authorize(execution_path=ExecutionPath.CODE_CHANGE.value, **values)
|
||||
|
||||
def authorize_git_operation(
|
||||
self, *, git_operation: str, **values: Any
|
||||
) -> GrantAuthorization:
|
||||
return self.authorize(
|
||||
execution_path=ExecutionPath.GIT_OPERATION.value,
|
||||
git_operation=git_operation,
|
||||
**values,
|
||||
)
|
||||
|
||||
def authorize_deployment(self, **values: Any) -> GrantAuthorization:
|
||||
return self.authorize(execution_path=ExecutionPath.DEPLOYMENT.value, **values)
|
||||
|
||||
def authorize_runtime_execute(self, **values: Any) -> GrantAuthorization:
|
||||
return self.authorize(execution_path=ExecutionPath.RUNTIME_EXECUTE.value, **values)
|
||||
|
||||
def authorize_evidence_write(self, **values: Any) -> GrantAuthorization:
|
||||
return self.authorize(execution_path=ExecutionPath.EVIDENCE_WRITE.value, **values)
|
||||
|
||||
def authorize_rollback(self, **values: Any) -> GrantAuthorization:
|
||||
return self.authorize(execution_path=ExecutionPath.ROLLBACK.value, **values)
|
||||
|
||||
def authorize_audit(self, **values: Any) -> GrantAuthorization:
|
||||
return self.authorize(execution_path=ExecutionPath.AUDIT.value, **values)
|
||||
@@ -1,265 +0,0 @@
|
||||
"""AIOS V2 运维操作 Provenance Gate 与服务级 Scoped Writer 工厂。"""
|
||||
from __future__ import annotations
|
||||
|
||||
import json
|
||||
import os
|
||||
from dataclasses import asdict, dataclass
|
||||
from pathlib import Path
|
||||
from typing import Any, Mapping, Protocol, Sequence
|
||||
|
||||
from .provenance import (
|
||||
Ed25519PublicKeyVerifier,
|
||||
ExecutionPath,
|
||||
ProvenanceAuthorization,
|
||||
ProvenanceControlledWriter,
|
||||
ProvenanceDenied,
|
||||
ProvenanceVerifier,
|
||||
SQLiteProvenanceStore,
|
||||
digest_payload,
|
||||
)
|
||||
from .provenance_grants import GrantAuthorization, GrantVerifier, SQLiteGrantStore
|
||||
from .provenance_scoped import ScopedLeastPrivilegeProvenanceWriter
|
||||
|
||||
|
||||
APPLICATION_PROVENANCE_SCOPE = (
|
||||
ExecutionPath.RUNTIME_EXECUTE.value,
|
||||
ExecutionPath.EVIDENCE_WRITE.value,
|
||||
ExecutionPath.AUDIT.value,
|
||||
)
|
||||
|
||||
|
||||
class AuthorizationWriter(Protocol):
|
||||
def authorize_deployment(self, **values: Any) -> Any: ...
|
||||
def authorize_rollback(self, **values: Any) -> Any: ...
|
||||
def authorize_audit(self, **values: Any) -> Any: ...
|
||||
def authorize_code_change(self, **values: Any) -> Any: ...
|
||||
def authorize_evidence_write(self, **values: Any) -> Any: ...
|
||||
def authorize_runtime_execute(self, **values: Any) -> Any: ...
|
||||
|
||||
|
||||
@dataclass(frozen=True)
|
||||
class OperationContext:
|
||||
provenance_id: str
|
||||
run_id: str
|
||||
tenant_id: str
|
||||
task_id: str
|
||||
agent_id: str
|
||||
principal_id: str
|
||||
|
||||
def as_dict(self) -> dict[str, str]:
|
||||
return asdict(self)
|
||||
|
||||
|
||||
@dataclass(frozen=True)
|
||||
class OperationReceipt:
|
||||
operation: str
|
||||
request_digest: str
|
||||
authorization_id: str
|
||||
provenance_id: str
|
||||
grant_id: str | None
|
||||
run_id: str
|
||||
tenant_id: str
|
||||
task_id: str
|
||||
agent_id: str
|
||||
principal_id: str
|
||||
execution_path: str
|
||||
authorized_at: str
|
||||
|
||||
def as_dict(self) -> dict[str, Any]:
|
||||
return asdict(self)
|
||||
|
||||
|
||||
class ProvenanceOperationGate:
|
||||
"""部署、回滚、审计和运行操作的统一授权入口。"""
|
||||
|
||||
def __init__(self, writer: AuthorizationWriter) -> None:
|
||||
self.writer = writer
|
||||
|
||||
def authorize(
|
||||
self,
|
||||
context: OperationContext,
|
||||
*,
|
||||
execution_path: str,
|
||||
operation: str,
|
||||
request: Mapping[str, Any],
|
||||
) -> OperationReceipt:
|
||||
path = ExecutionPath(execution_path).value
|
||||
normalized_operation = str(operation or "").strip()
|
||||
if not normalized_operation:
|
||||
raise ValueError("operation is required")
|
||||
digest = digest_payload(
|
||||
{
|
||||
"operation": normalized_operation,
|
||||
"execution_path": path,
|
||||
"request": dict(request),
|
||||
}
|
||||
)
|
||||
values = {
|
||||
"provenance_id": context.provenance_id,
|
||||
"run_id": context.run_id,
|
||||
"tenant_id": context.tenant_id,
|
||||
"task_id": context.task_id,
|
||||
"agent_id": context.agent_id,
|
||||
"principal_id": context.principal_id,
|
||||
"request_digest": digest,
|
||||
}
|
||||
if path == ExecutionPath.DEPLOYMENT.value:
|
||||
authorization = self.writer.authorize_deployment(**values)
|
||||
elif path == ExecutionPath.ROLLBACK.value:
|
||||
authorization = self.writer.authorize_rollback(**values)
|
||||
elif path == ExecutionPath.AUDIT.value:
|
||||
authorization = self.writer.authorize_audit(**values)
|
||||
elif path == ExecutionPath.CODE_CHANGE.value:
|
||||
authorization = self.writer.authorize_code_change(**values)
|
||||
elif path == ExecutionPath.EVIDENCE_WRITE.value:
|
||||
authorization = self.writer.authorize_evidence_write(**values)
|
||||
elif path == ExecutionPath.RUNTIME_EXECUTE.value:
|
||||
authorization = self.writer.authorize_runtime_execute(**values)
|
||||
else:
|
||||
raise ProvenanceDenied(
|
||||
"generic operation gate does not authorize git_operation; use ProvenanceGitWriter"
|
||||
)
|
||||
return self._receipt(normalized_operation, digest, authorization)
|
||||
|
||||
@staticmethod
|
||||
def _receipt(
|
||||
operation: str,
|
||||
request_digest: str,
|
||||
authorization: ProvenanceAuthorization | GrantAuthorization | Any,
|
||||
) -> OperationReceipt:
|
||||
return OperationReceipt(
|
||||
operation=operation,
|
||||
request_digest=request_digest,
|
||||
authorization_id=authorization.authorization_id,
|
||||
provenance_id=authorization.provenance_id,
|
||||
grant_id=getattr(authorization, "grant_id", None),
|
||||
run_id=authorization.run_id,
|
||||
tenant_id=authorization.tenant_id,
|
||||
task_id=authorization.task_id,
|
||||
agent_id=authorization.agent_id,
|
||||
principal_id=authorization.principal_id,
|
||||
execution_path=authorization.execution_path,
|
||||
authorized_at=authorization.authorized_at,
|
||||
)
|
||||
|
||||
|
||||
_GRANT_ENV_BY_PATH: Mapping[str, str] = {
|
||||
ExecutionPath.CODE_CHANGE.value: "AIOS_PROVENANCE_GRANT_CODE_CHANGE_ID",
|
||||
ExecutionPath.GIT_OPERATION.value: "AIOS_PROVENANCE_GRANT_GIT_ID",
|
||||
ExecutionPath.DEPLOYMENT.value: "AIOS_PROVENANCE_GRANT_DEPLOYMENT_ID",
|
||||
ExecutionPath.RUNTIME_EXECUTE.value: "AIOS_PROVENANCE_GRANT_RUNTIME_ID",
|
||||
ExecutionPath.EVIDENCE_WRITE.value: "AIOS_PROVENANCE_GRANT_EVIDENCE_ID",
|
||||
ExecutionPath.ROLLBACK.value: "AIOS_PROVENANCE_GRANT_ROLLBACK_ID",
|
||||
ExecutionPath.AUDIT.value: "AIOS_PROVENANCE_GRANT_AUDIT_ID",
|
||||
}
|
||||
|
||||
|
||||
def grant_ids_from_environment(
|
||||
*,
|
||||
required_paths: Sequence[str] | None = None,
|
||||
) -> dict[str, str]:
|
||||
paths = tuple(
|
||||
sorted(
|
||||
{
|
||||
ExecutionPath(path).value
|
||||
for path in (required_paths or tuple(item.value for item in ExecutionPath))
|
||||
}
|
||||
)
|
||||
)
|
||||
values = {path: os.getenv(_GRANT_ENV_BY_PATH[path], "").strip() for path in paths}
|
||||
missing = [_GRANT_ENV_BY_PATH[path] for path, value in values.items() if not value]
|
||||
if missing:
|
||||
raise RuntimeError(f"missing scoped Provenance Grant configuration: {missing}")
|
||||
return values
|
||||
|
||||
|
||||
def build_provenance_writer_from_env(
|
||||
*,
|
||||
state_dir: str | Path | None = None,
|
||||
required: bool | None = None,
|
||||
required_paths: Sequence[str] | None = None,
|
||||
writer_id: str = "aios-v2-application-grant-writer",
|
||||
) -> AuthorizationWriter | None:
|
||||
"""从环境构建服务级最小权限 Writer。
|
||||
|
||||
生产应用默认只加载 Runtime、Evidence、Audit Grant。Git、部署和回滚进程
|
||||
必须显式传入自己的 ``required_paths``，不能继承应用默认范围。旧全权限 Writer
|
||||
只允许在显式关闭强制模式的候选/测试环境中使用。
|
||||
"""
|
||||
|
||||
require_value = (
|
||||
bool(required)
|
||||
if required is not None
|
||||
else os.getenv("AIOS_REQUIRE_RUN_PROVENANCE", "0").strip().lower()
|
||||
in {"1", "true", "yes", "on"}
|
||||
)
|
||||
public_key_file = os.getenv("AIOS_PROVENANCE_PUBLIC_KEY_FILE", "").strip()
|
||||
key_id = os.getenv("AIOS_PROVENANCE_KEY_ID", "").strip()
|
||||
base = Path(state_dir or os.getenv("AIOS_V2_STATE_DIR", "/var/lib/aios-v2")).resolve()
|
||||
store_file = os.getenv(
|
||||
"AIOS_PROVENANCE_STORE_FILE", str(base / "run-provenance.sqlite3")
|
||||
).strip()
|
||||
receipt_root = os.getenv(
|
||||
"AIOS_PROVENANCE_RECEIPT_DIR", str(base / "provenance-receipts")
|
||||
).strip()
|
||||
configured = bool(public_key_file and key_id)
|
||||
if not configured:
|
||||
if require_value:
|
||||
raise RuntimeError(
|
||||
"Run Provenance is required but AIOS_PROVENANCE_PUBLIC_KEY_FILE or AIOS_PROVENANCE_KEY_ID is missing"
|
||||
)
|
||||
return None
|
||||
|
||||
verifier = Ed25519PublicKeyVerifier.from_file(public_key_file, key_id=key_id)
|
||||
parent_store = SQLiteProvenanceStore(store_file)
|
||||
normalized_paths = tuple(
|
||||
sorted(
|
||||
{
|
||||
ExecutionPath(path).value
|
||||
for path in (
|
||||
required_paths
|
||||
if required_paths is not None
|
||||
else APPLICATION_PROVENANCE_SCOPE
|
||||
)
|
||||
}
|
||||
)
|
||||
)
|
||||
|
||||
if require_value:
|
||||
if not normalized_paths:
|
||||
raise RuntimeError("production Run Provenance requires a non-empty service scope")
|
||||
grant_ids = grant_ids_from_environment(required_paths=normalized_paths)
|
||||
grant_store = SQLiteGrantStore(store_file)
|
||||
trusted_grants = GrantVerifier(parent_store, grant_store, {key_id: verifier})
|
||||
return ScopedLeastPrivilegeProvenanceWriter(
|
||||
trusted_grants,
|
||||
receipt_root,
|
||||
grant_ids,
|
||||
required_paths=normalized_paths,
|
||||
writer_id=writer_id,
|
||||
)
|
||||
|
||||
legacy = ProvenanceVerifier(parent_store, {key_id: verifier})
|
||||
return ProvenanceControlledWriter(legacy, receipt_root)
|
||||
|
||||
|
||||
def context_from_environment() -> OperationContext:
|
||||
values = {
|
||||
"provenance_id": os.getenv("AIOS_PROVENANCE_ID", ""),
|
||||
"run_id": os.getenv("AIOS_RUN_ID", ""),
|
||||
"tenant_id": os.getenv("AIOS_TENANT_ID", ""),
|
||||
"task_id": os.getenv("AIOS_TASK_ID", ""),
|
||||
"agent_id": os.getenv("AIOS_AGENT_ID", ""),
|
||||
"principal_id": os.getenv("AIOS_PRINCIPAL_ID", ""),
|
||||
}
|
||||
missing = [name for name, value in values.items() if not str(value).strip()]
|
||||
if missing:
|
||||
raise RuntimeError(f"missing Provenance context environment variables: {missing}")
|
||||
return OperationContext(**{name: str(value).strip() for name, value in values.items()})
|
||||
|
||||
|
||||
def load_request_file(path: str | Path) -> Mapping[str, Any]:
|
||||
value = json.loads(Path(path).read_text(encoding="utf-8"))
|
||||
if not isinstance(value, Mapping):
|
||||
raise ValueError("request file must contain a JSON object")
|
||||
return dict(value)
|
||||
@@ -1,131 +0,0 @@
|
||||
"""按服务范围加载的最小权限 Provenance Writer。
|
||||
|
||||
该 Writer 只持有调用进程需要的 Grant ID。未配置路径的方法即使被调用也会
|
||||
默认拒绝，避免应用进程获得 Git、部署或回滚权限。
|
||||
"""
|
||||
from __future__ import annotations
|
||||
|
||||
import json
|
||||
import os
|
||||
import threading
|
||||
from pathlib import Path
|
||||
from typing import Any, Mapping, Sequence
|
||||
|
||||
from .provenance import ExecutionPath, ProvenanceDenied, required
|
||||
from .provenance_grants import GrantAuthorization, GrantVerifier
|
||||
|
||||
|
||||
class ScopedLeastPrivilegeProvenanceWriter:
|
||||
"""只暴露指定 ExecutionPath 的最小权限 Writer。"""
|
||||
|
||||
def __init__(
|
||||
self,
|
||||
verifier: GrantVerifier,
|
||||
receipt_root: str | Path,
|
||||
grant_ids: Mapping[str, str],
|
||||
*,
|
||||
required_paths: Sequence[str],
|
||||
writer_id: str = "aios-v2-scoped-grant-writer",
|
||||
) -> None:
|
||||
self.verifier = verifier
|
||||
self.receipt_root = Path(receipt_root).resolve()
|
||||
self.receipt_root.mkdir(parents=True, exist_ok=True)
|
||||
normalized_required = tuple(
|
||||
sorted({ExecutionPath(path).value for path in required_paths})
|
||||
)
|
||||
if not normalized_required:
|
||||
raise ValueError("required_paths must not be empty")
|
||||
self.required_paths = frozenset(normalized_required)
|
||||
self.grant_ids = {
|
||||
path: required(grant_ids.get(path, ""), f"grant_id[{path}]")
|
||||
for path in normalized_required
|
||||
}
|
||||
unexpected = sorted(set(grant_ids) - self.required_paths)
|
||||
if unexpected:
|
||||
raise ValueError(
|
||||
f"scoped writer received unnecessary Grant mappings: {unexpected}"
|
||||
)
|
||||
self.writer_id = required(writer_id, "writer_id")
|
||||
self._lock = threading.RLock()
|
||||
|
||||
@staticmethod
|
||||
def _component(value: str) -> str:
|
||||
normalized = required(value, "path component")
|
||||
if normalized in {".", ".."} or "/" in normalized or "\\" in normalized:
|
||||
raise ProvenanceDenied("invalid receipt path component")
|
||||
return normalized
|
||||
|
||||
def _grant_for(self, path: str) -> str:
|
||||
normalized = ExecutionPath(path).value
|
||||
grant_id = self.grant_ids.get(normalized)
|
||||
if grant_id is None:
|
||||
raise ProvenanceDenied(
|
||||
f"this process is not allowed to authorize {normalized}"
|
||||
)
|
||||
return grant_id
|
||||
|
||||
def authorize(self, **values: Any) -> GrantAuthorization:
|
||||
path = ExecutionPath(values["execution_path"]).value
|
||||
grant_id = self._grant_for(path)
|
||||
parent_provenance_id = values.pop("provenance_id")
|
||||
authorization = self.verifier.authorize(
|
||||
grant_id=grant_id,
|
||||
parent_provenance_id=parent_provenance_id,
|
||||
**values,
|
||||
)
|
||||
tenant = self._component(authorization.tenant_id)
|
||||
parent = self._component(authorization.parent_provenance_id)
|
||||
grant = self._component(authorization.grant_id)
|
||||
target_dir = self.receipt_root / tenant / parent / grant
|
||||
target = target_dir / f"{authorization.authorization_id}.json"
|
||||
payload = authorization.as_dict()
|
||||
payload["writer_id"] = self.writer_id
|
||||
payload["scope"] = sorted(self.required_paths)
|
||||
with self._lock:
|
||||
target_dir.mkdir(parents=True, exist_ok=True)
|
||||
temporary = target.with_suffix(f".tmp-{os.getpid()}")
|
||||
temporary.write_text(
|
||||
json.dumps(payload, ensure_ascii=False, sort_keys=True, indent=2)
|
||||
+ "\n",
|
||||
encoding="utf-8",
|
||||
)
|
||||
os.chmod(temporary, 0o640)
|
||||
os.replace(temporary, target)
|
||||
return authorization
|
||||
|
||||
def authorize_code_change(self, **values: Any) -> GrantAuthorization:
|
||||
return self.authorize(
|
||||
execution_path=ExecutionPath.CODE_CHANGE.value, **values
|
||||
)
|
||||
|
||||
def authorize_git_operation(
|
||||
self, *, git_operation: str, **values: Any
|
||||
) -> GrantAuthorization:
|
||||
return self.authorize(
|
||||
execution_path=ExecutionPath.GIT_OPERATION.value,
|
||||
git_operation=git_operation,
|
||||
**values,
|
||||
)
|
||||
|
||||
def authorize_deployment(self, **values: Any) -> GrantAuthorization:
|
||||
return self.authorize(
|
||||
execution_path=ExecutionPath.DEPLOYMENT.value, **values
|
||||
)
|
||||
|
||||
def authorize_runtime_execute(self, **values: Any) -> GrantAuthorization:
|
||||
return self.authorize(
|
||||
execution_path=ExecutionPath.RUNTIME_EXECUTE.value, **values
|
||||
)
|
||||
|
||||
def authorize_evidence_write(self, **values: Any) -> GrantAuthorization:
|
||||
return self.authorize(
|
||||
execution_path=ExecutionPath.EVIDENCE_WRITE.value, **values
|
||||
)
|
||||
|
||||
def authorize_rollback(self, **values: Any) -> GrantAuthorization:
|
||||
return self.authorize(
|
||||
execution_path=ExecutionPath.ROLLBACK.value, **values
|
||||
)
|
||||
|
||||
def authorize_audit(self, **values: Any) -> GrantAuthorization:
|
||||
return self.authorize(execution_path=ExecutionPath.AUDIT.value, **values)
|
||||
@@ -1,607 +0,0 @@
|
||||
"""Durable execution truth registry for externally executed AIOS tasks.
|
||||
|
||||
A task manifest being present in Git is not evidence that an executor discovered
|
||||
or ran it. This registry separates declaration, registration, claim, start,
|
||||
heartbeat and terminal evidence. Release gates must require a terminal success
|
||||
record with immutable evidence hashes.
|
||||
"""
|
||||
from __future__ import annotations
|
||||
|
||||
import json
|
||||
import sqlite3
|
||||
import threading
|
||||
import uuid
|
||||
from dataclasses import asdict, dataclass, field, replace
|
||||
from datetime import datetime, timedelta, timezone
|
||||
from enum import Enum
|
||||
from pathlib import Path
|
||||
from typing import Any, Mapping, Sequence
|
||||
|
||||
|
||||
def utc_now() -> str:
|
||||
return datetime.now(timezone.utc).isoformat().replace("+00:00", "Z")
|
||||
|
||||
|
||||
def parse_time(value: str) -> datetime:
|
||||
normalized = str(value or "").strip()
|
||||
if normalized.endswith("Z"):
|
||||
normalized = normalized[:-1] + "+00:00"
|
||||
parsed = datetime.fromisoformat(normalized)
|
||||
if parsed.tzinfo is None:
|
||||
raise ValueError("timestamp requires timezone")
|
||||
return parsed.astimezone(timezone.utc)
|
||||
|
||||
|
||||
def required(value: str, label: str) -> str:
|
||||
normalized = str(value or "").strip()
|
||||
if not normalized:
|
||||
raise ValueError(f"{label} is required")
|
||||
return normalized
|
||||
|
||||
|
||||
class ExecutionTruthState(str, Enum):
|
||||
DECLARED = "DECLARED"
|
||||
REGISTERED = "REGISTERED"
|
||||
CLAIMED = "CLAIMED"
|
||||
RUNNING = "RUNNING"
|
||||
SUCCEEDED = "SUCCEEDED"
|
||||
FAILED = "FAILED"
|
||||
CANCELLED = "CANCELLED"
|
||||
NOT_STARTED = "NOT_STARTED"
|
||||
STALLED = "STALLED"
|
||||
|
||||
|
||||
TERMINAL_STATES = frozenset(
|
||||
{
|
||||
ExecutionTruthState.SUCCEEDED,
|
||||
ExecutionTruthState.FAILED,
|
||||
ExecutionTruthState.CANCELLED,
|
||||
ExecutionTruthState.NOT_STARTED,
|
||||
ExecutionTruthState.STALLED,
|
||||
}
|
||||
)
|
||||
|
||||
|
||||
@dataclass(frozen=True)
|
||||
class ExecutionTaskManifest:
|
||||
task_id: str
|
||||
executor: str
|
||||
source_branch: str
|
||||
source_oid: str
|
||||
target_version: str
|
||||
steps: Sequence[str]
|
||||
start_deadline_seconds: int = 300
|
||||
heartbeat_timeout_seconds: int = 180
|
||||
required_evidence: Sequence[str] = ()
|
||||
notification_events: Sequence[str] = ("STARTED", "SUCCEEDED", "FAILED")
|
||||
owner_notification_ref: str = "AIOS_OWNER_WECHAT_TARGET_REF"
|
||||
manifest_version: str = "aios.external-task.v1"
|
||||
|
||||
def __post_init__(self) -> None:
|
||||
for name in (
|
||||
"task_id",
|
||||
"executor",
|
||||
"source_branch",
|
||||
"source_oid",
|
||||
"target_version",
|
||||
"manifest_version",
|
||||
"owner_notification_ref",
|
||||
):
|
||||
object.__setattr__(self, name, required(getattr(self, name), name))
|
||||
steps = tuple(required(item, "step") for item in self.steps)
|
||||
if not steps:
|
||||
raise ValueError("at least one execution step is required")
|
||||
if self.start_deadline_seconds < 1 or self.heartbeat_timeout_seconds < 1:
|
||||
raise ValueError("execution deadlines must be positive")
|
||||
object.__setattr__(self, "steps", steps)
|
||||
object.__setattr__(
|
||||
self,
|
||||
"required_evidence",
|
||||
tuple(sorted({required(item, "required_evidence") for item in self.required_evidence})),
|
||||
)
|
||||
object.__setattr__(
|
||||
self,
|
||||
"notification_events",
|
||||
tuple(sorted({required(item, "notification_event") for item in self.notification_events})),
|
||||
)
|
||||
|
||||
def as_dict(self) -> dict[str, Any]:
|
||||
value = asdict(self)
|
||||
value["steps"] = list(self.steps)
|
||||
value["required_evidence"] = list(self.required_evidence)
|
||||
value["notification_events"] = list(self.notification_events)
|
||||
return value
|
||||
|
||||
@classmethod
|
||||
def from_dict(cls, value: Mapping[str, Any]) -> "ExecutionTaskManifest":
|
||||
return cls(**dict(value))
|
||||
|
||||
|
||||
@dataclass(frozen=True)
|
||||
class ExecutionTruthRecord:
|
||||
task_id: str
|
||||
manifest_json: str
|
||||
state: ExecutionTruthState
|
||||
executor_run_id: str | None = None
|
||||
executor_id: str | None = None
|
||||
declared_at: str = field(default_factory=utc_now)
|
||||
registered_at: str | None = None
|
||||
claimed_at: str | None = None
|
||||
started_at: str | None = None
|
||||
heartbeat_at: str | None = None
|
||||
completed_at: str | None = None
|
||||
current_step: int = 0
|
||||
evidence: Mapping[str, str] = field(default_factory=dict)
|
||||
error: Mapping[str, Any] = field(default_factory=dict)
|
||||
revision: int = 1
|
||||
|
||||
@property
|
||||
def manifest(self) -> ExecutionTaskManifest:
|
||||
return ExecutionTaskManifest.from_dict(json.loads(self.manifest_json))
|
||||
|
||||
def as_dict(self) -> dict[str, Any]:
|
||||
return {
|
||||
**asdict(self),
|
||||
"state": self.state.value,
|
||||
"manifest": self.manifest.as_dict(),
|
||||
"evidence": dict(self.evidence),
|
||||
"error": dict(self.error),
|
||||
}
|
||||
|
||||
|
||||
class ExecutionTruthConflict(RuntimeError):
|
||||
pass
|
||||
|
||||
|
||||
class SQLiteExecutionTruthRegistry:
|
||||
"""Persistent registration and run-evidence store."""
|
||||
|
||||
def __init__(self, path: str | Path) -> None:
|
||||
self.path = Path(path).resolve()
|
||||
self.path.parent.mkdir(parents=True, exist_ok=True)
|
||||
self._lock = threading.RLock()
|
||||
with self._connect() as connection:
|
||||
connection.executescript(
|
||||
"""
|
||||
CREATE TABLE IF NOT EXISTS execution_truth (
|
||||
task_id TEXT PRIMARY KEY,
|
||||
manifest_json TEXT NOT NULL,
|
||||
state TEXT NOT NULL,
|
||||
record_json TEXT NOT NULL,
|
||||
revision INTEGER NOT NULL,
|
||||
updated_at TEXT NOT NULL
|
||||
);
|
||||
CREATE TABLE IF NOT EXISTS execution_truth_events (
|
||||
event_id TEXT PRIMARY KEY,
|
||||
task_id TEXT NOT NULL,
|
||||
event_type TEXT NOT NULL,
|
||||
details_json TEXT NOT NULL,
|
||||
created_at TEXT NOT NULL,
|
||||
FOREIGN KEY(task_id) REFERENCES execution_truth(task_id)
|
||||
);
|
||||
CREATE INDEX IF NOT EXISTS idx_execution_truth_state
|
||||
ON execution_truth(state, updated_at);
|
||||
"""
|
||||
)
|
||||
|
||||
def _connect(self) -> sqlite3.Connection:
|
||||
connection = sqlite3.connect(str(self.path), timeout=30.0)
|
||||
connection.row_factory = sqlite3.Row
|
||||
connection.execute("PRAGMA journal_mode=WAL")
|
||||
connection.execute("PRAGMA synchronous=FULL")
|
||||
connection.execute("PRAGMA foreign_keys=ON")
|
||||
return connection
|
||||
|
||||
@staticmethod
|
||||
def _manifest_json(manifest: ExecutionTaskManifest) -> str:
|
||||
return json.dumps(manifest.as_dict(), ensure_ascii=False, sort_keys=True, separators=(",", ":"))
|
||||
|
||||
@staticmethod
|
||||
def _record_json(record: ExecutionTruthRecord) -> str:
|
||||
value = record.as_dict()
|
||||
value.pop("manifest", None)
|
||||
return json.dumps(value, ensure_ascii=False, sort_keys=True, separators=(",", ":"), default=str)
|
||||
|
||||
@staticmethod
|
||||
def _decode(row: sqlite3.Row) -> ExecutionTruthRecord:
|
||||
value = json.loads(row["record_json"])
|
||||
value["state"] = ExecutionTruthState(value["state"])
|
||||
value["evidence"] = dict(value.get("evidence") or {})
|
||||
value["error"] = dict(value.get("error") or {})
|
||||
return ExecutionTruthRecord(**value)
|
||||
|
||||
def _event(
|
||||
self,
|
||||
connection: sqlite3.Connection,
|
||||
task_id: str,
|
||||
event_type: str,
|
||||
details: Mapping[str, Any] | None = None,
|
||||
) -> None:
|
||||
connection.execute(
|
||||
"INSERT INTO execution_truth_events VALUES (?, ?, ?, ?, ?)",
|
||||
(
|
||||
f"truth_evt_{uuid.uuid4().hex}",
|
||||
task_id,
|
||||
event_type,
|
||||
json.dumps(dict(details or {}), ensure_ascii=False, sort_keys=True, default=str),
|
||||
utc_now(),
|
||||
),
|
||||
)
|
||||
|
||||
def declare(self, manifest: ExecutionTaskManifest) -> ExecutionTruthRecord:
|
||||
manifest_json = self._manifest_json(manifest)
|
||||
record = ExecutionTruthRecord(
|
||||
task_id=manifest.task_id,
|
||||
manifest_json=manifest_json,
|
||||
state=ExecutionTruthState.DECLARED,
|
||||
)
|
||||
with self._lock, self._connect() as connection:
|
||||
connection.execute("BEGIN IMMEDIATE")
|
||||
existing = connection.execute(
|
||||
"SELECT record_json FROM execution_truth WHERE task_id = ?",
|
||||
(manifest.task_id,),
|
||||
).fetchone()
|
||||
if existing is not None:
|
||||
current = self._decode(existing)
|
||||
if current.manifest_json != manifest_json:
|
||||
previous_manifest = current.manifest.as_dict()
|
||||
replacement_manifest = manifest.as_dict()
|
||||
previous_oid = previous_manifest.pop("source_oid")
|
||||
replacement_oid = replacement_manifest.pop("source_oid")
|
||||
if (
|
||||
current.state != ExecutionTruthState.NOT_STARTED
|
||||
or previous_manifest != replacement_manifest
|
||||
):
|
||||
connection.rollback()
|
||||
raise ExecutionTruthConflict(
|
||||
"task_id already declared with another manifest"
|
||||
)
|
||||
now = utc_now()
|
||||
updated = replace(
|
||||
current,
|
||||
manifest_json=manifest_json,
|
||||
revision=current.revision + 1,
|
||||
)
|
||||
connection.execute(
|
||||
"UPDATE execution_truth SET manifest_json = ?, record_json = ?, revision = ?, updated_at = ? WHERE task_id = ?",
|
||||
(
|
||||
manifest_json,
|
||||
self._record_json(updated),
|
||||
updated.revision,
|
||||
now,
|
||||
updated.task_id,
|
||||
),
|
||||
)
|
||||
self._event(
|
||||
connection,
|
||||
updated.task_id,
|
||||
"MANIFEST_SUPERSEDED",
|
||||
{
|
||||
"previous_source_oid": previous_oid,
|
||||
"source_oid": replacement_oid,
|
||||
"state": updated.state.value,
|
||||
},
|
||||
)
|
||||
connection.commit()
|
||||
return updated
|
||||
connection.rollback()
|
||||
return current
|
||||
connection.execute(
|
||||
"INSERT INTO execution_truth VALUES (?, ?, ?, ?, ?, ?)",
|
||||
(
|
||||
record.task_id,
|
||||
manifest_json,
|
||||
record.state.value,
|
||||
self._record_json(record),
|
||||
record.revision,
|
||||
record.declared_at,
|
||||
),
|
||||
)
|
||||
self._event(connection, record.task_id, "DECLARED", {"source_oid": manifest.source_oid})
|
||||
connection.commit()
|
||||
return record
|
||||
|
||||
def get(self, task_id: str) -> ExecutionTruthRecord:
|
||||
with self._lock, self._connect() as connection:
|
||||
row = connection.execute(
|
||||
"SELECT record_json FROM execution_truth WHERE task_id = ?",
|
||||
(required(task_id, "task_id"),),
|
||||
).fetchone()
|
||||
if row is None:
|
||||
raise KeyError("execution task not declared")
|
||||
return self._decode(row)
|
||||
|
||||
def _transition(
|
||||
self,
|
||||
task_id: str,
|
||||
*,
|
||||
allowed: Sequence[ExecutionTruthState],
|
||||
target: ExecutionTruthState,
|
||||
executor_run_id: str | None = None,
|
||||
executor_id: str | None = None,
|
||||
current_step: int | None = None,
|
||||
evidence: Mapping[str, str] | None = None,
|
||||
error: Mapping[str, Any] | None = None,
|
||||
) -> ExecutionTruthRecord:
|
||||
with self._lock, self._connect() as connection:
|
||||
connection.execute("BEGIN IMMEDIATE")
|
||||
row = connection.execute(
|
||||
"SELECT record_json FROM execution_truth WHERE task_id = ?",
|
||||
(required(task_id, "task_id"),),
|
||||
).fetchone()
|
||||
if row is None:
|
||||
connection.rollback()
|
||||
raise KeyError("execution task not declared")
|
||||
current = self._decode(row)
|
||||
if current.state not in set(allowed):
|
||||
connection.rollback()
|
||||
raise ExecutionTruthConflict(
|
||||
f"cannot transition {current.state.value} to {target.value}"
|
||||
)
|
||||
now = utc_now()
|
||||
updates: dict[str, Any] = {
|
||||
"state": target,
|
||||
"revision": current.revision + 1,
|
||||
}
|
||||
if executor_run_id is not None:
|
||||
if current.executor_run_id and current.executor_run_id != executor_run_id:
|
||||
connection.rollback()
|
||||
raise ExecutionTruthConflict("executor_run_id mismatch")
|
||||
updates["executor_run_id"] = required(executor_run_id, "executor_run_id")
|
||||
if executor_id is not None:
|
||||
if current.executor_id and current.executor_id != executor_id:
|
||||
connection.rollback()
|
||||
raise ExecutionTruthConflict("executor_id mismatch")
|
||||
updates["executor_id"] = required(executor_id, "executor_id")
|
||||
if target == ExecutionTruthState.REGISTERED:
|
||||
updates["registered_at"] = now
|
||||
if target == ExecutionTruthState.CLAIMED:
|
||||
updates["claimed_at"] = now
|
||||
updates["heartbeat_at"] = now
|
||||
if target == ExecutionTruthState.RUNNING:
|
||||
updates["started_at"] = current.started_at or now
|
||||
updates["heartbeat_at"] = now
|
||||
if current_step is not None:
|
||||
if current_step < current.current_step or current_step > len(current.manifest.steps):
|
||||
connection.rollback()
|
||||
raise ExecutionTruthConflict("invalid task step progression")
|
||||
updates["current_step"] = current_step
|
||||
updates["heartbeat_at"] = now
|
||||
if evidence is not None:
|
||||
updates["evidence"] = {
|
||||
**dict(current.evidence),
|
||||
**{required(key, "evidence key"): required(value, "evidence hash") for key, value in evidence.items()},
|
||||
}
|
||||
if error is not None:
|
||||
updates["error"] = json.loads(json.dumps(dict(error), default=str))
|
||||
if target in TERMINAL_STATES:
|
||||
updates["completed_at"] = now
|
||||
updated = replace(current, **updates)
|
||||
connection.execute(
|
||||
"UPDATE execution_truth SET state = ?, record_json = ?, revision = ?, updated_at = ? WHERE task_id = ?",
|
||||
(
|
||||
updated.state.value,
|
||||
self._record_json(updated),
|
||||
updated.revision,
|
||||
now,
|
||||
updated.task_id,
|
||||
),
|
||||
)
|
||||
self._event(
|
||||
connection,
|
||||
updated.task_id,
|
||||
target.value,
|
||||
{
|
||||
"executor_run_id": updated.executor_run_id,
|
||||
"executor_id": updated.executor_id,
|
||||
"current_step": updated.current_step,
|
||||
},
|
||||
)
|
||||
connection.commit()
|
||||
return updated
|
||||
|
||||
def register(self, task_id: str, *, executor_run_id: str) -> ExecutionTruthRecord:
|
||||
return self._transition(
|
||||
task_id,
|
||||
allowed=(ExecutionTruthState.DECLARED,),
|
||||
target=ExecutionTruthState.REGISTERED,
|
||||
executor_run_id=executor_run_id,
|
||||
)
|
||||
|
||||
def retry_not_started(
|
||||
self,
|
||||
task_id: str,
|
||||
*,
|
||||
executor_run_id: str,
|
||||
) -> ExecutionTruthRecord:
|
||||
"""Start a new audited attempt after the declaration deadline expired."""
|
||||
with self._lock, self._connect() as connection:
|
||||
connection.execute("BEGIN IMMEDIATE")
|
||||
row = connection.execute(
|
||||
"SELECT record_json FROM execution_truth WHERE task_id = ?",
|
||||
(required(task_id, "task_id"),),
|
||||
).fetchone()
|
||||
if row is None:
|
||||
connection.rollback()
|
||||
raise KeyError("execution task not declared")
|
||||
current = self._decode(row)
|
||||
if current.state != ExecutionTruthState.NOT_STARTED:
|
||||
connection.rollback()
|
||||
raise ExecutionTruthConflict(
|
||||
f"cannot retry task from {current.state.value}"
|
||||
)
|
||||
now = utc_now()
|
||||
updated = replace(
|
||||
current,
|
||||
state=ExecutionTruthState.REGISTERED,
|
||||
executor_run_id=required(executor_run_id, "executor_run_id"),
|
||||
executor_id=None,
|
||||
registered_at=now,
|
||||
claimed_at=None,
|
||||
started_at=None,
|
||||
heartbeat_at=None,
|
||||
completed_at=None,
|
||||
current_step=0,
|
||||
evidence={},
|
||||
error={},
|
||||
revision=current.revision + 1,
|
||||
)
|
||||
connection.execute(
|
||||
"UPDATE execution_truth SET state = ?, record_json = ?, revision = ?, updated_at = ? WHERE task_id = ?",
|
||||
(
|
||||
updated.state.value,
|
||||
self._record_json(updated),
|
||||
updated.revision,
|
||||
now,
|
||||
updated.task_id,
|
||||
),
|
||||
)
|
||||
self._event(
|
||||
connection,
|
||||
updated.task_id,
|
||||
"RETRIED",
|
||||
{
|
||||
"previous_state": current.state.value,
|
||||
"previous_executor_run_id": current.executor_run_id,
|
||||
"executor_run_id": updated.executor_run_id,
|
||||
"previous_error": dict(current.error),
|
||||
},
|
||||
)
|
||||
connection.commit()
|
||||
return updated
|
||||
|
||||
def claim(self, task_id: str, *, executor_run_id: str, executor_id: str) -> ExecutionTruthRecord:
|
||||
return self._transition(
|
||||
task_id,
|
||||
allowed=(ExecutionTruthState.REGISTERED,),
|
||||
target=ExecutionTruthState.CLAIMED,
|
||||
executor_run_id=executor_run_id,
|
||||
executor_id=executor_id,
|
||||
)
|
||||
|
||||
def start(self, task_id: str, *, executor_run_id: str, executor_id: str) -> ExecutionTruthRecord:
|
||||
return self._transition(
|
||||
task_id,
|
||||
allowed=(ExecutionTruthState.CLAIMED,),
|
||||
target=ExecutionTruthState.RUNNING,
|
||||
executor_run_id=executor_run_id,
|
||||
executor_id=executor_id,
|
||||
current_step=1,
|
||||
)
|
||||
|
||||
def heartbeat(
|
||||
self,
|
||||
task_id: str,
|
||||
*,
|
||||
executor_run_id: str,
|
||||
executor_id: str,
|
||||
current_step: int,
|
||||
) -> ExecutionTruthRecord:
|
||||
return self._transition(
|
||||
task_id,
|
||||
allowed=(ExecutionTruthState.RUNNING,),
|
||||
target=ExecutionTruthState.RUNNING,
|
||||
executor_run_id=executor_run_id,
|
||||
executor_id=executor_id,
|
||||
current_step=current_step,
|
||||
)
|
||||
|
||||
def succeed(
|
||||
self,
|
||||
task_id: str,
|
||||
*,
|
||||
executor_run_id: str,
|
||||
executor_id: str,
|
||||
evidence: Mapping[str, str],
|
||||
) -> ExecutionTruthRecord:
|
||||
current = self.get(task_id)
|
||||
missing = sorted(set(current.manifest.required_evidence) - set(evidence))
|
||||
if missing:
|
||||
raise ExecutionTruthConflict(f"missing required evidence: {missing}")
|
||||
if current.current_step != len(current.manifest.steps):
|
||||
raise ExecutionTruthConflict("all declared steps must complete before success")
|
||||
return self._transition(
|
||||
task_id,
|
||||
allowed=(ExecutionTruthState.RUNNING,),
|
||||
target=ExecutionTruthState.SUCCEEDED,
|
||||
executor_run_id=executor_run_id,
|
||||
executor_id=executor_id,
|
||||
evidence=evidence,
|
||||
)
|
||||
|
||||
def fail(
|
||||
self,
|
||||
task_id: str,
|
||||
*,
|
||||
executor_run_id: str,
|
||||
executor_id: str,
|
||||
error: Mapping[str, Any],
|
||||
evidence: Mapping[str, str] | None = None,
|
||||
) -> ExecutionTruthRecord:
|
||||
return self._transition(
|
||||
task_id,
|
||||
allowed=(ExecutionTruthState.REGISTERED, ExecutionTruthState.CLAIMED, ExecutionTruthState.RUNNING),
|
||||
target=ExecutionTruthState.FAILED,
|
||||
executor_run_id=executor_run_id,
|
||||
executor_id=executor_id,
|
||||
evidence=evidence,
|
||||
error=error,
|
||||
)
|
||||
|
||||
def evaluate_deadlines(self, task_id: str, *, now: datetime | None = None) -> ExecutionTruthRecord:
|
||||
current = self.get(task_id)
|
||||
current_time = (now or datetime.now(timezone.utc)).astimezone(timezone.utc)
|
||||
manifest = current.manifest
|
||||
if current.state in TERMINAL_STATES:
|
||||
return current
|
||||
declared = parse_time(current.declared_at)
|
||||
if current.state in {ExecutionTruthState.DECLARED, ExecutionTruthState.REGISTERED}:
|
||||
if current_time >= declared + timedelta(seconds=manifest.start_deadline_seconds):
|
||||
return self._transition(
|
||||
task_id,
|
||||
allowed=(current.state,),
|
||||
target=ExecutionTruthState.NOT_STARTED,
|
||||
error={"code": "start_deadline_exceeded"},
|
||||
)
|
||||
if current.state in {ExecutionTruthState.CLAIMED, ExecutionTruthState.RUNNING}:
|
||||
heartbeat = parse_time(current.heartbeat_at or current.claimed_at or current.declared_at)
|
||||
if current_time >= heartbeat + timedelta(seconds=manifest.heartbeat_timeout_seconds):
|
||||
return self._transition(
|
||||
task_id,
|
||||
allowed=(current.state,),
|
||||
target=ExecutionTruthState.STALLED,
|
||||
error={"code": "heartbeat_timeout"},
|
||||
)
|
||||
return current
|
||||
|
||||
def gate(self, task_id: str) -> Mapping[str, Any]:
|
||||
record = self.evaluate_deadlines(task_id)
|
||||
passed = record.state == ExecutionTruthState.SUCCEEDED
|
||||
return {
|
||||
"task_id": record.task_id,
|
||||
"state": record.state.value,
|
||||
"passed": passed,
|
||||
"release_blocking": not passed,
|
||||
"executor_run_id": record.executor_run_id,
|
||||
"executor_id": record.executor_id,
|
||||
"current_step": record.current_step,
|
||||
"total_steps": len(record.manifest.steps),
|
||||
"evidence": dict(record.evidence),
|
||||
"error": dict(record.error),
|
||||
}
|
||||
|
||||
def events(self, task_id: str) -> list[Mapping[str, Any]]:
|
||||
with self._lock, self._connect() as connection:
|
||||
rows = connection.execute(
|
||||
"SELECT event_id, event_type, details_json, created_at FROM execution_truth_events WHERE task_id = ? ORDER BY created_at, event_id",
|
||||
(required(task_id, "task_id"),),
|
||||
).fetchall()
|
||||
return [
|
||||
{
|
||||
"event_id": row["event_id"],
|
||||
"event_type": row["event_type"],
|
||||
"details": json.loads(row["details_json"]),
|
||||
"created_at": row["created_at"],
|
||||
}
|
||||
for row in rows
|
||||
]
|
||||
@@ -1,13 +0,0 @@
|
||||
"""AIOS unified, role-aware web portal."""
|
||||
|
||||
from .application import UnifiedPortalApplication, build_application
|
||||
from .capabilities import ROLE_CAPABILITIES, allows, require, resolve
|
||||
|
||||
__all__ = [
|
||||
"ROLE_CAPABILITIES",
|
||||
"UnifiedPortalApplication",
|
||||
"allows",
|
||||
"build_application",
|
||||
"require",
|
||||
"resolve",
|
||||
]
|
||||
@@ -1,512 +0,0 @@
|
||||
"""Unified, role-aware AIOS web application.
|
||||
|
||||
The portal wraps the production CandidateApplication instead of replacing its
|
||||
runtime/control-plane routes. Portal endpoints aggregate existing authoritative
|
||||
stores and require server-side capabilities before delegating any state change.
|
||||
"""
|
||||
from __future__ import annotations
|
||||
|
||||
import dataclasses
|
||||
import json
|
||||
import os
|
||||
import re
|
||||
import sqlite3
|
||||
import urllib.parse
|
||||
from enum import Enum
|
||||
from http import HTTPStatus
|
||||
from pathlib import Path
|
||||
from typing import Any, Mapping
|
||||
|
||||
from aios_v2.app import (
|
||||
CandidateApplication,
|
||||
CandidateHTTPServer,
|
||||
build_application as build_candidate_application,
|
||||
)
|
||||
from aios_v2.control_plane import RequestContext, TaskState
|
||||
from aios_v2.gitops_status import collect_gitops_status
|
||||
from aios_v2.provenance import SQLiteProvenanceStore
|
||||
from aios_v2.provenance_grants import SQLiteGrantStore
|
||||
|
||||
from .capabilities import allows, require, resolve
|
||||
|
||||
|
||||
def _json_value(value: Any) -> Any:
|
||||
if dataclasses.is_dataclass(value):
|
||||
return {
|
||||
field.name: _json_value(getattr(value, field.name))
|
||||
for field in dataclasses.fields(value)
|
||||
}
|
||||
if isinstance(value, Enum):
|
||||
return value.value
|
||||
if isinstance(value, Mapping):
|
||||
return {str(key): _json_value(item) for key, item in value.items()}
|
||||
if isinstance(value, (list, tuple, set, frozenset)):
|
||||
return [_json_value(item) for item in value]
|
||||
return value
|
||||
|
||||
|
||||
def _mapping(value: Any) -> Mapping[str, Any]:
|
||||
if not isinstance(value, Mapping):
|
||||
raise ValueError("JSON body must be an object")
|
||||
return value
|
||||
|
||||
|
||||
def _required(value: Any, label: str) -> str:
|
||||
normalized = str(value or "").strip()
|
||||
if not normalized:
|
||||
raise ValueError(f"{label} is required")
|
||||
return normalized
|
||||
|
||||
|
||||
def _safe_count(items: list[Any]) -> int:
|
||||
return len(items)
|
||||
|
||||
|
||||
class AuthorizationCatalog:
|
||||
"""Tenant-filtered read/revoke access to existing Provenance stores."""
|
||||
|
||||
def __init__(self, store_file: str | Path) -> None:
|
||||
self.store_file = Path(store_file).resolve()
|
||||
|
||||
def _read_connection(self) -> sqlite3.Connection | None:
|
||||
if not self.store_file.exists():
|
||||
return None
|
||||
connection = sqlite3.connect(
|
||||
f"file:{self.store_file}?mode=ro",
|
||||
uri=True,
|
||||
timeout=10.0,
|
||||
)
|
||||
connection.row_factory = sqlite3.Row
|
||||
return connection
|
||||
|
||||
def snapshot(self, *, tenant_id: str) -> Mapping[str, Any]:
|
||||
connection = self._read_connection()
|
||||
if connection is None:
|
||||
return {
|
||||
"configured": False,
|
||||
"workflows": [],
|
||||
"grants": [],
|
||||
"summary": {"workflows": 0, "grants": 0, "active_grants": 0},
|
||||
}
|
||||
try:
|
||||
workflows: list[dict[str, Any]] = []
|
||||
grants: list[dict[str, Any]] = []
|
||||
tables = {
|
||||
row["name"]
|
||||
for row in connection.execute(
|
||||
"SELECT name FROM sqlite_master WHERE type='table'"
|
||||
).fetchall()
|
||||
}
|
||||
if "provenance_records" in tables:
|
||||
rows = connection.execute(
|
||||
"""
|
||||
SELECT r.payload_json, r.status, r.signature_verified,
|
||||
r.created_at, r.updated_at,
|
||||
COUNT(u.authorization_id) AS usage_count
|
||||
FROM provenance_records r
|
||||
LEFT JOIN provenance_usage u
|
||||
ON u.provenance_id = r.provenance_id
|
||||
GROUP BY r.provenance_id
|
||||
ORDER BY r.updated_at DESC, r.provenance_id
|
||||
"""
|
||||
).fetchall()
|
||||
for row in rows:
|
||||
payload = json.loads(row["payload_json"])
|
||||
if payload.get("tenant_id") != tenant_id:
|
||||
continue
|
||||
workflows.append(
|
||||
{
|
||||
**payload,
|
||||
"status": row["status"],
|
||||
"signature_verified": bool(row["signature_verified"]),
|
||||
"usage_count": int(row["usage_count"]),
|
||||
"created_at": row["created_at"],
|
||||
"updated_at": row["updated_at"],
|
||||
}
|
||||
)
|
||||
if "provenance_grants" in tables:
|
||||
rows = connection.execute(
|
||||
"""
|
||||
SELECT g.payload_json, g.status, g.signature_verified,
|
||||
g.created_at, g.updated_at,
|
||||
COUNT(u.authorization_id) AS usage_count
|
||||
FROM provenance_grants g
|
||||
LEFT JOIN provenance_grant_usage u
|
||||
ON u.grant_id = g.grant_id
|
||||
GROUP BY g.grant_id
|
||||
ORDER BY g.updated_at DESC, g.grant_id
|
||||
"""
|
||||
).fetchall()
|
||||
for row in rows:
|
||||
payload = json.loads(row["payload_json"])
|
||||
if payload.get("tenant_id") != tenant_id:
|
||||
continue
|
||||
grants.append(
|
||||
{
|
||||
**payload,
|
||||
"status": row["status"],
|
||||
"signature_verified": bool(row["signature_verified"]),
|
||||
"usage_count": int(row["usage_count"]),
|
||||
"created_at": row["created_at"],
|
||||
"updated_at": row["updated_at"],
|
||||
}
|
||||
)
|
||||
active = sum(
|
||||
1
|
||||
for item in grants
|
||||
if item.get("status") not in {"revoked", "expired"}
|
||||
)
|
||||
return {
|
||||
"configured": True,
|
||||
"workflows": workflows,
|
||||
"grants": grants,
|
||||
"summary": {
|
||||
"workflows": len(workflows),
|
||||
"grants": len(grants),
|
||||
"active_grants": active,
|
||||
"revoked_grants": sum(
|
||||
1 for item in grants if item.get("status") == "revoked"
|
||||
),
|
||||
},
|
||||
}
|
||||
finally:
|
||||
connection.close()
|
||||
|
||||
def revoke_workflow(
|
||||
self,
|
||||
*,
|
||||
provenance_id: str,
|
||||
tenant_id: str,
|
||||
principal_id: str,
|
||||
reason: str,
|
||||
) -> Mapping[str, Any]:
|
||||
store = SQLiteProvenanceStore(self.store_file)
|
||||
try:
|
||||
record = store.get(provenance_id)
|
||||
if record.tenant_id != tenant_id:
|
||||
raise KeyError("workflow provenance not found")
|
||||
store.revoke(
|
||||
record.provenance_id,
|
||||
reason=reason,
|
||||
principal_id=principal_id,
|
||||
)
|
||||
return {
|
||||
"provenance_id": record.provenance_id,
|
||||
"status": store.status(record.provenance_id).value,
|
||||
}
|
||||
finally:
|
||||
store.close()
|
||||
|
||||
def revoke_grant(
|
||||
self,
|
||||
*,
|
||||
grant_id: str,
|
||||
tenant_id: str,
|
||||
principal_id: str,
|
||||
reason: str,
|
||||
) -> Mapping[str, Any]:
|
||||
store = SQLiteGrantStore(self.store_file)
|
||||
try:
|
||||
grant = store.get(grant_id)
|
||||
if grant.tenant_id != tenant_id:
|
||||
raise KeyError("provenance grant not found")
|
||||
store.revoke(
|
||||
grant.grant_id,
|
||||
reason=reason,
|
||||
principal_id=principal_id,
|
||||
)
|
||||
return {
|
||||
"grant_id": grant.grant_id,
|
||||
"status": store.status(grant.grant_id).value,
|
||||
}
|
||||
finally:
|
||||
store.close()
|
||||
|
||||
|
||||
class UnifiedPortalApplication:
|
||||
"""Role-aware portal facade over the existing production application."""
|
||||
|
||||
def __init__(
|
||||
self,
|
||||
base: CandidateApplication,
|
||||
*,
|
||||
provenance_store_file: str | Path,
|
||||
) -> None:
|
||||
self.base = base
|
||||
self.gateway = base.gateway
|
||||
self.orchestrator = base.orchestrator
|
||||
self.tracker = base.tracker
|
||||
self.hermes = base.hermes
|
||||
self.openclaw = base.openclaw
|
||||
self.authorization_catalog = AuthorizationCatalog(provenance_store_file)
|
||||
|
||||
def context(self, headers: Mapping[str, str]) -> RequestContext:
|
||||
return self.base.context(headers)
|
||||
|
||||
def _runtime(self, headers: Mapping[str, str]) -> Mapping[str, Any]:
|
||||
status, payload = self.base.handle_json("GET", "/api/v2/runtime", headers, {})
|
||||
if int(status) != HTTPStatus.OK:
|
||||
raise RuntimeError("runtime status is unavailable")
|
||||
return payload
|
||||
|
||||
def _gitops(self, context: RequestContext) -> Mapping[str, Any]:
|
||||
return {
|
||||
"tenant_id": context.tenant_id,
|
||||
"gitops": collect_gitops_status().as_dict(),
|
||||
}
|
||||
|
||||
def _tasks_view(self, context: RequestContext) -> list[Mapping[str, Any]]:
|
||||
service = self.orchestrator.control_plane
|
||||
tasks = service.list_tasks(context)
|
||||
dispatches = {
|
||||
item.task_id: item
|
||||
for item in self.orchestrator.dispatch_repository.list(
|
||||
tenant_id=context.tenant_id
|
||||
)
|
||||
}
|
||||
evidence_by_task: dict[str, list[Any]] = {}
|
||||
for evidence in self.tracker.list(tenant_id=context.tenant_id):
|
||||
evidence_by_task.setdefault(evidence.task_id, []).append(evidence)
|
||||
audit_by_task: dict[str, list[Any]] = {}
|
||||
for event in service.list_audit_events(context):
|
||||
if event.resource_type == "task":
|
||||
audit_by_task.setdefault(event.resource_id, []).append(event)
|
||||
capabilities = set(resolve(context).capabilities)
|
||||
result: list[Mapping[str, Any]] = []
|
||||
for task in tasks:
|
||||
actions: list[str] = []
|
||||
if task.state == TaskState.CREATED and "task.approve" in capabilities:
|
||||
actions.append("approve")
|
||||
if task.state in {TaskState.CREATED, TaskState.APPROVED, TaskState.RUNNING} and "task.cancel" in capabilities:
|
||||
actions.append("cancel")
|
||||
if task.state == TaskState.APPROVED and "task.dispatch" in capabilities:
|
||||
actions.append("dispatch")
|
||||
result.append(
|
||||
{
|
||||
"task": _json_value(task),
|
||||
"dispatch": _json_value(dispatches.get(task.task_id)),
|
||||
"evidence": _json_value(evidence_by_task.get(task.task_id, [])),
|
||||
"audit": _json_value(audit_by_task.get(task.task_id, [])[-12:]),
|
||||
"available_actions": actions,
|
||||
}
|
||||
)
|
||||
return result
|
||||
|
||||
def _overview(
|
||||
self,
|
||||
context: RequestContext,
|
||||
headers: Mapping[str, str],
|
||||
) -> Mapping[str, Any]:
|
||||
service = self.orchestrator.control_plane
|
||||
capabilities = resolve(context)
|
||||
sections: dict[str, Any] = {}
|
||||
tasks = service.list_tasks(context) if allows(context, "task.read") else []
|
||||
dispatches = (
|
||||
self.orchestrator.dispatch_repository.list(tenant_id=context.tenant_id)
|
||||
if allows(context, "dispatch.read")
|
||||
else []
|
||||
)
|
||||
evidence = (
|
||||
self.tracker.list(tenant_id=context.tenant_id)
|
||||
if allows(context, "evidence.read")
|
||||
else []
|
||||
)
|
||||
audit = (
|
||||
service.list_audit_events(context)
|
||||
if allows(context, "audit.read")
|
||||
else []
|
||||
)
|
||||
if allows(context, "runtime.read"):
|
||||
sections["runtime"] = self._runtime(headers)
|
||||
if allows(context, "release.read"):
|
||||
sections["release"] = {
|
||||
**self._gitops(context),
|
||||
"version": os.getenv("AIOS_RELEASE_VERSION", "V2R1C1"),
|
||||
"release_oid": os.getenv("AIOS_RELEASE_OID", "unknown"),
|
||||
"baseline": os.getenv("AIOS_BASELINE_VERSION", "V2R1C1"),
|
||||
"status": os.getenv("AIOS_RELEASE_STATUS", "PRODUCTION_DEPLOYED"),
|
||||
}
|
||||
if allows(context, "provenance.read"):
|
||||
sections["authorization"] = self.authorization_catalog.snapshot(
|
||||
tenant_id=context.tenant_id
|
||||
)["summary"]
|
||||
task_states: dict[str, int] = {}
|
||||
for task in tasks:
|
||||
task_states[task.state.value] = task_states.get(task.state.value, 0) + 1
|
||||
return {
|
||||
"identity": capabilities.as_dict(),
|
||||
"summary": {
|
||||
"tasks": _safe_count(tasks),
|
||||
"task_states": task_states,
|
||||
"dispatches": _safe_count(dispatches),
|
||||
"active_dispatches": sum(
|
||||
1
|
||||
for item in dispatches
|
||||
if item.state.value not in {"COMPLETED", "FAILED", "CANCELLED"}
|
||||
),
|
||||
"evidence": _safe_count(evidence),
|
||||
"audit_events": _safe_count(audit),
|
||||
},
|
||||
"sections": sections,
|
||||
"recent": {
|
||||
"tasks": _json_value(tasks[:8]),
|
||||
"dispatches": _json_value(dispatches[-8:]),
|
||||
"audit": _json_value(audit[-12:]),
|
||||
},
|
||||
}
|
||||
|
||||
def handle_json(
|
||||
self,
|
||||
method: str,
|
||||
raw_path: str,
|
||||
headers: Mapping[str, str],
|
||||
body: Any,
|
||||
) -> tuple[int, Mapping[str, Any]]:
|
||||
parsed = urllib.parse.urlparse(raw_path)
|
||||
path = parsed.path.rstrip("/") or "/"
|
||||
method = method.upper()
|
||||
|
||||
if not path.startswith("/api/v2/portal") and path != "/api/v2/me/capabilities":
|
||||
return self.base.handle_json(method, raw_path, headers, body)
|
||||
|
||||
context = self.context(headers)
|
||||
payload = _mapping(body or {})
|
||||
|
||||
if method == "GET" and path == "/api/v2/me/capabilities":
|
||||
require(context, "portal.access")
|
||||
return HTTPStatus.OK, resolve(context).as_dict()
|
||||
|
||||
if method == "GET" and path == "/api/v2/portal/overview":
|
||||
require(context, "dashboard.read")
|
||||
return HTTPStatus.OK, self._overview(context, headers)
|
||||
|
||||
if method == "GET" and path == "/api/v2/portal/tasks":
|
||||
require(context, "task.read")
|
||||
return HTTPStatus.OK, {"items": self._tasks_view(context)}
|
||||
|
||||
if method == "GET" and path == "/api/v2/portal/authorizations":
|
||||
require(context, "provenance.read")
|
||||
return HTTPStatus.OK, self.authorization_catalog.snapshot(
|
||||
tenant_id=context.tenant_id
|
||||
)
|
||||
|
||||
if method == "GET" and path == "/api/v2/portal/runtime":
|
||||
require(context, "runtime.read")
|
||||
return HTTPStatus.OK, {
|
||||
**self._runtime(headers),
|
||||
"dispatches": _json_value(
|
||||
self.orchestrator.dispatch_repository.list(
|
||||
tenant_id=context.tenant_id
|
||||
)
|
||||
),
|
||||
"hermes_jobs": _json_value(
|
||||
self.hermes.list(tenant_id=context.tenant_id)
|
||||
),
|
||||
}
|
||||
|
||||
if method == "GET" and path == "/api/v2/portal/evidence":
|
||||
require(context, "evidence.read")
|
||||
return HTTPStatus.OK, {
|
||||
"executions": _json_value(
|
||||
self.tracker.list(tenant_id=context.tenant_id)
|
||||
)
|
||||
}
|
||||
|
||||
if method == "GET" and path == "/api/v2/portal/audit":
|
||||
require(context, "audit.read")
|
||||
return HTTPStatus.OK, {
|
||||
"events": _json_value(
|
||||
self.orchestrator.control_plane.list_audit_events(context)
|
||||
)
|
||||
}
|
||||
|
||||
if method == "GET" and path == "/api/v2/portal/release":
|
||||
require(context, "release.read")
|
||||
return HTTPStatus.OK, {
|
||||
**self._gitops(context),
|
||||
"version": os.getenv("AIOS_RELEASE_VERSION", "V2R1C1"),
|
||||
"release_oid": os.getenv("AIOS_RELEASE_OID", "unknown"),
|
||||
"baseline": os.getenv("AIOS_BASELINE_VERSION", "V2R1C1"),
|
||||
"status": os.getenv("AIOS_RELEASE_STATUS", "PRODUCTION_DEPLOYED"),
|
||||
"operations": (
|
||||
["review_release", "request_tag", "request_rollback"]
|
||||
if allows(context, "release.operate")
|
||||
else []
|
||||
),
|
||||
"note": "Release operations remain GitOps approval requests; the portal does not mutate tags or production directly.",
|
||||
}
|
||||
|
||||
if method == "POST" and path == "/api/v2/portal/tasks":
|
||||
require(context, "task.create")
|
||||
return self.base.handle_json("POST", "/api/v2/tasks", headers, payload)
|
||||
|
||||
task_action = re.fullmatch(
|
||||
r"/api/v2/portal/tasks/([^/]+)/(approve|cancel|dispatch)", path
|
||||
)
|
||||
if method == "POST" and task_action:
|
||||
action = task_action.group(2)
|
||||
require(context, f"task.{action}")
|
||||
task_id = urllib.parse.unquote(task_action.group(1))
|
||||
target = (
|
||||
f"/api/v2/tasks/{task_id}/dispatch"
|
||||
if action == "dispatch"
|
||||
else f"/api/v2/tasks/{task_id}/{action}"
|
||||
)
|
||||
return self.base.handle_json("POST", target, headers, payload)
|
||||
|
||||
workflow_revoke = re.fullmatch(
|
||||
r"/api/v2/portal/provenance/([^/]+)/revoke", path
|
||||
)
|
||||
if method == "POST" and workflow_revoke:
|
||||
require(context, "provenance.revoke")
|
||||
reason = _required(payload.get("reason"), "reason")
|
||||
result = self.authorization_catalog.revoke_workflow(
|
||||
provenance_id=urllib.parse.unquote(workflow_revoke.group(1)),
|
||||
tenant_id=context.tenant_id,
|
||||
principal_id=context.principal_id,
|
||||
reason=reason,
|
||||
)
|
||||
return HTTPStatus.OK, {"workflow": result}
|
||||
|
||||
grant_revoke = re.fullmatch(r"/api/v2/portal/grants/([^/]+)/revoke", path)
|
||||
if method == "POST" and grant_revoke:
|
||||
require(context, "provenance.revoke")
|
||||
reason = _required(payload.get("reason"), "reason")
|
||||
result = self.authorization_catalog.revoke_grant(
|
||||
grant_id=urllib.parse.unquote(grant_revoke.group(1)),
|
||||
tenant_id=context.tenant_id,
|
||||
principal_id=context.principal_id,
|
||||
reason=reason,
|
||||
)
|
||||
return HTTPStatus.OK, {"grant": result}
|
||||
|
||||
return HTTPStatus.NOT_FOUND, {
|
||||
"error": "not_found",
|
||||
"message": "portal route not found",
|
||||
}
|
||||
|
||||
|
||||
def build_application() -> UnifiedPortalApplication:
|
||||
state_dir = Path(os.getenv("AIOS_V2_STATE_DIR", "/var/lib/aios-v2")).resolve()
|
||||
provenance_file = Path(
|
||||
os.getenv(
|
||||
"AIOS_PROVENANCE_STORE_FILE",
|
||||
str(state_dir / "run-provenance.sqlite3"),
|
||||
)
|
||||
)
|
||||
return UnifiedPortalApplication(
|
||||
build_candidate_application(),
|
||||
provenance_store_file=provenance_file,
|
||||
)
|
||||
|
||||
|
||||
def main() -> None:
|
||||
host = os.getenv("AIOS_V2_HOST", "127.0.0.1")
|
||||
port = int(os.getenv("AIOS_V2_PORT", "18920"))
|
||||
server = CandidateHTTPServer((host, port), build_application())
|
||||
print(f"AIOS V2 unified portal listening on {host}:{port}")
|
||||
server.serve_forever()
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@@ -1,111 +0,0 @@
|
||||
"""Server-side role and capability resolution for the unified AIOS portal."""
|
||||
from __future__ import annotations
|
||||
|
||||
from dataclasses import dataclass
|
||||
from typing import Mapping, Sequence
|
||||
|
||||
from aios_v2.control_plane import RequestContext, Unauthorized
|
||||
|
||||
|
||||
ROLE_CAPABILITIES: Mapping[str, frozenset[str]] = {
|
||||
"platform_admin": frozenset({
|
||||
"portal.access", "dashboard.read", "tenant.read", "tenant.manage",
|
||||
"agent.read", "agent.manage", "task.read", "task.create", "task.approve",
|
||||
"task.cancel", "task.dispatch", "policy.read", "audit.read", "evidence.read",
|
||||
"runtime.read", "runtime.operate", "dispatch.read", "provenance.read",
|
||||
"provenance.revoke", "external_task.read", "gitops.read", "release.read",
|
||||
"release.operate", "worktree.read", "system.admin",
|
||||
}),
|
||||
"tenant_admin": frozenset({
|
||||
"portal.access", "dashboard.read", "tenant.read", "agent.read", "agent.manage",
|
||||
"task.read", "task.create", "task.approve", "task.cancel", "task.dispatch",
|
||||
"policy.read", "audit.read", "evidence.read", "runtime.read", "dispatch.read",
|
||||
"provenance.read", "provenance.revoke", "external_task.read", "gitops.read",
|
||||
"release.read",
|
||||
}),
|
||||
"operator": frozenset({
|
||||
"portal.access", "dashboard.read", "tenant.read", "agent.read", "task.read",
|
||||
"task.create", "task.cancel", "task.dispatch", "runtime.read", "dispatch.read",
|
||||
"evidence.read", "provenance.read", "external_task.read", "gitops.read",
|
||||
"release.read",
|
||||
}),
|
||||
"approver": frozenset({
|
||||
"portal.access", "dashboard.read", "tenant.read", "task.read", "task.approve",
|
||||
"task.cancel", "policy.read", "audit.read", "provenance.read", "evidence.read",
|
||||
"external_task.read", "release.read",
|
||||
}),
|
||||
"auditor": frozenset({
|
||||
"portal.access", "dashboard.read", "tenant.read", "agent.read", "task.read",
|
||||
"audit.read", "evidence.read", "runtime.read", "dispatch.read",
|
||||
"provenance.read", "external_task.read", "gitops.read", "release.read",
|
||||
"worktree.read",
|
||||
}),
|
||||
"runtime": frozenset({
|
||||
"portal.access", "dashboard.read", "task.read", "runtime.read", "runtime.operate",
|
||||
"dispatch.read", "evidence.read", "provenance.read", "external_task.read",
|
||||
}),
|
||||
"release_manager": frozenset({
|
||||
"portal.access", "dashboard.read", "audit.read", "runtime.read", "dispatch.read",
|
||||
"provenance.read", "external_task.read", "gitops.read", "release.read",
|
||||
"release.operate", "worktree.read",
|
||||
}),
|
||||
"viewer": frozenset({
|
||||
"portal.access", "dashboard.read", "task.read", "runtime.read",
|
||||
"external_task.read",
|
||||
}),
|
||||
}
|
||||
|
||||
|
||||
NAVIGATION: Sequence[Mapping[str, str]] = (
|
||||
{"id": "overview", "label": "总览", "capability": "dashboard.read"},
|
||||
{"id": "resources", "label": "租户与 Agent", "capability": "tenant.read"},
|
||||
{"id": "tasks", "label": "任务中心", "capability": "task.read"},
|
||||
{"id": "execution", "label": "执行中心", "capability": "external_task.read"},
|
||||
{"id": "authorization", "label": "授权中心", "capability": "provenance.read"},
|
||||
{"id": "runtime", "label": "运行与运维", "capability": "runtime.read"},
|
||||
{"id": "evidence", "label": "执行证据", "capability": "evidence.read"},
|
||||
{"id": "audit", "label": "审计中心", "capability": "audit.read"},
|
||||
{"id": "release", "label": "GitOps 与发布", "capability": "release.read"},
|
||||
)
|
||||
|
||||
|
||||
@dataclass(frozen=True)
|
||||
class ResolvedCapabilities:
|
||||
tenant_id: str
|
||||
principal_id: str
|
||||
roles: tuple[str, ...]
|
||||
capabilities: tuple[str, ...]
|
||||
navigation: tuple[Mapping[str, str], ...]
|
||||
|
||||
def as_dict(self) -> dict[str, object]:
|
||||
return {
|
||||
"tenant_id": self.tenant_id,
|
||||
"principal_id": self.principal_id,
|
||||
"roles": list(self.roles),
|
||||
"capabilities": list(self.capabilities),
|
||||
"navigation": [dict(item) for item in self.navigation],
|
||||
}
|
||||
|
||||
|
||||
def resolve(context: RequestContext) -> ResolvedCapabilities:
|
||||
capabilities: set[str] = set()
|
||||
for role in context.roles:
|
||||
capabilities.update(ROLE_CAPABILITIES.get(role, ()))
|
||||
ordered = tuple(sorted(capabilities))
|
||||
navigation = tuple(item for item in NAVIGATION if item["capability"] in capabilities)
|
||||
return ResolvedCapabilities(
|
||||
tenant_id=context.tenant_id,
|
||||
principal_id=context.principal_id,
|
||||
roles=tuple(sorted(context.roles)),
|
||||
capabilities=ordered,
|
||||
navigation=navigation,
|
||||
)
|
||||
|
||||
|
||||
def require(context: RequestContext, capability: str) -> None:
|
||||
if capability not in resolve(context).capabilities:
|
||||
raise Unauthorized(f"portal capability is required: {capability}")
|
||||
|
||||
|
||||
def allows(context: RequestContext, capability: str) -> bool:
|
||||
return capability in resolve(context).capabilities
|
||||
@@ -1,48 +0,0 @@
|
||||
"""Unified portal HTML export with V2R1C2 resource and execution centers.
|
||||
|
||||
The canonical dependency-free portal remains in ``aios_v2.console``. This
|
||||
module applies deterministic, fail-fast extensions at import time so the
|
||||
V2R1C1 production entrypoint remains unchanged while the V2R1C2 candidate gets
|
||||
resource and portable-executor views.
|
||||
"""
|
||||
from __future__ import annotations
|
||||
|
||||
from aios_v2.console import CONSOLE_HTML as _BASE_PORTAL_HTML
|
||||
|
||||
|
||||
def _extend_portal(source: str) -> str:
|
||||
replacements = (
|
||||
(
|
||||
'<section id="overview" class="view active"></section>\n <section id="tasks" class="view"></section>\n <section id="authorization" class="view"></section>',
|
||||
'<section id="overview" class="view active"></section>\n <section id="resources" class="view"></section>\n <section id="tasks" class="view"></section>\n <section id="execution" class="view"></section>\n <section id="authorization" class="view"></section>',
|
||||
),
|
||||
(
|
||||
"const labels={overview:'系统总览',tasks:'任务中心',authorization:'授权中心'",
|
||||
"const labels={overview:'系统总览',resources:'租户与 Agent',tasks:'任务中心',execution:'执行中心',authorization:'授权中心'",
|
||||
),
|
||||
(
|
||||
"if(view==='overview')await overview();if(view==='tasks')await tasks();if(view==='authorization')await authorizations();",
|
||||
"if(view==='overview')await overview();if(view==='resources')await resources();if(view==='tasks')await tasks();if(view==='execution')await execution();if(view==='authorization')await authorizations();",
|
||||
),
|
||||
(
|
||||
"async function tasks(){const d=await api('/api/v2/portal/tasks');",
|
||||
"""async function resources(){const d=await api('/api/v2/portal/resources');const t=d.tenant||{},agents=d.agents||[],ops=d.operations||{};const agentButton=ops.agent_create?'<button class=\"btn\" id=\"newAgent\">注册 Agent</button>':'';$('#resources').innerHTML=`<div class=\"cards\">${card('租户',t.tenant_id||'—',t.status||'')}${card('Agent',d.summary?.agents||0,`启用 ${d.summary?.enabled_agents||0}`)}${card('任务',d.summary?.tasks||0)}${card('Runtime 类型',(d.summary?.runtimes||[]).length,(d.summary?.runtimes||[]).join(', '))}</div><div class=\"grid\"><div class=\"panel\"><div class=\"panel-head\"><h2>当前租户</h2></div><div class=\"kv\"><div>Tenant ID</div><div>${esc(t.tenant_id||'—')}</div><div>名称</div><div>${esc(t.display_name||'—')}</div><div>状态</div><div>${pill(t.status||'unknown')}</div><div>创建时间</div><div>${esc(t.created_at||'—')}</div><div>更新时间</div><div>${esc(t.updated_at||'—')}</div></div></div><div class=\"panel\"><div class=\"panel-head\"><h2>Agent Registry</h2><div>${agentButton}</div></div>${table([['Agent',x=>esc(x.agent_id)],['名称',x=>esc(x.display_name)],['Runtime',x=>pill(x.runtime)],['能力',x=>(x.capabilities||[]).map(pill).join('')],['启用',x=>pill(x.enabled?'enabled':'disabled')],['任务数',x=>esc(x.task_count)]],agents)}</div></div>`;$('#newAgent')?.addEventListener('click',()=>{const agent_id=prompt('Agent ID');const display_name=prompt('显示名称',agent_id||'');const runtime=prompt('Runtime Provider','openclaw');const capabilities=prompt('能力，逗号分隔','');if(!agent_id||!display_name||!runtime)return;api('/api/v2/portal/agents',{method:'POST',body:JSON.stringify({agent_id,display_name,runtime,capabilities:String(capabilities||'').split(',').map(x=>x.trim()).filter(Boolean),metadata:{source:'unified-portal'}})}).then(resources).catch(err)})}
|
||||
function executionStage(x){const s=x.stage||{},status=x.truth||{},record=status.record||{},gate=status.gate||{},d=x.dependency_gate||{},notifications=gate.notifications||[],evidence=record.evidence||{};const stateName=record.state||'WAITING_DEPENDENCY';const deps=(s.depends_on||[]).join(', ')||'根阶段';return `<div class=\"panel\" style=\"background:#fbfcfe\"><div class=\"panel-head\"><h2>${esc(s.stage_id)} · ${esc(s.role)}</h2><div>${pill(stateName)} ${pill(s.executor_type)}</div></div><div class=\"chain\"><div class=\"chain-item\"><b>Provider</b><div>${esc(s.executor_type)}</div><small>${esc(deps)}</small></div><span class=\"chain-arrow\">→</span><div class=\"chain-item\"><b>Run</b><div>${esc(record.executor_run_id||'未注册')}</div><small>${esc(record.executor_id||'')}</small></div><span class=\"chain-arrow\">→</span><div class=\"chain-item\"><b>Progress</b><div>${esc(record.current_step||0)}/${esc((record.manifest?.steps||s.steps||[]).length)}</div><small>${esc(record.heartbeat_at||'无心跳')}</small></div><span class=\"chain-arrow\">→</span><div class=\"chain-item\"><b>Evidence</b><div>${Object.keys(evidence).length} 项</div><small>${Object.keys(evidence).slice(0,2).map(esc).join(', ')}</small></div><span class=\"chain-arrow\">→</span><div class=\"chain-item\"><b>Notification</b><div>${notifications.length} 条</div><small>${notifications.map(n=>n.status).join(', ')||'无'}</small></div><span class=\"chain-arrow\">→</span><div class=\"chain-item\"><b>Gate</b><div>${pill(gate.passed?'PASS':'BLOCKED')}</div><small>${d.passed?'依赖满足':'等待依赖'}</small></div></div>${Object.keys(record.error||{}).length?json(record.error):''}</div>`}
|
||||
async function execution(){const d=await api('/api/v2/portal/execution');const providers=d.providers||[],plans=d.plans||[];$('#execution').innerHTML=`<div class=\"cards\">${card('Provider',providers.length)}${card('Execution Plan',plans.length)}${card('协议',d.protocol_version||'—')}${card('Plan Schema',d.plan_schema_version||'—')}</div><div class=\"panel\"><div class=\"panel-head\"><h2>Executor Provider Catalog</h2></div>${table([['Provider',x=>esc(x.executor_type)],['Adapter',x=>esc(x.adapter_version)],['协议',x=>esc(x.protocol_version)],['Trust Roles',x=>(x.trust_roles||[]).map(pill).join('')],['Capabilities',x=>(x.capabilities||[]).map(pill).join('')]],providers)}</div>${plans.map(p=>`<div class=\"panel\"><div class=\"panel-head\"><h2>${esc(p.plan_id)} · ${esc(p.target_version)}</h2><div>${pill(p.gate?.passed?'PASS':'BLOCKED')}</div></div><div class=\"kv\"><div>Source Branch</div><div>${esc(p.source_branch)}</div><div>Source OID</div><div>${esc(p.source_oid)}</div><div>Release Gate</div><div>${pill(p.gate?.passed?'PASS':'BLOCKED')}</div></div></div>${(p.snapshot?.stages||[]).map(executionStage).join('')}`).join('')||'<div class=\"empty\">尚未声明执行计划</div>'}`}
|
||||
async function tasks(){const d=await api('/api/v2/portal/tasks');""",
|
||||
),
|
||||
)
|
||||
result = source
|
||||
for old, new in replacements:
|
||||
if old not in result:
|
||||
raise RuntimeError(f"unified portal extension anchor not found: {old[:100]}")
|
||||
result = result.replace(old, new, 1)
|
||||
return result
|
||||
|
||||
|
||||
PORTAL_HTML = _extend_portal(_BASE_PORTAL_HTML)
|
||||
|
||||
if "\n+function executionStage" in PORTAL_HTML or "\n+async function execution" in PORTAL_HTML:
|
||||
raise RuntimeError("execution center contains an invalid diff marker")
|
||||
|
||||
__all__ = ["PORTAL_HTML"]
|
||||
@@ -1,130 +0,0 @@
|
||||
"""HTTP facade for portable multi-provider execution plans."""
|
||||
from __future__ import annotations
|
||||
|
||||
import urllib.parse
|
||||
from http import HTTPStatus
|
||||
from typing import Any, Mapping
|
||||
|
||||
from aios_v2.control_plane import RequestContext, Unauthorized
|
||||
from aios_v2.execution_plan import ExecutionPlanCoordinator
|
||||
from aios_v2.executor_protocol import ExecutorProviderRegistry, normalize_executor
|
||||
|
||||
from .capabilities import require
|
||||
|
||||
|
||||
class ExecutionPlanAPI:
|
||||
"""Portal read model and provider-authenticated plan discovery API."""
|
||||
|
||||
INTERNAL_PREFIX = "/api/v2/internal/execution-plans"
|
||||
PORTAL_PATH = "/api/v2/portal/execution"
|
||||
|
||||
def __init__(
|
||||
self,
|
||||
coordinator: ExecutionPlanCoordinator,
|
||||
*,
|
||||
providers: ExecutorProviderRegistry,
|
||||
) -> None:
|
||||
self.coordinator = coordinator
|
||||
self.providers = providers
|
||||
|
||||
@classmethod
|
||||
def is_route(cls, raw_path: str) -> bool:
|
||||
path = urllib.parse.urlparse(raw_path).path.rstrip("/") or "/"
|
||||
return path == cls.PORTAL_PATH or path.startswith(cls.INTERNAL_PREFIX)
|
||||
|
||||
def _require_provider(
|
||||
self,
|
||||
context: RequestContext,
|
||||
executor_type: str,
|
||||
) -> str:
|
||||
normalized = normalize_executor(executor_type)
|
||||
if not self.providers.trusted(
|
||||
executor_type=normalized,
|
||||
roles=tuple(context.roles),
|
||||
platform_admin="platform_admin" in context.roles,
|
||||
):
|
||||
raise Unauthorized(
|
||||
f"trusted role for executor Provider is required: {normalized}"
|
||||
)
|
||||
return normalized
|
||||
|
||||
def _portal_snapshot(self) -> Mapping[str, Any]:
|
||||
plans = []
|
||||
for plan in self.coordinator.plan_store.list():
|
||||
plans.append(
|
||||
{
|
||||
"plan_id": plan.plan_id,
|
||||
"target_version": plan.target_version,
|
||||
"source_branch": plan.source_branch,
|
||||
"source_oid": plan.source_oid,
|
||||
"snapshot": self.coordinator.snapshot(plan.plan_id),
|
||||
"gate": self.coordinator.gate(plan.plan_id),
|
||||
}
|
||||
)
|
||||
return {
|
||||
"protocol_version": "aios.executor.v1",
|
||||
"plan_schema_version": "aios.execution-plan.v2",
|
||||
"providers": [
|
||||
item.as_dict() for item in self.providers.list_descriptors()
|
||||
],
|
||||
"plans": plans,
|
||||
}
|
||||
|
||||
def handle(
|
||||
self,
|
||||
method: str,
|
||||
raw_path: str,
|
||||
context: RequestContext,
|
||||
body: Any,
|
||||
) -> tuple[int, Mapping[str, Any]]:
|
||||
del body
|
||||
parsed = urllib.parse.urlparse(raw_path)
|
||||
path = parsed.path.rstrip("/") or "/"
|
||||
method = method.upper()
|
||||
|
||||
if method == "GET" and path == self.PORTAL_PATH:
|
||||
require(context, "external_task.read")
|
||||
return HTTPStatus.OK, self._portal_snapshot()
|
||||
|
||||
if not path.startswith(f"{self.INTERNAL_PREFIX}/"):
|
||||
return HTTPStatus.NOT_FOUND, {
|
||||
"error": "not_found",
|
||||
"message": "execution plan route not found",
|
||||
}
|
||||
|
||||
remainder = urllib.parse.unquote(path[len(self.INTERNAL_PREFIX) + 1 :])
|
||||
parts = tuple(item for item in remainder.split("/") if item)
|
||||
if len(parts) != 2:
|
||||
return HTTPStatus.NOT_FOUND, {
|
||||
"error": "not_found",
|
||||
"message": "execution plan route not found",
|
||||
}
|
||||
plan_id, action = parts
|
||||
query = urllib.parse.parse_qs(parsed.query)
|
||||
executor_type = self._require_provider(
|
||||
context,
|
||||
str(query.get("executor", [""])[0]),
|
||||
)
|
||||
|
||||
if method == "GET" and action == "discover":
|
||||
items = self.coordinator.discover_ready(
|
||||
plan_id=plan_id,
|
||||
executor_type=executor_type,
|
||||
)
|
||||
return HTTPStatus.OK, {
|
||||
"plan_id": plan_id,
|
||||
"executor_type": executor_type,
|
||||
"count": len(items),
|
||||
"items": items,
|
||||
}
|
||||
|
||||
if method == "GET" and action == "snapshot":
|
||||
return HTTPStatus.OK, self.coordinator.snapshot(plan_id)
|
||||
|
||||
if method == "GET" and action == "gate":
|
||||
return HTTPStatus.OK, self.coordinator.gate(plan_id)
|
||||
|
||||
return HTTPStatus.NOT_FOUND, {
|
||||
"error": "not_found",
|
||||
"message": "execution plan route not found",
|
||||
}
|
||||
@@ -1,276 +0,0 @@
|
||||
"""Protected HTTP facade for portable executor truth and notification receipts."""
|
||||
from __future__ import annotations
|
||||
|
||||
import urllib.parse
|
||||
from http import HTTPStatus
|
||||
from pathlib import Path
|
||||
from typing import Any, Mapping, Sequence
|
||||
|
||||
from aios_v2.control_plane import RequestContext, Unauthorized
|
||||
from aios_v2.executor_protocol import ExecutorProviderRegistry, normalize_executor
|
||||
from aios_v2.external_task_control import ExternalTaskCoordinator
|
||||
from aios_v2.external_task_query import list_records
|
||||
from aios_v2.task_execution_registry import ExecutionTruthState
|
||||
|
||||
from .capabilities import require
|
||||
|
||||
|
||||
def _body(value: Any) -> Mapping[str, Any]:
|
||||
if not isinstance(value, Mapping):
|
||||
raise ValueError("JSON body must be an object")
|
||||
return value
|
||||
|
||||
|
||||
def _required(value: Any, label: str) -> str:
|
||||
normalized = str(value or "").strip()
|
||||
if not normalized:
|
||||
raise ValueError(f"{label} is required")
|
||||
return normalized
|
||||
|
||||
|
||||
def _mapping_strings(value: Any, label: str) -> dict[str, str]:
|
||||
if not isinstance(value, Mapping):
|
||||
raise ValueError(f"{label} must be an object")
|
||||
return {
|
||||
_required(key, f"{label} key"): _required(item, f"{label}[{key}]")
|
||||
for key, item in value.items()
|
||||
}
|
||||
|
||||
|
||||
class ExternalTaskAPI:
|
||||
"""Fail-closed external task API shared by every registered Provider."""
|
||||
|
||||
INTERNAL_PREFIX = "/api/v2/internal/external-tasks"
|
||||
|
||||
def __init__(
|
||||
self,
|
||||
coordinator: ExternalTaskCoordinator,
|
||||
*,
|
||||
store_file: str | Path,
|
||||
providers: ExecutorProviderRegistry,
|
||||
) -> None:
|
||||
self.coordinator = coordinator
|
||||
self.store_file = Path(store_file).resolve()
|
||||
self.providers = providers
|
||||
|
||||
@staticmethod
|
||||
def is_route(path: str) -> bool:
|
||||
normalized = path.rstrip("/") or "/"
|
||||
return normalized.startswith(ExternalTaskAPI.INTERNAL_PREFIX) or normalized == "/api/v2/portal/external-tasks"
|
||||
|
||||
def _require_executor(self, context: RequestContext, executor_type: str) -> str:
|
||||
normalized = normalize_executor(executor_type)
|
||||
if not self.providers.trusted(
|
||||
executor_type=normalized,
|
||||
roles=tuple(context.roles),
|
||||
platform_admin="platform_admin" in context.roles,
|
||||
):
|
||||
raise Unauthorized(
|
||||
f"trusted role for executor Provider is required: {normalized}"
|
||||
)
|
||||
return normalized
|
||||
|
||||
def _task_executor(self, task_id: str) -> str:
|
||||
return normalize_executor(
|
||||
self.coordinator.registry.get(task_id).manifest.executor
|
||||
)
|
||||
|
||||
@staticmethod
|
||||
def _executor_identity(
|
||||
context: RequestContext,
|
||||
payload: Mapping[str, Any],
|
||||
) -> str:
|
||||
executor_id = _required(payload.get("executor_id"), "executor_id")
|
||||
if executor_id != context.principal_id and "platform_admin" not in context.roles:
|
||||
raise Unauthorized("executor_id must match trusted principal")
|
||||
return executor_id
|
||||
|
||||
def declare_directory(self, directory: str | Path) -> list[Mapping[str, Any]]:
|
||||
root = Path(directory).resolve()
|
||||
if not root.exists():
|
||||
return []
|
||||
declared: list[Mapping[str, Any]] = []
|
||||
for manifest in sorted(root.glob("*.json")):
|
||||
record = self.coordinator.declare_file(manifest)
|
||||
self.providers.validate_manifest(record.manifest)
|
||||
declared.append(
|
||||
{
|
||||
"manifest": str(manifest),
|
||||
"task_id": record.task_id,
|
||||
"executor_type": record.manifest.executor,
|
||||
"state": record.state.value,
|
||||
}
|
||||
)
|
||||
return declared
|
||||
|
||||
def handle(
|
||||
self,
|
||||
method: str,
|
||||
raw_path: str,
|
||||
context: RequestContext,
|
||||
body: Any,
|
||||
) -> tuple[int, Mapping[str, Any]]:
|
||||
parsed = urllib.parse.urlparse(raw_path)
|
||||
path = parsed.path.rstrip("/") or "/"
|
||||
method = method.upper()
|
||||
payload = _body(body or {})
|
||||
|
||||
if method == "GET" and path == "/api/v2/portal/external-tasks":
|
||||
require(context, "external_task.read")
|
||||
records = list_records(self.store_file)
|
||||
return HTTPStatus.OK, {
|
||||
"count": len(records),
|
||||
"items": [self.coordinator.status(item.task_id) for item in records],
|
||||
}
|
||||
|
||||
if method == "GET" and path == f"{self.INTERNAL_PREFIX}/discover":
|
||||
query = urllib.parse.parse_qs(parsed.query)
|
||||
states = tuple(query.get("state", ()))
|
||||
executor = self._require_executor(
|
||||
context,
|
||||
str(query.get("executor", [""])[0]),
|
||||
)
|
||||
records = list_records(
|
||||
self.store_file,
|
||||
executor=executor,
|
||||
states=states,
|
||||
)
|
||||
return HTTPStatus.OK, {
|
||||
"count": len(records),
|
||||
"executor_type": executor,
|
||||
"items": [item.as_dict() for item in records],
|
||||
}
|
||||
|
||||
if method == "GET" and path == f"{self.INTERNAL_PREFIX}/notifications":
|
||||
query = urllib.parse.parse_qs(parsed.query)
|
||||
executor = self._require_executor(
|
||||
context,
|
||||
str(query.get("executor", [""])[0]),
|
||||
)
|
||||
task_id = query.get("task_id", [None])[0]
|
||||
status = query.get("status", [None])[0]
|
||||
items = self.coordinator.notifications.list(
|
||||
task_id=task_id,
|
||||
status=status,
|
||||
)
|
||||
filtered = [
|
||||
item
|
||||
for item in items
|
||||
if self._task_executor(item.task_id) == executor
|
||||
]
|
||||
return HTTPStatus.OK, {
|
||||
"count": len(filtered),
|
||||
"executor_type": executor,
|
||||
"items": [item.as_dict() for item in filtered],
|
||||
}
|
||||
|
||||
notification_ack = self._match(
|
||||
path,
|
||||
f"{self.INTERNAL_PREFIX}/notifications/",
|
||||
"/ack",
|
||||
)
|
||||
if method == "POST" and notification_ack:
|
||||
notification = self.coordinator.notifications.get(notification_ack)
|
||||
executor = self._task_executor(notification.task_id)
|
||||
self._require_executor(context, executor)
|
||||
self._executor_identity(context, payload)
|
||||
record = self.coordinator.notifications.acknowledge(
|
||||
notification_ack,
|
||||
receipt_sha256=_required(
|
||||
payload.get("receipt_sha256"),
|
||||
"receipt_sha256",
|
||||
),
|
||||
)
|
||||
return HTTPStatus.OK, {"notification": record.as_dict()}
|
||||
|
||||
truth_task = self._match(path, f"{self.INTERNAL_PREFIX}/", "/truth")
|
||||
if method == "GET" and truth_task:
|
||||
self._require_executor(context, self._task_executor(truth_task))
|
||||
return HTTPStatus.OK, self.coordinator.status(truth_task)
|
||||
|
||||
for action in ("register", "retry", "claim", "start", "heartbeat", "succeed", "fail"):
|
||||
task_id = self._match(path, f"{self.INTERNAL_PREFIX}/", f"/{action}")
|
||||
if method != "POST" or not task_id:
|
||||
continue
|
||||
executor_type = self._task_executor(task_id)
|
||||
self._require_executor(context, executor_type)
|
||||
run_id = _required(payload.get("executor_run_id"), "executor_run_id")
|
||||
if action == "register":
|
||||
return HTTPStatus.OK, {
|
||||
"record": self.coordinator.register(
|
||||
task_id,
|
||||
executor_run_id=run_id,
|
||||
).as_dict()
|
||||
}
|
||||
if action == "retry":
|
||||
return HTTPStatus.OK, {
|
||||
"record": self.coordinator.retry_not_started(
|
||||
task_id,
|
||||
executor_run_id=run_id,
|
||||
).as_dict()
|
||||
}
|
||||
executor_id = self._executor_identity(context, payload)
|
||||
if action == "claim":
|
||||
record = self.coordinator.claim(
|
||||
task_id,
|
||||
executor_run_id=run_id,
|
||||
executor_id=executor_id,
|
||||
)
|
||||
elif action == "start":
|
||||
record = self.coordinator.start(
|
||||
task_id,
|
||||
executor_run_id=run_id,
|
||||
executor_id=executor_id,
|
||||
)
|
||||
elif action == "heartbeat":
|
||||
record = self.coordinator.heartbeat(
|
||||
task_id,
|
||||
executor_run_id=run_id,
|
||||
executor_id=executor_id,
|
||||
current_step=int(payload.get("current_step")),
|
||||
)
|
||||
elif action == "succeed":
|
||||
record = self.coordinator.succeed(
|
||||
task_id,
|
||||
executor_run_id=run_id,
|
||||
executor_id=executor_id,
|
||||
evidence=_mapping_strings(payload.get("evidence"), "evidence"),
|
||||
)
|
||||
else:
|
||||
error = payload.get("error")
|
||||
if not isinstance(error, Mapping):
|
||||
raise ValueError("error must be an object")
|
||||
evidence_value = payload.get("evidence")
|
||||
evidence = (
|
||||
_mapping_strings(evidence_value, "evidence")
|
||||
if evidence_value is not None
|
||||
else None
|
||||
)
|
||||
record = self.coordinator.fail(
|
||||
task_id,
|
||||
executor_run_id=run_id,
|
||||
executor_id=executor_id,
|
||||
error=dict(error),
|
||||
evidence=evidence,
|
||||
)
|
||||
return HTTPStatus.OK, {"record": record.as_dict()}
|
||||
|
||||
return HTTPStatus.NOT_FOUND, {
|
||||
"error": "not_found",
|
||||
"message": "external task route not found",
|
||||
}
|
||||
|
||||
@staticmethod
|
||||
def _match(path: str, prefix: str, suffix: str) -> str | None:
|
||||
if not path.startswith(prefix) or not path.endswith(suffix):
|
||||
return None
|
||||
middle = path[len(prefix) : len(path) - len(suffix)]
|
||||
if not middle or "/" in middle:
|
||||
return None
|
||||
return urllib.parse.unquote(middle)
|
||||
|
||||
|
||||
DISCOVERABLE_STATES: Sequence[str] = (
|
||||
ExecutionTruthState.DECLARED.value,
|
||||
ExecutionTruthState.REGISTERED.value,
|
||||
)
|
||||
@@ -1,376 +0,0 @@
|
||||
"""V2R1C2 unified portal and portable executor release entrypoint.
|
||||
|
||||
The V2R1C1 production entrypoint remains unchanged. This candidate entrypoint
|
||||
uses an isolated state directory, loads a versioned executor catalog, declares
|
||||
portable multi-provider execution plans and exposes both portal read models and
|
||||
provider-authenticated lifecycle APIs.
|
||||
"""
|
||||
from __future__ import annotations
|
||||
|
||||
import json
|
||||
import os
|
||||
import re
|
||||
import urllib.parse
|
||||
from dataclasses import replace
|
||||
from http import HTTPStatus
|
||||
from pathlib import Path
|
||||
from typing import Any, Mapping, Sequence
|
||||
|
||||
import aios_v2.app as candidate_app_module
|
||||
from aios_v2.app import (
|
||||
CandidateApplication,
|
||||
CandidateHTTPServer,
|
||||
build_application as build_candidate_application,
|
||||
)
|
||||
from aios_v2.control_plane import RequestContext
|
||||
from aios_v2.execution_plan import ExecutionPlanCoordinator, ExecutionPlanManifest
|
||||
from aios_v2.executor_catalog import FileExecutorCatalogStore
|
||||
from aios_v2.official_executor_providers import official_provider_factories
|
||||
|
||||
from .application import UnifiedPortalApplication, _json_value, _mapping
|
||||
from .capabilities import allows, require
|
||||
from .console import PORTAL_HTML
|
||||
from .execution_plan_api import ExecutionPlanAPI
|
||||
from .external_task_api import ExternalTaskAPI
|
||||
|
||||
|
||||
_READ_BRIDGE_ROLES = frozenset({"approver", "runtime", "viewer", "release_manager"})
|
||||
_GIT_OID = re.compile(r"^[0-9a-f]{40}$")
|
||||
|
||||
|
||||
def _resolve_environment_value(value: Any, *, label: str) -> Any:
|
||||
if not isinstance(value, str) or not value.startswith("ENV:"):
|
||||
return value
|
||||
variable = value[4:].strip()
|
||||
if not variable:
|
||||
raise ValueError(f"{label} environment variable name is empty")
|
||||
resolved = str(os.getenv(variable, "")).strip()
|
||||
if not resolved:
|
||||
raise RuntimeError(f"required environment variable is not set: {variable}")
|
||||
return resolved
|
||||
|
||||
|
||||
def _load_execution_plan(path: str | Path) -> ExecutionPlanManifest:
|
||||
source = Path(path).resolve()
|
||||
value = json.loads(source.read_text(encoding="utf-8"))
|
||||
if not isinstance(value, Mapping):
|
||||
raise ValueError(f"execution plan must contain a JSON object: {source}")
|
||||
payload = dict(value)
|
||||
for label in ("source_branch", "source_oid", "target_version"):
|
||||
payload[label] = _resolve_environment_value(payload.get(label), label=label)
|
||||
source_oid = str(payload.get("source_oid") or "").strip().lower()
|
||||
if not _GIT_OID.fullmatch(source_oid):
|
||||
raise ValueError(
|
||||
"execution plan source_oid must resolve to an exact 40-character Git OID"
|
||||
)
|
||||
payload["source_oid"] = source_oid
|
||||
return ExecutionPlanManifest.from_dict(payload)
|
||||
|
||||
|
||||
def _path_list(value: str) -> tuple[Path, ...]:
|
||||
return tuple(
|
||||
Path(item).expanduser().resolve()
|
||||
for item in value.split(os.pathsep)
|
||||
if item.strip()
|
||||
)
|
||||
|
||||
|
||||
class V2R1C2PortalApplication(UnifiedPortalApplication):
|
||||
"""Unified portal candidate with provider-neutral execution governance."""
|
||||
|
||||
def __init__(
|
||||
self,
|
||||
base: CandidateApplication,
|
||||
*,
|
||||
provenance_store_file: str | Path,
|
||||
external_task_api: ExternalTaskAPI,
|
||||
execution_plan_api: ExecutionPlanAPI,
|
||||
plan_coordinator: ExecutionPlanCoordinator,
|
||||
catalog_snapshot: Mapping[str, Any],
|
||||
declared_plans: Sequence[str],
|
||||
) -> None:
|
||||
super().__init__(base, provenance_store_file=provenance_store_file)
|
||||
self.external_task_api = external_task_api
|
||||
self.execution_plan_api = execution_plan_api
|
||||
self.plan_coordinator = plan_coordinator
|
||||
self.catalog_snapshot = dict(catalog_snapshot)
|
||||
self.declared_plans = tuple(declared_plans)
|
||||
|
||||
def context(self, headers: Mapping[str, str]) -> RequestContext:
|
||||
original = self.base.context(headers)
|
||||
if original.roles.intersection(_READ_BRIDGE_ROLES):
|
||||
return replace(original, roles=frozenset((*original.roles, "auditor")))
|
||||
return original
|
||||
|
||||
def _resource_snapshot(self, context: RequestContext) -> Mapping[str, Any]:
|
||||
service = self.orchestrator.control_plane
|
||||
tenant = service.get_tenant(context)
|
||||
agents = service.list_agents(context) if allows(context, "agent.read") else []
|
||||
tasks = service.list_tasks(context) if allows(context, "task.read") else []
|
||||
tasks_by_agent: dict[str, int] = {}
|
||||
for task in tasks:
|
||||
tasks_by_agent[task.agent_id] = tasks_by_agent.get(task.agent_id, 0) + 1
|
||||
return {
|
||||
"tenant": _json_value(tenant),
|
||||
"agents": [
|
||||
{
|
||||
**_json_value(agent),
|
||||
"task_count": tasks_by_agent.get(agent.agent_id, 0),
|
||||
}
|
||||
for agent in agents
|
||||
],
|
||||
"summary": {
|
||||
"agents": len(agents),
|
||||
"enabled_agents": sum(1 for agent in agents if agent.enabled),
|
||||
"tasks": len(tasks),
|
||||
"runtimes": sorted({agent.runtime for agent in agents}),
|
||||
},
|
||||
"operations": {
|
||||
"tenant_create": allows(context, "tenant.manage"),
|
||||
"agent_create": allows(context, "agent.manage"),
|
||||
},
|
||||
}
|
||||
|
||||
def _runtime_snapshot(
|
||||
self,
|
||||
context: RequestContext,
|
||||
headers: Mapping[str, str],
|
||||
) -> Mapping[str, Any]:
|
||||
return {
|
||||
**self._runtime(headers),
|
||||
"dispatches": _json_value(
|
||||
self.orchestrator.dispatch_repository.list(
|
||||
tenant_id=context.tenant_id
|
||||
)
|
||||
),
|
||||
"hermes_jobs": _json_value(
|
||||
self.hermes.list_jobs(tenant_id=context.tenant_id)
|
||||
),
|
||||
"contract": {
|
||||
"openclaw": os.getenv(
|
||||
"AIOS_OPENCLAW_CONTRACT_VERSION",
|
||||
"aios.openclaw.command.v2",
|
||||
),
|
||||
"signature_algorithm": os.getenv(
|
||||
"AIOS_OPENCLAW_SIGNATURE_ALGORITHM",
|
||||
"Ed25519",
|
||||
),
|
||||
"plugin_version": os.getenv(
|
||||
"AIOS_OPENCLAW_PLUGIN_VERSION",
|
||||
"2.1.0-rc.4",
|
||||
),
|
||||
"key_id": os.getenv(
|
||||
"AIOS_OPENCLAW_SIGNING_KEY_ID",
|
||||
"openclaw-v2r1-candidate-ed25519",
|
||||
),
|
||||
"executor_protocol": "aios.executor.v1",
|
||||
"execution_plan": "aios.execution-plan.v2",
|
||||
},
|
||||
}
|
||||
|
||||
def _release_snapshot(self, context: RequestContext) -> Mapping[str, Any]:
|
||||
plans = []
|
||||
for plan_id in self.declared_plans:
|
||||
plans.append(
|
||||
{
|
||||
"plan_id": plan_id,
|
||||
"gate": self.plan_coordinator.gate(plan_id),
|
||||
}
|
||||
)
|
||||
aggregate_passed = bool(plans) and all(
|
||||
item["gate"]["passed"] for item in plans
|
||||
)
|
||||
return {
|
||||
**self._gitops(context),
|
||||
"version": os.getenv("AIOS_RELEASE_VERSION", "V2R1C2-CANDIDATE"),
|
||||
"target_version": os.getenv("AIOS_TARGET_VERSION", "V2R1C2"),
|
||||
"release_oid": os.getenv("AIOS_RELEASE_OID", "candidate-not-tagged"),
|
||||
"source_oid": os.getenv("AIOS_RELEASE_SOURCE_OID", "missing"),
|
||||
"tag": os.getenv("AIOS_RELEASE_TAG", "NOT_CREATED"),
|
||||
"baseline": os.getenv("AIOS_BASELINE_VERSION", "V2R1C1"),
|
||||
"previous_version": os.getenv("AIOS_PREVIOUS_VERSION", "V2R1C1"),
|
||||
"status": os.getenv("AIOS_RELEASE_STATUS", "CANDIDATE_VALIDATION"),
|
||||
"evidence_manifest_sha256": os.getenv(
|
||||
"AIOS_RELEASE_EVIDENCE_SHA256",
|
||||
"pending",
|
||||
),
|
||||
"executor_catalog": {
|
||||
"path": self.catalog_snapshot.get("path"),
|
||||
"sha256": self.catalog_snapshot.get("catalog_sha256"),
|
||||
"protocol_version": "aios.executor.v1",
|
||||
},
|
||||
"execution_plans": plans,
|
||||
"execution_gate": {
|
||||
"passed": aggregate_passed,
|
||||
"release_blocking": not aggregate_passed,
|
||||
},
|
||||
"operations": (
|
||||
["review_release", "request_tag", "request_rollback"]
|
||||
if allows(context, "release.operate")
|
||||
else []
|
||||
),
|
||||
"note": (
|
||||
"Release operations remain GitOps approval requests. The portal "
|
||||
"never mutates tags, main, or production directly. Tag approval "
|
||||
"must remain blocked until every required execution-plan gate passes."
|
||||
),
|
||||
}
|
||||
|
||||
def handle_json(
|
||||
self,
|
||||
method: str,
|
||||
raw_path: str,
|
||||
headers: Mapping[str, str],
|
||||
body: Any,
|
||||
) -> tuple[int, Mapping[str, Any]]:
|
||||
parsed = urllib.parse.urlparse(raw_path)
|
||||
path = parsed.path.rstrip("/") or "/"
|
||||
method = method.upper()
|
||||
|
||||
if self.execution_plan_api.is_route(raw_path):
|
||||
context = (
|
||||
self.context(headers)
|
||||
if path == ExecutionPlanAPI.PORTAL_PATH
|
||||
else self.base.context(headers)
|
||||
)
|
||||
return self.execution_plan_api.handle(
|
||||
method,
|
||||
raw_path,
|
||||
context,
|
||||
body,
|
||||
)
|
||||
|
||||
if self.external_task_api.is_route(path):
|
||||
context = (
|
||||
self.context(headers)
|
||||
if path == "/api/v2/portal/external-tasks"
|
||||
else self.base.context(headers)
|
||||
)
|
||||
return self.external_task_api.handle(
|
||||
method,
|
||||
raw_path,
|
||||
context,
|
||||
body,
|
||||
)
|
||||
|
||||
context: RequestContext | None = None
|
||||
if path in {
|
||||
"/api/v2/portal/resources",
|
||||
"/api/v2/portal/runtime",
|
||||
"/api/v2/portal/release",
|
||||
"/api/v2/portal/tenants",
|
||||
"/api/v2/portal/agents",
|
||||
}:
|
||||
context = self.context(headers)
|
||||
|
||||
if method == "GET" and path == "/api/v2/portal/resources":
|
||||
assert context is not None
|
||||
require(context, "tenant.read")
|
||||
return HTTPStatus.OK, self._resource_snapshot(context)
|
||||
|
||||
if method == "POST" and path == "/api/v2/portal/tenants":
|
||||
assert context is not None
|
||||
require(context, "tenant.manage")
|
||||
return self.base.handle_json(
|
||||
"POST",
|
||||
"/api/v2/tenants",
|
||||
headers,
|
||||
_mapping(body),
|
||||
)
|
||||
|
||||
if method == "POST" and path == "/api/v2/portal/agents":
|
||||
assert context is not None
|
||||
require(context, "agent.manage")
|
||||
return self.base.handle_json(
|
||||
"POST",
|
||||
"/api/v2/agents",
|
||||
headers,
|
||||
_mapping(body),
|
||||
)
|
||||
|
||||
if method == "GET" and path == "/api/v2/portal/runtime":
|
||||
assert context is not None
|
||||
require(context, "runtime.read")
|
||||
return HTTPStatus.OK, self._runtime_snapshot(context, headers)
|
||||
|
||||
if method == "GET" and path == "/api/v2/portal/release":
|
||||
assert context is not None
|
||||
require(context, "release.read")
|
||||
return HTTPStatus.OK, self._release_snapshot(context)
|
||||
|
||||
return super().handle_json(method, raw_path, headers, body)
|
||||
|
||||
|
||||
def build_application() -> V2R1C2PortalApplication:
|
||||
state_dir = Path(
|
||||
os.getenv("AIOS_V2_STATE_DIR", "/var/lib/aios-v2r1c2-portal")
|
||||
).resolve()
|
||||
state_dir.mkdir(parents=True, exist_ok=True)
|
||||
provenance_file = Path(
|
||||
os.getenv(
|
||||
"AIOS_PROVENANCE_STORE_FILE",
|
||||
str(state_dir / "run-provenance.sqlite3"),
|
||||
)
|
||||
).resolve()
|
||||
truth_file = Path(
|
||||
os.getenv(
|
||||
"AIOS_EXTERNAL_TASK_STORE_FILE",
|
||||
str(state_dir / "external-task-truth.sqlite3"),
|
||||
)
|
||||
).resolve()
|
||||
catalog_file = Path(
|
||||
os.getenv(
|
||||
"AIOS_EXECUTOR_CATALOG_FILE",
|
||||
str(state_dir / "executor-catalog.json"),
|
||||
)
|
||||
).resolve()
|
||||
|
||||
catalog_store = FileExecutorCatalogStore(catalog_file)
|
||||
catalog_snapshot = catalog_store.initialize_defaults()
|
||||
providers = catalog_store.registry(
|
||||
provider_factories=official_provider_factories()
|
||||
)
|
||||
plan_coordinator = ExecutionPlanCoordinator.from_file(
|
||||
truth_file,
|
||||
providers=providers,
|
||||
)
|
||||
|
||||
declared_plans: list[str] = []
|
||||
plan_files = _path_list(os.getenv("AIOS_EXECUTION_PLAN_FILES", ""))
|
||||
for plan_file in plan_files:
|
||||
plan = _load_execution_plan(plan_file)
|
||||
plan_coordinator.declare(plan)
|
||||
declared_plans.append(plan.plan_id)
|
||||
|
||||
base: CandidateApplication = build_candidate_application()
|
||||
external_task_api = ExternalTaskAPI(
|
||||
plan_coordinator.task_coordinator,
|
||||
store_file=truth_file,
|
||||
providers=providers,
|
||||
)
|
||||
execution_plan_api = ExecutionPlanAPI(
|
||||
plan_coordinator,
|
||||
providers=providers,
|
||||
)
|
||||
return V2R1C2PortalApplication(
|
||||
base,
|
||||
provenance_store_file=provenance_file,
|
||||
external_task_api=external_task_api,
|
||||
execution_plan_api=execution_plan_api,
|
||||
plan_coordinator=plan_coordinator,
|
||||
catalog_snapshot=catalog_snapshot.as_dict(),
|
||||
declared_plans=declared_plans,
|
||||
)
|
||||
|
||||
|
||||
def main() -> None:
|
||||
candidate_app_module.CONSOLE_HTML = PORTAL_HTML
|
||||
host = os.getenv("AIOS_V2_HOST", "127.0.0.1")
|
||||
port = int(os.getenv("AIOS_V2_PORT", "18921"))
|
||||
server = CandidateHTTPServer((host, port), build_application())
|
||||
print(f"AIOS V2R1C2 unified portal listening on {host}:{port}")
|
||||
server.serve_forever()
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@@ -0,0 +1,43 @@
|
||||
{
|
||||
"actor_identity": "codex-chartgpt-bridge",
|
||||
"allowed_branch_patterns": [
|
||||
"patch/**",
|
||||
"feature/**",
|
||||
"fix/**",
|
||||
"release-candidate/**"
|
||||
],
|
||||
"allowed_operations": [
|
||||
"commit_file.atomic"
|
||||
],
|
||||
"allowed_path_patterns": [
|
||||
"active-runtime/**",
|
||||
"services/**",
|
||||
"deploy/**",
|
||||
"tests/**",
|
||||
"docs/**",
|
||||
"versions/**",
|
||||
"release/**"
|
||||
],
|
||||
"denied_branch_patterns": [
|
||||
"main",
|
||||
"master",
|
||||
"governance/approvals",
|
||||
"integration/**",
|
||||
"production/**"
|
||||
],
|
||||
"denied_operations": [
|
||||
"force_push",
|
||||
"history_rewrite",
|
||||
"branch_delete",
|
||||
"tag.write",
|
||||
"registry.write",
|
||||
"baseline.write",
|
||||
"production.deploy",
|
||||
"approval.submit",
|
||||
"secret.read"
|
||||
],
|
||||
"expires_at": "2027-07-29T00:00:00Z",
|
||||
"policy_id": "STANDING-GOVERNED-DEVELOPMENT-WRITER-V1",
|
||||
"repository": "aios/aios",
|
||||
"writer_audience": "aios-governed-development-writer"
|
||||
}
|
||||
@@ -0,0 +1,23 @@
|
||||
{
|
||||
"actor_identity": "codex-chartgpt-bridge",
|
||||
"allowed_operations": [
|
||||
"commit_file.atomic"
|
||||
],
|
||||
"allowed_paths": [
|
||||
"services/**",
|
||||
"deploy/**",
|
||||
"tests/**",
|
||||
"docs/**",
|
||||
"release/**"
|
||||
],
|
||||
"branch": "patch/v2r1c4-release-completion-20260729",
|
||||
"expected_base_oid": "<40_HEX_OID>",
|
||||
"expected_policy_sha256": "<64_HEX_SHA256>",
|
||||
"expires_at": "2026-08-05T00:00:00Z",
|
||||
"grant_id": "grant-REPLACE",
|
||||
"max_operations": 200,
|
||||
"max_total_bytes": 67108864,
|
||||
"repository": "aios/aios",
|
||||
"task_id": "V2R1C4-RELEASE-COMPLETION",
|
||||
"writer_audience": "aios-governed-development-writer"
|
||||
}
|
||||
@@ -0,0 +1,7 @@
|
||||
{
|
||||
"authoritative_git_dir": "/data/aios-gitops/repo.git",
|
||||
"poll_seconds": 5,
|
||||
"receipts_dir": "/var/lib/aios-gitops/autonomous-control-plane/mirror/receipts",
|
||||
"requests_dir": "/var/lib/aios-gitops/autonomous-control-plane/mirror/requests",
|
||||
"source_git_dir": "/data/aios-gitops/runtime/gitea-bin/data/gitea-repositories/aios/aios.git"
|
||||
}
|
||||
@@ -0,0 +1,19 @@
|
||||
{
|
||||
"socket_path": "/run/aios-gitops/autonomous-control-plane/publisher.sock",
|
||||
"allowed_peer_uids": [
|
||||
0
|
||||
],
|
||||
"repository": "aios/aios",
|
||||
"base_branch": "governance/approvals",
|
||||
"head_prefix": "governance/request/",
|
||||
"owner_reviewer": "owner",
|
||||
"gitea_base_url": "http://127.0.0.1:3000",
|
||||
"remote_url": "http://127.0.0.1:3000/aios/aios.git",
|
||||
"credential_name": "gitea_http",
|
||||
"allowed_git_dir_roots": [
|
||||
"/data/aios-gitops/worktrees",
|
||||
"/data/aios-gitops/repo.git"
|
||||
],
|
||||
"operation_ledger": "/var/lib/aios-gitops/autonomous-control-plane/publisher/operations.sqlite",
|
||||
"audit_path": "/var/lib/aios-gitops/autonomous-control-plane/publisher/audit.jsonl"
|
||||
}
|
||||
@@ -0,0 +1,62 @@
|
||||
{
|
||||
"authoritative_git_dir": "/data/aios-gitops/repo.git",
|
||||
"approval": {
|
||||
"gitea_db_path": "/data/aios-gitops/runtime/gitea-bin/data/gitea.db",
|
||||
"repo_id": 1,
|
||||
"owner_user_id": 2,
|
||||
"governance_ref": "refs/heads/governance/approvals",
|
||||
"required_machine_contexts": [
|
||||
"aios/branch-protection",
|
||||
"aios/evidence-closure",
|
||||
"aios/secret-scan",
|
||||
"aios/state-machine",
|
||||
"aios/validator"
|
||||
]
|
||||
},
|
||||
"merge_transport": {
|
||||
"transport": "unix_json",
|
||||
"socket_path": "/run/aios-gitops/integration-merge-writer.sock",
|
||||
"timeout_seconds": 120
|
||||
},
|
||||
"tag_transport": {
|
||||
"transport": "http_json",
|
||||
"url": "http://127.0.0.1:8080/api/create-tag",
|
||||
"credential_name": "tag_api",
|
||||
"timeout_seconds": 120,
|
||||
"expected_statuses": [
|
||||
200
|
||||
]
|
||||
},
|
||||
"remote_tag": {
|
||||
"remote_url": "https://g.cnnetmkt.top/git/aios/aios.git",
|
||||
"gitea_base_url": "https://g.cnnetmkt.top/git",
|
||||
"repo_owner": "aios",
|
||||
"repo_name": "aios",
|
||||
"credential_name": "gitea_http"
|
||||
},
|
||||
"deployment": {
|
||||
"artifact_path": "/var/lib/aios-gitops/artifacts/V2R1C4.tar.zst",
|
||||
"artifact_manifest_member": "artifact-manifest.json",
|
||||
"release_root": "/opt/aios/releases",
|
||||
"current_symlink": "/opt/aios/current",
|
||||
"previous_symlink": "/opt/aios/previous",
|
||||
"state_path": "/var/lib/aios-gitops/autonomous-control-plane/release/deployment-state.json",
|
||||
"service_units": [
|
||||
"aios-gitops-model-api.service"
|
||||
],
|
||||
"health_checks": [
|
||||
{
|
||||
"url": "http://127.0.0.1:8080/health",
|
||||
"expected_status": 200,
|
||||
"timeout_seconds": 10
|
||||
}
|
||||
]
|
||||
},
|
||||
"metadata": {
|
||||
"registry_path": "/var/lib/aios-gitops/release/versions/V2R1C4.json",
|
||||
"baseline_path": "/var/lib/aios-gitops/release/PRODUCTION_BASELINE",
|
||||
"registry_plan_path": "/var/lib/aios-gitops/autonomous-control-plane/release/registry-plan.json",
|
||||
"baseline_plan_path": "/var/lib/aios-gitops/autonomous-control-plane/release/baseline-plan.txt",
|
||||
"metadata_snapshot_root": "/var/lib/aios-gitops/autonomous-control-plane/release/metadata-snapshots"
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,24 @@
|
||||
{
|
||||
"approval_expires_at": "2026-08-05T00:00:00Z",
|
||||
"approval_head_oid": "<40_HEX_OID>",
|
||||
"approval_manifest_path": "approvals/release/V2R1C4-PRODUCTION-RELEASE-ENVELOPE.json",
|
||||
"approval_manifest_sha256": "<64_HEX_SHA256>",
|
||||
"approval_merge_oid": "<40_HEX_OID>",
|
||||
"approval_plan_id": "<OWNER_APPROVED_PLAN_ID>",
|
||||
"approval_pr_number": 1,
|
||||
"artifact_sha256": "<64_HEX_SHA256>",
|
||||
"baseline_plan_sha256": "<64_HEX_SHA256>",
|
||||
"deployment_plan_sha256": "<64_HEX_SHA256>",
|
||||
"evidence_closure_oid": "<40_HEX_OID>",
|
||||
"evidence_closure_sha256": "<64_HEX_SHA256>",
|
||||
"owner_review_oid": 1,
|
||||
"registry_plan_sha256": "<64_HEX_SHA256>",
|
||||
"rollback_artifact_sha256": "<64_HEX_SHA256>",
|
||||
"rollback_plan_sha256": "<64_HEX_SHA256>",
|
||||
"sbom_sha256": "<64_HEX_SHA256>",
|
||||
"tag_plan_sha256": "<64_HEX_SHA256>",
|
||||
"target_oid": "<40_HEX_TARGET_OID>",
|
||||
"target_tree_oid": "<40_HEX_TREE_OID>",
|
||||
"test_evidence_sha256": "<64_HEX_SHA256>",
|
||||
"version": "V2R1C4"
|
||||
}
|
||||
@@ -0,0 +1,96 @@
|
||||
{
|
||||
"state_path": "/var/lib/aios-gitops/autonomous-control-plane/release/state.json",
|
||||
"audit_path": "/var/lib/aios-gitops/autonomous-control-plane/release/audit.jsonl",
|
||||
"hooks": {
|
||||
"verify_owner_approval": [
|
||||
"/usr/bin/aios-release-hook",
|
||||
"verify_owner_approval",
|
||||
"--config",
|
||||
"/etc/aios-gitops/autonomous-control-plane/release-actions.json"
|
||||
],
|
||||
"merge_release": [
|
||||
"/usr/bin/aios-release-hook",
|
||||
"merge_release",
|
||||
"--config",
|
||||
"/etc/aios-gitops/autonomous-control-plane/release-actions.json"
|
||||
],
|
||||
"create_tag": [
|
||||
"/usr/bin/aios-release-hook",
|
||||
"create_tag",
|
||||
"--config",
|
||||
"/etc/aios-gitops/autonomous-control-plane/release-actions.json"
|
||||
],
|
||||
"verify_remote_tag": [
|
||||
"/usr/bin/aios-release-hook",
|
||||
"verify_remote_tag",
|
||||
"--config",
|
||||
"/etc/aios-gitops/autonomous-control-plane/release-actions.json"
|
||||
],
|
||||
"deploy": [
|
||||
"/usr/bin/aios-release-hook",
|
||||
"deploy",
|
||||
"--config",
|
||||
"/etc/aios-gitops/autonomous-control-plane/release-actions.json"
|
||||
],
|
||||
"health_check": [
|
||||
"/usr/bin/aios-release-hook",
|
||||
"health_check",
|
||||
"--config",
|
||||
"/etc/aios-gitops/autonomous-control-plane/release-actions.json"
|
||||
],
|
||||
"rollback": [
|
||||
"/usr/bin/aios-release-hook",
|
||||
"rollback",
|
||||
"--config",
|
||||
"/etc/aios-gitops/autonomous-control-plane/release-actions.json"
|
||||
],
|
||||
"verify_previous": [
|
||||
"/usr/bin/aios-release-hook",
|
||||
"verify_previous",
|
||||
"--config",
|
||||
"/etc/aios-gitops/autonomous-control-plane/release-actions.json"
|
||||
],
|
||||
"restore": [
|
||||
"/usr/bin/aios-release-hook",
|
||||
"restore",
|
||||
"--config",
|
||||
"/etc/aios-gitops/autonomous-control-plane/release-actions.json"
|
||||
],
|
||||
"verify_restored": [
|
||||
"/usr/bin/aios-release-hook",
|
||||
"verify_restored",
|
||||
"--config",
|
||||
"/etc/aios-gitops/autonomous-control-plane/release-actions.json"
|
||||
],
|
||||
"update_registry": [
|
||||
"/usr/bin/aios-release-hook",
|
||||
"update_registry",
|
||||
"--config",
|
||||
"/etc/aios-gitops/autonomous-control-plane/release-actions.json"
|
||||
],
|
||||
"update_baseline": [
|
||||
"/usr/bin/aios-release-hook",
|
||||
"update_baseline",
|
||||
"--config",
|
||||
"/etc/aios-gitops/autonomous-control-plane/release-actions.json"
|
||||
],
|
||||
"verify_consistency": [
|
||||
"/usr/bin/aios-release-hook",
|
||||
"verify_consistency",
|
||||
"--config",
|
||||
"/etc/aios-gitops/autonomous-control-plane/release-actions.json"
|
||||
],
|
||||
"snapshot_metadata": [
|
||||
"/usr/bin/aios-release-hook",
|
||||
"snapshot_metadata",
|
||||
"--config",
|
||||
"/etc/aios-gitops/autonomous-control-plane/release-actions.json"
|
||||
],
|
||||
"restore_metadata": [
|
||||
"/usr/bin/aios-release-hook",
|
||||
"restore_metadata",
|
||||
"--config",
|
||||
"/etc/aios-gitops/autonomous-control-plane/release-actions.json"
|
||||
]
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,9 @@
|
||||
{
|
||||
"allowed_output_roots": [
|
||||
"/var/lib/aios-gitops/autonomous-control-plane/projection/releases"
|
||||
],
|
||||
"poll_seconds": 5,
|
||||
"receipts_dir": "/var/lib/aios-gitops/autonomous-control-plane/projection/receipts",
|
||||
"requests_dir": "/var/lib/aios-gitops/autonomous-control-plane/projection/requests",
|
||||
"source_git_dir": "/data/aios-gitops/runtime/gitea-bin/data/gitea-repositories/aios/aios.git"
|
||||
}
|
||||
@@ -0,0 +1,5 @@
|
||||
{
|
||||
"poll_seconds": 10,
|
||||
"receipts_dir": "/var/lib/aios-gitops/autonomous-control-plane/renewal/receipts",
|
||||
"requests_dir": "/var/lib/aios-gitops/autonomous-control-plane/renewal/requests"
|
||||
}
|
||||
@@ -0,0 +1,11 @@
|
||||
{
|
||||
"admin_credential_name": "admin_gitea_http",
|
||||
"encrypted_credential_path": "/etc/credstore.encrypted/aios-governed-development-writer.gitea_http",
|
||||
"expected_writer_username": "aios-governed-development-writer",
|
||||
"gitea_base_url": "http://127.0.0.1:3000",
|
||||
"grant_path": "/var/lib/aios-gitops/autonomous-control-plane/writer/grant.json",
|
||||
"receipt_path": "/var/lib/aios-gitops/autonomous-control-plane/writer/revocation-receipt.json",
|
||||
"revoked_grant_path": "/var/lib/aios-gitops/autonomous-control-plane/writer/grant.revoked.json",
|
||||
"writer_credential_name": "writer_gitea_http",
|
||||
"writer_unit": "aios-governed-development-writer.service"
|
||||
}
|
||||
@@ -0,0 +1,8 @@
|
||||
{
|
||||
"exact_paths": [
|
||||
"/usr/libexec/aios-autonomous-release-authorization/controller.py",
|
||||
"/usr/libexec/aios-chatgpt-action-task-router-continuous-20260726/action_task_router.py"
|
||||
],
|
||||
"output_path": "/var/lib/aios-gitops/autonomous-control-plane/projection/runtime-source-evidence.json",
|
||||
"task_id": "V2R1C4-RELEASE-COMPLETION"
|
||||
}
|
||||
@@ -0,0 +1,8 @@
|
||||
{
|
||||
"gitea_db_path": "/data/aios-gitops/runtime/gitea-bin/data/gitea.db",
|
||||
"output_dir": "/var/lib/aios-gitops/autonomous-control-plane/watcher/status",
|
||||
"owner_user_id": 2,
|
||||
"poll_seconds": 5,
|
||||
"repo_id": 1,
|
||||
"requests_dir": "/var/lib/aios-gitops/autonomous-control-plane/watcher/requests"
|
||||
}
|
||||
@@ -0,0 +1,17 @@
|
||||
{
|
||||
"socket_path": "/run/aios-gitops/autonomous-control-plane/writer.sock",
|
||||
"allowed_peer_uids": [
|
||||
0
|
||||
],
|
||||
"policy_path": "/etc/aios-gitops/autonomous-control-plane/development-policy.json",
|
||||
"grant_path": "/var/lib/aios-gitops/autonomous-control-plane/writer/grant.json",
|
||||
"grant_quota_ledger": "/var/lib/aios-gitops/autonomous-control-plane/writer/grant-quota.sqlite",
|
||||
"worktree_roots": [
|
||||
"/data/aios-gitops/worktrees"
|
||||
],
|
||||
"credential_name": "gitea_http",
|
||||
"remote": "origin",
|
||||
"operation_ledger": "/var/lib/aios-gitops/autonomous-control-plane/writer/operations.sqlite",
|
||||
"audit_path": "/var/lib/aios-gitops/autonomous-control-plane/writer/audit.jsonl",
|
||||
"max_request_bytes": 4194304
|
||||
}
|
||||
@@ -1,45 +0,0 @@
|
||||
[Unit]
|
||||
Description=AIOS V2R1C4 Unified Portal Candidate
|
||||
After=network-online.target
|
||||
Wants=network-online.target
|
||||
ConditionPathExists=/opt/aios/releases/V2R1C4/active-runtime/app/aios_web/release_application.py
|
||||
|
||||
[Service]
|
||||
Type=simple
|
||||
User=aios
|
||||
Group=aios
|
||||
WorkingDirectory=/opt/aios/releases/V2R1C4/active-runtime/app
|
||||
EnvironmentFile=/etc/aios-v2/aios-v2r1c4-candidate.env
|
||||
Environment=PYTHONUNBUFFERED=1
|
||||
Environment=PYTHONDONTWRITEBYTECODE=1
|
||||
Environment=AIOS_GITOPS_WRITES_ENABLED=false
|
||||
ExecStartPre=/usr/bin/test "$AIOS_V2_PORT" = "18921"
|
||||
ExecStartPre=/usr/bin/test "$AIOS_RELEASE_VERSION" = "V2R1C4"
|
||||
ExecStartPre=/usr/bin/test -n "$AIOS_RELEASE_SOURCE_OID"
|
||||
ExecStart=/usr/bin/python3 -m aios_web.release_application
|
||||
Restart=on-failure
|
||||
RestartSec=3
|
||||
TimeoutStartSec=60
|
||||
TimeoutStopSec=30
|
||||
KillSignal=SIGTERM
|
||||
LimitCORE=0
|
||||
NoNewPrivileges=true
|
||||
PrivateTmp=true
|
||||
ProtectSystem=strict
|
||||
ProtectHome=true
|
||||
ProtectKernelTunables=true
|
||||
ProtectKernelModules=true
|
||||
ProtectControlGroups=true
|
||||
RestrictSUIDSGID=true
|
||||
RestrictRealtime=true
|
||||
LockPersonality=true
|
||||
MemoryDenyWriteExecute=true
|
||||
ReadOnlyPaths=/opt/aios/releases/V2R1C4
|
||||
ReadWritePaths=/var/lib/aios-v2r1c4-candidate
|
||||
StateDirectory=aios-v2r1c4-candidate
|
||||
StateDirectoryMode=0750
|
||||
UMask=0027
|
||||
LimitNOFILE=65536
|
||||
|
||||
[Install]
|
||||
WantedBy=multi-user.target
|
||||
@@ -1,2 +0,0 @@
|
||||
[Service]
|
||||
LimitCORE=0
|
||||
@@ -1,45 +0,0 @@
|
||||
[Unit]
|
||||
Description=AIOS V2R1C4 Unified Portal Production
|
||||
After=network-online.target
|
||||
Wants=network-online.target
|
||||
ConditionPathExists=/opt/aios/releases/V2R1C4/active-runtime/app/aios_web/release_application.py
|
||||
|
||||
[Service]
|
||||
Type=simple
|
||||
User=aios
|
||||
Group=aios
|
||||
WorkingDirectory=/opt/aios/releases/V2R1C4/active-runtime/app
|
||||
EnvironmentFile=/etc/aios-v2/aios-v2r1c4-production.env
|
||||
Environment=PYTHONUNBUFFERED=1
|
||||
Environment=PYTHONDONTWRITEBYTECODE=1
|
||||
Environment=AIOS_GITOPS_WRITES_ENABLED=false
|
||||
ExecStartPre=/usr/bin/test "$AIOS_V2_PORT" = "18920"
|
||||
ExecStartPre=/usr/bin/test "$AIOS_RELEASE_VERSION" = "V2R1C4"
|
||||
ExecStartPre=/usr/bin/test -n "$AIOS_RELEASE_SOURCE_OID"
|
||||
ExecStart=/usr/bin/python3 -m aios_web.release_application
|
||||
Restart=on-failure
|
||||
RestartSec=3
|
||||
TimeoutStartSec=60
|
||||
TimeoutStopSec=30
|
||||
KillSignal=SIGTERM
|
||||
LimitCORE=0
|
||||
NoNewPrivileges=true
|
||||
PrivateTmp=true
|
||||
ProtectSystem=strict
|
||||
ProtectHome=true
|
||||
ProtectKernelTunables=true
|
||||
ProtectKernelModules=true
|
||||
ProtectControlGroups=true
|
||||
RestrictSUIDSGID=true
|
||||
RestrictRealtime=true
|
||||
LockPersonality=true
|
||||
MemoryDenyWriteExecute=true
|
||||
ReadOnlyPaths=/opt/aios/releases/V2R1C4
|
||||
ReadWritePaths=/var/lib/aios-v2r1c4-production
|
||||
StateDirectory=aios-v2r1c4-production
|
||||
StateDirectoryMode=0750
|
||||
UMask=0027
|
||||
LimitNOFILE=65536
|
||||
|
||||
[Install]
|
||||
WantedBy=multi-user.target
|
||||
@@ -1,12 +0,0 @@
|
||||
[Unit]
|
||||
Description=Watch natural AIOS V2R1C4 Protected Dispatch evidence
|
||||
After=openclaw-gateway-v2r1c4.service aios-v2r1c4-production.service
|
||||
|
||||
[Path]
|
||||
PathChanged=/var/lib/aios/openclaw-session-v2r1c4/agents/main/sessions
|
||||
PathChanged=/var/lib/aios/openclaw-provenance-v2r1c4/issued/.witnesses
|
||||
PathChanged=/var/lib/aios/openclaw-session-v2r1c4/tmp
|
||||
Unit=aios-v2r1c4-protected-dispatch-evidence-collector.service
|
||||
|
||||
[Install]
|
||||
WantedBy=multi-user.target
|
||||
@@ -1,53 +0,0 @@
|
||||
[Unit]
|
||||
Description=AIOS V2R1C4 natural Protected Dispatch evidence collector
|
||||
After=openclaw-gateway-v2r1c4.service aios-v2r1c4-production.service
|
||||
Wants=openclaw-gateway-v2r1c4.service aios-v2r1c4-production.service
|
||||
|
||||
[Service]
|
||||
Type=oneshot
|
||||
User=root
|
||||
Group=root
|
||||
UMask=0027
|
||||
Environment=PYTHONDONTWRITEBYTECODE=1
|
||||
EnvironmentFile=/etc/aios/v2r1c4-evidence-collector.env
|
||||
ExecStartPre=/usr/bin/sleep 3
|
||||
ExecStart=/usr/bin/python3 -B /opt/aios/releases/V2R1C4/tools/v2r1c4_protected_dispatch_collector.py --once
|
||||
TimeoutStartSec=180
|
||||
Nice=10
|
||||
LimitCORE=0
|
||||
NoNewPrivileges=yes
|
||||
PrivateNetwork=yes
|
||||
RestrictAddressFamilies=AF_UNIX
|
||||
CapabilityBoundingSet=CAP_DAC_READ_SEARCH
|
||||
AmbientCapabilities=CAP_DAC_READ_SEARCH
|
||||
ProtectSystem=strict
|
||||
ProtectHome=true
|
||||
ProtectKernelTunables=true
|
||||
ProtectKernelModules=true
|
||||
ProtectKernelLogs=true
|
||||
ProtectControlGroups=true
|
||||
ProtectClock=true
|
||||
ProtectHostname=true
|
||||
ProtectProc=invisible
|
||||
PrivateDevices=true
|
||||
LockPersonality=true
|
||||
MemoryDenyWriteExecute=true
|
||||
RestrictRealtime=true
|
||||
RestrictSUIDSGID=true
|
||||
SystemCallArchitectures=native
|
||||
ReadOnlyPaths=/opt/aios/releases/V2R1C4
|
||||
ReadOnlyPaths=/var/lib/aios/openclaw-session-v2r1c4/agents/main/sessions
|
||||
ReadOnlyPaths=/var/lib/aios/openclaw-session-v2r1c4/state
|
||||
ReadOnlyPaths=/var/lib/aios/openclaw-session-v2r1c4/openclaw-weixin
|
||||
ReadOnlyPaths=/var/lib/aios/openclaw-session-v2r1c4/openclaw.json
|
||||
ReadOnlyPaths=/var/lib/aios/openclaw-session-v2r1c4/tmp
|
||||
ReadOnlyPaths=/var/lib/aios/openclaw-provenance-v2r1c4/issued
|
||||
ReadOnlyPaths=/var/lib/aios/openclaw-provenance-v2r1c4/public
|
||||
ReadOnlyPaths=-/run/log/journal
|
||||
ReadOnlyPaths=-/var/log/journal
|
||||
ReadOnlyPaths=-/var/lib/systemd/coredump
|
||||
ReadOnlyPaths=-/var/crash
|
||||
ReadWritePaths=/var/lib/aios/openclaw-session-v2r1c4/evidence/v2r1c4-protected-dispatch-acceptance
|
||||
|
||||
[Install]
|
||||
WantedBy=multi-user.target
|
||||
@@ -1,50 +0,0 @@
|
||||
[Unit]
|
||||
Description=OpenClaw Gateway V2R1C4 isolated candidate
|
||||
After=network-online.target
|
||||
Wants=network-online.target
|
||||
ConditionPathExists=/opt/aios/releases/V2R1C4/openclaw/openclaw.mjs
|
||||
ConditionPathExists=/var/lib/aios/openclaw-session-v2r1c4/openclaw.json
|
||||
ConditionPathIsDirectory=/var/lib/aios/openclaw-session-v2r1c4/tmp
|
||||
|
||||
[Service]
|
||||
Type=simple
|
||||
EnvironmentFile=/etc/aios/openclaw-gateway-v2r1c4.env
|
||||
Environment=OPENCLAW_HOME=/var/lib/aios/openclaw-session-v2r1c4/home
|
||||
Environment=OPENCLAW_STATE_DIR=/var/lib/aios/openclaw-session-v2r1c4
|
||||
Environment=OPENCLAW_CONFIG_PATH=/var/lib/aios/openclaw-session-v2r1c4/openclaw.json
|
||||
Environment=AIOS_GITOPS_WRITES_ENABLED=false
|
||||
WorkingDirectory=/var/lib/aios/openclaw-session-v2r1c4
|
||||
ExecStart=/usr/bin/node /opt/aios/releases/V2R1C4/openclaw/openclaw.mjs gateway run --port 18790 --bind loopback --auth none --allow-unconfigured
|
||||
Restart=on-failure
|
||||
RestartSec=5
|
||||
User=aios
|
||||
Group=aios
|
||||
KillMode=control-group
|
||||
LimitCORE=0
|
||||
UMask=0027
|
||||
NoNewPrivileges=yes
|
||||
CapabilityBoundingSet=
|
||||
AmbientCapabilities=
|
||||
PrivateTmp=true
|
||||
PrivateDevices=true
|
||||
ProtectSystem=strict
|
||||
ProtectHome=true
|
||||
ProtectKernelTunables=true
|
||||
ProtectKernelModules=true
|
||||
ProtectKernelLogs=true
|
||||
ProtectControlGroups=true
|
||||
ProtectClock=true
|
||||
ProtectHostname=true
|
||||
ProtectProc=invisible
|
||||
ProcSubset=pid
|
||||
LockPersonality=true
|
||||
RestrictRealtime=true
|
||||
RestrictSUIDSGID=true
|
||||
RestrictAddressFamilies=AF_UNIX AF_INET AF_INET6
|
||||
ReadOnlyPaths=/opt/aios/releases/V2R1C4
|
||||
ReadWritePaths=/var/lib/aios/openclaw-session-v2r1c4
|
||||
ReadWritePaths=/var/lib/aios/openclaw-provenance-v2r1c4
|
||||
BindPaths=/var/lib/aios/openclaw-session-v2r1c4/tmp:/tmp/openclaw
|
||||
|
||||
[Install]
|
||||
WantedBy=multi-user.target
|
||||
@@ -1,51 +0,0 @@
|
||||
[Unit]
|
||||
Description=OpenClaw Gateway V2R1C4 with pseudonymous Weixin state
|
||||
After=network-online.target
|
||||
Wants=network-online.target
|
||||
Conflicts=openclaw-gateway.service
|
||||
ConditionPathExists=/opt/aios/releases/V2R1C4/openclaw/openclaw.mjs
|
||||
ConditionPathExists=/var/lib/aios/openclaw-session-v2r1c4/openclaw.json
|
||||
ConditionPathIsDirectory=/var/lib/aios/openclaw-session-v2r1c4/tmp
|
||||
|
||||
[Service]
|
||||
Type=simple
|
||||
EnvironmentFile=/etc/aios/openclaw-gateway-v2r1c4.env
|
||||
Environment=OPENCLAW_HOME=/var/lib/aios/openclaw-session-v2r1c4/home
|
||||
Environment=OPENCLAW_STATE_DIR=/var/lib/aios/openclaw-session-v2r1c4
|
||||
Environment=OPENCLAW_CONFIG_PATH=/var/lib/aios/openclaw-session-v2r1c4/openclaw.json
|
||||
Environment=AIOS_GITOPS_WRITES_ENABLED=false
|
||||
WorkingDirectory=/var/lib/aios/openclaw-session-v2r1c4
|
||||
ExecStart=/usr/bin/node /opt/aios/releases/V2R1C4/openclaw/openclaw.mjs gateway run --port 18789 --bind loopback --auth none --allow-unconfigured
|
||||
Restart=always
|
||||
RestartSec=5
|
||||
User=aios
|
||||
Group=aios
|
||||
KillMode=control-group
|
||||
LimitCORE=0
|
||||
UMask=0027
|
||||
NoNewPrivileges=yes
|
||||
CapabilityBoundingSet=
|
||||
AmbientCapabilities=
|
||||
PrivateTmp=true
|
||||
PrivateDevices=true
|
||||
ProtectSystem=strict
|
||||
ProtectHome=true
|
||||
ProtectKernelTunables=true
|
||||
ProtectKernelModules=true
|
||||
ProtectKernelLogs=true
|
||||
ProtectControlGroups=true
|
||||
ProtectClock=true
|
||||
ProtectHostname=true
|
||||
ProtectProc=invisible
|
||||
ProcSubset=pid
|
||||
LockPersonality=true
|
||||
RestrictRealtime=true
|
||||
RestrictSUIDSGID=true
|
||||
RestrictAddressFamilies=AF_UNIX AF_INET AF_INET6
|
||||
ReadOnlyPaths=/opt/aios/releases/V2R1C4
|
||||
ReadWritePaths=/var/lib/aios/openclaw-session-v2r1c4
|
||||
ReadWritePaths=/var/lib/aios/openclaw-provenance-v2r1c4
|
||||
BindPaths=/var/lib/aios/openclaw-session-v2r1c4/tmp:/tmp/openclaw
|
||||
|
||||
[Install]
|
||||
WantedBy=multi-user.target
|
||||
@@ -1,3 +0,0 @@
|
||||
AIOS_V2R1C4_SOURCE_OID=<40-lowercase-hex-source-oid>
|
||||
AIOS_V2R1C4_INDEX_SHA256=<64-lowercase-hex-index-sha256>
|
||||
AIOS_V2R1C4_POLICY_SHA256=<64-lowercase-hex-policy-sha256>
|
||||
@@ -1,47 +0,0 @@
|
||||
#!/bin/sh
|
||||
set -eu
|
||||
|
||||
if [ "$(id -u)" -ne 0 ]; then
|
||||
echo "install-fastlane-candidate must run as root" >&2
|
||||
exit 77
|
||||
fi
|
||||
|
||||
SCRIPT_DIR=$(CDPATH= cd -- "$(dirname -- "$0")" && pwd -P)
|
||||
REPOSITORY_ROOT=$(CDPATH= cd -- "$SCRIPT_DIR/../.." && pwd -P)
|
||||
|
||||
test -f "$REPOSITORY_ROOT/schemas/aios-fastlane-release-plan-v1.schema.json"
|
||||
test -f "$REPOSITORY_ROOT/services/aios-release-controller/aios_release_controller/cli.py"
|
||||
test -f "$REPOSITORY_ROOT/services/aios-deploy-helper/aios_deploy_helper.py"
|
||||
|
||||
if ! getent group aios-release >/dev/null 2>&1; then
|
||||
/usr/sbin/groupadd --system aios-release
|
||||
fi
|
||||
if ! getent passwd aios-release >/dev/null 2>&1; then
|
||||
/usr/sbin/useradd --system --gid aios-release --home-dir /var/lib/aios-release --shell /usr/sbin/nologin aios-release
|
||||
fi
|
||||
|
||||
/usr/bin/install -d -o root -g root -m 0700 \
|
||||
/var/lib/aios/openclaw-session-v2r1c4 \
|
||||
/var/lib/aios/openclaw-provenance-v2r1c4
|
||||
/usr/bin/install -d -o root -g root -m 0755 /etc/aios /etc/aios-v2
|
||||
|
||||
/usr/bin/install -d -o root -g root -m 0755 /usr/lib/aios-release-controller/aios_release_controller
|
||||
for source in "$REPOSITORY_ROOT"/services/aios-release-controller/aios_release_controller/*.py; do
|
||||
name=${source##*/}
|
||||
/usr/bin/install -o root -g root -m 0644 "$source" "/usr/lib/aios-release-controller/aios_release_controller/$name"
|
||||
done
|
||||
/usr/bin/install -o root -g root -m 0755 "$REPOSITORY_ROOT/deploy/fastlane/libexec/aios-release-controller" /usr/libexec/aios-release-controller
|
||||
/usr/bin/install -o root -g root -m 0755 "$REPOSITORY_ROOT/services/aios-deploy-helper/aios_deploy_helper.py" /usr/libexec/aios-deploy-helper
|
||||
|
||||
for unit in "$REPOSITORY_ROOT"/deploy/fastlane/systemd/*.service; do
|
||||
/usr/bin/install -o root -g root -m 0644 "$unit" "/etc/systemd/system/${unit##*/}"
|
||||
done
|
||||
/usr/bin/install -o root -g root -m 0644 "$REPOSITORY_ROOT/deploy/fastlane/polkit/49-aios-release-controller.rules" /etc/polkit-1/rules.d/49-aios-release-controller.rules
|
||||
/usr/bin/install -o root -g root -m 0644 "$REPOSITORY_ROOT/deploy/fastlane/tmpfiles.d/aios-release.conf" /etc/tmpfiles.d/aios-release.conf
|
||||
|
||||
/usr/bin/systemd-tmpfiles --create /etc/tmpfiles.d/aios-release.conf
|
||||
/usr/bin/systemctl daemon-reload
|
||||
|
||||
echo "candidate_install=PASS"
|
||||
echo "controller_started=false"
|
||||
echo "production_changed=false"
|
||||
@@ -1,10 +0,0 @@
|
||||
#!/usr/bin/python3
|
||||
from __future__ import annotations
|
||||
|
||||
import sys
|
||||
|
||||
sys.path.insert(0, "/usr/lib/aios-release-controller")
|
||||
|
||||
from aios_release_controller.cli import main
|
||||
|
||||
raise SystemExit(main())
|
||||
@@ -1,16 +0,0 @@
|
||||
polkit.addRule(function(action, subject) {
|
||||
if (action.id !== "org.freedesktop.systemd1.manage-units" || subject.user !== "aios-release") {
|
||||
return polkit.Result.NOT_HANDLED;
|
||||
}
|
||||
var allowed = [
|
||||
"aios-deploy-helper-health-check.service",
|
||||
"aios-deploy-helper-install-candidate.service",
|
||||
"aios-deploy-helper-promote.service",
|
||||
"aios-deploy-helper-rollback.service",
|
||||
"aios-deploy-helper-verify.service"
|
||||
];
|
||||
if (action.lookup("verb") === "start" && allowed.indexOf(action.lookup("unit")) !== -1) {
|
||||
return polkit.Result.YES;
|
||||
}
|
||||
return polkit.Result.NOT_HANDLED;
|
||||
});
|
||||
@@ -1,33 +0,0 @@
|
||||
[Unit]
|
||||
Description=AIOS V2R1C4 candidate health check
|
||||
After=aios-v2r1c4-candidate.service
|
||||
|
||||
[Service]
|
||||
Type=oneshot
|
||||
User=root
|
||||
UMask=0077
|
||||
LoadCredential=release-plan:/var/lib/aios-release/release-plan.json
|
||||
LoadCredential=release-plan.sig:/var/lib/aios-release/release-plan.sig
|
||||
LoadCredential=kms-public-key.der:/var/lib/aios-release/kms-public-key.der
|
||||
LoadCredential=kms-binding:/var/lib/aios-release/kms-binding.json
|
||||
ExecStart=/usr/libexec/aios-deploy-helper health-check
|
||||
NoNewPrivileges=true
|
||||
PrivateTmp=true
|
||||
PrivateDevices=true
|
||||
ProtectSystem=strict
|
||||
ProtectHome=true
|
||||
ProtectKernelTunables=true
|
||||
ProtectKernelModules=true
|
||||
ProtectKernelLogs=true
|
||||
ProtectControlGroups=true
|
||||
ProtectClock=true
|
||||
ProtectHostname=true
|
||||
LockPersonality=true
|
||||
RestrictSUIDSGID=true
|
||||
RestrictRealtime=true
|
||||
MemoryDenyWriteExecute=true
|
||||
RestrictAddressFamilies=AF_UNIX AF_INET AF_INET6
|
||||
CapabilityBoundingSet=
|
||||
AmbientCapabilities=
|
||||
ReadOnlyPaths=/usr/libexec/aios-deploy-helper
|
||||
ReadWritePaths=/var/lib/aios-release
|
||||
@@ -1,42 +0,0 @@
|
||||
[Unit]
|
||||
Description=AIOS V2R1C4 install isolated candidate
|
||||
ConditionPathExists=/var/lib/aios-release/release-plan.json
|
||||
|
||||
[Service]
|
||||
Type=oneshot
|
||||
User=root
|
||||
UMask=0077
|
||||
LoadCredential=release-plan:/var/lib/aios-release/release-plan.json
|
||||
LoadCredential=release-plan.sig:/var/lib/aios-release/release-plan.sig
|
||||
LoadCredential=kms-public-key.der:/var/lib/aios-release/kms-public-key.der
|
||||
LoadCredential=kms-binding:/var/lib/aios-release/kms-binding.json
|
||||
ExecStart=/usr/libexec/aios-deploy-helper install-candidate
|
||||
NoNewPrivileges=true
|
||||
PrivateTmp=true
|
||||
PrivateDevices=true
|
||||
ProtectSystem=strict
|
||||
ProtectHome=true
|
||||
ProtectKernelTunables=true
|
||||
ProtectKernelModules=true
|
||||
ProtectKernelLogs=true
|
||||
ProtectControlGroups=true
|
||||
ProtectClock=true
|
||||
ProtectHostname=true
|
||||
LockPersonality=true
|
||||
RestrictSUIDSGID=true
|
||||
RestrictRealtime=true
|
||||
MemoryDenyWriteExecute=true
|
||||
RestrictAddressFamilies=AF_UNIX
|
||||
CapabilityBoundingSet=
|
||||
AmbientCapabilities=
|
||||
ReadOnlyPaths=/usr/libexec/aios-deploy-helper
|
||||
ReadOnlyPaths=/var/lib/aios-release/artifacts
|
||||
ReadOnlyPaths=/var/lib/aios/openclaw-session
|
||||
ReadOnlyPaths=/var/lib/aios/openclaw-provenance
|
||||
ReadWritePaths=/opt/aios/releases
|
||||
ReadWritePaths=/etc/systemd/system
|
||||
ReadWritePaths=/etc/aios-v2
|
||||
ReadWritePaths=/etc/aios
|
||||
ReadWritePaths=/var/lib/aios-release
|
||||
ReadWritePaths=/var/lib/aios/openclaw-session-v2r1c4
|
||||
ReadWritePaths=/var/lib/aios/openclaw-provenance-v2r1c4
|
||||
@@ -1,34 +0,0 @@
|
||||
[Unit]
|
||||
Description=AIOS V2R1C4 promote candidate to production
|
||||
After=aios-v2r1c4-candidate.service
|
||||
|
||||
[Service]
|
||||
Type=oneshot
|
||||
User=root
|
||||
UMask=0077
|
||||
LoadCredential=release-plan:/var/lib/aios-release/release-plan.json
|
||||
LoadCredential=release-plan.sig:/var/lib/aios-release/release-plan.sig
|
||||
LoadCredential=kms-public-key.der:/var/lib/aios-release/kms-public-key.der
|
||||
LoadCredential=kms-binding:/var/lib/aios-release/kms-binding.json
|
||||
ExecStart=/usr/libexec/aios-deploy-helper promote
|
||||
NoNewPrivileges=true
|
||||
PrivateTmp=true
|
||||
PrivateDevices=true
|
||||
ProtectSystem=strict
|
||||
ProtectHome=true
|
||||
ProtectKernelTunables=true
|
||||
ProtectKernelModules=true
|
||||
ProtectKernelLogs=true
|
||||
ProtectControlGroups=true
|
||||
ProtectClock=true
|
||||
ProtectHostname=true
|
||||
LockPersonality=true
|
||||
RestrictSUIDSGID=true
|
||||
RestrictRealtime=true
|
||||
MemoryDenyWriteExecute=true
|
||||
RestrictAddressFamilies=AF_UNIX AF_INET AF_INET6
|
||||
CapabilityBoundingSet=
|
||||
AmbientCapabilities=
|
||||
ReadOnlyPaths=/usr/libexec/aios-deploy-helper
|
||||
ReadWritePaths=/etc/systemd/system
|
||||
ReadWritePaths=/var/lib/aios-release
|
||||
@@ -1,32 +0,0 @@
|
||||
[Unit]
|
||||
Description=AIOS V2R1C4 rollback to frozen V2R1C3
|
||||
|
||||
[Service]
|
||||
Type=oneshot
|
||||
User=root
|
||||
UMask=0077
|
||||
LoadCredential=release-plan:/var/lib/aios-release/release-plan.json
|
||||
LoadCredential=release-plan.sig:/var/lib/aios-release/release-plan.sig
|
||||
LoadCredential=kms-public-key.der:/var/lib/aios-release/kms-public-key.der
|
||||
LoadCredential=kms-binding:/var/lib/aios-release/kms-binding.json
|
||||
ExecStart=/usr/libexec/aios-deploy-helper rollback
|
||||
NoNewPrivileges=true
|
||||
PrivateTmp=true
|
||||
PrivateDevices=true
|
||||
ProtectSystem=strict
|
||||
ProtectHome=true
|
||||
ProtectKernelTunables=true
|
||||
ProtectKernelModules=true
|
||||
ProtectKernelLogs=true
|
||||
ProtectControlGroups=true
|
||||
ProtectClock=true
|
||||
ProtectHostname=true
|
||||
LockPersonality=true
|
||||
RestrictSUIDSGID=true
|
||||
RestrictRealtime=true
|
||||
MemoryDenyWriteExecute=true
|
||||
RestrictAddressFamilies=AF_UNIX AF_INET AF_INET6
|
||||
CapabilityBoundingSet=
|
||||
AmbientCapabilities=
|
||||
ReadOnlyPaths=/usr/libexec/aios-deploy-helper
|
||||
ReadWritePaths=/var/lib/aios-release
|
||||
@@ -1,32 +0,0 @@
|
||||
[Unit]
|
||||
Description=AIOS V2R1C4 verify active production target
|
||||
|
||||
[Service]
|
||||
Type=oneshot
|
||||
User=root
|
||||
UMask=0077
|
||||
LoadCredential=release-plan:/var/lib/aios-release/release-plan.json
|
||||
LoadCredential=release-plan.sig:/var/lib/aios-release/release-plan.sig
|
||||
LoadCredential=kms-public-key.der:/var/lib/aios-release/kms-public-key.der
|
||||
LoadCredential=kms-binding:/var/lib/aios-release/kms-binding.json
|
||||
ExecStart=/usr/libexec/aios-deploy-helper verify
|
||||
NoNewPrivileges=true
|
||||
PrivateTmp=true
|
||||
PrivateDevices=true
|
||||
ProtectSystem=strict
|
||||
ProtectHome=true
|
||||
ProtectKernelTunables=true
|
||||
ProtectKernelModules=true
|
||||
ProtectKernelLogs=true
|
||||
ProtectControlGroups=true
|
||||
ProtectClock=true
|
||||
ProtectHostname=true
|
||||
LockPersonality=true
|
||||
RestrictSUIDSGID=true
|
||||
RestrictRealtime=true
|
||||
MemoryDenyWriteExecute=true
|
||||
RestrictAddressFamilies=AF_UNIX AF_INET AF_INET6
|
||||
CapabilityBoundingSet=
|
||||
AmbientCapabilities=
|
||||
ReadOnlyPaths=/usr/libexec/aios-deploy-helper
|
||||
ReadWritePaths=/var/lib/aios-release
|
||||
@@ -1,45 +0,0 @@
|
||||
[Unit]
|
||||
Description=AIOS V2R1C4 Fastlane Release Controller
|
||||
After=network-online.target
|
||||
Wants=network-online.target
|
||||
ConditionPathExists=/var/lib/aios-release/release-plan.json
|
||||
|
||||
[Service]
|
||||
Type=oneshot
|
||||
User=aios-release
|
||||
Group=aios-release
|
||||
SupplementaryGroups=gitops
|
||||
UMask=0077
|
||||
StateDirectory=aios-release
|
||||
StateDirectoryMode=0700
|
||||
LoadCredentialEncrypted=gitea-task-token:/etc/credstore.encrypted/aios-v2r1c4-gitea-task-token
|
||||
LoadCredentialEncrypted=aws-workload-identity-reference:/etc/credstore.encrypted/aios-v2r1c4-aws-workload-identity-reference
|
||||
LoadCredential=release-plan:/var/lib/aios-release/release-plan.json
|
||||
LoadCredential=release-plan.sha256:/var/lib/aios-release/release-plan.sha256
|
||||
LoadCredential=kms-binding:/var/lib/aios-release/kms-binding.json
|
||||
ExecStart=/usr/libexec/aios-release-controller run
|
||||
NoNewPrivileges=true
|
||||
PrivateTmp=true
|
||||
PrivateDevices=true
|
||||
ProtectSystem=strict
|
||||
ProtectHome=true
|
||||
ProtectKernelTunables=true
|
||||
ProtectKernelModules=true
|
||||
ProtectKernelLogs=true
|
||||
ProtectControlGroups=true
|
||||
ProtectClock=true
|
||||
ProtectHostname=true
|
||||
ProtectProc=invisible
|
||||
ProcSubset=pid
|
||||
LockPersonality=true
|
||||
RestrictSUIDSGID=true
|
||||
RestrictRealtime=true
|
||||
MemoryDenyWriteExecute=true
|
||||
RestrictAddressFamilies=AF_UNIX AF_INET AF_INET6
|
||||
CapabilityBoundingSet=
|
||||
AmbientCapabilities=
|
||||
ReadWritePaths=/data/aios-gitops/repo.git
|
||||
ReadOnlyPaths=/data/aios-gitops/runtime/gitea-bin/data/repositories/aios/aios.git
|
||||
ReadOnlyPaths=/usr/libexec/aios-release-controller
|
||||
ReadWritePaths=/var/lib/aios-release
|
||||
SystemCallArchitectures=native
|
||||
@@ -1,4 +0,0 @@
|
||||
d /var/lib/aios-release 0700 aios-release aios-release -
|
||||
d /var/lib/aios-release/receipts 0700 root root -
|
||||
d /var/lib/aios-release/artifacts 0750 root aios-release -
|
||||
d /opt/aios/releases 0755 root root -
|
||||
@@ -1,71 +0,0 @@
|
||||
#!/usr/bin/env bash
|
||||
set -Eeuo pipefail
|
||||
|
||||
umask 022
|
||||
|
||||
INSTALL_ROOT="${AIOS_INSTALL_ROOT:-/}"
|
||||
SOURCE_ROOT="${1:-$(cd "$(dirname "${BASH_SOURCE[0]}")/../.." && pwd)}"
|
||||
PYTHON_BIN="${AIOS_PYTHON_BIN:-/usr/bin/python3}"
|
||||
|
||||
[[ "$INSTALL_ROOT" = /* ]] || {
|
||||
echo "AIOS_INSTALL_ROOT must be absolute" >&2
|
||||
exit 2
|
||||
}
|
||||
[[ -x "$PYTHON_BIN" ]] || {
|
||||
echo "python executable unavailable: $PYTHON_BIN" >&2
|
||||
exit 2
|
||||
}
|
||||
|
||||
packages=(
|
||||
"$SOURCE_ROOT/services/aios-autonomous-control-plane"
|
||||
"$SOURCE_ROOT/services/aios-autonomous-release-candidate"
|
||||
"$SOURCE_ROOT/services/aios-single-owner-governance"
|
||||
)
|
||||
for package in "${packages[@]}"; do
|
||||
[[ -f "$package/pyproject.toml" ]] || {
|
||||
echo "package missing: $package" >&2
|
||||
exit 2
|
||||
}
|
||||
done
|
||||
|
||||
"$PYTHON_BIN" -m pip install \
|
||||
--disable-pip-version-check \
|
||||
--no-input \
|
||||
--no-deps \
|
||||
--no-build-isolation \
|
||||
--root "$INSTALL_ROOT" \
|
||||
--prefix /usr \
|
||||
"${packages[@]}"
|
||||
|
||||
generated_bin="$INSTALL_ROOT/usr/local/bin"
|
||||
target_bin="$INSTALL_ROOT/usr/bin"
|
||||
install -d -m 0755 "$target_bin"
|
||||
|
||||
entrypoints=(
|
||||
aios-autonomous-control-plane
|
||||
aios-autonomous-release
|
||||
aios-autonomous-release-service
|
||||
aios-autonomous-renewal-controller
|
||||
aios-development-writer-revoker
|
||||
aios-development-writer-server
|
||||
aios-governance-approval-watcher
|
||||
aios-governance-mirror-worker
|
||||
aios-governance-request-publisher
|
||||
aios-release-hook
|
||||
aios-release-object-projector
|
||||
aios-runtime-source-projector
|
||||
aios-single-owner-governance
|
||||
aios-v2r1c4-release-executor
|
||||
)
|
||||
|
||||
for entrypoint in "${entrypoints[@]}"; do
|
||||
source_path="$generated_bin/$entrypoint"
|
||||
[[ -x "$source_path" ]] || {
|
||||
echo "generated entrypoint missing: $source_path" >&2
|
||||
exit 3
|
||||
}
|
||||
install -m 0755 "$source_path" "$target_bin/$entrypoint"
|
||||
done
|
||||
|
||||
echo "AIOS_GOVERNANCE_ENTRYPOINTS_INSTALLED=${#entrypoints[@]}"
|
||||
echo "AIOS_GOVERNANCE_INSTALL_ROOT=$INSTALL_ROOT"
|
||||
@@ -1 +0,0 @@
|
||||
{"checks": {"72h_acceptance_gate": true, "approle_implemented": true, "approle_secret_not_persisted_in_hcl": true, "approle_secret_survives_isolated_restore": true, "audit_implemented": true, "autonomy_tls_readers_use_ca_only_bind": true, "backup_implemented": true, "backup_restore_share_without_openbao_private_key_group": true, "branch_protection_gate_not_bypassable": true, "charter_store_sign_verify": true, "continuous_optimization_implemented": true, "controller_uses_charter_only_bind": true, "declarative_self_initialization": true, "embedded_shell_syntax": true, "exact_checksum_duplicate_rejected": true, "exact_checksum_good_fixture": true, "exact_checksum_missing_rejected": true, "fault_injection_does_not_require_service_it_kills": true, "fault_injection_failure_phase_evidence": true, "fault_injection_implemented": true, "fault_injection_missing_seal_reaches_static_seal_validation": true, "fault_injection_systemd_sandbox": true, "gitea_1_22_6_rejected": true, "gitea_1_23_0_accepted": true, "gitea_1_27_nonempty_tag_allowlist": true, "gitea_probe_traversal_and_cleanup": true, "gitea_tag_api_version_gate": true, "isolated_restore_implemented": true, "isolated_restore_uses_private_ephemeral_audit_sink": true, "kv_v2_implemented": true, "machine_credential_persisted": true, "masked_systemd_units_do_not_change_dev_null": true, "no_git_force_push": true, "no_git_tag_mutation": true, "openbao_2_6_heredoc_compatible": true, "openbao_2_6_runtime_verifier": true, "openbao_config_memfd_injection": true, "openbao_ready_gate_not_bypassable": true, "outer_bash_syntax": true, "policy_implemented": true, "ready_not_predeclared": true, "restored_approle_login_has_bounded_readiness_retry": true, "root_token_not_persisted": true, "runtime_state_directory_remains_writable": true, "self_contained_no_sibling_preflight": true, "self_init_marker_bound_to_raft_lifecycle": true, "self_init_secret_removal_implemented": true, "systemd_credentials_mandatory": true, "systemd_runtime_directories": true, "tag_protection_gate_implemented": true, "transit_charter_key_implemented": true, "transit_runtime_key_implemented": true}, "passed": 52, "runtime_claims": false, "schema": "AIOS_OPENBAO_BOOTSTRAP_STATIC_SELF_TEST_V3", "scope": "static_and_fixture_only", "script_sha256": "f687e17b1806e4f4265013b85e2cc3b4472f508720856fc8374607e7d20dbcc6", "total": 52}
|
||||
File diff suppressed because it is too large
Load Diff
@@ -1 +0,0 @@
|
||||
f687e17b1806e4f4265013b85e2cc3b4472f508720856fc8374607e7d20dbcc6 admin-bootstrap-openbao-autonomy-v1-v3.sh
|
||||
@@ -1,4 +0,0 @@
|
||||
6bd0d51fbdd1c90df2f6ea8c667edecfaf892aaf76744c41757979407af0d424 admin-bootstrap-openbao-autonomy-v1-v3.self-test.json
|
||||
f687e17b1806e4f4265013b85e2cc3b4472f508720856fc8374607e7d20dbcc6 admin-bootstrap-openbao-autonomy-v1-v3.sh
|
||||
b7aa70280a417cebaa0363380024dc378714267de5d2eeb681b16a4f610a6ce5 admin-bootstrap-openbao-autonomy-v1-v3.sha256
|
||||
c355df01c83c2801ae3a0df43806c562ee70f97c9aa558e3f67dd097efa5ac99 test-admin-bootstrap-openbao-autonomy-v1-v3.sh
|
||||
@@ -1,39 +0,0 @@
|
||||
#!/usr/bin/env bash
|
||||
set -Eeuo pipefail
|
||||
umask 077
|
||||
|
||||
script="${1:-$(CDPATH= cd -- "$(dirname -- "${BASH_SOURCE[0]}")" && pwd -P)/admin-bootstrap-openbao-autonomy-v1-v3.sh}"
|
||||
report="${2:-$(CDPATH= cd -- "$(dirname -- "${BASH_SOURCE[0]}")" && pwd -P)/admin-bootstrap-openbao-autonomy-v1-v3.self-test.json}"
|
||||
|
||||
[[ -f "$script" ]] || {
|
||||
printf 'missing script: %s\n' "$script" >&2
|
||||
exit 66
|
||||
}
|
||||
|
||||
bash -n "$script"
|
||||
tmp="$(mktemp)"
|
||||
trap 'rm -f "$tmp"' EXIT
|
||||
bash "$script" --self-test >"$tmp"
|
||||
|
||||
python3 - "$script" "$tmp" <<'PY'
|
||||
import hashlib
|
||||
import json
|
||||
import pathlib
|
||||
import sys
|
||||
|
||||
script, report = map(pathlib.Path, sys.argv[1:])
|
||||
data = json.loads(report.read_text())
|
||||
actual_hash = hashlib.sha256(script.read_bytes()).hexdigest()
|
||||
|
||||
assert data["schema"] == "AIOS_OPENBAO_BOOTSTRAP_STATIC_SELF_TEST_V3"
|
||||
assert data["scope"] == "static_and_fixture_only"
|
||||
assert data["runtime_claims"] is False
|
||||
assert data["script_sha256"] == actual_hash
|
||||
assert data["passed"] == data["total"]
|
||||
assert all(data["checks"].values())
|
||||
PY
|
||||
|
||||
install -m 0600 "$tmp" "$report"
|
||||
printf 'PASS bash-n + embedded static/fixture tests\n'
|
||||
printf 'report=%s\n' "$report"
|
||||
sha256sum "$script"
|
||||
@@ -0,0 +1,71 @@
|
||||
# AIOS Autonomous Release Agent Deployment Instructions
|
||||
|
||||
## Objective
|
||||
|
||||
Deploy only candidate/shadow environments first. Production activation requires a separate owner release approval.
|
||||
|
||||
## Agent execution order
|
||||
|
||||
1. Verify git references:
|
||||
- local
|
||||
- authoritative bare
|
||||
- remote
|
||||
- Gitea API
|
||||
|
||||
2. Build candidate artifact.
|
||||
|
||||
3. Run:
|
||||
- unit tests
|
||||
- security scans
|
||||
- secret scans
|
||||
- artifact verification
|
||||
|
||||
4. Start candidate workers:
|
||||
- OpenClaw native adapter
|
||||
- Codex native adapter
|
||||
- dedicated writer
|
||||
|
||||
5. Execute shadow task:
|
||||
|
||||
```
|
||||
TaskPlan
|
||||
-> Planner
|
||||
-> Worker Router
|
||||
-> Session lifecycle
|
||||
-> Evidence chain
|
||||
-> Artifact verification
|
||||
-> ReleasePlan
|
||||
```
|
||||
|
||||
## Hard restrictions
|
||||
|
||||
Never:
|
||||
|
||||
- write main directly
|
||||
- force push
|
||||
- rewrite tags
|
||||
- export secrets
|
||||
- bypass owner approval
|
||||
- modify production flags during candidate validation
|
||||
|
||||
## Production release gate
|
||||
|
||||
Require:
|
||||
|
||||
```
|
||||
owner_approval=true
|
||||
artifact_verified=true
|
||||
evidence_closure=true
|
||||
rollback_ready=true
|
||||
remote_tag_verified=true
|
||||
baseline_verified=true
|
||||
registry_verified=true
|
||||
```
|
||||
|
||||
Until then keep:
|
||||
|
||||
```
|
||||
AIOS_GITOPS_WRITES_ENABLED=false
|
||||
AIOS_TASK_PLANE_EXECUTION_ENABLED=false
|
||||
AIOS_SILENT_RELEASE_EXECUTION_ENABLED=false
|
||||
```
|
||||
@@ -0,0 +1,133 @@
|
||||
# AIOS V2R1C4 Dormant Shadow-Only Release Execution
|
||||
|
||||
## Purpose
|
||||
|
||||
Deploy verified V2R1C4 code while keeping autonomous execution capabilities disabled.
|
||||
|
||||
This release separates code deployment from capability activation. Capability activation requires a later, independently approved release.
|
||||
|
||||
## Deployment mode
|
||||
|
||||
```text
|
||||
deployment_mode=dormant_shadow_only
|
||||
```
|
||||
|
||||
Required production flags:
|
||||
|
||||
```text
|
||||
AIOS_GITOPS_WRITES_ENABLED=false
|
||||
AIOS_TASK_PLANE_EXECUTION_ENABLED=false
|
||||
AIOS_SILENT_RELEASE_EXECUTION_ENABLED=false
|
||||
```
|
||||
|
||||
Required dispatch transport:
|
||||
|
||||
```text
|
||||
protectedDispatchTransport=sandbox
|
||||
```
|
||||
|
||||
Disabled capabilities:
|
||||
|
||||
```text
|
||||
native_openclaw_enabled=false
|
||||
native_codex_enabled=false
|
||||
automatic_release_enabled=false
|
||||
production_side_effects=false
|
||||
activation_deferred=true
|
||||
```
|
||||
|
||||
## Release flow
|
||||
|
||||
```text
|
||||
Integration verification
|
||||
|
|
||||
v
|
||||
Owner dormant release approval
|
||||
|
|
||||
v
|
||||
Merge PR
|
||||
|
|
||||
v
|
||||
Read final main merge OID
|
||||
|
|
||||
v
|
||||
Rebuild production artifact
|
||||
|
|
||||
v
|
||||
Deploy dormant runtime
|
||||
|
|
||||
v
|
||||
Create V2R1C4 tag
|
||||
|
|
||||
v
|
||||
Verify Registry and Baseline consistency
|
||||
```
|
||||
|
||||
## Two-stage approval model
|
||||
|
||||
### Pre-merge approval
|
||||
|
||||
The pre-merge approval binds:
|
||||
|
||||
- version
|
||||
- PR number
|
||||
- integration OID and tree OID
|
||||
- candidate artifact and evidence hashes
|
||||
- deployment mode
|
||||
- all production execution flags remaining false
|
||||
|
||||
It authorizes the governed merge and production artifact rebuild. It does not predeclare the final production target OID.
|
||||
|
||||
### Final release approval
|
||||
|
||||
After the governed merge, the final approval binds:
|
||||
|
||||
- final main merge OID
|
||||
- final main tree OID
|
||||
- production artifact, manifest, package closure, and evidence closure
|
||||
- rollback artifact and production configuration hashes
|
||||
- V2R1C4 tag target
|
||||
|
||||
The integration OID must never be used as the final production target OID.
|
||||
|
||||
## Deferred activation
|
||||
|
||||
The following are separate activation gates and must not block dormant code deployment:
|
||||
|
||||
- OpenClaw native session provider
|
||||
- Codex app-server provider
|
||||
- Gitea Admin API automation
|
||||
- Secret Manager V2
|
||||
- autonomous production execution
|
||||
|
||||
They require a later activation release with separate evidence and approval.
|
||||
|
||||
## Hard restrictions
|
||||
|
||||
Never:
|
||||
|
||||
- write main directly
|
||||
- force push
|
||||
- rewrite tags
|
||||
- export secrets
|
||||
- enable autonomous production execution without approval
|
||||
- treat integration OID as production target OID
|
||||
- update Registry or Baseline before remote and Gitea tag verification
|
||||
|
||||
## Dormant production acceptance
|
||||
|
||||
A dormant deployment is acceptable only when:
|
||||
|
||||
```text
|
||||
deployment_mode=dormant_shadow_only
|
||||
production_side_effects=false
|
||||
protectedDispatchTransport=sandbox
|
||||
native_openclaw_enabled=false
|
||||
native_codex_enabled=false
|
||||
automatic_release_enabled=false
|
||||
AIOS_GITOPS_WRITES_ENABLED=false
|
||||
AIOS_TASK_PLANE_EXECUTION_ENABLED=false
|
||||
AIOS_SILENT_RELEASE_EXECUTION_ENABLED=false
|
||||
```
|
||||
|
||||
The release report must preserve deferred activation blockers rather than falsely marking native-agent or automatic-release capabilities as enabled.
|
||||
@@ -0,0 +1,35 @@
|
||||
{
|
||||
"execution_renewal_manifest_blob_oid": "417f78abb3d795f7b0c04a0894069bd166bb15df",
|
||||
"execution_renewal_manifest_sha256": "069091eff9c7c46bceccde365da6d07a8538e76bee9e288a57211f3114b94ab3",
|
||||
"execution_renewal_merge_oid": "3a22c3c7d86930efd4bd93ac05d80ad322050cb9",
|
||||
"observed_at": "2026-07-28T09:09:27.841968Z",
|
||||
"runtime_source_evidence_sha256": "23f03d9c6abe6f11e1acda5210b8708696e3b77caa0083b6bfaef30a44b2a35f",
|
||||
"runtime_source_observed_at": "2026-07-28T05:53:01.253909Z",
|
||||
"schema": "aios.integration-refresh-source-map/v1",
|
||||
"source_mapping_approval_merge_oid": "9514062cf33e45941abe4a8c98377e0713b0b3f6",
|
||||
"source_mapping_manifest_blob_oid": "00c5e90e529cb98c7750a5761b0a0d6ccf507174",
|
||||
"source_mapping_manifest_sha256": "17af8ebc43673c0e46bb9ab1bf44497e8c147f1b4a9d7a8a404edd5c0abd6f21",
|
||||
"sources": [
|
||||
{
|
||||
"byte_for_byte_equal": true,
|
||||
"canonical_blob_oid": "9c68be36e0b6a18260e3099e3d7b0dcab6d814aa",
|
||||
"canonical_commit_oid": "85426f4f570e4d40b212318d47e52e4aed5cb06a",
|
||||
"canonical_git_path": "active-runtime/app/aios_autonomous_release_authorization/controller.py",
|
||||
"canonical_tree_oid": "cdbd9bb845b18d4b5224d91aace2656a51eb7c14",
|
||||
"runtime_blob_oid": "9c68be36e0b6a18260e3099e3d7b0dcab6d814aa",
|
||||
"runtime_path": "/usr/libexec/aios-autonomous-release-authorization/controller.py",
|
||||
"runtime_sha256": "39b532c3058c4ae49ed691d7c66c3b7745a25111fa61039f388c8335fd262c50"
|
||||
},
|
||||
{
|
||||
"byte_for_byte_equal": true,
|
||||
"canonical_blob_oid": "ee0595ca61a0598f8cb3dc10865a255e21679b2a",
|
||||
"canonical_commit_oid": "85426f4f570e4d40b212318d47e52e4aed5cb06a",
|
||||
"canonical_git_path": "active-runtime/app/aios_chatgpt_action_task_router/action_task_router.py",
|
||||
"canonical_tree_oid": "cdbd9bb845b18d4b5224d91aace2656a51eb7c14",
|
||||
"runtime_blob_oid": "ee0595ca61a0598f8cb3dc10865a255e21679b2a",
|
||||
"runtime_path": "/usr/libexec/aios-chatgpt-action-task-router-continuous-20260726/action_task_router.py",
|
||||
"runtime_sha256": "738fb7035a6b792115d6467b4d1e4ffd47a8c5d5646f7032ebc68ea587cbd554"
|
||||
}
|
||||
],
|
||||
"task_id": "AIOS-INTEGRATION-REFRESH-PROVISIONER-IMPLEMENTATION-20260726"
|
||||
}
|
||||
@@ -0,0 +1,414 @@
|
||||
# AIOS V2R1C4 Dormant Release — Final Agent Execution Contract
|
||||
|
||||
## 1. Purpose
|
||||
|
||||
This document is the machine/operator execution contract for completing the governed V2R1C4 dormant release after Candidate development is frozen.
|
||||
|
||||
It does not grant production authority. Every consequential action remains subject to the exact approval, Git reference, artifact, tag, Registry and Baseline gates defined below.
|
||||
|
||||
## 2. Release mode
|
||||
|
||||
The only permitted deployment mode for V2R1C4 is:
|
||||
|
||||
```text
|
||||
deployment_mode=dormant_shadow_only
|
||||
```
|
||||
|
||||
The following values are mandatory before, during and after deployment:
|
||||
|
||||
```text
|
||||
AIOS_GITOPS_WRITES_ENABLED=false
|
||||
AIOS_TASK_PLANE_EXECUTION_ENABLED=false
|
||||
AIOS_SILENT_RELEASE_EXECUTION_ENABLED=false
|
||||
AIOS_PRODUCTION_DEPLOYMENT_ENABLED=false
|
||||
production_side_effects=false
|
||||
native_openclaw_enabled=false
|
||||
native_codex_enabled=false
|
||||
automatic_release_enabled=false
|
||||
activation_deferred=true
|
||||
protectedDispatchTransport=sandbox
|
||||
```
|
||||
|
||||
Any deviation is a hard stop.
|
||||
|
||||
## 3. Authoritative branches
|
||||
|
||||
```text
|
||||
candidate_branch=patch/chatgpt-autonomous-completion-contract-20260726
|
||||
integration_branch=integration/chatgpt-autonomous-completion-20260726
|
||||
production_branch=main
|
||||
version=V2R1C4
|
||||
pull_request=20
|
||||
```
|
||||
|
||||
Never infer a target OID from workspace HEAD. Always read and record full 40-character OIDs.
|
||||
|
||||
## 4. Phase A — Candidate freeze and verification
|
||||
|
||||
1. Read the current Candidate OID and tree OID.
|
||||
2. Verify the Candidate worktree is clean.
|
||||
3. Verify four-way Candidate reference closure:
|
||||
- local branch ref;
|
||||
- authoritative bare ref;
|
||||
- `git ls-remote` ref;
|
||||
- Gitea API branch ref.
|
||||
4. Run the complete test and static validation suite defined in `V2R1C4_TEST_AND_RELEASE_CHECKLIST.md`.
|
||||
5. Build the deterministic Candidate artifact and manifest from the exact Candidate OID.
|
||||
6. Record:
|
||||
- artifact SHA-256;
|
||||
- manifest SHA-256;
|
||||
- package closure SHA-256;
|
||||
- test evidence SHA-256;
|
||||
- rollback artifact SHA-256;
|
||||
- production configuration SHA-256.
|
||||
7. Do not reuse any digest generated from an older Candidate OID.
|
||||
|
||||
Failure state:
|
||||
|
||||
```text
|
||||
CANDIDATE_ACCEPTANCE_BLOCKED
|
||||
```
|
||||
|
||||
## 5. Phase B — Integration refresh
|
||||
|
||||
1. Refresh the Integration branch from the latest Candidate using a governed non-fast-forward merge.
|
||||
2. Use:
|
||||
|
||||
```text
|
||||
merge --no-ff
|
||||
```
|
||||
|
||||
3. Do not squash, rebase, force push or rewrite Candidate history.
|
||||
4. Verify the Candidate OID is reachable from the new Integration OID.
|
||||
5. Verify four-way Integration reference closure.
|
||||
6. Run the full Candidate test suite again from the Integration worktree.
|
||||
7. Rebuild Integration evidence and Candidate package metadata if any tracked file changed during the merge.
|
||||
|
||||
Failure state:
|
||||
|
||||
```text
|
||||
INTEGRATION_ACCEPTANCE_BLOCKED
|
||||
```
|
||||
|
||||
## 6. Phase C — Candidate acceptance
|
||||
|
||||
Create Candidate acceptance evidence and execute:
|
||||
|
||||
```text
|
||||
python scripts/autonomous-release/run_acceptance.py \
|
||||
--phase candidate \
|
||||
--input <candidate-evidence.json> \
|
||||
--output <candidate-acceptance.json>
|
||||
```
|
||||
|
||||
The result must contain:
|
||||
|
||||
```text
|
||||
phase=candidate
|
||||
status=READY
|
||||
production_action_authorized=false
|
||||
```
|
||||
|
||||
The Candidate gate must verify:
|
||||
|
||||
```text
|
||||
candidate_four_way_ref_closure=true
|
||||
integration_four_way_ref_closure=true
|
||||
candidate_reachable_from_integration=true
|
||||
worktree_clean=true
|
||||
tests_failed=0
|
||||
tests_passed>0
|
||||
```
|
||||
|
||||
It must also verify all dormant runtime flags remain disabled.
|
||||
|
||||
`READY` authorizes review only. It does not authorize merge, deployment, tagging, Registry writes or Baseline writes.
|
||||
|
||||
## 7. Phase D — Pre-merge owner approval
|
||||
|
||||
Obtain a governed Owner approval plan for the exact Integration package.
|
||||
|
||||
The approval subject must bind at least:
|
||||
|
||||
```text
|
||||
version
|
||||
pull_request
|
||||
candidate_oid
|
||||
candidate_tree_oid
|
||||
integration_oid
|
||||
integration_tree_oid
|
||||
candidate_acceptance_digest
|
||||
candidate_release_digest
|
||||
artifact_sha256
|
||||
manifest_sha256
|
||||
package_closure_sha256
|
||||
evidence_closure_oid
|
||||
rollback_artifact_sha256
|
||||
production_config_sha256
|
||||
deployment_mode=dormant_shadow_only
|
||||
all execution flags=false
|
||||
```
|
||||
|
||||
The approval must not predeclare the final production target OID.
|
||||
|
||||
Without an Owner-approved plan, stop with:
|
||||
|
||||
```text
|
||||
BLOCKED_EXTERNAL_OWNER_SIGNATURE
|
||||
```
|
||||
|
||||
## 8. Phase E — Governed merge
|
||||
|
||||
1. Merge PR #20 only through the governed merge path.
|
||||
2. Do not push directly to `main`.
|
||||
3. After merge, read the exact resulting `main` merge OID and tree OID.
|
||||
4. Verify four-way `main` reference closure.
|
||||
5. Verify the merged Integration OID is reachable from the final `main` merge OID.
|
||||
6. Never use the Integration OID as the production target OID.
|
||||
|
||||
Failure state:
|
||||
|
||||
```text
|
||||
MAIN_RECONCILIATION_REQUIRED
|
||||
```
|
||||
|
||||
## 9. Phase F — Production artifact rebuild
|
||||
|
||||
Rebuild all production artifacts from the exact final `main` merge OID.
|
||||
|
||||
Record new values for:
|
||||
|
||||
```text
|
||||
artifact_sha256
|
||||
manifest_sha256
|
||||
package_closure_sha256
|
||||
evidence_closure_oid
|
||||
rollback_artifact_sha256
|
||||
production_config_sha256
|
||||
```
|
||||
|
||||
Candidate or Integration artifacts may not be promoted by renaming or metadata substitution. The final artifact must be demonstrably rebuilt from the final production target.
|
||||
|
||||
## 10. Phase G — Final release digest and Owner approval
|
||||
|
||||
1. Construct the `FinalDormantRelease` object using the final `main` target and rebuilt artifact evidence.
|
||||
2. Compute its exact `release_digest`.
|
||||
3. Obtain an Owner approval receipt bound to that exact digest.
|
||||
4. Record:
|
||||
|
||||
```text
|
||||
approval_plan_id
|
||||
approval_receipt_sha256
|
||||
approved_release_digest
|
||||
owner_approval_verified=true
|
||||
```
|
||||
|
||||
Required equality:
|
||||
|
||||
```text
|
||||
approved_release_digest == FinalDormantRelease.digest()
|
||||
```
|
||||
|
||||
A generic approval, previous approval, Candidate approval or Integration approval is insufficient.
|
||||
|
||||
## 11. Phase H — Final acceptance
|
||||
|
||||
Execute:
|
||||
|
||||
```text
|
||||
python scripts/autonomous-release/run_acceptance.py \
|
||||
--phase final \
|
||||
--input <final-evidence.json> \
|
||||
--output <final-acceptance.json>
|
||||
```
|
||||
|
||||
The result must contain:
|
||||
|
||||
```text
|
||||
phase=final
|
||||
status=READY
|
||||
production_action_authorized=false
|
||||
```
|
||||
|
||||
Required final evidence:
|
||||
|
||||
```text
|
||||
main_four_way_ref_closure=true
|
||||
target_is_main_head=true
|
||||
worktree_clean=true
|
||||
artifact_rebuilt_from_target=true
|
||||
rollback_verified=true
|
||||
runtime_boundary_verified=true
|
||||
owner_approval_verified=true
|
||||
approved_release_digest=<exact final release digest>
|
||||
```
|
||||
|
||||
The acceptance report is evidence, not an execution credential.
|
||||
|
||||
## 12. Phase I — Dormant deployment
|
||||
|
||||
Deployment requires a separate production execution approval referencing:
|
||||
|
||||
```text
|
||||
version=V2R1C4
|
||||
target_oid=<final main merge OID>
|
||||
evidence_closure_oid=<final evidence closure OID>
|
||||
approval_plan_id=<approved plan>
|
||||
final_acceptance_digest=<final acceptance digest>
|
||||
```
|
||||
|
||||
Deploy only the dormant runtime. Before starting services, verify all disabled flags and the sandbox transport in the rendered production configuration.
|
||||
|
||||
After start, verify:
|
||||
|
||||
```text
|
||||
services_active=true
|
||||
loopback_bindings_only=true
|
||||
production_side_effects=false
|
||||
write_endpoints_disabled=true
|
||||
task_plane_execution_disabled=true
|
||||
silent_release_execution_disabled=true
|
||||
native_agent_execution_disabled=true
|
||||
```
|
||||
|
||||
If any side-effect-capable path is active, stop services and mark:
|
||||
|
||||
```text
|
||||
DORMANT_RUNTIME_BOUNDARY_VIOLATION
|
||||
```
|
||||
|
||||
## 13. Phase J — Tag governance
|
||||
|
||||
Tagging is permitted only after dormant deployment verification and exact Owner approval.
|
||||
|
||||
Every tag request must carry:
|
||||
|
||||
```text
|
||||
version=V2R1C4
|
||||
target_oid=<full final main merge OID>
|
||||
evidence_closure_oid=<full final evidence closure OID>
|
||||
approval_plan_id=<approved plan ID>
|
||||
```
|
||||
|
||||
When an existing same-name tag is found:
|
||||
|
||||
- identical tag OID and peeled target: treat as idempotent and reverify;
|
||||
- different tag OID or peeled target: stop with `MANUAL_OWNER_REVIEW_REQUIRED`.
|
||||
|
||||
Never force push, delete, move or rewrite a formal tag.
|
||||
|
||||
## 14. Phase K — Remote and Gitea tag acceptance
|
||||
|
||||
Before any Registry or Baseline update, verify:
|
||||
|
||||
```text
|
||||
local_tag_exists=true
|
||||
remote_tag_exists=true
|
||||
gitea_api_tag_exists=true
|
||||
local_tag_oid == remote_tag_oid
|
||||
remote_peeled_target_oid == target_oid
|
||||
gitea_peeled_target_oid == target_oid
|
||||
repository_identity=aios/aios
|
||||
```
|
||||
|
||||
For annotated tags, verify both the tag object and peeled commit.
|
||||
|
||||
Failure state:
|
||||
|
||||
```text
|
||||
REMOTE_PUSH_PENDING
|
||||
```
|
||||
|
||||
or:
|
||||
|
||||
```text
|
||||
RECONCILIATION_REQUIRED
|
||||
```
|
||||
|
||||
## 15. Phase L — Registry and Baseline
|
||||
|
||||
Only after remote and Gitea tag acceptance:
|
||||
|
||||
1. register or update the V2R1C4 Registry entry;
|
||||
2. reread the Registry and verify the exact target OID;
|
||||
3. update the Production Baseline to V2R1C4;
|
||||
4. reread the Baseline;
|
||||
5. run final release consistency acceptance.
|
||||
|
||||
Required equality:
|
||||
|
||||
```text
|
||||
Registry version
|
||||
= Production Baseline
|
||||
= local refs/tags/V2R1C4
|
||||
= remote refs/tags/V2R1C4
|
||||
= Gitea API tag
|
||||
= expected final main target
|
||||
```
|
||||
|
||||
Do not write `PRODUCTION_DEPLOYED` before this equality is proven.
|
||||
|
||||
## 16. Rollback
|
||||
|
||||
If deployment verification fails:
|
||||
|
||||
1. disable the V2R1C4 Candidate services;
|
||||
2. preserve evidence and logs;
|
||||
3. submit a governed rollback request with the target version and reason;
|
||||
4. distinguish `requested`, `approved`, `executed` and `verified` states.
|
||||
|
||||
Do not delete tags, rewrite history or independently perform a production rollback.
|
||||
|
||||
## 17. Mandatory stop conditions
|
||||
|
||||
Stop without consequential execution when any of the following is missing or false:
|
||||
|
||||
```text
|
||||
four_way_ref_closure
|
||||
clean_worktree
|
||||
full_test_closure
|
||||
artifact_digest_verification
|
||||
rollback_evidence
|
||||
runtime_boundary_verification
|
||||
exact_owner_approval
|
||||
exact_target_oid
|
||||
exact_evidence_closure_oid
|
||||
exact_approval_plan_id
|
||||
remote_tag_verification
|
||||
gitea_tag_verification
|
||||
```
|
||||
|
||||
## 18. Final report schema
|
||||
|
||||
Return:
|
||||
|
||||
```text
|
||||
execution_status=COMPLETED|PARTIALLY_COMPLETED|BLOCKED|FAILED
|
||||
candidate_oid=<full OID>
|
||||
integration_oid=<full OID>
|
||||
main_target_oid=<full OID>
|
||||
artifact_sha256=<digest>
|
||||
manifest_sha256=<digest>
|
||||
package_closure_sha256=<digest>
|
||||
evidence_closure_oid=<full OID>
|
||||
candidate_acceptance_status=<status>
|
||||
final_acceptance_status=<status>
|
||||
owner_approval_verified=<bool>
|
||||
dormant_deployment_verified=<bool>
|
||||
local_tag_verified=<bool>
|
||||
remote_tag_verified=<bool>
|
||||
gitea_tag_verified=<bool>
|
||||
registry_verified=<bool>
|
||||
baseline_verified=<bool>
|
||||
release_consistency=<status>
|
||||
```
|
||||
|
||||
Always include:
|
||||
|
||||
```text
|
||||
force_push_used: false
|
||||
tag_rewritten: false
|
||||
direct_main_push: false
|
||||
secrets_committed: false
|
||||
owner_approval_respected: true
|
||||
```
|
||||
@@ -0,0 +1,30 @@
|
||||
# AIOS V2R1C4 Dormant Release Agent Execution
|
||||
|
||||
## Scope
|
||||
|
||||
This package is a dormant, shadow-only Candidate release. It does not authorize a production deployment, tag, baseline update, registry update, or a write to main.
|
||||
|
||||
## Required runtime boundary
|
||||
|
||||
deployment_mode=dormant_shadow_only
|
||||
AIOS_GITOPS_WRITES_ENABLED=false
|
||||
AIOS_TASK_PLANE_EXECUTION_ENABLED=false
|
||||
AIOS_SILENT_RELEASE_EXECUTION_ENABLED=false
|
||||
production_side_effects=false
|
||||
|
||||
## Governed sequence
|
||||
|
||||
1. Verify the Integration branch with the Candidate test suite and four-way Git reference closure.
|
||||
2. Obtain Owner approval for dormant review only.
|
||||
3. Merge only after a separate production release approval; this document does not grant that approval.
|
||||
4. Read the resulting main merge OID before building an artifact.
|
||||
5. Deploy only the dormant Candidate runtime after explicit production approval.
|
||||
6. Create a tag and update Registry or Baseline only under their separate governed approvals.
|
||||
|
||||
## Evidence requirements
|
||||
|
||||
The execution agent must retain task ID, commit OID, artifact and manifest digests, test evidence, rollback package reference, and approval receipt metadata. It must not include plaintext credentials or private keys.
|
||||
|
||||
## Stop conditions
|
||||
|
||||
Stop with NOT_EXECUTED if any approval, four-way reference closure, artifact verification, or deployment gate is absent. Do not infer production authorization from Candidate authorization.
|
||||
@@ -1,98 +0,0 @@
|
||||
# AIOS V2R1C4 Fastlane Release Design
|
||||
|
||||
## Frozen scope
|
||||
|
||||
This release replaces the generic Governance Bootstrap deployment route with one non-root
|
||||
`aios-release-controller` oneshot and five explicit root `aios-deploy-helper` oneshots. The
|
||||
Bootstrap branch and commit remain immutable history and are marked
|
||||
`SUPERSEDED_BY_V2R1C4_FASTLANE_RELEASE`; they are not production prerequisites.
|
||||
|
||||
The release controller is the only component allowed to call Gitea, AWS KMS, and the fixed
|
||||
authority repository. The root helper has no Git, Gitea, KMS, Registry, Baseline, tag, arbitrary
|
||||
command, arbitrary path, template-instance, or network-service interface.
|
||||
|
||||
## Object model and the non-circular PR carrier
|
||||
|
||||
`release-plan.json` cannot contain the Git OID of the commit that contains that same file. The
|
||||
plan therefore separates immutable release content from the exact reviewed PR carrier:
|
||||
|
||||
- `head_oid`, `source_commit_oid`, `expected_tag_oid`, and `expected_peeled_target_oid` identify
|
||||
the immutable release-content commit.
|
||||
- `evidence_closure_oid` identifies the later commit containing all pre-review test evidence.
|
||||
- the exact PR carrier commit contains the plan and its pending signature descriptor; its OID is
|
||||
written to root-owned `controller.json` as `reviewed_pr_head_oid` after the PR exists.
|
||||
- the formal Owner Review and all five statuses bind the exact PR carrier, while the lightweight
|
||||
`V2R1C4` tag binds the release-content commit specified by the signed plan.
|
||||
|
||||
The controller verifies that the carrier is a commit and that both the authoritative base and the
|
||||
observed Gitea base are ancestors. KMS signs only the canonical plan digest. The signature envelope
|
||||
also records the real Review ID and exact reviewed carrier OID.
|
||||
|
||||
## Existing Gitea drift reconciliation
|
||||
|
||||
Live discovery on 2026-08-02 found:
|
||||
|
||||
```text
|
||||
authority_main=875d41c3101093149414292067fd700dc214d4d3
|
||||
gitea_main=8291b8368bf690416a3159ac5d21d9f8139c2e61
|
||||
authority_is_ancestor_of_gitea=true
|
||||
gitea_pr20_owner_review=false
|
||||
```
|
||||
|
||||
No ref is rewound. The Fastlane carrier has the authoritative lineage as first parent and the
|
||||
observed Gitea head as a reconciliation parent, with the Fastlane tree selected explicitly. One
|
||||
formal Owner Review therefore approves the exact reconciled carrier. Gitea advances with
|
||||
`fast-forward-only`; the controller then imports that exact commit into the authority repository
|
||||
and advances authority `main` with `git update-ref <new> <expected-old>` compare-and-swap. No
|
||||
force-push or direct human/Agent write to `main` is used.
|
||||
|
||||
Registry and Baseline commits are created sequentially through the Gitea content API. After the
|
||||
Baseline readback passes, the controller imports the exact final commit and advances authority
|
||||
`main` by the same compare-and-swap rule. The lightweight tag is created in Gitea, verified as a
|
||||
commit ref, imported, and created in authority only if the authority tag does not already exist.
|
||||
|
||||
## Candidate and rollback surfaces
|
||||
|
||||
Candidate acceptance binds both product surfaces:
|
||||
|
||||
```text
|
||||
AIOS candidate: aios-v2r1c4-candidate.service 127.0.0.1:18921
|
||||
OpenClaw candidate: openclaw-gateway-v2r1c4-candidate.service 127.0.0.1:18790
|
||||
AIOS production: aios-v2r1c4-production.service 127.0.0.1:18920
|
||||
OpenClaw production:openclaw-gateway-v2r1c4.service 127.0.0.1:18789
|
||||
```
|
||||
|
||||
The helper copies the active V2R1C3 OpenClaw state into versioned roots without mutating the
|
||||
source. The two observed source symlinks are accepted only by exact relative path and exact target;
|
||||
they are replaced by regular files/directories from the signed V2R1C4 artifact. Any symlink drift,
|
||||
source change during the snapshot, SQLite integrity failure, raw Owner identity remainder, or
|
||||
artifact conflict fails closed before the candidate units start.
|
||||
|
||||
Promotion stops both candidates, stops the V2R1C3 AIOS and Gateway units, then starts and checks
|
||||
both V2R1C4 production units. Any promotion failure immediately restores both V2R1C3 units.
|
||||
The rollback test restores V2R1C3, verifies ports 18920 and 18789, then redeploys and re-verifies
|
||||
both V2R1C4 candidate units.
|
||||
|
||||
## Credential and retry rules
|
||||
|
||||
Only these encrypted credentials are projected:
|
||||
|
||||
```text
|
||||
gitea-task-token
|
||||
aws-workload-identity-reference
|
||||
```
|
||||
|
||||
The Gitea token is non-admin, repository-bound, valid for at most two hours, carried only in the
|
||||
HTTP Authorization header, and revoked with Gitea's current-token endpoint. The AWS credential
|
||||
contains a standard temporary workload-identity configuration; long-lived Access Keys and software
|
||||
private-key fallback are forbidden.
|
||||
|
||||
SQLite owns one V2R1C4 plan digest and nonce. A completed plan retry returns the original run ID
|
||||
without side effects. A failed run resumes only after its last durable stage, so statuses and merge
|
||||
are not repeated. Every invocation revokes the task token supplied to that invocation.
|
||||
|
||||
## Success invariant
|
||||
|
||||
Completion requires equality of authority/Gitea main refs, authority/Gitea lightweight tag refs,
|
||||
Registry target, Baseline target, and production target. Any mismatch leaves Baseline unchanged or
|
||||
marks the run `RECONCILIATION_REQUIRED`; it is never reported as `PRODUCTION_DEPLOYED`.
|
||||
@@ -1,13 +0,0 @@
|
||||
{
|
||||
"schema": "aios.fastlane-supersession/v1",
|
||||
"recorded_at": "2026-08-02T00:00:00Z",
|
||||
"status": "SUPERSEDED_BY_V2R1C4_FASTLANE_RELEASE",
|
||||
"superseded_branch": "feat/aios-governance-bootstrap-v1-delivery",
|
||||
"frozen_commit": "48d4f1e471390e5e8f55d684d39b98e45ac41485",
|
||||
"superseded_installer": "AIOS-GOVERNANCE-M1-ONECLICK.zip",
|
||||
"deleted": false,
|
||||
"history_rewritten": false,
|
||||
"production_deployed": false,
|
||||
"replacement_branch": "release/v2r1c4-fastlane",
|
||||
"reason": "The V2R1C4 release now uses the bounded single-controller Fastlane path."
|
||||
}
|
||||
@@ -1,184 +0,0 @@
|
||||
# V2R1C4 Fastlane 外部绑定一次性管理员操作单
|
||||
|
||||
状态：`REQUIRED_BEFORE_FASTLANE_PR_ACTIVATION`。本单仅补齐当前宿主缺失的 AWS KMS、IAM Roles Anywhere 工作负载身份和 Gitea task credential；不得执行发布、Owner Review、合并、Tag、Registry 或 Baseline 写入。
|
||||
|
||||
## 冻结结果
|
||||
|
||||
完成后必须同时存在：
|
||||
|
||||
```text
|
||||
/usr/local/bin/aws
|
||||
/usr/local/bin/aws_signing_helper
|
||||
/etc/credstore.encrypted/aios-v2r1c4-gitea-task-token
|
||||
/etc/credstore.encrypted/aios-v2r1c4-aws-workload-identity-reference
|
||||
/var/lib/aios-release/kms-binding.json
|
||||
```
|
||||
|
||||
KMS 固定为：
|
||||
|
||||
```text
|
||||
provider=aws-kms
|
||||
key_spec=RSA_3072
|
||||
key_usage=SIGN_VERIFY
|
||||
algorithm=RSASSA_PSS_SHA_256
|
||||
```
|
||||
|
||||
AWS 官方说明：Roles Anywhere 为 AWS 外部工作负载签发临时凭据，不需要长期 Access Key；credential helper 支持 PKCS#11 URI 与 TPM handle。KMS `Sign` 在 `MessageType=DIGEST` 时直接签署已计算摘要，`GetPublicKey` 可供本地独立验签。
|
||||
|
||||
- https://docs.aws.amazon.com/rolesanywhere/latest/userguide/introduction.html
|
||||
- https://docs.aws.amazon.com/rolesanywhere/latest/userguide/credential-helper.html
|
||||
- https://docs.aws.amazon.com/cli/latest/reference/kms/sign.html
|
||||
- https://docs.aws.amazon.com/kms/latest/developerguide/download-public-key.html
|
||||
|
||||
## A. 管理员一次性准备
|
||||
|
||||
管理员在受控终端一次性确定并记录下列非秘密值：
|
||||
|
||||
```text
|
||||
AWS_ACCOUNT_ID
|
||||
AWS_REGION
|
||||
KMS_KEY_ARN
|
||||
KMS_PUBLIC_KEY_SHA256
|
||||
ROLE_ARN
|
||||
ROLES_ANYWHERE_TRUST_ANCHOR_ARN
|
||||
ROLES_ANYWHERE_PROFILE_ARN
|
||||
CLIENT_CERTIFICATE_PATH
|
||||
HSM_PKCS11_PROVIDER
|
||||
HSM_PKCS11_ENDPOINT
|
||||
HSM_PKCS11_LIBRARY_SHA256
|
||||
HSM_PKCS11_KEY_URI
|
||||
HSM_TLS_CA_SHA256
|
||||
GITEA_TASK_TOKEN_ID
|
||||
ISSUED_AT_UTC
|
||||
EXPIRES_AT_UTC # 必须不超过 ISSUED_AT_UTC + 2h
|
||||
```
|
||||
|
||||
当前发布主机没有 `/dev/tpm*`，因此本单不得填写 TPM handle 或假设本机 TPM 存在。`HSM_PKCS11_KEY_URI` 必须引用外部 HSM 中不可导出的工作负载身份 key；生产启用前必须冻结 provider、endpoint、PKCS#11 library SHA-256、key URI 与 TLS CA 指纹。禁止 PEM 私钥、软件 key、长期 AWS Access Key、PKCS#11 PIN argv 或自动 fallback。
|
||||
|
||||
## B. AWS CLI 与 Roles Anywhere helper
|
||||
|
||||
1. 按 AWS 官方 GPG 验证流程安装固定 AWS CLI v2；安装结果必须解析为 `/usr/local/bin/aws`，不得使用未校验下载物：
|
||||
|
||||
https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html
|
||||
|
||||
2. 安装官方 `aws_signing_helper` Linux x86-64 v1.8.4，并在安装前验证：
|
||||
|
||||
```text
|
||||
sha256=b7568acd6e1517a4e1adaee68d52bfd6284a0e5305677166cd83d43a07c815c9
|
||||
destination=/usr/local/bin/aws_signing_helper
|
||||
owner=root:root
|
||||
mode=0755
|
||||
```
|
||||
|
||||
3. CA/证书管理员签发只用于 `aios-v2r1c4-release` 的短期 X.509 客户端证书。Role trust policy 必须同时绑定精确 Trust Anchor ARN、证书 subject CN 与 issuer CN；不得仅信任整个 CA。
|
||||
|
||||
## C. AWS KMS 与最小 IAM
|
||||
|
||||
创建一个新的 asymmetric KMS key：
|
||||
|
||||
```text
|
||||
KeySpec=RSA_3072
|
||||
KeyUsage=SIGN_VERIFY
|
||||
MultiRegion=false
|
||||
Description=AIOS V2R1C4 Fastlane Release Plan Signer
|
||||
```
|
||||
|
||||
工作负载 Role 的权限策略只能是：
|
||||
|
||||
```json
|
||||
{
|
||||
"Version": "2012-10-17",
|
||||
"Statement": [{
|
||||
"Sid": "SignExactFastlanePlan",
|
||||
"Effect": "Allow",
|
||||
"Action": ["kms:Sign", "kms:GetPublicKey", "kms:DescribeKey"],
|
||||
"Resource": "<KMS_KEY_ARN>",
|
||||
"Condition": {
|
||||
"StringEquals": {"kms:SigningAlgorithm": "RSASSA_PSS_SHA_256"}
|
||||
}
|
||||
}]
|
||||
}
|
||||
```
|
||||
|
||||
显式确认 Role 不含 `kms:*`、`kms:DisableKey`、`kms:ScheduleKeyDeletion`、`kms:PutKeyPolicy`、Git、Gitea、Registry、Baseline 或生产权限。
|
||||
|
||||
## D. 生成并加密 AWS 工作负载引用
|
||||
|
||||
在 root-only 临时目录创建 AWS config；私钥参数必须是已冻结的外部 HSM PKCS#11 URI，模块路径必须对应已核验 SHA-256 的只读安装物：
|
||||
|
||||
```ini
|
||||
[profile aios-release]
|
||||
region = <AWS_REGION>
|
||||
credential_process = /usr/local/bin/aws_signing_helper credential-process --certificate <CLIENT_CERTIFICATE_PATH> --private-key <HSM_PKCS11_KEY_URI> --pkcs11-lib <FIXED_PKCS11_LIBRARY_PATH> --trust-anchor-arn <ROLES_ANYWHERE_TRUST_ANCHOR_ARN> --profile-arn <ROLES_ANYWHERE_PROFILE_ARN> --role-arn <ROLE_ARN> --session-duration 900 --role-session-name aios-v2r1c4-release
|
||||
```
|
||||
|
||||
用固定 credential name 加密；明文临时文件必须位于 root-only 临时目录，成功后立即销毁：
|
||||
|
||||
```text
|
||||
systemd-creds encrypt --name=aws-workload-identity-reference <aws-config> /etc/credstore.encrypted/aios-v2r1c4-aws-workload-identity-reference
|
||||
```
|
||||
|
||||
不得把该内容放入 argv、日志、Git 或用户主目录。
|
||||
|
||||
## E. 创建 Gitea 非管理员 task identity
|
||||
|
||||
1. 管理员创建或启用 `aios-v2r1c4-release` 非管理员账号。
|
||||
2. 只向 `aios/aios` 授予 Write collaborator 权限；不得授予站点管理员、组织 Owner 或其他仓库权限。Gitea 的 Write 权限仍受 protected branch/tag 规则约束：
|
||||
|
||||
https://docs.gitea.com/1.26/usage/access-control/permissions
|
||||
|
||||
3. 创建 scopes 精确为 `read:repository,write:repository` 的一次性 token。Controller 最终调用 Gitea 官方 `DELETE /api/v1/token` 自撤销当前 token：
|
||||
|
||||
https://docs.gitea.com/api/
|
||||
|
||||
4. Token 不得出现在 argv。管理员在无回显终端读取 token，并通过标准输入生成两小时内有效的 credential JSON，再直接交给 `systemd-creds encrypt`：
|
||||
|
||||
```text
|
||||
read -r -s GITEA_TASK_TOKEN
|
||||
printf '%s' "$GITEA_TASK_TOKEN" |
|
||||
/usr/bin/python3 scripts/fastlane/seal-gitea-task-credential.py \
|
||||
--token-id <GITEA_TASK_TOKEN_ID> \
|
||||
--issued-at <ISSUED_AT_UTC> \
|
||||
--expires-at <EXPIRES_AT_UTC> |
|
||||
systemd-creds encrypt --name=gitea-task-token - \
|
||||
/etc/credstore.encrypted/aios-v2r1c4-gitea-task-token
|
||||
unset GITEA_TASK_TOKEN
|
||||
```
|
||||
|
||||
若 Controller 未在到期前运行，管理员必须在 Gitea 删除该 token；不得延期或复用。
|
||||
|
||||
## F. 固定 KMS binding
|
||||
|
||||
写入 `/var/lib/aios-release/kms-binding.json`，owner `aios-release:aios-release`、mode `0600`：
|
||||
|
||||
```json
|
||||
{
|
||||
"region": "<AWS_REGION>",
|
||||
"key_arn": "<KMS_KEY_ARN>",
|
||||
"public_key_fingerprint": "<KMS_PUBLIC_KEY_SHA256>",
|
||||
"role_arn": "<ROLE_ARN>"
|
||||
}
|
||||
```
|
||||
|
||||
`KMS_PUBLIC_KEY_SHA256` 必须是 `GetPublicKey.PublicKey` Base64 解码后的 DER SHA-256，不是 PEM 文本摘要。
|
||||
|
||||
## G. 只返回非秘密回执
|
||||
|
||||
管理员完成后只返回：
|
||||
|
||||
```text
|
||||
kms_binding_secret_ref=systemd-credential://aios-release-controller.service/aws-workload-identity-reference
|
||||
signer_trust_secret_ref=file:///var/lib/aios-release/kms-binding.json
|
||||
gitea_task_secret_ref=systemd-credential://aios-release-controller.service/gitea-task-token
|
||||
binding_projection_status=ACTIVE
|
||||
aws_cli_version=<exact>
|
||||
aws_cli_artifact_sha256=<sha256>
|
||||
roles_anywhere_helper_version=1.8.4
|
||||
roles_anywhere_helper_sha256=b7568acd6e1517a4e1adaee68d52bfd6284a0e5305677166cd83d43a07c815c9
|
||||
kms_key_arn=<exact ARN>
|
||||
kms_public_key_fingerprint=<64 lowercase hex>
|
||||
role_arn=<exact ARN>
|
||||
grant_expires_at=<UTC>
|
||||
```
|
||||
|
||||
不得返回 token、证书私钥、HSM auth、session credential、管理员 token 或明文 credential 内容。
|
||||
@@ -1,48 +0,0 @@
|
||||
# V2R1C4 Owner 隐私迁移与回滚 Runbook
|
||||
|
||||
本 Runbook 只在 Owner 批准精确 `source_commit_oid`、`source_tree_oid`、Artifact SHA-256 与回滚 Artifact SHA-256 后执行。不得原地修改 V2R1C3，也不得在写入未静止时迁移。
|
||||
|
||||
## 前置门禁
|
||||
|
||||
1. 核验 V2R1C3 Tag、运行目录和回滚包摘要；保存 18920、Gateway、PID、重启次数和端口健康基线。
|
||||
2. 将 V2R1C4 Artifact 展开到新的 `/opt/aios/releases/V2R1C4`，不得覆盖 `/opt/aios/releases/V2R1C3`。
|
||||
3. 在隔离副本上运行 `patch_openclaw_weixin_owner_privacy.py --isolation-root <V2R1C4-root> <plugin-root>`；
|
||||
隔离根必须含内容严格为 `V2R1C4\n` 的 `.aios-v2r1c4-isolated-root`，要求 package version 为
|
||||
`2.4.6`、第二次执行 `changed=false`，并核对输出文件摘要。工具会拒绝当前生产插件路径。
|
||||
上游包中 `src/`、`dist/` 下的历史 `.bak` 文件只允许在该隔离副本内删除，并把删除前摘要写入构建证据。
|
||||
构建结果固定保存为 Artifact 内的 `vendor/openclaw-weixin`；状态快照完成后，仅把该目录复制到
|
||||
`openclaw-session-v2r1c4` 中原 npm package 的对应位置，并在启动前逐文件核验构建摘要。
|
||||
不得对当前 `/var/lib/aios/openclaw-session` 或已安装 `/opt/aios/releases` 原地运行补丁器。
|
||||
4. 为生产应用与 Gateway 的 V2R1C4 unit 安装 `aios-v2r1c4-no-core.conf`，使用 `systemd-analyze verify`，但在切换前不启动。
|
||||
5. 原始 Owner ID 仅通过 root 读取的匿名 FD 提供给迁移器。禁止 argv、环境变量、终端输出、日志或 Evidence 保存原值。
|
||||
|
||||
## 事务快照与迁移
|
||||
|
||||
1. 停止 V2R1C4 预切换写入入口；V2R1C3 仍可服务，直到切换窗口开始。
|
||||
2. 在切换窗口内停止 Gateway 与会写入 OpenClaw state 的服务，记录停止时间和 PID。不得停止回滚资产。
|
||||
3. 对每个 SQLite 执行 `PRAGMA wal_checkpoint(TRUNCATE)` 和 `PRAGMA integrity_check`；任何 WAL 无法收敛立即回滚，不复制活动 WAL。
|
||||
4. 对 OpenClaw Session、Provenance 与日志创建只读快照和 SHA-256 清单。固定事故记录必须匹配：
|
||||
- record: `91c5892f30cefe0db9448abef799c6e97237b92e60d0704ba4af408ee33acf68`
|
||||
- manifest record: `8ad6ec28c69f25c63d0ac7dff95f574b39119be12b00184408242460df33442c`
|
||||
5. 对快照运行 `v2r1c4_owner_privacy_snapshot.py`，分别生成 `/var/lib/aios/openclaw-session-v2r1c4` 与 `/var/lib/aios/openclaw-provenance-v2r1c4`。迁移器只创建新输出；失败时删除不完整输出，不修改源。
|
||||
6. 要求 `raw_owner_id_occurrences_after=0`、`pseudonym_consistency=PASS`、`database_integrity=PASS`、`event_relationships_preserved=true`。
|
||||
7. 将配置中的 Owner allowlist 替换为同一 `principal:sha256:<64-lowercase-hex>`，不得保留明文兼容项。
|
||||
迁移器同时把插件加载目录、Provenance Store/Public Key、Runtime State 和 Writer Audit
|
||||
精确重绑定到 V2R1C4 的不可变 Artifact 与新状态目录；任何未识别的旧路径不得人工猜测替换。
|
||||
新目录及 `/etc/aios/openclaw-gateway-v2r1c4.env` 必须归 `aios` 运行账户可读写（环境文件为
|
||||
`root:aios 0640`，状态目录为 `aios:aios 0750`）；V2R1C4 Gateway 禁止以 root 身份运行。
|
||||
切换前创建 `openclaw-session-v2r1c4/tmp`；Gateway 的私有 `/tmp/openclaw` 仅绑定到该目录，
|
||||
Collector 从同一版本化目录只读日志，不读取旧生产 `/tmp/openclaw`。
|
||||
8. 对新目录再次扫描活动文件、轮转日志、Session、SQLite、WAL/SHM、Provenance、Evidence、journal 与 core metadata。任何原始身份形态或扫描缺口均阻断。旧状态只能作为访问受控的回滚快照保留，不得继续挂载为活动目录。
|
||||
|
||||
## 切换与验收
|
||||
|
||||
1. 启动独立 V2R1C4 Gateway/生产 unit；确认 `LimitCORE=0`、`AIOS_GITOPS_WRITES_ENABLED=false`。
|
||||
2. 先验证 18921，再以可立即回滚方式切换 18920。V2R1C3 目录、Tag、unit 定义和回滚包保持不变。
|
||||
3. 启用 V2R1C4 Collector path，要求 `.path=active/waiting`、`.service=oneshot`。
|
||||
4. 只等待新的自然 Owner 微信事件；禁止 CLI 注入、伪造 sender、历史重放或直接调用内部接口。
|
||||
5. 只有 Witness、Provider 三态、签名、Receipt、隐私扫描、core 扫描和真实回复全部通过，才允许关闭运行时验收。
|
||||
|
||||
## 回滚
|
||||
|
||||
任一 Health、API、UI、Role Matrix、Tenant Isolation、微信回复、签名、隐私或 core 门禁失败：立即把 18920 路由恢复到 V2R1C3；停止 V2R1C4 unit；保留 V2R1C4 失败 Evidence 和新状态目录；不得删除或重写任何 Tag。恢复 V2R1C3 后重新执行健康与微信普通回复检查。迁移源快照保持只读，用于审计，不声明底层介质已物理擦除。
|
||||
@@ -0,0 +1,65 @@
|
||||
{
|
||||
"evidence_type": "FULL_PACKAGE_FILE_MANIFEST_DRIFT_CLOSURE",
|
||||
"release": "V2R1C4",
|
||||
"entries": [
|
||||
{
|
||||
"path": "VERSION",
|
||||
"old_sha256": "1095953d5764d9c72f02e84b1d525e265d3a67a5bdb451ab9ef51a8e8b3032b8",
|
||||
"new_sha256": "b090062a92aeb14211bbfc1fcd43b5ee4f315d30054b437f3bcdac657210ee95",
|
||||
"source_commit": "9917145a643c7938a1a4f4f72690674f13f4c3dd",
|
||||
"reason": "V2R1C4 release completion froze the candidate package version",
|
||||
"resolution": "accept the V2R1C4 candidate content and update only this manifest entry"
|
||||
},
|
||||
{
|
||||
"path": "active-runtime/app/aios_gitops_model_api.py",
|
||||
"old_sha256": "ee6e4fc6bc98a590fbc3585b62707e2562115e5a3f722e69a7c464d966bdc458",
|
||||
"new_sha256": "a664714bc1e13160cdd0dc32de460c65a83a3a95aa5cdad1833b1b650ab90e9d",
|
||||
"source_commit": "45dd78ec796faf9fdfba397e5bab73176aeef3f6",
|
||||
"reason": "tracked GitOps API gained the governed short-link and webhook endpoint",
|
||||
"resolution": "accept current tracked content and update only this manifest entry"
|
||||
},
|
||||
{
|
||||
"path": "config/domains.env",
|
||||
"old_sha256": "a3872f24e4cd64288758846ecd0b374db4aa41111feec3b17c41438136d6d5d0",
|
||||
"new_sha256": "5a27d48db343dcb723bcc1d9d8222aa3f72094c57cc43640aebe6558963bd20f",
|
||||
"source_commit": "e7d36ad706473c95a4d4b9ec791120271ed856cd",
|
||||
"reason": "tracked authentication routing made cnnetmkt Casdoor the primary endpoint",
|
||||
"resolution": "accept current tracked content and update only this manifest entry"
|
||||
},
|
||||
{
|
||||
"path": "scripts/install_v1r1c0_gitops_model_overlay.sh",
|
||||
"old_sha256": "4d54a4ed6d35bbb6e9fe2924f3cfceeea9c3eed898017788f6c5ab8041394a47",
|
||||
"new_sha256": "e76cd986d2387b76439e4a7fe503e48a2de8fc70fb52c45a13641c9d943f108f",
|
||||
"source_commit": "a2481421589e167680e7d801433758c6a01db832",
|
||||
"reason": "tracked installer added online Codex patch-branch synchronization",
|
||||
"resolution": "accept current tracked content and update only this manifest entry"
|
||||
},
|
||||
{
|
||||
"path": "scripts/package_contract_check_v1r1c0.sh",
|
||||
"old_sha256": "e0abd8ad44d4f088108f2046fd9d7bbd4465af50f79bd3b9fcbb72a8c61bee65",
|
||||
"new_sha256": "f537c58fc08685601f47fac5c0a3a2856e3ce9806c1918848c87a194a49c28a0",
|
||||
"source_commit": "9917145a643c7938a1a4f4f72690674f13f4c3dd",
|
||||
"reason": "release completion generalized the legacy version check without weakening required files or compilation checks",
|
||||
"resolution": "accept the generalized semantic version check and update only this manifest entry"
|
||||
},
|
||||
{
|
||||
"path": "scripts/release_version.sh",
|
||||
"old_sha256": "abef8df642c6d233af4a03c512876b02b326e19c924020b8dd8cc74236d18817",
|
||||
"new_sha256": "14ab40a7c342e21e8315def14d552dcff4b214d23f1f4be493e9d3fc2cee1a2f",
|
||||
"source_commit": "27a0ae126b96d63c40544174e7a3859e30eba056",
|
||||
"reason": "tracked release helper closed tag-publication governance gaps",
|
||||
"resolution": "accept current tracked content and update only this manifest entry"
|
||||
}
|
||||
],
|
||||
"verifier_change": {
|
||||
"path": "package_verify_full.sh",
|
||||
"old_sha256": "b77bce1ca78cede27de6594e25f6ce5bb0c4990c0953eeb79f7e2608d2515c32",
|
||||
"new_sha256": "ca49f4165b50171968485ffa5535bc33d2158237ea55af10a3888a5fa0f7a535",
|
||||
"source_commit": "V2R1C4 release completion candidate",
|
||||
"reason": "remove the checksum failure suppression and fail closed when the manifest is absent or mismatched",
|
||||
"resolution": "update only the verifier self-entry after the six historical drifts were closed"
|
||||
},
|
||||
"entry_count": 6,
|
||||
"whole_manifest_regenerated": false,
|
||||
"verifier_fail_closed": true
|
||||
}
|
||||
@@ -0,0 +1,14 @@
|
||||
# Agent Integration Plan
|
||||
|
||||
1. Verify package SHA-256 and FILE_SHA256.json.
|
||||
2. Apply added/modified source files to patch/v2r1c4-release-completion-20260729.
|
||||
3. Do not copy __pycache__, .pytest_cache, TEST_RECEIPT.json, or local package metadata into runtime paths.
|
||||
4. Preserve existing approved WeChat and single-owner activation Git objects.
|
||||
5. Install the Python package and verify every pyproject console entrypoint.
|
||||
6. Render environment-specific JSON configs from config/examples.
|
||||
7. Use systemd encrypted credentials only; never persist plaintext tokens.
|
||||
8. Run compileall, all repository tests, systemd unit verification, secret scan, and online copied-Gitea acceptance.
|
||||
9. Build one autonomous-control-plane Artifact and rollback Artifact.
|
||||
10. Create one Owner approval for AIOS_AUTONOMOUS_RELEASE_CONTROL_PLANE_BOOTSTRAP.
|
||||
11. After deployment, complete V2R1C4 code freeze and create one V2R1C4_PRODUCTION_RELEASE_ENVELOPE.
|
||||
12. Do not split unchanged code/artifact/permission scope into additional approvals.
|
||||
@@ -0,0 +1,78 @@
|
||||
{
|
||||
"capabilities": {
|
||||
"approval_mirror_worker": "DELIVERED",
|
||||
"approval_watcher": "DELIVERED",
|
||||
"artifact_atomic_deployment": "DELIVERED",
|
||||
"automatic_renewal_controller": "DELIVERED",
|
||||
"credential_revoker_with_old_token_401": "DELIVERED",
|
||||
"governance_request_publisher": "DELIVERED",
|
||||
"governed_development_writer_server": "DELIVERED",
|
||||
"governed_merge_transport": "DELIVERED",
|
||||
"governed_tag_transport": "DELIVERED",
|
||||
"grant_quota_idempotency": "DELIVERED",
|
||||
"grant_revocation_evidence": "DELIVERED",
|
||||
"health_rollback_restore": "DELIVERED",
|
||||
"owner_exact_head_release_approval_verification": "DELIVERED",
|
||||
"registry_baseline_snapshot_compensation": "DELIVERED",
|
||||
"release_object_projection": "DELIVERED",
|
||||
"remote_tag_and_final_consistency": "DELIVERED",
|
||||
"runtime_source_projection": "DELIVERED",
|
||||
"task_bound_writer_grant": "DELIVERED",
|
||||
"unified_release_envelope_executor": "DELIVERED"
|
||||
},
|
||||
"delivery_status": "CODE_COMPLETE_OFFLINE_VALIDATED",
|
||||
"direct_main_push": false,
|
||||
"entrypoints": {
|
||||
"aios-autonomous-control-plane": "aios_autonomous_control_plane.cli:main",
|
||||
"aios-autonomous-renewal-controller": "aios_autonomous_control_plane.renewal_service:main",
|
||||
"aios-development-writer-revoker": "aios_autonomous_control_plane.revoker:main",
|
||||
"aios-development-writer-server": "aios_autonomous_control_plane.writer_server:main",
|
||||
"aios-governance-approval-watcher": "aios_autonomous_control_plane.watcher_service:main",
|
||||
"aios-governance-mirror-worker": "aios_autonomous_control_plane.mirror_service:main",
|
||||
"aios-governance-request-publisher": "aios_autonomous_control_plane.publisher:main",
|
||||
"aios-release-hook": "aios_autonomous_control_plane.release_action:main",
|
||||
"aios-release-object-projector": "aios_autonomous_control_plane.projection_service:release_main",
|
||||
"aios-runtime-source-projector": "aios_autonomous_control_plane.projection_service:runtime_main",
|
||||
"aios-v2r1c4-release-executor": "aios_autonomous_control_plane.release_service:main"
|
||||
},
|
||||
"force_push": false,
|
||||
"global_writes_must_remain_false": true,
|
||||
"package_version": "0.2.0",
|
||||
"schema": "aios.code-handoff/v2",
|
||||
"source": "codex-chartgpt-bridge",
|
||||
"systemd_units": [
|
||||
"deploy/systemd/aios-autonomous-renewal-controller.service",
|
||||
"deploy/systemd/aios-governance-approval-watcher.service",
|
||||
"deploy/systemd/aios-governance-mirror-worker.service",
|
||||
"deploy/systemd/aios-governance-request-publisher.service",
|
||||
"deploy/systemd/aios-governed-development-writer-revoker.service",
|
||||
"deploy/systemd/aios-governed-development-writer-revoker.timer",
|
||||
"deploy/systemd/aios-governed-development-writer.service",
|
||||
"deploy/systemd/aios-release-object-projection.service",
|
||||
"deploy/systemd/aios-runtime-source-read-projection.service",
|
||||
"deploy/systemd/aios-v2r1c4-release-envelope.service"
|
||||
],
|
||||
"tag_rewrite": false,
|
||||
"target_branch": "patch/v2r1c4-release-completion-20260729",
|
||||
"tests": {
|
||||
"collection_errors": 0,
|
||||
"compileall": "PASS",
|
||||
"pytest_failed": 0,
|
||||
"pytest_passed": 21,
|
||||
"secret_findings": [
|
||||
{
|
||||
"path": "tests/autonomous_control_plane/test_policy_and_writer.py",
|
||||
"rule": "literal-credential-assignment"
|
||||
}
|
||||
],
|
||||
"secret_findings_classification": {
|
||||
"tests/autonomous_control_plane/test_policy_and_writer.py": "Deliberate fake api_key assignment used by the negative secret-rejection test."
|
||||
},
|
||||
"secret_scan": "PASS_TEST_FIXTURE_ONLY"
|
||||
},
|
||||
"wechat_backend": {
|
||||
"new_code_generated": false,
|
||||
"reason": "The controlled PR #20 full diff remains too large for this interface; existing exact Git objects must be retained and validated, not re-invented.",
|
||||
"required_agent_action": "Preserve already integrated approved WeChat code, run its online acceptance suite, and include its exact object IDs in the final release envelope."
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,84 @@
|
||||
{
|
||||
"added_files": [
|
||||
"AGENT_INTEGRATION_PLAN.md",
|
||||
"config/examples/grant.json",
|
||||
"config/examples/mirror.json",
|
||||
"config/examples/publisher.json",
|
||||
"config/examples/release-actions.json",
|
||||
"config/examples/release-envelope.json",
|
||||
"config/examples/release-hooks.json",
|
||||
"config/examples/release-projection.json",
|
||||
"config/examples/renewal.json",
|
||||
"config/examples/revoker.json",
|
||||
"config/examples/runtime-projection.json",
|
||||
"config/examples/watcher.json",
|
||||
"config/examples/writer-server.json",
|
||||
"deploy/systemd/aios-v2r1c4-release-envelope.service",
|
||||
"services/aios-autonomous-control-plane/aios_autonomous_control_plane/credentials.py",
|
||||
"services/aios-autonomous-control-plane/aios_autonomous_control_plane/gitea_api.py",
|
||||
"services/aios-autonomous-control-plane/aios_autonomous_control_plane/grant.py",
|
||||
"services/aios-autonomous-control-plane/aios_autonomous_control_plane/mirror_service.py",
|
||||
"services/aios-autonomous-control-plane/aios_autonomous_control_plane/projection_service.py",
|
||||
"services/aios-autonomous-control-plane/aios_autonomous_control_plane/publisher.py",
|
||||
"services/aios-autonomous-control-plane/aios_autonomous_control_plane/release_action.py",
|
||||
"services/aios-autonomous-control-plane/aios_autonomous_control_plane/release_deploy.py",
|
||||
"services/aios-autonomous-control-plane/aios_autonomous_control_plane/release_hooks.py",
|
||||
"services/aios-autonomous-control-plane/aios_autonomous_control_plane/release_service.py",
|
||||
"services/aios-autonomous-control-plane/aios_autonomous_control_plane/release_transport.py",
|
||||
"services/aios-autonomous-control-plane/aios_autonomous_control_plane/renewal_service.py",
|
||||
"services/aios-autonomous-control-plane/aios_autonomous_control_plane/revoker.py",
|
||||
"services/aios-autonomous-control-plane/aios_autonomous_control_plane/socket_service.py",
|
||||
"services/aios-autonomous-control-plane/aios_autonomous_control_plane/watcher_service.py",
|
||||
"services/aios-autonomous-control-plane/aios_autonomous_control_plane/writer_server.py",
|
||||
"tests/autonomous_control_plane/test_deployment_and_contracts.py",
|
||||
"tests/autonomous_control_plane/test_services_and_hooks.py"
|
||||
],
|
||||
"base_package_sha256": "795feb406541af86f30c1fb31f85e6d7485ee72a9d3ac93351f9a63fe4ad3e8f",
|
||||
"deleted_files": [
|
||||
"services/aios-autonomous-control-plane/aios_autonomous_control_plane/__pycache__/__init__.cpython-313.pyc",
|
||||
"services/aios-autonomous-control-plane/aios_autonomous_control_plane/__pycache__/cli.cpython-313.pyc",
|
||||
"services/aios-autonomous-control-plane/aios_autonomous_control_plane/__pycache__/common.cpython-313.pyc",
|
||||
"services/aios-autonomous-control-plane/aios_autonomous_control_plane/__pycache__/ledger.cpython-313.pyc",
|
||||
"services/aios-autonomous-control-plane/aios_autonomous_control_plane/__pycache__/mirror.cpython-313.pyc",
|
||||
"services/aios-autonomous-control-plane/aios_autonomous_control_plane/__pycache__/policy.cpython-313.pyc",
|
||||
"services/aios-autonomous-control-plane/aios_autonomous_control_plane/__pycache__/projection.cpython-313.pyc",
|
||||
"services/aios-autonomous-control-plane/aios_autonomous_control_plane/__pycache__/release.cpython-313.pyc",
|
||||
"services/aios-autonomous-control-plane/aios_autonomous_control_plane/__pycache__/renewal.cpython-313.pyc",
|
||||
"services/aios-autonomous-control-plane/aios_autonomous_control_plane/__pycache__/watcher.cpython-313.pyc",
|
||||
"services/aios-autonomous-control-plane/aios_autonomous_control_plane/__pycache__/writer.cpython-313.pyc",
|
||||
"tests/.pytest_cache/.gitignore",
|
||||
"tests/.pytest_cache/CACHEDIR.TAG",
|
||||
"tests/.pytest_cache/README.md",
|
||||
"tests/.pytest_cache/v/cache/lastfailed",
|
||||
"tests/.pytest_cache/v/cache/nodeids",
|
||||
"tests/__pycache__/conftest.cpython-313-pytest-9.0.2.pyc",
|
||||
"tests/autonomous_control_plane/__pycache__/test_mirror_projection.cpython-313-pytest-9.0.2.pyc",
|
||||
"tests/autonomous_control_plane/__pycache__/test_policy_and_writer.cpython-313-pytest-9.0.2.pyc",
|
||||
"tests/autonomous_control_plane/__pycache__/test_renewal_release.cpython-313-pytest-9.0.2.pyc",
|
||||
"tests/autonomous_control_plane/__pycache__/test_watcher.cpython-313-pytest-9.0.2.pyc"
|
||||
],
|
||||
"deletion_policy": "Only generated caches listed here may be removed. Do not delete repository source files.",
|
||||
"integration_strategy": "Apply additions and replacements on patch/v2r1c4-release-completion-20260729; preserve existing approved Git objects and user code.",
|
||||
"modified_files": [
|
||||
"CODE_HANDOFF_MANIFEST.json",
|
||||
"INTEGRATION_NOTES.md",
|
||||
"TEST_RECEIPT.json",
|
||||
"deploy/systemd/aios-autonomous-renewal-controller.service",
|
||||
"deploy/systemd/aios-governance-approval-watcher.service",
|
||||
"deploy/systemd/aios-governance-mirror-worker.service",
|
||||
"deploy/systemd/aios-governance-request-publisher.service",
|
||||
"deploy/systemd/aios-governed-development-writer-revoker.service",
|
||||
"deploy/systemd/aios-governed-development-writer.service",
|
||||
"deploy/systemd/aios-release-object-projection.service",
|
||||
"deploy/systemd/aios-runtime-source-read-projection.service",
|
||||
"deploy/tmpfiles.d/aios-autonomous-control-plane.conf",
|
||||
"services/aios-autonomous-control-plane/aios_autonomous_control_plane/projection.py",
|
||||
"services/aios-autonomous-control-plane/aios_autonomous_control_plane/release.py",
|
||||
"services/aios-autonomous-control-plane/aios_autonomous_control_plane/writer.py",
|
||||
"services/aios-autonomous-control-plane/pyproject.toml",
|
||||
"tests/autonomous_control_plane/test_mirror_projection.py",
|
||||
"tests/autonomous_control_plane/test_renewal_release.py"
|
||||
],
|
||||
"schema": "aios.code-handoff-delta/v1",
|
||||
"target_package_name": "aios_v2r1c4_autonomy_patch_v2_20260729.zip"
|
||||
}
|
||||
@@ -0,0 +1,66 @@
|
||||
{
|
||||
"AGENT_INTEGRATION_PLAN.md": "0af0bb6c3ed22d30c48e1e9af74540a0f4571dabe5dcf97bc67077d5cca6ea1d",
|
||||
"CODE_HANDOFF_MANIFEST.json": "b1e3fde19a864671b28945ff21fd6c4f1fe2fd4bb7d78048ba1430d3de286cf9",
|
||||
"DELTA_FROM_V1.json": "296571cac8fe3117443ad04c045a02203f1bb9eef5284f1704dda9c04e75e9ae",
|
||||
"INTEGRATION_NOTES.md": "e70df9ca86ed136d193b1773596f7187d6c1f8751f40c133d3e93f017233d05c",
|
||||
"TEST_RECEIPT.json": "e1e3cd8934d8b79a88bf740575e37c1407ab2a6dbad099a2730476e3b073564a",
|
||||
"config/examples/development-policy.json": "51ab926a733c9a5173df43a3bf23d25ee3bd2b4743f2005cc458dcef232f62e4",
|
||||
"config/examples/grant.json": "2dbece7418377880c63108e07155a3e97859f8b24d087ad353749cddf2572ffd",
|
||||
"config/examples/mirror.json": "41b3948ad34a0a58b5af389d93f9a51241544449b08b90daa93b74ab5d22d292",
|
||||
"config/examples/publisher.json": "d5198ba71dc87e9863b1fa1fcce0fabcc5d347e508fa2736041772fa68c083ea",
|
||||
"config/examples/release-actions.json": "08d08fe97f3fdd336cd8f0dbc1c358bb5c9a9b2c7b1f66d5ab0682ea6aa0572e",
|
||||
"config/examples/release-envelope.json": "6b3f31e75a9ec0d820e304932487c8a7961488d65b98c59a45320c52b3ca7a0f",
|
||||
"config/examples/release-hooks.json": "6bb755673fee080e968395478cbf3d4697b8afc47d1f791890b528693cfcdbf2",
|
||||
"config/examples/release-projection.json": "fa898f3fdb877f1c449999a827a9afb8797e026fd574ca7375b386069cf60e3d",
|
||||
"config/examples/renewal.json": "59c27809e4f066e7b12cd0b57fecf46dedf28640be1c92c6906c1b1c19e7b25a",
|
||||
"config/examples/revoker.json": "e4eaf3255e444c50ed29e9ee78b5d3284d26d74b55e17d0060b7e285b88b5845",
|
||||
"config/examples/runtime-projection.json": "4f11d1d15d8daf26b2c6dc7e01d5626315fa7f2ca3c32923f029728a67b86534",
|
||||
"config/examples/watcher.json": "95d83d7eedc3cbaf43901e9ec313f3cf08d9f5832c02910837187a2e32b9a465",
|
||||
"config/examples/writer-server.json": "f0b5648f3f8e4e37ad934aaff8c55480a25139b731f676e49adf9ae1a0ebe0e1",
|
||||
"deploy/systemd/aios-autonomous-renewal-controller.service": "38cf3269cac8e73cc004de50e051f26ea2e1f1a1427682e129b47960210e3c31",
|
||||
"deploy/systemd/aios-governance-approval-watcher.service": "e48174384113644771eaf893c68e49432fc7b5e8ab4b4fa301d191f079b4e30f",
|
||||
"deploy/systemd/aios-governance-mirror-worker.service": "1ef26557563b93d411b7a116800ca960dcde69051fd222c64555bf274ec15ca8",
|
||||
"deploy/systemd/aios-governance-request-publisher.service": "c4a69bea0fc23849aa3307d8939e08c3925c9df445d0e43ef7fb689e285e5f89",
|
||||
"deploy/systemd/aios-governed-development-writer-revoker.service": "f9128b9a2a4f77bde98f7e8a735babc67e14186860e8cb34eb94f6126dd6f7b5",
|
||||
"deploy/systemd/aios-governed-development-writer-revoker.timer": "0bf2bc416012b5009ccb9c7b8f76d546fa6485295a926829fd3b26e0c1f071ce",
|
||||
"deploy/systemd/aios-governed-development-writer.service": "b5d052b9f3cf81bc5587dd0545ac25ae55d29e37c32c760fb9725dced351598e",
|
||||
"deploy/systemd/aios-release-object-projection.service": "91acf73dcab189aebe7900237f25a3accaa804624c1b4f52a2b477128142ed46",
|
||||
"deploy/systemd/aios-runtime-source-read-projection.service": "45cf8a5c17fcd6960970ed8f26b02a1d3fdc53874d39c14b4a1d1d89d543679e",
|
||||
"deploy/systemd/aios-v2r1c4-release-envelope.service": "b9b4ffb3a41cf90256cb970fb300a8e633e91527f19c8a8b8ee1e3cabdda4492",
|
||||
"deploy/tmpfiles.d/aios-autonomous-control-plane.conf": "d5f3aefe63515b5699fbb81421480015bfa3bc1794ec02b8214a3c21f9cea8f2",
|
||||
"services/aios-autonomous-control-plane/aios_autonomous_control_plane/__init__.py": "52a7864b6a4ac94be8f67100c825813b19ccf889283bbb7dbecbd342b9ec29dc",
|
||||
"services/aios-autonomous-control-plane/aios_autonomous_control_plane/cli.py": "cd42b70c35b2d810433db0df013a439dc7993c45c68ea930a9efd5b5faced84c",
|
||||
"services/aios-autonomous-control-plane/aios_autonomous_control_plane/common.py": "395c669df606ed366774663d4ac229225469c77ab3ff72f6a9efcbcef8031f9e",
|
||||
"services/aios-autonomous-control-plane/aios_autonomous_control_plane/credentials.py": "61322d9f494a63764f1148550853d7ca7bcd9be74451bd3c3cf3cbe6388d2136",
|
||||
"services/aios-autonomous-control-plane/aios_autonomous_control_plane/gitea_api.py": "9b0a7d9db9a4497078d8f4b0bf7622b292b40282204a1e1855e11f1edc93b6de",
|
||||
"services/aios-autonomous-control-plane/aios_autonomous_control_plane/grant.py": "5b1cb302a1365f4a6f03df73f8c5f8a1595304d65e9d7ac129178d51b38dde59",
|
||||
"services/aios-autonomous-control-plane/aios_autonomous_control_plane/ledger.py": "a51eea543d4e44c2faab6b59c7850600908f36090f0a1ddf448c1ca7c21acdbd",
|
||||
"services/aios-autonomous-control-plane/aios_autonomous_control_plane/mirror.py": "20093cf68c0b4db4940d1092b0f09d7638ed210e2739973b1a558a4016208e01",
|
||||
"services/aios-autonomous-control-plane/aios_autonomous_control_plane/mirror_service.py": "a46549c4c8b29006ed2b1aec201e470e88e2f9b347ef2fa81839ac7d8093320b",
|
||||
"services/aios-autonomous-control-plane/aios_autonomous_control_plane/policy.py": "5fc5b50e781cfa47e99164635155a9559d168f1f556d8ca2f1694b57b1b57195",
|
||||
"services/aios-autonomous-control-plane/aios_autonomous_control_plane/projection.py": "6ee91b9b6482d4f10c98aa7e78bd23dc5f9f759c875db2e0a3207cfe27714c4c",
|
||||
"services/aios-autonomous-control-plane/aios_autonomous_control_plane/projection_service.py": "2019ca8e51affcebe6c776c2c3b51a54e1d6134874e3a9b12fc774393023172a",
|
||||
"services/aios-autonomous-control-plane/aios_autonomous_control_plane/publisher.py": "fd65490c1b384b2725315a066715c9822255bbef3c213ab343495c6c96a7e90f",
|
||||
"services/aios-autonomous-control-plane/aios_autonomous_control_plane/release.py": "2579fc38834d77c6370dcdc4269134fe42cf85540efcebf9e4f769ab6cbde200",
|
||||
"services/aios-autonomous-control-plane/aios_autonomous_control_plane/release_action.py": "26254215e032f361737584e2b8eb8367fe9f6930b946511e16f57d8e7f50cee9",
|
||||
"services/aios-autonomous-control-plane/aios_autonomous_control_plane/release_deploy.py": "bfb46b6dfacd88c69cee14c9f482a99a95a7b12f1de4b8778fdcdf1b66cfdbd3",
|
||||
"services/aios-autonomous-control-plane/aios_autonomous_control_plane/release_hooks.py": "10e485d39a4fcfba4323297101f4281e6a0a94a60f6ee64a8e22a5d171d79965",
|
||||
"services/aios-autonomous-control-plane/aios_autonomous_control_plane/release_service.py": "8d67a4b1562879b500120f65fb8f030183b0fb70acee646656dd235f00d0b618",
|
||||
"services/aios-autonomous-control-plane/aios_autonomous_control_plane/release_transport.py": "822257f2c48c1fe861d8766aad2d61302e8b4e223a15b26f3c75c993c30140e2",
|
||||
"services/aios-autonomous-control-plane/aios_autonomous_control_plane/renewal.py": "2272c428999a769218142b27b0a80e938c96b7cf1e553fdfd94873123dd9ad86",
|
||||
"services/aios-autonomous-control-plane/aios_autonomous_control_plane/renewal_service.py": "c7fc5e307bd6eaef35844868cecc530b463088b4f320e531800d8683f3a3733a",
|
||||
"services/aios-autonomous-control-plane/aios_autonomous_control_plane/revoker.py": "6953ec6442635a495ec602fbf6b2815aee40e43ad3790bf972a887bbb2de537d",
|
||||
"services/aios-autonomous-control-plane/aios_autonomous_control_plane/socket_service.py": "a42c80002e8fcea7000ee0f4fd2a437b44b18773edbdbb9dfc088d385d2782e7",
|
||||
"services/aios-autonomous-control-plane/aios_autonomous_control_plane/watcher.py": "eed557d5f6acfe44881bee44dd92fea6e04ac19f33e2dea874c2a4662b04c824",
|
||||
"services/aios-autonomous-control-plane/aios_autonomous_control_plane/watcher_service.py": "db502f08bafad752935180477894bb78d5b36f6261f8af13d8db2d9ecce184bb",
|
||||
"services/aios-autonomous-control-plane/aios_autonomous_control_plane/writer.py": "59b8f8d5c96a455e280de5a12280aca05070f86deb443e8f6fd842d7872dc60f",
|
||||
"services/aios-autonomous-control-plane/aios_autonomous_control_plane/writer_server.py": "1680ca5a053da5b9a7430a616904f474cf27833496f50ead2803227598fd901f",
|
||||
"services/aios-autonomous-control-plane/pyproject.toml": "4dae4bf9a88d033511a8de6d2871583d36cff868c3e0c6287c78d584933816df",
|
||||
"tests/autonomous_control_plane/test_deployment_and_contracts.py": "2606242519f4cdf5783dd36708357c6ec9520d66f8f8ec18ef28529e3bd240d4",
|
||||
"tests/autonomous_control_plane/test_mirror_projection.py": "5dc56cc0b5910d4b83afa4354f0375a2668ed5a328823357dc3ef2819235f26e",
|
||||
"tests/autonomous_control_plane/test_policy_and_writer.py": "723a6fafcc542de7da028d2a2f76a6eb2b7975d4e6e9d1a23c17973019f74b7c",
|
||||
"tests/autonomous_control_plane/test_renewal_release.py": "3199b9e87995d43ee97e8e62ebe85ef4f242afb16912bd1551d7570cb7d7474c",
|
||||
"tests/autonomous_control_plane/test_services_and_hooks.py": "e58bde487ed38dfbb123a37ae43733c28a519d294a7729d01823adf7d2e48dd5",
|
||||
"tests/autonomous_control_plane/test_watcher.py": "025ab4432522478ab7094751edf8da702b0e7be25d93876115cf9f416b7188b1",
|
||||
"tests/conftest.py": "32a3df0734d253b070594fce0327b929c8ee0bbb136ea6fa83a2abecb826415b"
|
||||
}
|
||||
@@ -0,0 +1,41 @@
|
||||
# AIOS V2R1C4 Autonomy Patch v2
|
||||
|
||||
This package completes the capabilities that were missing from the first handoff.
|
||||
|
||||
## Newly delivered
|
||||
|
||||
- Idempotent, credential-isolated governance request publisher.
|
||||
- Authenticated Unix-socket development writer server with SO_PEERCRED checks.
|
||||
- Root-owned task/branch/repository/path-bound Writer Grant and idempotent quota ledger.
|
||||
- Writer credential revocation, old-token HTTP 401 proof, encrypted credential removal,
|
||||
and read-only revoked Grant evidence.
|
||||
- Persistent watcher, mirror, projection, and renewal service entrypoints.
|
||||
- Complete release hook implementation:
|
||||
- Owner exact-head and machine-status validation.
|
||||
- Approved governance Manifest verification.
|
||||
- Governed merge and tag transports.
|
||||
- Remote/Gitea tag verification.
|
||||
- Safe Artifact extraction and atomic release symlink deployment.
|
||||
- systemd health checks.
|
||||
- rollback and restore.
|
||||
- Registry/Baseline snapshots, compensation, and final consistency.
|
||||
- Unified V2R1C4 release executor with automatic failure rollback.
|
||||
- 11 installed console entrypoints and 10 systemd/timer contracts.
|
||||
|
||||
## Offline verification
|
||||
|
||||
- compileall: PASS
|
||||
- pytest: 21 passed
|
||||
- Secret scan: REVIEW
|
||||
- Path traversal archive test: PASS
|
||||
- Metadata compensation test: PASS
|
||||
- Publisher idempotency test: PASS
|
||||
- Grant replay/quota test: PASS
|
||||
- Old credential 401 test: PASS
|
||||
|
||||
## Integration rule
|
||||
|
||||
Apply this package to `patch/v2r1c4-release-completion-20260729`.
|
||||
Agent should only supply environment configuration, existing governed endpoint
|
||||
addresses, encrypted credentials, exact Git object IDs, and online acceptance.
|
||||
Do not redesign or replace the delivered control-plane logic.
|
||||
@@ -0,0 +1,77 @@
|
||||
{
|
||||
"compatibility_adaptations": [
|
||||
{
|
||||
"binding": "resolved active Python executable; release hook rejects symlink executables",
|
||||
"new_sha256": "bd5c90b12f5f128cb3151f83e27748e8c382d1f07672dc67e3a97f5cb7ef5b03",
|
||||
"old_sha256": "e58bde487ed38dfbb123a37ae43733c28a519d294a7729d01823adf7d2e48dd5",
|
||||
"path": "tests/autonomous_control_plane/test_services_and_hooks.py",
|
||||
"product_runtime_modified": false,
|
||||
"reason": "host Python is 3.12 and package declares requires-python >=3.11; remove fixture-only /usr/bin/python3.13 binding"
|
||||
}
|
||||
],
|
||||
"compiled_cache_files_integrated": false,
|
||||
"delta_added_count": 32,
|
||||
"delta_deleted_cache_count": 21,
|
||||
"delta_modified_count": 18,
|
||||
"direct_main_push": false,
|
||||
"force_push_used": false,
|
||||
"gitea_api_bootstrap_token_status": 401,
|
||||
"gitea_api_preapply_oid": "e5dc9185dd153efdfb007f9b674197f613c10796",
|
||||
"gitea_api_reader_token_status": 401,
|
||||
"global_gitops_writes_enabled": false,
|
||||
"handoff_metadata_location": "evidence/releases/V2R1C4-code-handoff-v2",
|
||||
"integrated_runtime_and_test_paths": [
|
||||
"config/examples/grant.json",
|
||||
"config/examples/mirror.json",
|
||||
"config/examples/publisher.json",
|
||||
"config/examples/release-actions.json",
|
||||
"config/examples/release-envelope.json",
|
||||
"config/examples/release-hooks.json",
|
||||
"config/examples/release-projection.json",
|
||||
"config/examples/renewal.json",
|
||||
"config/examples/revoker.json",
|
||||
"config/examples/runtime-projection.json",
|
||||
"config/examples/watcher.json",
|
||||
"config/examples/writer-server.json",
|
||||
"deploy/systemd/aios-v2r1c4-release-envelope.service",
|
||||
"services/aios-autonomous-control-plane/aios_autonomous_control_plane/credentials.py",
|
||||
"services/aios-autonomous-control-plane/aios_autonomous_control_plane/gitea_api.py",
|
||||
"services/aios-autonomous-control-plane/aios_autonomous_control_plane/grant.py",
|
||||
"services/aios-autonomous-control-plane/aios_autonomous_control_plane/mirror_service.py",
|
||||
"services/aios-autonomous-control-plane/aios_autonomous_control_plane/projection_service.py",
|
||||
"services/aios-autonomous-control-plane/aios_autonomous_control_plane/publisher.py",
|
||||
"services/aios-autonomous-control-plane/aios_autonomous_control_plane/release_action.py",
|
||||
"services/aios-autonomous-control-plane/aios_autonomous_control_plane/release_deploy.py",
|
||||
"services/aios-autonomous-control-plane/aios_autonomous_control_plane/release_hooks.py",
|
||||
"services/aios-autonomous-control-plane/aios_autonomous_control_plane/release_service.py",
|
||||
"services/aios-autonomous-control-plane/aios_autonomous_control_plane/release_transport.py",
|
||||
"services/aios-autonomous-control-plane/aios_autonomous_control_plane/renewal_service.py",
|
||||
"services/aios-autonomous-control-plane/aios_autonomous_control_plane/revoker.py",
|
||||
"services/aios-autonomous-control-plane/aios_autonomous_control_plane/socket_service.py",
|
||||
"services/aios-autonomous-control-plane/aios_autonomous_control_plane/watcher_service.py",
|
||||
"services/aios-autonomous-control-plane/aios_autonomous_control_plane/writer_server.py",
|
||||
"tests/autonomous_control_plane/test_deployment_and_contracts.py",
|
||||
"tests/autonomous_control_plane/test_services_and_hooks.py",
|
||||
"deploy/systemd/aios-autonomous-renewal-controller.service",
|
||||
"deploy/systemd/aios-governance-approval-watcher.service",
|
||||
"deploy/systemd/aios-governance-mirror-worker.service",
|
||||
"deploy/systemd/aios-governance-request-publisher.service",
|
||||
"deploy/systemd/aios-governed-development-writer-revoker.service",
|
||||
"deploy/systemd/aios-governed-development-writer.service",
|
||||
"deploy/systemd/aios-release-object-projection.service",
|
||||
"deploy/systemd/aios-runtime-source-read-projection.service",
|
||||
"deploy/tmpfiles.d/aios-autonomous-control-plane.conf",
|
||||
"services/aios-autonomous-control-plane/aios_autonomous_control_plane/projection.py",
|
||||
"services/aios-autonomous-control-plane/aios_autonomous_control_plane/release.py",
|
||||
"services/aios-autonomous-control-plane/aios_autonomous_control_plane/writer.py",
|
||||
"services/aios-autonomous-control-plane/pyproject.toml",
|
||||
"tests/autonomous_control_plane/test_mirror_projection.py",
|
||||
"tests/autonomous_control_plane/test_renewal_release.py"
|
||||
],
|
||||
"schema": "aios.code-handoff-integration/v2",
|
||||
"source_file_hash_entries": 64,
|
||||
"source_file_hashes_verified": true,
|
||||
"source_zip_sha256": "7afbcfae0ff692d2b859cd1e7e96536b8e80188667554803da438dcddc292d69",
|
||||
"tag_rewritten": false,
|
||||
"v1_modified_base_files_verified": 15
|
||||
}
|
||||
@@ -0,0 +1,20 @@
|
||||
{
|
||||
"collection_errors": 0,
|
||||
"compileall_returncode": 0,
|
||||
"delta_added_files": 32,
|
||||
"delta_deleted_files": 21,
|
||||
"delta_modified_files": 18,
|
||||
"entrypoint_count": 11,
|
||||
"generated_at": "2026-07-29T08:11:08.888275Z",
|
||||
"pytest_failed": 0,
|
||||
"pytest_passed": 21,
|
||||
"pytest_returncode": 0,
|
||||
"secret_findings": [
|
||||
{
|
||||
"path": "tests/autonomous_control_plane/test_policy_and_writer.py",
|
||||
"rule": "literal-credential-assignment"
|
||||
}
|
||||
],
|
||||
"secret_scan": "PASS_TEST_FIXTURE_ONLY",
|
||||
"systemd_contract_count": 10
|
||||
}
|
||||
@@ -0,0 +1,104 @@
|
||||
{
|
||||
"actions": {
|
||||
"artifact_built": false,
|
||||
"baseline_modified": false,
|
||||
"control_plane_deployed": false,
|
||||
"core_redesigned_by_agent": false,
|
||||
"main_modified": false,
|
||||
"online_write_acceptance_executed": false,
|
||||
"owner_approval_pr_created": false,
|
||||
"production_modified": false,
|
||||
"registry_modified": false,
|
||||
"tag_created": false
|
||||
},
|
||||
"blocking_layer": "CODE_HANDOFF_SECURITY_INVARIANTS",
|
||||
"candidate_base_oid": "e5dc9185dd153efdfb007f9b674197f613c10796",
|
||||
"confirmed_security_findings": [
|
||||
{
|
||||
"evidence": "release_action.py:53-98",
|
||||
"id": "P0-OWNER-ENVELOPE-BINDING",
|
||||
"summary": "approved manifest digest is checked but manifest fields are not parsed and made equal to the release envelope"
|
||||
},
|
||||
{
|
||||
"evidence": "release.py:20-30,52-59",
|
||||
"id": "P0-UNCONSUMED-RELEASE-DIGESTS",
|
||||
"summary": "rollback, SBOM, test, evidence and tag/deployment/rollback plan digests are format checked but not verified against objects before side effects"
|
||||
},
|
||||
{
|
||||
"evidence": "release_deploy.py:173-188; release.py:168-170,210-214",
|
||||
"id": "P0-PARTIAL-DEPLOY-NO-COMPENSATION",
|
||||
"summary": "deployment side effects occur while phase is TAG_VERIFIED, which is excluded from automatic rollback"
|
||||
},
|
||||
{
|
||||
"evidence": "release_deploy.py:191-212",
|
||||
"id": "P0-ROLLBACK-TARGET-UNBOUND",
|
||||
"summary": "previous and restored directories are not constrained to release_root and are not bound to the approved rollback digest"
|
||||
},
|
||||
{
|
||||
"evidence": "policy.py:72-76; grant.py:10-25,62-71; writer.py:94-107; writer_server.py:28-38,64-68",
|
||||
"id": "P0-WRITER-GRANT-BOUNDARY",
|
||||
"summary": "expected base ancestry, exact task worktree/common-dir/remote and task credential identity are not closed"
|
||||
},
|
||||
{
|
||||
"evidence": "revoker.py:36-64; aios-governed-development-writer-revoker.timer:4-8",
|
||||
"id": "P0-REVOKER-EXPIRY-RECOVERY",
|
||||
"summary": "fixed five-minute timer ignores grant expiry and credential deletion precedes recoverable grant and receipt closure"
|
||||
},
|
||||
{
|
||||
"evidence": "deploy/tmpfiles.d/aios-autonomous-control-plane.conf:1-19",
|
||||
"id": "P1-SERVICE-DIRECTORY-PERMISSIONS",
|
||||
"summary": "0750 root:gitops directories are not writable by non-root writer and publisher users"
|
||||
},
|
||||
{
|
||||
"evidence": "release_transport.py:65-76; release_deploy.py:221-228",
|
||||
"id": "P1-LOOPBACK-URL-PREFIX",
|
||||
"summary": "string prefix checks accept non-loopback hosts and can forward credentials"
|
||||
}
|
||||
],
|
||||
"deployment_decision": "BLOCKED_PRODUCTION_DEPLOYMENT",
|
||||
"execution_status": "PARTIALLY_COMPLETED",
|
||||
"governance": {
|
||||
"AIOS_GITOPS_WRITES_ENABLED": false,
|
||||
"direct_main_push": false,
|
||||
"force_push_used": false,
|
||||
"owner_approval_respected": true,
|
||||
"secrets_committed": false,
|
||||
"tag_rewritten": false
|
||||
},
|
||||
"integrity": {
|
||||
"file_sha256": "64/64 PASS",
|
||||
"hardcoded_credentials": 0,
|
||||
"path_traversal_entries": 0,
|
||||
"secret_scan": "PASS",
|
||||
"v1_modified_base_files": "15/15 PASS",
|
||||
"zip_sha256": "7afbcfae0ff692d2b859cd1e7e96536b8e80188667554803da438dcddc292d69"
|
||||
},
|
||||
"live_binding_inventory": {
|
||||
"authoritative_bare": "/data/aios-gitops/repo.git",
|
||||
"candidate_health_endpoint_127_0_0_1_18890": "PRESENT_HTTP_200_NOT_APPROVED_AS_RELEASE_BINDING",
|
||||
"configured_health_endpoint_127_0_0_1_8080": "ABSENT",
|
||||
"configured_tag_endpoint_127_0_0_1_8080": "ABSENT",
|
||||
"gitea_bare": "/data/aios-gitops/runtime/gitea-bin/data/repositories/aios/aios.git",
|
||||
"gitea_db": "/data/aios-gitops/runtime/gitea-bin/data/gitea.db",
|
||||
"gitea_repo_id": 1,
|
||||
"integration_merge_writer_socket": "ABSENT",
|
||||
"owner_user_id": 2,
|
||||
"production_baseline_path": "ABSENT",
|
||||
"release_root_current_previous": "ABSENT",
|
||||
"v2r1c4_artifact": "ABSENT",
|
||||
"v2r1c4_registry": "ABSENT"
|
||||
},
|
||||
"observed_at": "2026-07-29T09:11:19.725943+00:00",
|
||||
"schema": "aios.code-handoff-validation/v2",
|
||||
"verification": {
|
||||
"collection_errors": 0,
|
||||
"compileall": "PASS",
|
||||
"console_entrypoints": "11/11 load PASS",
|
||||
"package_tests_after_fixture_adapter": "21 passed",
|
||||
"package_tests_original_host": "20 passed, 1 failed due fixture-only /usr/bin/python3.13 binding",
|
||||
"package_version": "0.2.0",
|
||||
"repository_tests": "660 passed, 1 skipped, 180 subtests passed",
|
||||
"runtime_dependencies": "0",
|
||||
"systemd_units": "10/10 staged-root syntax PASS"
|
||||
}
|
||||
}
|
||||
Some files were not shown because too many files have changed in this diff Show More
Reference in New Issue
Block a user