Compare commits
| Author | SHA1 | Date | |
|---|---|---|---|
 chatgpt-gitops-bot
|
c2525ecd51 |
@@ -88,10 +88,7 @@ BASE_MODELS = [
|
||||
{'id':'base.gpt-5.5','provider':'openai','model':'gpt-5.5','display_name':'GPT-5.5','scope':'global'},
|
||||
]
|
||||
SECRET_RE = re.compile(r'(?i)(api[_-]?key|secret[_-]?access[_-]?key|secret|password|token)\s*[:=]\s*["\']?([A-Za-z0-9_./+=:-]{16,})')
|
||||
SECRET_VAL_RE = re.compile(
|
||||
r'(?<![A-Za-z0-9_])'
|
||||
r'(sk-[A-Za-z0-9_-]{20,}|HPUA[A-Z0-9]{10,}|SDC[A-Za-z0-9]{20,})'
|
||||
)
|
||||
SECRET_VAL_RE = re.compile(r'(sk-[A-Za-z0-9_-]{20,}|HPUA[A-Z0-9]{10,}|SDC[A-Za-z0-9]{20,})')
|
||||
|
||||
READ_ONLY_GET_PATHS = frozenset({
|
||||
'/', '/health', '/api/health', '/api/openapi.yaml',
|
||||
@@ -103,14 +100,10 @@ READ_ONLY_GET_PATHS = frozenset({
|
||||
'/admin/ai-evolution/api/data',
|
||||
'/api/release-consistency', '/api/tag-publication-status',
|
||||
'/api/release-acceptance',
|
||||
'/getReleaseCandidate', '/getReleasePlan', '/getReleaseAcceptance',
|
||||
'/getApprovalEnvelope', '/getReleaseSaga', '/getCapabilityStatus',
|
||||
'/getRecoveryStatus',
|
||||
'/getReleaseCandidate', '/getApprovalEnvelope', '/getReleaseSaga',
|
||||
})
|
||||
SILENT_RELEASE_POST_PATHS = frozenset({
|
||||
'/createReleaseCandidate',
|
||||
'/createReleaseIntent',
|
||||
'/submitSignedApproval',
|
||||
'/submitOwnerApproval',
|
||||
'/startDeployment',
|
||||
})
|
||||
@@ -144,7 +137,7 @@ def _file_sha256(path: Path) -> str:
|
||||
digest.update(chunk)
|
||||
return digest.hexdigest()
|
||||
|
||||
def _build_silent_release_service() -> SilentReleaseActionService:
|
||||
def silent_release_service() -> SilentReleaseActionService:
|
||||
verifier=None
|
||||
if SILENT_RELEASE_PUBLIC_KEYS.is_file():
|
||||
verifier=SignedApprovalVerifier(
|
||||
@@ -162,15 +155,6 @@ def _build_silent_release_service() -> SilentReleaseActionService:
|
||||
expected_repository=REPOSITORY_IDENTITY,
|
||||
policy_sha256=policy_sha,
|
||||
)
|
||||
|
||||
# Construct once during service startup. If production execution is enabled
|
||||
# without every trusted builder/orchestrator dependency, construction fails
|
||||
# closed before the HTTP server accepts traffic.
|
||||
_SILENT_RELEASE_SERVICE = _build_silent_release_service()
|
||||
|
||||
|
||||
def silent_release_service() -> SilentReleaseActionService:
|
||||
return _SILENT_RELEASE_SERVICE
|
||||
def relpath(path: str) -> str:
|
||||
x = str(path or '').replace('\\','/').strip()
|
||||
if not x or x.startswith('/') or '..' in Path(x).parts or Path(x).parts[0] == '.git': raise ValueError('invalid path')
|
||||
@@ -540,11 +524,8 @@ class H(BaseHTTPRequestHandler):
|
||||
return self.sendj(publication_publisher().run_release_acceptance(request))
|
||||
if path in (
|
||||
'/getReleaseCandidate',
|
||||
'/getReleasePlan',
|
||||
'/getReleaseAcceptance',
|
||||
'/getApprovalEnvelope',
|
||||
'/getReleaseSaga',
|
||||
'/getCapabilityStatus',
|
||||
):
|
||||
candidate_id=(q.get('candidate_id') or [''])[0]
|
||||
if not candidate_id:
|
||||
@@ -558,19 +539,7 @@ class H(BaseHTTPRequestHandler):
|
||||
return self.sendj(
|
||||
service.get_approval_envelope(candidate_id)
|
||||
)
|
||||
if path == '/getReleasePlan':
|
||||
return self.sendj(service.get_release_plan(candidate_id))
|
||||
if path == '/getReleaseAcceptance':
|
||||
return self.sendj(service.get_acceptance(candidate_id))
|
||||
if path == '/getCapabilityStatus':
|
||||
return self.sendj(
|
||||
service.get_capability_status(candidate_id)
|
||||
)
|
||||
return self.sendj(service.get_release_saga(candidate_id))
|
||||
if path == '/getRecoveryStatus':
|
||||
return self.sendj(
|
||||
silent_release_service().get_recovery_status()
|
||||
)
|
||||
# Admin AI Evolution Dashboard
|
||||
if path in ('/admin/ai-evolution','/admin/ai-evolution/'):
|
||||
return self.ai_evolution_page()
|
||||
@@ -604,13 +573,7 @@ class H(BaseHTTPRequestHandler):
|
||||
return self.sendj(
|
||||
silent_release_service().create_release_candidate(data)
|
||||
)
|
||||
if path == '/createReleaseIntent':
|
||||
a=self.need('release:candidate')
|
||||
if not a: return
|
||||
return self.sendj(
|
||||
silent_release_service().create_release_intent(data)
|
||||
)
|
||||
if path in ('/submitOwnerApproval','/submitSignedApproval'):
|
||||
if path == '/submitOwnerApproval':
|
||||
a=self.need('release:approve')
|
||||
if not a: return
|
||||
return self.sendj(
|
||||
@@ -619,9 +582,15 @@ class H(BaseHTTPRequestHandler):
|
||||
if path == '/startDeployment':
|
||||
a=self.need('release:deploy')
|
||||
if not a: return
|
||||
approval=(
|
||||
SignedReleasePlanApproval.from_dict(data['approval'])
|
||||
if isinstance(data.get('approval'), dict)
|
||||
else None
|
||||
)
|
||||
return self.sendj(
|
||||
silent_release_service().start_deployment(
|
||||
str(data.get('candidate_id') or '')
|
||||
str(data.get('candidate_id') or ''),
|
||||
approval=approval,
|
||||
)
|
||||
)
|
||||
if path in ('/api/branch','/api/create-branch'): return self.branch(data)
|
||||
|
||||
@@ -1,316 +0,0 @@
|
||||
"""Task-scoped hardened wrapper around the existing Action API."""
|
||||
from __future__ import annotations
|
||||
|
||||
import json
|
||||
import os
|
||||
import subprocess
|
||||
from pathlib import Path
|
||||
import urllib.parse
|
||||
|
||||
import aios_chatgpt_actions_api as api
|
||||
import aios_isolated_writer_policy as policy
|
||||
from isolated_writer_authz import AuthorizationError, authorize
|
||||
from isolated_writer_commit_file import AtomicCommitFile, CommitFileError, OperationLedger
|
||||
from isolated_writer_token_registry import TokenRegistry
|
||||
|
||||
_reject = api.reject_non_read_http
|
||||
_write_file = api.write_file
|
||||
_sync_branch = api.sync_branch
|
||||
_original_do_get = api.H.do_GET
|
||||
api.OPENAPI = Path(os.getenv("AIOS_GITOPS_ISOLATED_WRITER_OPENAPI", str(api.OPENAPI)))
|
||||
|
||||
|
||||
def _registry() -> TokenRegistry:
|
||||
return TokenRegistry(Path(os.environ["AIOS_GITOPS_TOKEN_REGISTRY_V2"]))
|
||||
|
||||
|
||||
def _atomic_writer() -> AtomicCommitFile:
|
||||
return AtomicCommitFile(
|
||||
workspace=api.WS,
|
||||
bare_repo=api.BARE_REPO,
|
||||
ledger=OperationLedger(Path(os.environ["AIOS_GITOPS_WRITER_OPERATION_LEDGER"])),
|
||||
remote=os.getenv("AIOS_GITOPS_GITEA_PUSH_REMOTE", ""),
|
||||
audit=policy.append_audit_record,
|
||||
)
|
||||
|
||||
|
||||
def _bearer(handler) -> str:
|
||||
value = handler.headers.get("Authorization", "")
|
||||
return value[7:].strip() if value.startswith("Bearer ") else ""
|
||||
|
||||
|
||||
def _authorize(handler, *, method: str, path: str, branch=None, target_path=None):
|
||||
grant = authorize(
|
||||
_registry(),
|
||||
_bearer(handler),
|
||||
method=method,
|
||||
path=path,
|
||||
source_ip=str(handler.client_address[0]),
|
||||
workspace=api.WS,
|
||||
branch=branch,
|
||||
target_path=target_path,
|
||||
)
|
||||
grant.record["_source_ip"] = str(handler.client_address[0])
|
||||
return grant
|
||||
|
||||
|
||||
def _authorization_error(handler, exc: AuthorizationError):
|
||||
return handler.sendj({"error": exc.code}, exc.status)
|
||||
|
||||
|
||||
def _isolated_runtime_status(handler):
|
||||
branch = api.sh(["rev-parse", "--abbrev-ref", "HEAD"], True)["stdout"]
|
||||
head = api.sh(["rev-parse", "HEAD"], True)["stdout"]
|
||||
return handler.sendj({
|
||||
"service": os.getenv(
|
||||
"AIOS_GITOPS_SERVICE_AUDIENCE",
|
||||
"aios-isolated-writer.service",
|
||||
),
|
||||
"status": "active",
|
||||
"runtime_role": os.getenv("AIOS_GITOPS_RUNTIME_ROLE"),
|
||||
"workspace_role": os.getenv("AIOS_GITOPS_WORKSPACE_ROLE"),
|
||||
"writes_enabled": os.getenv("AIOS_GITOPS_WRITES_ENABLED", "").lower()
|
||||
in {"1", "true", "yes", "on"},
|
||||
"allowed_branch": policy.allowed_branch(),
|
||||
"approved_base_oid": policy.allowed_base_oid(),
|
||||
"workspace_branch": branch,
|
||||
"workspace_head_oid": head,
|
||||
"repository_identity": os.getenv("AIOS_GITOPS_REPOSITORY_IDENTITY"),
|
||||
"token_policy_version": 2,
|
||||
"atomic_commit_file": True,
|
||||
"path_policy_sha256": policy.configured_path_policy_sha256(),
|
||||
})
|
||||
|
||||
|
||||
def _isolated_do_get(self):
|
||||
path = urllib.parse.urlparse(self.path).path.rstrip("/") or "/"
|
||||
if path in {"/health", "/api/health"}:
|
||||
return self.sendj({
|
||||
"status": "ok",
|
||||
"service": os.getenv(
|
||||
"AIOS_GITOPS_SERVICE_AUDIENCE",
|
||||
"aios-isolated-writer.service",
|
||||
),
|
||||
})
|
||||
if path not in {"/api/runtime-status", "/api/baseline", "/api/patches"}:
|
||||
return self.sendj({"error": "isolated_writer_operation_forbidden"}, 403)
|
||||
try:
|
||||
_authorize(self, method="GET", path=path)
|
||||
except AuthorizationError as exc:
|
||||
return _authorization_error(self, exc)
|
||||
if path == "/api/runtime-status":
|
||||
return _isolated_runtime_status(self)
|
||||
return _original_do_get(self)
|
||||
|
||||
|
||||
def _read_commit_file_body(handler):
|
||||
try:
|
||||
length = int(handler.headers.get("Content-Length", "0"))
|
||||
except ValueError:
|
||||
raise CommitFileError("writer_content_length_rejected") from None
|
||||
if length <= 0:
|
||||
raise CommitFileError("writer_request_object_required")
|
||||
if length > 1_100_000:
|
||||
raise CommitFileError("writer_request_too_large", 413)
|
||||
raw = handler.rfile.read(length)
|
||||
try:
|
||||
value = json.loads(raw.decode("utf-8"))
|
||||
except (UnicodeDecodeError, json.JSONDecodeError):
|
||||
raise CommitFileError("writer_request_json_rejected") from None
|
||||
if not isinstance(value, dict):
|
||||
raise CommitFileError("writer_request_object_required")
|
||||
return value
|
||||
|
||||
|
||||
def _isolated_do_post(self):
|
||||
path = urllib.parse.urlparse(self.path).path.rstrip("/") or "/"
|
||||
if path != "/api/commit-file":
|
||||
return self.sendj({"error": "isolated_writer_operation_forbidden"}, 403)
|
||||
try:
|
||||
data = _read_commit_file_body(self)
|
||||
branch = str(data.get("branch") or "")
|
||||
target_path = str(data.get("path") or "")
|
||||
grant = _authorize(
|
||||
self,
|
||||
method="POST",
|
||||
path=path,
|
||||
branch=branch,
|
||||
target_path=target_path,
|
||||
)
|
||||
if api.content_has_secret(str(data.get("content") or "")):
|
||||
raise CommitFileError("writer_secret_content_rejected", 403)
|
||||
result = _atomic_writer().execute(grant, data)
|
||||
return self.sendj(result)
|
||||
except AuthorizationError as exc:
|
||||
return _authorization_error(self, exc)
|
||||
except CommitFileError as exc:
|
||||
return self.sendj({"error": exc.code}, exc.status)
|
||||
except PermissionError:
|
||||
return self.sendj({"error": "isolated_writer_policy_rejected"}, 403)
|
||||
|
||||
|
||||
def reject_non_read_http(handler, method: str, path: str) -> bool:
|
||||
if _reject(handler, method, path):
|
||||
return True
|
||||
try:
|
||||
policy.validate_endpoint(method, path, api.WS, api.BARE_REPO)
|
||||
return False
|
||||
except PermissionError as exc:
|
||||
handler.sendj({"error": str(exc)}, 403)
|
||||
return True
|
||||
|
||||
|
||||
def checkout(branch, base="main", create=False):
|
||||
api.ensure_git()
|
||||
target = api.branch_name(branch)
|
||||
policy.validate_branch_request({"branch": target, "base": base})
|
||||
exists = api.sh(["rev-parse", "--verify", target])["code"] == 0
|
||||
if exists:
|
||||
if api.sh(["rev-parse", "--abbrev-ref", "HEAD"], True)["stdout"] != target:
|
||||
api.sh(["checkout", target], True)
|
||||
elif create:
|
||||
api.sh(["checkout", "-b", target, base], True)
|
||||
else:
|
||||
raise PermissionError("isolated_writer_branch_missing")
|
||||
policy.require_service_invariants(api.WS, api.BARE_REPO)
|
||||
return target
|
||||
|
||||
|
||||
def write_file(path, content):
|
||||
policy.validate_path(path, api.WS)
|
||||
return _write_file(path, content)
|
||||
|
||||
|
||||
def sync_branch(branch: str):
|
||||
policy.validate_sync_branch(branch)
|
||||
local = _sync_branch(branch)
|
||||
remote = os.getenv("AIOS_GITOPS_GITEA_PUSH_REMOTE", "").strip()
|
||||
if remote != "gitea-http":
|
||||
raise PermissionError("isolated_writer_gitea_remote_rejected")
|
||||
head = api.sh(["rev-parse", "HEAD"], True)["stdout"]
|
||||
pushed = subprocess.run(
|
||||
["git", "push", "--porcelain", remote, f"HEAD:refs/heads/{branch}"],
|
||||
cwd=api.WS,
|
||||
text=True,
|
||||
capture_output=True,
|
||||
)
|
||||
if pushed.returncode != 0:
|
||||
raise RuntimeError("isolated_writer_gitea_push_failed")
|
||||
verified = subprocess.run(
|
||||
["git", "ls-remote", "--heads", remote, f"refs/heads/{branch}"],
|
||||
cwd=api.WS,
|
||||
text=True,
|
||||
capture_output=True,
|
||||
)
|
||||
if verified.returncode != 0:
|
||||
raise RuntimeError("isolated_writer_gitea_verification_failed")
|
||||
fields = verified.stdout.strip().split()
|
||||
if len(fields) != 2 or fields[0] != head or fields[1] != f"refs/heads/{branch}":
|
||||
raise RuntimeError("isolated_writer_gitea_oid_mismatch")
|
||||
return {
|
||||
"status": "verified",
|
||||
"target": "authoritative-bare+gitea",
|
||||
"branch": branch,
|
||||
"oid": head,
|
||||
"local": local.get("status"),
|
||||
}
|
||||
|
||||
|
||||
def commit(paths, msg):
|
||||
policy.validate_commit_paths(paths, api.WS)
|
||||
api.ensure_git()
|
||||
selected = [api.relpath(p) for p in paths] if paths else ["."]
|
||||
api.sh(["add", *selected], True)
|
||||
policy.validate_staged_paths(api.WS)
|
||||
branch = api.sh(["rev-parse", "--abbrev-ref", "HEAD"], True)["stdout"]
|
||||
if not api.sh(["status", "--short"])["stdout"]:
|
||||
return {"status": "no_changes", "branch": branch, "sync": sync_branch(branch)}
|
||||
out = api.sh(["commit", "-m", msg], True)
|
||||
branch = api.sh(["rev-parse", "--abbrev-ref", "HEAD"], True)["stdout"]
|
||||
return {
|
||||
"status": "committed",
|
||||
"branch": branch,
|
||||
"rev": api.sh(["rev-parse", "--short", "HEAD"], True)["stdout"],
|
||||
"git": out,
|
||||
"sync": sync_branch(branch),
|
||||
}
|
||||
|
||||
|
||||
def audit(actor, action, target, payload):
|
||||
policy.append_audit_record(
|
||||
{
|
||||
"at": api.now(),
|
||||
"actor": actor,
|
||||
"action": action,
|
||||
"target": target,
|
||||
"payload": api.sanitize(payload),
|
||||
}
|
||||
)
|
||||
|
||||
|
||||
def _validate_request(self, data, validate):
|
||||
try:
|
||||
validate(data)
|
||||
return True
|
||||
except PermissionError as exc:
|
||||
self.sendj({"error": str(exc)}, 403)
|
||||
return False
|
||||
|
||||
|
||||
def _checked_branch(self, data):
|
||||
if not _validate_request(self, data, policy.validate_branch_request):
|
||||
return
|
||||
return _branch(self, data)
|
||||
|
||||
|
||||
def _checked_file(self, data):
|
||||
data = dict(data)
|
||||
data.setdefault("branch", policy.allowed_branch())
|
||||
if not _validate_request(self, data, policy.validate_branch_request):
|
||||
return
|
||||
if not _validate_request(
|
||||
self,
|
||||
{"path": data.get("path", "")},
|
||||
lambda item: policy.validate_path(item["path"], api.WS),
|
||||
):
|
||||
return
|
||||
return _file(self, data)
|
||||
|
||||
|
||||
def _checked_commit(self, data):
|
||||
data = dict(data)
|
||||
data.setdefault("branch", policy.allowed_branch())
|
||||
if not _validate_request(self, data, policy.validate_branch_request):
|
||||
return
|
||||
return _commit(self, data)
|
||||
|
||||
|
||||
def _checked_patch(self, data):
|
||||
data = dict(data)
|
||||
data["branch"] = policy.allowed_branch()
|
||||
if not _validate_request(self, data, policy.validate_branch_request):
|
||||
return
|
||||
return _patch(self, data)
|
||||
|
||||
|
||||
_branch, _file, _commit, _patch = api.H.branch, api.H.file, api.H.commit, api.H.patch
|
||||
api.reject_non_read_http = reject_non_read_http
|
||||
api.checkout, api.write_file, api.sync_branch, api.commit, api.audit = (
|
||||
checkout,
|
||||
write_file,
|
||||
sync_branch,
|
||||
commit,
|
||||
audit,
|
||||
)
|
||||
api.H.branch, api.H.file, api.H.commit, api.H.patch = (
|
||||
_checked_branch,
|
||||
_checked_file,
|
||||
_checked_commit,
|
||||
_checked_patch,
|
||||
)
|
||||
api.H.do_GET = _isolated_do_get
|
||||
api.H.do_POST = _isolated_do_post
|
||||
|
||||
if __name__ == "__main__":
|
||||
policy.require_service_invariants(api.WS, api.BARE_REPO)
|
||||
api.ThreadingHTTPServer((api.HOST, api.PORT), api.H).serve_forever()
|
||||
@@ -1,310 +0,0 @@
|
||||
"""Fail-closed policy used only by the task-scoped Action writer."""
|
||||
from __future__ import annotations
|
||||
|
||||
import os
|
||||
import json
|
||||
import stat
|
||||
import subprocess
|
||||
import re
|
||||
from pathlib import Path, PurePosixPath, PureWindowsPath
|
||||
from urllib.parse import unquote
|
||||
|
||||
import isolated_writer_path_policy as path_policy
|
||||
|
||||
WRITE_ENDPOINTS = frozenset({"/api/commit-file"})
|
||||
ALLOWED_ROOTS = (
|
||||
"active-runtime",
|
||||
"docs",
|
||||
"patches",
|
||||
"reports",
|
||||
"scripts",
|
||||
"test",
|
||||
"tests",
|
||||
)
|
||||
DENIED_ROOTS = ("baseline", "config", "deploy", "deployments", "ops", "runtime", "services")
|
||||
_TRUE = frozenset({"1", "true", "yes", "on"})
|
||||
_FALSE = frozenset({"0", "false", "no", "off"})
|
||||
_DENY_FLAGS = (
|
||||
"AIOS_GITOPS_ALLOW_MAIN_WRITE",
|
||||
"AIOS_GITOPS_ALLOW_TAG_WRITE",
|
||||
"AIOS_GITOPS_ALLOW_BASELINE_WRITE",
|
||||
"AIOS_GITOPS_ALLOW_REGISTRY_WRITE",
|
||||
"AIOS_GITOPS_ALLOW_ROLLBACK",
|
||||
"AIOS_GITOPS_ALLOW_DEPLOYMENT",
|
||||
)
|
||||
|
||||
|
||||
def enforcement_required() -> bool:
|
||||
return os.getenv("AIOS_GITOPS_ISOLATED_WRITER_ENFORCEMENT", "") == "required"
|
||||
|
||||
|
||||
def allowed_branch() -> str:
|
||||
value = os.getenv("AIOS_GITOPS_ALLOWED_BRANCH", "").strip()
|
||||
if not value:
|
||||
raise PermissionError("isolated_writer_missing_allowed_branch")
|
||||
return value
|
||||
|
||||
|
||||
def allowed_base_oid() -> str:
|
||||
value = os.getenv("AIOS_GITOPS_ALLOWED_BASE_OID", "").strip().lower()
|
||||
if len(value) != 40 or any(ch not in "0123456789abcdef" for ch in value):
|
||||
raise PermissionError("isolated_writer_invalid_allowed_base_oid")
|
||||
return value
|
||||
|
||||
|
||||
def _git(workspace: Path, *args: str) -> str:
|
||||
result = subprocess.run(["git", *args], cwd=workspace, text=True, capture_output=True)
|
||||
if result.returncode != 0:
|
||||
raise PermissionError("isolated_writer_git_validation_failed")
|
||||
return result.stdout.strip()
|
||||
|
||||
|
||||
def require_service_invariants(workspace: Path, bare_repo: Path) -> None:
|
||||
if not enforcement_required():
|
||||
return
|
||||
if os.getenv("AIOS_GITOPS_WRITES_ENABLED", "").strip().lower() not in _TRUE:
|
||||
raise PermissionError("isolated_writer_write_gate_required")
|
||||
if os.getenv("AIOS_GITOPS_RUNTIME_ROLE", "") != "isolated-writer":
|
||||
raise PermissionError("isolated_writer_role_required")
|
||||
if os.getenv("AIOS_GITOPS_WORKSPACE_ROLE", "") != "isolated-writer":
|
||||
raise PermissionError("isolated_writer_workspace_role_required")
|
||||
if os.getenv("AIOS_GITOPS_TOKEN_POLICY_VERSION_REQUIRED", "") != "2":
|
||||
raise PermissionError("isolated_writer_token_policy_v2_required")
|
||||
if not os.getenv("AIOS_GITOPS_SERVICE_AUDIENCE", "").strip():
|
||||
raise PermissionError("isolated_writer_service_audience_required")
|
||||
if not os.getenv("AIOS_GITOPS_TOKEN_REGISTRY_V2", "").strip():
|
||||
raise PermissionError("isolated_writer_token_registry_required")
|
||||
if not os.getenv("AIOS_GITOPS_WRITER_OPERATION_LEDGER", "").strip():
|
||||
raise PermissionError("isolated_writer_operation_ledger_required")
|
||||
path_policy.configured_path_policy()
|
||||
for name in _DENY_FLAGS:
|
||||
if os.getenv(name, "").strip().lower() not in _FALSE:
|
||||
raise PermissionError("isolated_writer_forbidden_capability_flag")
|
||||
if os.getenv("AIOS_GITOPS_REPOSITORY_IDENTITY", "") != "aios/aios":
|
||||
raise PermissionError("isolated_writer_repository_identity_rejected")
|
||||
configured_bare_value = os.getenv("AIOS_GITOPS_AUTHORITATIVE_GIT_DIR", "").strip()
|
||||
if not configured_bare_value:
|
||||
raise PermissionError("isolated_writer_authoritative_repo_rejected")
|
||||
configured_bare = Path(configured_bare_value)
|
||||
if configured_bare.resolve(strict=True) != bare_repo.resolve(strict=True):
|
||||
raise PermissionError("isolated_writer_authoritative_repo_rejected")
|
||||
writer_root_value = os.getenv("AIOS_GITOPS_APPROVED_WRITER_ROOT", "").strip()
|
||||
if not writer_root_value:
|
||||
raise PermissionError("isolated_writer_workspace_outside_approved_root")
|
||||
writer_root = Path(writer_root_value).resolve(strict=True)
|
||||
lexical_workspace = Path(os.path.abspath(str(workspace)))
|
||||
canonical_workspace = lexical_workspace.resolve(strict=True)
|
||||
if lexical_workspace != canonical_workspace:
|
||||
raise PermissionError("isolated_writer_workspace_symlink_rejected")
|
||||
try:
|
||||
canonical_workspace.relative_to(writer_root)
|
||||
except (ValueError, FileNotFoundError):
|
||||
raise PermissionError("isolated_writer_workspace_outside_approved_root") from None
|
||||
if _git(workspace, "rev-parse", "--abbrev-ref", "HEAD") != allowed_branch():
|
||||
raise PermissionError("isolated_writer_current_branch_rejected")
|
||||
approved_base = allowed_base_oid()
|
||||
try:
|
||||
_git(workspace, "cat-file", "-e", f"{approved_base}^{{commit}}")
|
||||
subprocess.run(
|
||||
["git", "merge-base", "--is-ancestor", approved_base, "HEAD"],
|
||||
cwd=workspace,
|
||||
check=True,
|
||||
stdout=subprocess.DEVNULL,
|
||||
stderr=subprocess.DEVNULL,
|
||||
)
|
||||
except (PermissionError, subprocess.CalledProcessError):
|
||||
raise PermissionError("isolated_writer_approved_base_not_ancestor") from None
|
||||
if _git(workspace, "merge-base", approved_base, "HEAD") != approved_base:
|
||||
raise PermissionError("isolated_writer_merge_base_rejected")
|
||||
common = Path(_git(workspace, "rev-parse", "--git-common-dir"))
|
||||
if not common.is_absolute():
|
||||
common = (workspace / common).resolve()
|
||||
if common.resolve() != bare_repo.resolve():
|
||||
raise PermissionError("isolated_writer_common_repo_rejected")
|
||||
|
||||
|
||||
def approved_audit_log_path() -> Path:
|
||||
root_value = os.getenv("AIOS_GITOPS_APPROVED_AUDIT_ROOT", "").strip()
|
||||
log_value = os.getenv("AIOS_GITOPS_AUDIT_LOG", "").strip()
|
||||
if not root_value or not log_value:
|
||||
raise PermissionError("isolated_writer_audit_path_missing")
|
||||
lexical_root = Path(os.path.abspath(root_value))
|
||||
lexical_log = Path(os.path.abspath(log_value))
|
||||
root = lexical_root.resolve(strict=True)
|
||||
if lexical_root != root or root.is_symlink() or not root.is_dir():
|
||||
raise PermissionError("isolated_writer_audit_root_rejected")
|
||||
try:
|
||||
lexical_log.relative_to(root)
|
||||
except ValueError:
|
||||
raise PermissionError("isolated_writer_audit_path_outside_approved_root") from None
|
||||
if lexical_log.parent.resolve(strict=True) != lexical_log.parent:
|
||||
raise PermissionError("isolated_writer_audit_parent_symlink_rejected")
|
||||
if lexical_log.exists() and lexical_log.is_symlink():
|
||||
raise PermissionError("isolated_writer_audit_log_symlink_rejected")
|
||||
os.chmod(root, 0o750)
|
||||
os.chmod(lexical_log.parent, 0o750)
|
||||
return lexical_log
|
||||
|
||||
|
||||
def append_audit_record(record: dict) -> None:
|
||||
path = approved_audit_log_path()
|
||||
flags = os.O_WRONLY | os.O_APPEND | os.O_CREAT
|
||||
if hasattr(os, "O_NOFOLLOW"):
|
||||
flags |= os.O_NOFOLLOW
|
||||
descriptor = os.open(path, flags, 0o600)
|
||||
try:
|
||||
info = os.fstat(descriptor)
|
||||
if not stat.S_ISREG(info.st_mode):
|
||||
raise PermissionError("isolated_writer_audit_log_not_regular")
|
||||
os.fchmod(descriptor, 0o600)
|
||||
line = json.dumps(
|
||||
_audit_sanitize(record),
|
||||
ensure_ascii=False,
|
||||
sort_keys=True,
|
||||
separators=(",", ":"),
|
||||
).encode("utf-8") + b"\n"
|
||||
os.write(descriptor, line)
|
||||
os.fsync(descriptor)
|
||||
finally:
|
||||
os.close(descriptor)
|
||||
parent_fd = os.open(path.parent, os.O_RDONLY | getattr(os, "O_DIRECTORY", 0))
|
||||
try:
|
||||
os.fsync(parent_fd)
|
||||
finally:
|
||||
os.close(parent_fd)
|
||||
|
||||
|
||||
def _audit_sanitize(value):
|
||||
if isinstance(value, dict):
|
||||
return {
|
||||
key: (
|
||||
"[REDACTED]"
|
||||
if any(
|
||||
marker in str(key).lower()
|
||||
for marker in (
|
||||
"authorization",
|
||||
"credential",
|
||||
"password",
|
||||
"secret",
|
||||
"token",
|
||||
"private_key",
|
||||
)
|
||||
)
|
||||
and str(key).lower() != "token_id"
|
||||
else _audit_sanitize(inner)
|
||||
)
|
||||
for key, inner in value.items()
|
||||
}
|
||||
if isinstance(value, list):
|
||||
return [_audit_sanitize(item) for item in value]
|
||||
if isinstance(value, str) and re.search(
|
||||
r"(?i)(authorization\s*:\s*bearer|(?:token|password|secret)\s*[:=])",
|
||||
value,
|
||||
):
|
||||
return "[REDACTED]"
|
||||
return value
|
||||
|
||||
|
||||
def validate_endpoint(method: str, path: str, workspace: Path, bare_repo: Path) -> None:
|
||||
if not enforcement_required():
|
||||
return
|
||||
if method != "POST" or path not in WRITE_ENDPOINTS:
|
||||
raise PermissionError("isolated_writer_operation_forbidden")
|
||||
require_service_invariants(workspace, bare_repo)
|
||||
|
||||
|
||||
def validate_branch_request(data: dict) -> None:
|
||||
if not enforcement_required():
|
||||
return
|
||||
branch = allowed_branch() if "branch" not in data else str(data.get("branch") or "").strip()
|
||||
if branch != allowed_branch():
|
||||
raise PermissionError("isolated_writer_branch_rejected")
|
||||
if str(data.get("base", "main")).strip() != "main":
|
||||
raise PermissionError("isolated_writer_base_rejected")
|
||||
if data.get("force") or data.get("force_push"):
|
||||
raise PermissionError("isolated_writer_force_rejected")
|
||||
|
||||
|
||||
def validate_path(path: str, workspace: Path | None = None) -> str:
|
||||
if not isinstance(path, str):
|
||||
raise PermissionError("isolated_writer_path_rejected")
|
||||
value = path
|
||||
if not value or value != value.strip() or "\x00" in value or "\\" in value:
|
||||
raise PermissionError("isolated_writer_path_rejected")
|
||||
try:
|
||||
decoded = unquote(value, errors="strict")
|
||||
except (UnicodeDecodeError, ValueError):
|
||||
raise PermissionError("isolated_writer_path_rejected") from None
|
||||
if decoded != value:
|
||||
raise PermissionError("isolated_writer_path_rejected")
|
||||
windows = PureWindowsPath(value)
|
||||
posix = PurePosixPath(value)
|
||||
parts = value.split("/")
|
||||
if (
|
||||
posix.is_absolute()
|
||||
or windows.is_absolute()
|
||||
or bool(windows.drive)
|
||||
or any(part in {"", ".", ".."} for part in parts)
|
||||
):
|
||||
raise PermissionError("isolated_writer_path_rejected")
|
||||
first = parts[0]
|
||||
service_exact_path = False
|
||||
if first in DENIED_ROOTS:
|
||||
try:
|
||||
path_policy.require_service_path("commit_file.atomic", value)
|
||||
service_exact_path = True
|
||||
except path_policy.PathPolicyError as exc:
|
||||
raise PermissionError(str(exc)) from None
|
||||
if value != "README.md" and first not in ALLOWED_ROOTS and not service_exact_path:
|
||||
raise PermissionError("isolated_writer_path_outside_allowed_roots")
|
||||
if workspace is not None:
|
||||
lexical_root = Path(os.path.abspath(str(workspace)))
|
||||
root = lexical_root.resolve(strict=True)
|
||||
if lexical_root != root:
|
||||
raise PermissionError("isolated_writer_workspace_symlink_rejected")
|
||||
current = root
|
||||
for part in parts:
|
||||
current = current / part
|
||||
if current.is_symlink():
|
||||
raise PermissionError("isolated_writer_path_symlink_rejected")
|
||||
candidate = (root / value).resolve(strict=False)
|
||||
try:
|
||||
candidate.relative_to(root)
|
||||
except ValueError:
|
||||
raise PermissionError("isolated_writer_path_escapes_workspace") from None
|
||||
return value
|
||||
|
||||
|
||||
def validate_content_for_path(path: str, content: str) -> None:
|
||||
if path.split("/", 1)[0] not in DENIED_ROOTS:
|
||||
return
|
||||
try:
|
||||
path_policy.validate_content("commit_file.atomic", path, content)
|
||||
except path_policy.PathPolicyError as exc:
|
||||
raise PermissionError(str(exc)) from None
|
||||
|
||||
|
||||
def configured_path_policy_sha256() -> str | None:
|
||||
try:
|
||||
return path_policy.configured_path_policy_sha256()
|
||||
except path_policy.PathPolicyError as exc:
|
||||
raise PermissionError(str(exc)) from None
|
||||
|
||||
|
||||
def validate_commit_paths(paths: list[str], workspace: Path | None = None) -> None:
|
||||
if enforcement_required():
|
||||
for path in paths:
|
||||
if str(path).strip() != ".":
|
||||
validate_path(str(path), workspace)
|
||||
|
||||
|
||||
def validate_staged_paths(workspace: Path) -> None:
|
||||
if not enforcement_required():
|
||||
return
|
||||
for path in _git(workspace, "diff", "--cached", "--name-only").splitlines():
|
||||
validate_path(path, workspace)
|
||||
|
||||
|
||||
def validate_sync_branch(branch: str) -> None:
|
||||
if enforcement_required() and branch != allowed_branch():
|
||||
raise PermissionError("isolated_writer_sync_branch_rejected")
|
||||
@@ -1,167 +0,0 @@
|
||||
"""Fail-closed operation authorization for an isolated Git writer."""
|
||||
from __future__ import annotations
|
||||
|
||||
import ipaddress
|
||||
import os
|
||||
import re
|
||||
import subprocess
|
||||
from dataclasses import dataclass
|
||||
from datetime import datetime, timezone
|
||||
from pathlib import Path
|
||||
from typing import Any
|
||||
|
||||
from isolated_writer_token_registry import TokenRegistry
|
||||
|
||||
|
||||
ROUTE_OPERATIONS = {
|
||||
("GET", "/api/runtime-status"): "runtime.status.read",
|
||||
("GET", "/api/baseline"): "baseline.read",
|
||||
("GET", "/api/patches"): "patches.read",
|
||||
("POST", "/api/commit-file"): "commit_file.atomic",
|
||||
}
|
||||
OID_RE = re.compile(r"[0-9a-f]{40}")
|
||||
|
||||
|
||||
class AuthorizationError(PermissionError):
|
||||
def __init__(self, code: str, status: int = 403):
|
||||
super().__init__(code)
|
||||
self.code = code
|
||||
self.status = status
|
||||
|
||||
|
||||
@dataclass(frozen=True)
|
||||
class AuthorizedGrant:
|
||||
record: dict[str, Any]
|
||||
operation: str
|
||||
use_count: int
|
||||
|
||||
@property
|
||||
def token_id(self) -> str:
|
||||
return str(self.record["token_id"])
|
||||
|
||||
@property
|
||||
def task_id(self) -> str:
|
||||
return str(self.record["task_id"])
|
||||
|
||||
|
||||
def operation_for(method: str, path: str) -> str:
|
||||
operation = ROUTE_OPERATIONS.get((method.upper(), path))
|
||||
if not operation:
|
||||
raise AuthorizationError("isolated_writer_operation_forbidden")
|
||||
return operation
|
||||
|
||||
|
||||
def _parse_time(value: Any) -> datetime:
|
||||
try:
|
||||
parsed = datetime.fromisoformat(str(value).replace("Z", "+00:00"))
|
||||
except (TypeError, ValueError):
|
||||
raise AuthorizationError("writer_token_time_invalid") from None
|
||||
if parsed.tzinfo is None:
|
||||
raise AuthorizationError("writer_token_time_invalid")
|
||||
return parsed.astimezone(timezone.utc)
|
||||
|
||||
|
||||
def _git_is_ancestor(workspace: Path, base: str, branch: str) -> bool:
|
||||
result = subprocess.run(
|
||||
["git", "merge-base", "--is-ancestor", base, branch],
|
||||
cwd=workspace,
|
||||
stdout=subprocess.DEVNULL,
|
||||
stderr=subprocess.DEVNULL,
|
||||
)
|
||||
return result.returncode == 0
|
||||
|
||||
|
||||
def _validate_grant(
|
||||
grant: dict[str, Any],
|
||||
*,
|
||||
audience: str,
|
||||
source_ip: str,
|
||||
operation: str,
|
||||
branch: str | None,
|
||||
path: str | None,
|
||||
workspace: Path,
|
||||
current_time: datetime,
|
||||
) -> None:
|
||||
if int(grant.get("schema_version", 0)) != 2:
|
||||
raise AuthorizationError("writer_token_policy_v2_required", 401)
|
||||
if str(grant.get("audience") or "") != audience:
|
||||
raise AuthorizationError("writer_token_audience_rejected")
|
||||
try:
|
||||
peer = ipaddress.ip_address(source_ip)
|
||||
networks = [ipaddress.ip_network(str(value), strict=True) for value in grant.get("source_cidrs", [])]
|
||||
except ValueError:
|
||||
raise AuthorizationError("writer_token_source_rejected") from None
|
||||
if not networks or not any(peer in network for network in networks):
|
||||
raise AuthorizationError("writer_token_source_rejected")
|
||||
created = _parse_time(grant.get("created_at"))
|
||||
not_before = _parse_time(grant.get("not_before"))
|
||||
expires = _parse_time(grant.get("expires_at"))
|
||||
if expires <= not_before or (expires - created).total_seconds() > 1800:
|
||||
raise AuthorizationError("writer_token_lifetime_rejected")
|
||||
if current_time < not_before:
|
||||
raise AuthorizationError("writer_token_not_yet_valid", 401)
|
||||
if current_time >= expires:
|
||||
raise AuthorizationError("writer_token_expired", 401)
|
||||
if bool(grant.get("revoked")):
|
||||
raise AuthorizationError("writer_token_revoked", 401)
|
||||
operations = grant.get("allowed_operations")
|
||||
if not isinstance(operations, list) or operation not in operations:
|
||||
raise AuthorizationError("writer_token_operation_rejected")
|
||||
expected_branch = str(grant.get("allowed_branch") or "")
|
||||
configured_branch = os.getenv("AIOS_GITOPS_ALLOWED_BRANCH", "")
|
||||
if expected_branch != configured_branch:
|
||||
raise AuthorizationError("writer_token_branch_rejected")
|
||||
if branch is not None and branch != expected_branch:
|
||||
raise AuthorizationError("writer_token_branch_rejected")
|
||||
if path is not None:
|
||||
paths = grant.get("allowed_paths")
|
||||
if not isinstance(paths, list) or path not in paths:
|
||||
raise AuthorizationError("writer_token_path_rejected")
|
||||
base = str(grant.get("approved_base_oid") or "").lower()
|
||||
if not OID_RE.fullmatch(base):
|
||||
raise AuthorizationError("writer_token_base_rejected")
|
||||
if not _git_is_ancestor(workspace, base, expected_branch):
|
||||
raise AuthorizationError("writer_token_base_not_ancestor")
|
||||
|
||||
|
||||
def authorize(
|
||||
registry: TokenRegistry,
|
||||
token: str,
|
||||
*,
|
||||
method: str,
|
||||
path: str,
|
||||
source_ip: str,
|
||||
workspace: Path,
|
||||
branch: str | None = None,
|
||||
target_path: str | None = None,
|
||||
current_time: datetime | None = None,
|
||||
) -> AuthorizedGrant:
|
||||
if os.getenv("AIOS_GITOPS_TOKEN_POLICY_VERSION_REQUIRED", "") != "2":
|
||||
raise AuthorizationError("writer_token_policy_v2_not_required")
|
||||
if not token:
|
||||
raise AuthorizationError("unauthorized", 401)
|
||||
grant = registry.find(token)
|
||||
if grant is None:
|
||||
raise AuthorizationError("unauthorized", 401)
|
||||
operation = operation_for(method, path)
|
||||
_validate_grant(
|
||||
grant,
|
||||
audience=os.getenv("AIOS_GITOPS_SERVICE_AUDIENCE", ""),
|
||||
source_ip=source_ip,
|
||||
operation=operation,
|
||||
branch=branch,
|
||||
path=target_path,
|
||||
workspace=workspace,
|
||||
current_time=current_time or datetime.now(timezone.utc),
|
||||
)
|
||||
limits = grant.get("max_uses")
|
||||
if not isinstance(limits, dict):
|
||||
raise AuthorizationError("writer_token_use_limit_missing")
|
||||
try:
|
||||
used = registry.consume(str(grant["token_id"]), operation, int(limits[operation]))
|
||||
except (KeyError, TypeError, ValueError):
|
||||
raise AuthorizationError("writer_token_use_limit_missing") from None
|
||||
except PermissionError as exc:
|
||||
code = str(exc)
|
||||
raise AuthorizationError(code, 401 if code == "writer_token_revoked" else 403) from None
|
||||
return AuthorizedGrant(grant, operation, used)
|
||||
@@ -1,403 +0,0 @@
|
||||
"""Atomic, idempotent commit-file Saga for the isolated writer."""
|
||||
from __future__ import annotations
|
||||
|
||||
import fcntl
|
||||
import hashlib
|
||||
import json
|
||||
import os
|
||||
import re
|
||||
import sqlite3
|
||||
import subprocess
|
||||
import tempfile
|
||||
import threading
|
||||
from pathlib import Path
|
||||
from typing import Any
|
||||
|
||||
import aios_isolated_writer_policy as policy
|
||||
|
||||
|
||||
OID_RE = re.compile(r"[0-9a-f]{40}")
|
||||
IDEMPOTENCY_RE = re.compile(r"[A-Za-z0-9][A-Za-z0-9._:-]{7,127}")
|
||||
STATES = frozenset({
|
||||
"PENDING", "FILE_WRITTEN", "COMMITTED", "PUSHED", "VERIFIED", "COMPLETED",
|
||||
"FAILED_RECOVERABLE", "MANUAL_REVIEW_REQUIRED",
|
||||
})
|
||||
_LOCKS: dict[str, threading.Lock] = {}
|
||||
_LOCKS_GUARD = threading.Lock()
|
||||
_LEDGER_INIT_LOCK = threading.Lock()
|
||||
|
||||
|
||||
class CommitFileError(RuntimeError):
|
||||
def __init__(self, code: str, status: int = 400):
|
||||
super().__init__(code)
|
||||
self.code = code
|
||||
self.status = status
|
||||
|
||||
|
||||
class SimulatedCrash(RuntimeError):
|
||||
pass
|
||||
|
||||
|
||||
def canonical_digest(data: dict[str, Any]) -> str:
|
||||
payload = {
|
||||
"branch": data["branch"],
|
||||
"path": data["path"],
|
||||
"content_sha256": hashlib.sha256(data["content"].encode("utf-8")).hexdigest(),
|
||||
"message": data["message"],
|
||||
"expected_head_oid": data["expected_head_oid"],
|
||||
}
|
||||
encoded = json.dumps(payload, sort_keys=True, separators=(",", ":")).encode("utf-8")
|
||||
return hashlib.sha256(encoded).hexdigest()
|
||||
|
||||
|
||||
class OperationLedger:
|
||||
def __init__(self, path: Path | str):
|
||||
self.path = Path(path)
|
||||
self.path.parent.mkdir(parents=True, exist_ok=True)
|
||||
if self.path.parent.is_symlink() or self.path.is_symlink():
|
||||
raise PermissionError("writer_operation_ledger_symlink_rejected")
|
||||
with _LEDGER_INIT_LOCK:
|
||||
with self.connect() as db:
|
||||
db.execute(
|
||||
"""
|
||||
CREATE TABLE IF NOT EXISTS writer_operations (
|
||||
operation_id TEXT PRIMARY KEY,
|
||||
token_id TEXT NOT NULL,
|
||||
task_id TEXT NOT NULL,
|
||||
idempotency_key TEXT NOT NULL UNIQUE,
|
||||
operation_digest TEXT NOT NULL,
|
||||
branch TEXT NOT NULL,
|
||||
path TEXT NOT NULL,
|
||||
content_sha256 TEXT NOT NULL,
|
||||
pre_head_oid TEXT NOT NULL,
|
||||
commit_oid TEXT,
|
||||
push_status TEXT,
|
||||
verification_status TEXT,
|
||||
state TEXT NOT NULL,
|
||||
created_at TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP,
|
||||
updated_at TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP,
|
||||
error_code TEXT
|
||||
)
|
||||
"""
|
||||
)
|
||||
os.chmod(self.path, 0o600)
|
||||
|
||||
def connect(self) -> sqlite3.Connection:
|
||||
db = sqlite3.connect(self.path, timeout=30)
|
||||
db.row_factory = sqlite3.Row
|
||||
db.execute("PRAGMA journal_mode=WAL")
|
||||
db.execute("PRAGMA synchronous=FULL")
|
||||
return db
|
||||
|
||||
def get_or_create(self, grant: Any, data: dict[str, Any], digest: str) -> dict[str, Any]:
|
||||
key = data["idempotency_key"]
|
||||
with self.connect() as db:
|
||||
db.execute("BEGIN IMMEDIATE")
|
||||
row = db.execute(
|
||||
"SELECT * FROM writer_operations WHERE idempotency_key=?", (key,)
|
||||
).fetchone()
|
||||
if row:
|
||||
db.commit()
|
||||
record = dict(row)
|
||||
if record["operation_digest"] != digest:
|
||||
raise CommitFileError("writer_idempotency_conflict", 409)
|
||||
if (
|
||||
record["token_id"] != grant.token_id
|
||||
or record["task_id"] != grant.task_id
|
||||
):
|
||||
raise CommitFileError("writer_idempotency_owner_conflict", 409)
|
||||
return record
|
||||
operation_id = hashlib.sha256(
|
||||
f"{grant.task_id}\0{key}".encode("utf-8")
|
||||
).hexdigest()
|
||||
content_sha = hashlib.sha256(data["content"].encode("utf-8")).hexdigest()
|
||||
db.execute(
|
||||
"""
|
||||
INSERT INTO writer_operations(
|
||||
operation_id,token_id,task_id,idempotency_key,operation_digest,
|
||||
branch,path,content_sha256,pre_head_oid,state
|
||||
) VALUES(?,?,?,?,?,?,?,?,?,?)
|
||||
""",
|
||||
(
|
||||
operation_id, grant.token_id, grant.task_id, key, digest,
|
||||
data["branch"], data["path"], content_sha,
|
||||
data["expected_head_oid"], "PENDING",
|
||||
),
|
||||
)
|
||||
db.commit()
|
||||
return self.get(key)
|
||||
|
||||
def get(self, key: str) -> dict[str, Any]:
|
||||
with self.connect() as db:
|
||||
row = db.execute(
|
||||
"SELECT * FROM writer_operations WHERE idempotency_key=?", (key,)
|
||||
).fetchone()
|
||||
if row is None:
|
||||
raise KeyError(key)
|
||||
return dict(row)
|
||||
|
||||
def update(self, key: str, state: str, **fields: Any) -> dict[str, Any]:
|
||||
if state not in STATES:
|
||||
raise ValueError("invalid writer operation state")
|
||||
allowed = {"commit_oid", "push_status", "verification_status", "error_code"}
|
||||
assignments = ["state=?", "updated_at=CURRENT_TIMESTAMP"]
|
||||
values: list[Any] = [state]
|
||||
for name, value in fields.items():
|
||||
if name not in allowed:
|
||||
raise ValueError("invalid ledger field")
|
||||
assignments.append(f"{name}=?")
|
||||
values.append(value)
|
||||
values.append(key)
|
||||
with self.connect() as db:
|
||||
db.execute("BEGIN IMMEDIATE")
|
||||
db.execute(
|
||||
f"UPDATE writer_operations SET {','.join(assignments)} WHERE idempotency_key=?",
|
||||
values,
|
||||
)
|
||||
db.commit()
|
||||
return self.get(key)
|
||||
|
||||
|
||||
class AtomicCommitFile:
|
||||
def __init__(
|
||||
self,
|
||||
*,
|
||||
workspace: Path,
|
||||
bare_repo: Path,
|
||||
ledger: OperationLedger,
|
||||
remote: str,
|
||||
audit,
|
||||
crash_after_state: str | None = None,
|
||||
):
|
||||
self.workspace = workspace
|
||||
self.bare_repo = bare_repo
|
||||
self.ledger = ledger
|
||||
self.remote = remote
|
||||
self.audit = audit
|
||||
self.crash_after_state = crash_after_state
|
||||
|
||||
def _git(self, *args: str, check: bool = True) -> str:
|
||||
result = subprocess.run(
|
||||
["git", *args], cwd=self.workspace, text=True, capture_output=True
|
||||
)
|
||||
if check and result.returncode != 0:
|
||||
raise CommitFileError("writer_git_operation_failed", 500)
|
||||
return result.stdout.strip()
|
||||
|
||||
def _transition(self, key: str, state: str, **fields: Any) -> dict[str, Any]:
|
||||
record = self.ledger.update(key, state, **fields)
|
||||
if self.crash_after_state == state:
|
||||
raise SimulatedCrash(state)
|
||||
return record
|
||||
|
||||
def _validate(self, data: Any) -> dict[str, Any]:
|
||||
if not isinstance(data, dict):
|
||||
raise CommitFileError("writer_request_object_required")
|
||||
required = ("branch", "path", "content", "message", "expected_head_oid", "idempotency_key")
|
||||
if any(field not in data for field in required):
|
||||
raise CommitFileError("writer_request_incomplete")
|
||||
if data.get("force") or data.get("force_push"):
|
||||
raise CommitFileError("isolated_writer_force_rejected", 403)
|
||||
if set(data) != set(required):
|
||||
raise CommitFileError("writer_request_fields_rejected")
|
||||
item = {field: data[field] for field in required}
|
||||
if item["branch"] != policy.allowed_branch():
|
||||
raise CommitFileError("isolated_writer_branch_rejected", 403)
|
||||
try:
|
||||
item["path"] = policy.validate_path(item["path"], self.workspace)
|
||||
except PermissionError as exc:
|
||||
raise CommitFileError(str(exc), 403) from None
|
||||
if not isinstance(item["content"], str) or "\x00" in item["content"]:
|
||||
raise CommitFileError("writer_content_rejected")
|
||||
try:
|
||||
policy.validate_content_for_path(item["path"], item["content"])
|
||||
except PermissionError as exc:
|
||||
raise CommitFileError(str(exc), 403) from None
|
||||
if len(item["content"].encode("utf-8")) > 1_048_576:
|
||||
raise CommitFileError("writer_content_too_large", 413)
|
||||
message = item["message"]
|
||||
if (
|
||||
not isinstance(message, str)
|
||||
or not 1 <= len(message) <= 200
|
||||
or "\x00" in message
|
||||
or "\n" in message
|
||||
or "\r" in message
|
||||
):
|
||||
raise CommitFileError("writer_message_rejected")
|
||||
if not isinstance(item["expected_head_oid"], str) or not OID_RE.fullmatch(item["expected_head_oid"]):
|
||||
raise CommitFileError("writer_expected_head_rejected")
|
||||
if not isinstance(item["idempotency_key"], str) or not IDEMPOTENCY_RE.fullmatch(item["idempotency_key"]):
|
||||
raise CommitFileError("writer_idempotency_key_rejected")
|
||||
return item
|
||||
|
||||
def _atomic_write(self, relative: str, content: str) -> None:
|
||||
target = self.workspace / relative
|
||||
target.parent.mkdir(parents=True, exist_ok=True)
|
||||
fd, temporary = tempfile.mkstemp(prefix=".writer-", dir=target.parent)
|
||||
try:
|
||||
with os.fdopen(fd, "wb", closefd=True) as stream:
|
||||
stream.write(content.encode("utf-8"))
|
||||
stream.flush()
|
||||
os.fsync(stream.fileno())
|
||||
os.replace(temporary, target)
|
||||
parent_fd = os.open(target.parent, os.O_RDONLY | getattr(os, "O_DIRECTORY", 0))
|
||||
try:
|
||||
os.fsync(parent_fd)
|
||||
finally:
|
||||
os.close(parent_fd)
|
||||
finally:
|
||||
if os.path.exists(temporary):
|
||||
os.unlink(temporary)
|
||||
|
||||
def _verify_remote(self, branch: str, oid: str) -> None:
|
||||
bare = subprocess.run(
|
||||
["git", "--git-dir", str(self.bare_repo), "rev-parse", f"refs/heads/{branch}"],
|
||||
text=True, capture_output=True,
|
||||
)
|
||||
if bare.returncode != 0 or bare.stdout.strip() != oid:
|
||||
raise CommitFileError("writer_authoritative_bare_oid_mismatch", 500)
|
||||
remote = subprocess.run(
|
||||
["git", "ls-remote", "--heads", self.remote, f"refs/heads/{branch}"],
|
||||
cwd=self.workspace, text=True, capture_output=True,
|
||||
)
|
||||
if remote.returncode != 0:
|
||||
raise CommitFileError("writer_gitea_verification_failed", 503)
|
||||
fields = remote.stdout.strip().split()
|
||||
if len(fields) != 2:
|
||||
raise CommitFileError("writer_gitea_ref_missing", 503)
|
||||
if fields[0] != oid:
|
||||
raise CommitFileError("writer_gitea_oid_conflict", 409)
|
||||
|
||||
def execute(self, grant: Any, raw_data: Any) -> dict[str, Any]:
|
||||
data = self._validate(raw_data)
|
||||
digest = canonical_digest(data)
|
||||
branch = data["branch"]
|
||||
with _LOCKS_GUARD:
|
||||
lock = _LOCKS.setdefault(branch, threading.Lock())
|
||||
lock_path = self.ledger.path.parent / f"{hashlib.sha256(branch.encode()).hexdigest()}.lock"
|
||||
with lock, open(lock_path, "a+b") as branch_lock:
|
||||
fcntl.flock(branch_lock.fileno(), fcntl.LOCK_EX)
|
||||
return self._execute_locked(grant, data, digest)
|
||||
|
||||
def _execute_locked(self, grant: Any, data: dict[str, Any], digest: str) -> dict[str, Any]:
|
||||
key = data["idempotency_key"]
|
||||
record = self.ledger.get_or_create(grant, data, digest)
|
||||
if record["state"] == "COMPLETED":
|
||||
return self._result(record, idempotent=True)
|
||||
if self._git("rev-parse", "--abbrev-ref", "HEAD") != data["branch"]:
|
||||
record = self._transition(
|
||||
key, "MANUAL_REVIEW_REQUIRED", error_code="writer_current_branch_conflict"
|
||||
)
|
||||
self._audit(grant, data, digest, record, "manual_review_required")
|
||||
raise CommitFileError("writer_current_branch_conflict", 409)
|
||||
head = self._git("rev-parse", "HEAD")
|
||||
commit_oid = record.get("commit_oid")
|
||||
if head != record["pre_head_oid"] and head != commit_oid:
|
||||
record = self._transition(
|
||||
key, "MANUAL_REVIEW_REQUIRED", error_code="writer_branch_head_conflict"
|
||||
)
|
||||
self._audit(grant, data, digest, record, "manual_review_required")
|
||||
raise CommitFileError("writer_branch_head_conflict", 409)
|
||||
try:
|
||||
state = record["state"]
|
||||
if state == "MANUAL_REVIEW_REQUIRED":
|
||||
raise CommitFileError("writer_manual_review_required", 409)
|
||||
if state == "FAILED_RECOVERABLE":
|
||||
if record.get("push_status") == "confirmed":
|
||||
state = "PUSHED"
|
||||
else:
|
||||
state = "COMMITTED" if commit_oid else "FILE_WRITTEN"
|
||||
if state == "PENDING":
|
||||
self._atomic_write(data["path"], data["content"])
|
||||
record = self._transition(key, "FILE_WRITTEN")
|
||||
state = record["state"]
|
||||
if state == "FILE_WRITTEN":
|
||||
actual_sha = hashlib.sha256(
|
||||
(self.workspace / data["path"]).read_bytes()
|
||||
).hexdigest()
|
||||
if actual_sha != record["content_sha256"]:
|
||||
raise CommitFileError("writer_file_content_conflict", 409)
|
||||
staged_before = self._git("diff", "--cached", "--name-only", check=False).splitlines()
|
||||
if staged_before:
|
||||
raise CommitFileError("writer_extra_staged_files_rejected", 409)
|
||||
self._git("add", "--", data["path"])
|
||||
staged = self._git("diff", "--cached", "--name-only").splitlines()
|
||||
if staged != [data["path"]]:
|
||||
raise CommitFileError("writer_extra_staged_files_rejected", 409)
|
||||
self._git("commit", "-m", data["message"])
|
||||
commit_oid = self._git("rev-parse", "HEAD")
|
||||
record = self._transition(key, "COMMITTED", commit_oid=commit_oid)
|
||||
state = record["state"]
|
||||
if state == "COMMITTED":
|
||||
commit_oid = str(record["commit_oid"])
|
||||
pushed = subprocess.run(
|
||||
["git", "push", "--porcelain", self.remote, f"HEAD:refs/heads/{data['branch']}"],
|
||||
cwd=self.workspace, text=True, capture_output=True,
|
||||
)
|
||||
if pushed.returncode != 0:
|
||||
self._transition(
|
||||
key, "FAILED_RECOVERABLE",
|
||||
push_status="failed", error_code="writer_gitea_push_failed",
|
||||
)
|
||||
raise CommitFileError("writer_gitea_push_failed", 503)
|
||||
record = self._transition(key, "PUSHED", push_status="confirmed")
|
||||
state = record["state"]
|
||||
if state == "PUSHED":
|
||||
commit_oid = str(record["commit_oid"])
|
||||
self._verify_remote(data["branch"], commit_oid)
|
||||
record = self._transition(
|
||||
key, "VERIFIED", verification_status="bare+gitea"
|
||||
)
|
||||
state = record["state"]
|
||||
if state == "VERIFIED":
|
||||
record = self._transition(key, "COMPLETED", error_code=None)
|
||||
self._audit(grant, data, digest, record, "completed")
|
||||
return self._result(record, idempotent=False)
|
||||
except SimulatedCrash:
|
||||
raise
|
||||
except CommitFileError as exc:
|
||||
latest = self.ledger.get(key)
|
||||
if latest["state"] not in {"FAILED_RECOVERABLE", "MANUAL_REVIEW_REQUIRED"}:
|
||||
failure_state = (
|
||||
"MANUAL_REVIEW_REQUIRED"
|
||||
if exc.code in {
|
||||
"writer_gitea_oid_conflict",
|
||||
"writer_file_content_conflict",
|
||||
"writer_current_branch_conflict",
|
||||
}
|
||||
else "FAILED_RECOVERABLE"
|
||||
)
|
||||
latest = self._transition(key, failure_state, error_code=exc.code)
|
||||
self._audit(grant, data, digest, latest, "failed")
|
||||
raise
|
||||
|
||||
def _audit(self, grant: Any, data: dict[str, Any], digest: str, record: dict[str, Any], result: str) -> None:
|
||||
self.audit({
|
||||
"token_id": grant.token_id,
|
||||
"task_id": grant.task_id,
|
||||
"audience": grant.record["audience"],
|
||||
"source_ip": grant.record.get("_source_ip", "socket-peer"),
|
||||
"operation": grant.operation,
|
||||
"branch": data["branch"],
|
||||
"path": data["path"],
|
||||
"idempotency_key": data["idempotency_key"],
|
||||
"operation_digest": digest,
|
||||
"path_policy_sha256": policy.configured_path_policy_sha256(),
|
||||
"pre_head_oid": record["pre_head_oid"],
|
||||
"commit_oid": record.get("commit_oid"),
|
||||
"result": result,
|
||||
})
|
||||
|
||||
@staticmethod
|
||||
def _result(record: dict[str, Any], *, idempotent: bool) -> dict[str, Any]:
|
||||
return {
|
||||
"status": "completed",
|
||||
"state": record["state"],
|
||||
"operation_id": record["operation_id"],
|
||||
"branch": record["branch"],
|
||||
"path": record["path"],
|
||||
"commit_oid": record.get("commit_oid"),
|
||||
"push_status": record.get("push_status"),
|
||||
"verification_status": record.get("verification_status"),
|
||||
"idempotent": idempotent,
|
||||
}
|
||||
@@ -1,422 +0,0 @@
|
||||
"""Strict service-level exact-path policy for isolated Git writers."""
|
||||
from __future__ import annotations
|
||||
|
||||
import grp
|
||||
import hashlib
|
||||
import json
|
||||
import os
|
||||
import re
|
||||
import stat
|
||||
from dataclasses import dataclass
|
||||
from functools import lru_cache
|
||||
from pathlib import Path, PurePosixPath, PureWindowsPath
|
||||
from typing import Any
|
||||
from urllib.parse import unquote
|
||||
|
||||
|
||||
MAX_POLICY_BYTES = 65_536
|
||||
POLICY_FIELDS = frozenset(
|
||||
{
|
||||
"schema_version",
|
||||
"policy_id",
|
||||
"audience",
|
||||
"repository_identity",
|
||||
"allowed_branch",
|
||||
"allowed_operations",
|
||||
}
|
||||
)
|
||||
OPERATION_FIELDS = frozenset({"exact_paths", "max_content_bytes", "content_profile"})
|
||||
SUPPORTED_OPERATIONS = frozenset({"commit_file.atomic"})
|
||||
SUPPORTED_CONTENT_PROFILES = frozenset({"systemd-codex-review-worker-v1"})
|
||||
_SECRET_RE = re.compile(
|
||||
r"(?i)(authorization\s*:|bearer\s+|(?:token|password|secret)\s*[:=])"
|
||||
)
|
||||
_SYSTEMD_NAME_RE = re.compile(r"[A-Za-z][A-Za-z0-9]*\Z")
|
||||
_SYSTEMD_MAX_LINE_BYTES = 4096
|
||||
_SYSTEMD_ALLOWED_DIRECTIVES = {
|
||||
"Unit": frozenset({"Description", "After", "Wants"}),
|
||||
"Service": frozenset(
|
||||
{
|
||||
"Type",
|
||||
"User",
|
||||
"Group",
|
||||
"WorkingDirectory",
|
||||
"Environment",
|
||||
"ExecStart",
|
||||
"Restart",
|
||||
"RestartSec",
|
||||
"NoNewPrivileges",
|
||||
"PrivateTmp",
|
||||
"PrivateDevices",
|
||||
"ProtectSystem",
|
||||
"ProtectHome",
|
||||
"ProtectKernelTunables",
|
||||
"ProtectKernelModules",
|
||||
"ProtectControlGroups",
|
||||
"LockPersonality",
|
||||
"RestrictSUIDSGID",
|
||||
"RestrictRealtime",
|
||||
"MemoryDenyWriteExecute",
|
||||
"RuntimeDirectory",
|
||||
"StateDirectory",
|
||||
"CacheDirectory",
|
||||
"ReadOnlyPaths",
|
||||
"ReadWritePaths",
|
||||
"UMask",
|
||||
}
|
||||
),
|
||||
"Install": frozenset({"WantedBy"}),
|
||||
}
|
||||
_SYSTEMD_MULTI_DIRECTIVES = frozenset(
|
||||
{
|
||||
("Service", "Environment"),
|
||||
("Service", "ReadOnlyPaths"),
|
||||
("Service", "ReadWritePaths"),
|
||||
}
|
||||
)
|
||||
_SYSTEMD_EXACT_SINGLE_VALUES = {
|
||||
("Unit", "Description"): "AIOS Codex Review/Test Worker",
|
||||
("Unit", "After"): "network-online.target",
|
||||
("Unit", "Wants"): "network-online.target",
|
||||
("Service", "Type"): "simple",
|
||||
("Service", "User"): "aiman",
|
||||
("Service", "Group"): "gitops",
|
||||
(
|
||||
"Service",
|
||||
"WorkingDirectory",
|
||||
): "/usr/libexec/aios-codex-review-test-worker/current",
|
||||
(
|
||||
"Service",
|
||||
"ExecStart",
|
||||
): "/usr/bin/python3 -m task_plane.workers.codex_review_test",
|
||||
("Service", "Restart"): "on-failure",
|
||||
("Service", "RestartSec"): "2",
|
||||
("Service", "NoNewPrivileges"): "true",
|
||||
("Service", "PrivateTmp"): "true",
|
||||
("Service", "PrivateDevices"): "true",
|
||||
("Service", "ProtectSystem"): "strict",
|
||||
("Service", "ProtectHome"): "true",
|
||||
("Service", "ProtectKernelTunables"): "true",
|
||||
("Service", "ProtectKernelModules"): "true",
|
||||
("Service", "ProtectControlGroups"): "true",
|
||||
("Service", "LockPersonality"): "true",
|
||||
("Service", "RestrictSUIDSGID"): "true",
|
||||
("Service", "RestrictRealtime"): "true",
|
||||
("Service", "MemoryDenyWriteExecute"): "true",
|
||||
("Service", "RuntimeDirectory"): "aios-codex-review-test-worker",
|
||||
("Service", "StateDirectory"): "aios-codex-review-test-worker",
|
||||
("Service", "CacheDirectory"): "aios-codex-review-test-worker",
|
||||
("Service", "UMask"): "0077",
|
||||
("Install", "WantedBy"): "multi-user.target",
|
||||
}
|
||||
_SYSTEMD_EXACT_MULTI_VALUES = {
|
||||
("Service", "Environment"): (
|
||||
"AIOS_CODEX_WORKER_MODE=shadow",
|
||||
"AIOS_TASK_PLANE_EXECUTION_ENABLED=false",
|
||||
"PYTHONDONTWRITEBYTECODE=1",
|
||||
),
|
||||
("Service", "ReadOnlyPaths"): (
|
||||
"/data/aios-gitops/repo.git",
|
||||
"/usr/libexec/aios-codex-review-test-worker",
|
||||
),
|
||||
("Service", "ReadWritePaths"): (
|
||||
"/run/aios-codex-review-test-worker",
|
||||
"/var/lib/aios-codex-review-test-worker",
|
||||
"/var/cache/aios-codex-review-test-worker",
|
||||
),
|
||||
}
|
||||
|
||||
|
||||
class PathPolicyError(PermissionError):
|
||||
pass
|
||||
|
||||
|
||||
@dataclass(frozen=True)
|
||||
class OperationPolicy:
|
||||
exact_paths: tuple[str, ...]
|
||||
max_content_bytes: int
|
||||
content_profile: str
|
||||
|
||||
|
||||
@dataclass(frozen=True)
|
||||
class ServicePathPolicy:
|
||||
schema_version: int
|
||||
policy_id: str
|
||||
audience: str
|
||||
repository_identity: str
|
||||
allowed_branch: str
|
||||
allowed_operations: dict[str, OperationPolicy]
|
||||
sha256: str
|
||||
|
||||
def operation(self, name: str) -> OperationPolicy:
|
||||
try:
|
||||
return self.allowed_operations[name]
|
||||
except KeyError:
|
||||
raise PathPolicyError("isolated_writer_service_operation_rejected") from None
|
||||
|
||||
def require_exact_path(self, operation: str, path: str) -> OperationPolicy:
|
||||
selected = self.operation(operation)
|
||||
if path not in selected.exact_paths:
|
||||
raise PathPolicyError("isolated_writer_service_path_rejected")
|
||||
return selected
|
||||
|
||||
|
||||
def _canonical_json(value: Any) -> bytes:
|
||||
return (
|
||||
json.dumps(value, ensure_ascii=False, sort_keys=True, separators=(",", ":"))
|
||||
+ "\n"
|
||||
).encode("utf-8")
|
||||
|
||||
|
||||
def validate_relative_path_syntax(path: str) -> str:
|
||||
if not isinstance(path, str):
|
||||
raise PathPolicyError("isolated_writer_path_rejected")
|
||||
if not path or path != path.strip() or "\x00" in path or "\\" in path:
|
||||
raise PathPolicyError("isolated_writer_path_rejected")
|
||||
try:
|
||||
decoded = unquote(path, errors="strict")
|
||||
except (UnicodeDecodeError, ValueError):
|
||||
raise PathPolicyError("isolated_writer_path_rejected") from None
|
||||
if decoded != path:
|
||||
raise PathPolicyError("isolated_writer_path_rejected")
|
||||
posix = PurePosixPath(path)
|
||||
windows = PureWindowsPath(path)
|
||||
parts = path.split("/")
|
||||
if (
|
||||
posix.is_absolute()
|
||||
or windows.is_absolute()
|
||||
or bool(windows.drive)
|
||||
or any(part in {"", ".", ".."} for part in parts)
|
||||
):
|
||||
raise PathPolicyError("isolated_writer_path_rejected")
|
||||
return path
|
||||
|
||||
|
||||
def _require_fields(value: dict[str, Any], allowed: frozenset[str], code: str) -> None:
|
||||
if set(value) != allowed:
|
||||
raise PathPolicyError(code)
|
||||
|
||||
|
||||
def _parse_policy(document: Any, canonical: bytes) -> ServicePathPolicy:
|
||||
if not isinstance(document, dict):
|
||||
raise PathPolicyError("isolated_writer_path_policy_object_required")
|
||||
_require_fields(document, POLICY_FIELDS, "isolated_writer_path_policy_fields_rejected")
|
||||
if document["schema_version"] != 1:
|
||||
raise PathPolicyError("isolated_writer_path_policy_schema_rejected")
|
||||
text_fields = (
|
||||
"policy_id",
|
||||
"audience",
|
||||
"repository_identity",
|
||||
"allowed_branch",
|
||||
)
|
||||
if any(
|
||||
not isinstance(document[field], str) or not document[field].strip()
|
||||
for field in text_fields
|
||||
):
|
||||
raise PathPolicyError("isolated_writer_path_policy_value_rejected")
|
||||
raw_operations = document["allowed_operations"]
|
||||
if not isinstance(raw_operations, dict) or not raw_operations:
|
||||
raise PathPolicyError("isolated_writer_path_policy_operations_rejected")
|
||||
if not set(raw_operations).issubset(SUPPORTED_OPERATIONS):
|
||||
raise PathPolicyError("isolated_writer_path_policy_operations_rejected")
|
||||
operations: dict[str, OperationPolicy] = {}
|
||||
for name, raw in raw_operations.items():
|
||||
if not isinstance(raw, dict):
|
||||
raise PathPolicyError("isolated_writer_path_policy_operation_rejected")
|
||||
_require_fields(
|
||||
raw,
|
||||
OPERATION_FIELDS,
|
||||
"isolated_writer_path_policy_operation_fields_rejected",
|
||||
)
|
||||
paths = raw["exact_paths"]
|
||||
if (
|
||||
not isinstance(paths, list)
|
||||
or not paths
|
||||
or any(not isinstance(item, str) for item in paths)
|
||||
):
|
||||
raise PathPolicyError("isolated_writer_path_policy_paths_rejected")
|
||||
validated = tuple(validate_relative_path_syntax(item) for item in paths)
|
||||
if len(set(validated)) != len(validated):
|
||||
raise PathPolicyError("isolated_writer_path_policy_paths_rejected")
|
||||
maximum = raw["max_content_bytes"]
|
||||
if not isinstance(maximum, int) or isinstance(maximum, bool) or not 1 <= maximum <= 1_048_576:
|
||||
raise PathPolicyError("isolated_writer_path_policy_size_rejected")
|
||||
profile = raw["content_profile"]
|
||||
if profile not in SUPPORTED_CONTENT_PROFILES:
|
||||
raise PathPolicyError("isolated_writer_path_policy_profile_rejected")
|
||||
operations[name] = OperationPolicy(validated, maximum, profile)
|
||||
return ServicePathPolicy(
|
||||
schema_version=1,
|
||||
policy_id=document["policy_id"],
|
||||
audience=document["audience"],
|
||||
repository_identity=document["repository_identity"],
|
||||
allowed_branch=document["allowed_branch"],
|
||||
allowed_operations=operations,
|
||||
sha256=hashlib.sha256(canonical).hexdigest(),
|
||||
)
|
||||
|
||||
|
||||
def load_path_policy(
|
||||
path: Path,
|
||||
*,
|
||||
expected_owner_uid: int = 0,
|
||||
expected_group_gid: int | None = None,
|
||||
expected_parent_mode: int = 0o750,
|
||||
expected_file_mode: int = 0o640,
|
||||
) -> ServicePathPolicy:
|
||||
lexical = Path(os.path.abspath(str(path)))
|
||||
if lexical.is_symlink():
|
||||
raise PathPolicyError("isolated_writer_path_policy_symlink_rejected")
|
||||
try:
|
||||
parent_info = lexical.parent.stat(follow_symlinks=False)
|
||||
file_info = lexical.stat(follow_symlinks=False)
|
||||
except FileNotFoundError:
|
||||
raise PathPolicyError("isolated_writer_path_policy_missing") from None
|
||||
if stat.S_ISLNK(parent_info.st_mode) or not stat.S_ISDIR(parent_info.st_mode):
|
||||
raise PathPolicyError("isolated_writer_path_policy_parent_rejected")
|
||||
if stat.S_ISLNK(file_info.st_mode) or not stat.S_ISREG(file_info.st_mode):
|
||||
raise PathPolicyError("isolated_writer_path_policy_file_rejected")
|
||||
if lexical.resolve(strict=True) != lexical:
|
||||
raise PathPolicyError("isolated_writer_path_policy_symlink_rejected")
|
||||
if (
|
||||
parent_info.st_uid != expected_owner_uid
|
||||
or stat.S_IMODE(parent_info.st_mode) != expected_parent_mode
|
||||
):
|
||||
raise PathPolicyError("isolated_writer_path_policy_parent_permissions_rejected")
|
||||
if (
|
||||
file_info.st_uid != expected_owner_uid
|
||||
or stat.S_IMODE(file_info.st_mode) != expected_file_mode
|
||||
):
|
||||
raise PathPolicyError("isolated_writer_path_policy_permissions_rejected")
|
||||
if expected_group_gid is not None and (
|
||||
parent_info.st_gid != expected_group_gid or file_info.st_gid != expected_group_gid
|
||||
):
|
||||
raise PathPolicyError("isolated_writer_path_policy_group_rejected")
|
||||
if file_info.st_size <= 0 or file_info.st_size > MAX_POLICY_BYTES:
|
||||
raise PathPolicyError("isolated_writer_path_policy_file_size_rejected")
|
||||
raw = lexical.read_bytes()
|
||||
try:
|
||||
document = json.loads(raw.decode("utf-8"))
|
||||
except (UnicodeDecodeError, json.JSONDecodeError):
|
||||
raise PathPolicyError("isolated_writer_path_policy_json_rejected") from None
|
||||
canonical = _canonical_json(document)
|
||||
if raw != canonical:
|
||||
raise PathPolicyError("isolated_writer_path_policy_not_canonical")
|
||||
return _parse_policy(document, canonical)
|
||||
|
||||
|
||||
@lru_cache(maxsize=1)
|
||||
def configured_path_policy() -> ServicePathPolicy | None:
|
||||
configured = os.getenv("AIOS_GITOPS_PATH_POLICY_FILE", "").strip()
|
||||
if not configured:
|
||||
return None
|
||||
if not Path(configured).is_absolute():
|
||||
raise PathPolicyError("isolated_writer_path_policy_path_rejected")
|
||||
try:
|
||||
gitops_gid = grp.getgrnam("gitops").gr_gid
|
||||
except KeyError:
|
||||
raise PathPolicyError("isolated_writer_path_policy_group_rejected") from None
|
||||
loaded = load_path_policy(Path(configured), expected_group_gid=gitops_gid)
|
||||
if loaded.audience != os.getenv("AIOS_GITOPS_SERVICE_AUDIENCE", ""):
|
||||
raise PathPolicyError("isolated_writer_path_policy_audience_rejected")
|
||||
if loaded.repository_identity != os.getenv("AIOS_GITOPS_REPOSITORY_IDENTITY", ""):
|
||||
raise PathPolicyError("isolated_writer_path_policy_repository_rejected")
|
||||
if loaded.allowed_branch != os.getenv("AIOS_GITOPS_ALLOWED_BRANCH", ""):
|
||||
raise PathPolicyError("isolated_writer_path_policy_branch_rejected")
|
||||
return loaded
|
||||
|
||||
|
||||
def clear_path_policy_cache() -> None:
|
||||
configured_path_policy.cache_clear()
|
||||
|
||||
|
||||
def require_service_path(operation: str, path: str) -> OperationPolicy:
|
||||
loaded = configured_path_policy()
|
||||
if loaded is None:
|
||||
raise PathPolicyError("isolated_writer_service_path_policy_required")
|
||||
return loaded.require_exact_path(operation, path)
|
||||
|
||||
|
||||
def configured_path_policy_sha256() -> str | None:
|
||||
loaded = configured_path_policy()
|
||||
return None if loaded is None else loaded.sha256
|
||||
|
||||
|
||||
def validate_content(operation: str, path: str, content: str) -> None:
|
||||
selected = require_service_path(operation, path)
|
||||
try:
|
||||
encoded = content.encode("utf-8", errors="strict")
|
||||
except (AttributeError, UnicodeEncodeError):
|
||||
raise PathPolicyError("isolated_writer_systemd_profile_rejected") from None
|
||||
if len(encoded) > selected.max_content_bytes:
|
||||
raise PathPolicyError("isolated_writer_service_content_too_large")
|
||||
if selected.content_profile == "systemd-codex-review-worker-v1":
|
||||
_validate_systemd_codex_review_worker(content)
|
||||
return
|
||||
raise PathPolicyError("isolated_writer_path_policy_profile_rejected")
|
||||
|
||||
|
||||
def _validate_systemd_codex_review_worker(content: str) -> None:
|
||||
if not isinstance(content, str):
|
||||
raise PathPolicyError("isolated_writer_systemd_profile_rejected")
|
||||
try:
|
||||
content.encode("utf-8", errors="strict")
|
||||
except UnicodeEncodeError:
|
||||
raise PathPolicyError("isolated_writer_systemd_profile_rejected") from None
|
||||
if (
|
||||
"\x00" in content
|
||||
or "\r" in content
|
||||
or _SECRET_RE.search(content)
|
||||
or not content.endswith("\n")
|
||||
):
|
||||
raise PathPolicyError("isolated_writer_systemd_profile_rejected")
|
||||
|
||||
sections: set[str] = set()
|
||||
values: dict[tuple[str, str], list[str]] = {}
|
||||
section: str | None = None
|
||||
for line in content.splitlines():
|
||||
if len(line.encode("utf-8")) > _SYSTEMD_MAX_LINE_BYTES:
|
||||
raise PathPolicyError("isolated_writer_systemd_profile_rejected")
|
||||
if not line:
|
||||
continue
|
||||
if line[0].isspace() or line.startswith(("#", ";")):
|
||||
raise PathPolicyError("isolated_writer_systemd_profile_rejected")
|
||||
if line.startswith("[") and line.endswith("]"):
|
||||
candidate = line[1:-1]
|
||||
if (
|
||||
not _SYSTEMD_NAME_RE.fullmatch(candidate)
|
||||
or candidate not in _SYSTEMD_ALLOWED_DIRECTIVES
|
||||
or candidate in sections
|
||||
):
|
||||
raise PathPolicyError("isolated_writer_systemd_profile_rejected")
|
||||
sections.add(candidate)
|
||||
section = candidate
|
||||
continue
|
||||
if section is None or "=" not in line:
|
||||
raise PathPolicyError("isolated_writer_systemd_profile_rejected")
|
||||
directive, value = line.split("=", 1)
|
||||
if (
|
||||
not _SYSTEMD_NAME_RE.fullmatch(directive)
|
||||
or directive not in _SYSTEMD_ALLOWED_DIRECTIVES[section]
|
||||
or not value
|
||||
or value != value.strip()
|
||||
):
|
||||
raise PathPolicyError("isolated_writer_systemd_profile_rejected")
|
||||
key = (section, directive)
|
||||
if key in values and key not in _SYSTEMD_MULTI_DIRECTIVES:
|
||||
raise PathPolicyError("isolated_writer_systemd_profile_rejected")
|
||||
values.setdefault(key, []).append(value)
|
||||
|
||||
if sections != set(_SYSTEMD_ALLOWED_DIRECTIVES):
|
||||
raise PathPolicyError("isolated_writer_systemd_profile_rejected")
|
||||
if set(values) != set(_SYSTEMD_EXACT_SINGLE_VALUES) | set(
|
||||
_SYSTEMD_EXACT_MULTI_VALUES
|
||||
):
|
||||
raise PathPolicyError("isolated_writer_systemd_profile_rejected")
|
||||
for key, expected in _SYSTEMD_EXACT_SINGLE_VALUES.items():
|
||||
if values.get(key) != [expected]:
|
||||
raise PathPolicyError("isolated_writer_systemd_profile_rejected")
|
||||
for key, expected in _SYSTEMD_EXACT_MULTI_VALUES.items():
|
||||
observed = values.get(key, [])
|
||||
if len(observed) != len(set(observed)) or tuple(observed) != expected:
|
||||
raise PathPolicyError("isolated_writer_systemd_profile_rejected")
|
||||
@@ -1,241 +0,0 @@
|
||||
"""Digest-only, task-scoped token registry for isolated writers."""
|
||||
from __future__ import annotations
|
||||
|
||||
import argparse
|
||||
import hashlib
|
||||
import hmac
|
||||
import json
|
||||
import os
|
||||
import grp
|
||||
import pwd
|
||||
import secrets
|
||||
import sqlite3
|
||||
import stat
|
||||
import threading
|
||||
from datetime import datetime, timezone
|
||||
from pathlib import Path
|
||||
from typing import Any
|
||||
|
||||
_REGISTRY_INIT_LOCK = threading.Lock()
|
||||
|
||||
|
||||
def utc_now() -> str:
|
||||
return datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
|
||||
|
||||
|
||||
def token_digest(token: str) -> str:
|
||||
return hashlib.sha256(token.encode("utf-8")).hexdigest()
|
||||
|
||||
|
||||
class TokenRegistry:
|
||||
def __init__(self, path: Path | str):
|
||||
self.path = Path(path)
|
||||
self._prepare()
|
||||
|
||||
def _prepare(self) -> None:
|
||||
self.path.parent.mkdir(parents=True, exist_ok=True)
|
||||
if self.path.parent.is_symlink() or self.path.is_symlink():
|
||||
raise PermissionError("writer_token_registry_symlink_rejected")
|
||||
with _REGISTRY_INIT_LOCK:
|
||||
with self._connect() as db:
|
||||
db.executescript(
|
||||
"""
|
||||
CREATE TABLE IF NOT EXISTS token_grants (
|
||||
token_id TEXT PRIMARY KEY,
|
||||
token_digest TEXT NOT NULL UNIQUE,
|
||||
grant_json TEXT NOT NULL,
|
||||
revoked INTEGER NOT NULL DEFAULT 0,
|
||||
created_at TEXT NOT NULL
|
||||
);
|
||||
CREATE TABLE IF NOT EXISTS token_uses (
|
||||
token_id TEXT NOT NULL,
|
||||
operation TEXT NOT NULL,
|
||||
use_count INTEGER NOT NULL DEFAULT 0,
|
||||
PRIMARY KEY(token_id, operation),
|
||||
FOREIGN KEY(token_id) REFERENCES token_grants(token_id)
|
||||
);
|
||||
"""
|
||||
)
|
||||
os.chmod(self.path, 0o600)
|
||||
|
||||
def _connect(self) -> sqlite3.Connection:
|
||||
db = sqlite3.connect(self.path, timeout=30, isolation_level=None)
|
||||
db.row_factory = sqlite3.Row
|
||||
db.execute("PRAGMA journal_mode=WAL")
|
||||
db.execute("PRAGMA synchronous=FULL")
|
||||
db.execute("PRAGMA foreign_keys=ON")
|
||||
return db
|
||||
|
||||
def issue(self, grant: dict[str, Any], token: str | None = None) -> tuple[str, dict[str, Any]]:
|
||||
value = token or secrets.token_urlsafe(32)
|
||||
if len(value.encode("utf-8")) < 32:
|
||||
raise ValueError("writer_token_entropy_insufficient")
|
||||
record = dict(grant)
|
||||
record["schema_version"] = 2
|
||||
record["token_digest"] = token_digest(value)
|
||||
record["revoked"] = False
|
||||
record.setdefault("created_at", utc_now())
|
||||
required = (
|
||||
"token_id",
|
||||
"audience",
|
||||
"task_id",
|
||||
"source_cidrs",
|
||||
"allowed_branch",
|
||||
"approved_base_oid",
|
||||
"allowed_operations",
|
||||
"allowed_paths",
|
||||
"not_before",
|
||||
"expires_at",
|
||||
"max_uses",
|
||||
"issued_by",
|
||||
)
|
||||
if any(not record.get(field) for field in required):
|
||||
raise ValueError("writer_token_grant_incomplete")
|
||||
encoded = json.dumps(record, sort_keys=True, separators=(",", ":"))
|
||||
with self._connect() as db:
|
||||
db.execute("BEGIN IMMEDIATE")
|
||||
try:
|
||||
db.execute(
|
||||
"""
|
||||
INSERT INTO token_grants(token_id, token_digest, grant_json, revoked, created_at)
|
||||
VALUES(?,?,?,?,?)
|
||||
""",
|
||||
(
|
||||
str(record["token_id"]),
|
||||
str(record["token_digest"]),
|
||||
encoded,
|
||||
0,
|
||||
str(record["created_at"]),
|
||||
),
|
||||
)
|
||||
db.execute("COMMIT")
|
||||
except Exception:
|
||||
db.execute("ROLLBACK")
|
||||
raise
|
||||
return value, record
|
||||
|
||||
def find(self, token: str) -> dict[str, Any] | None:
|
||||
candidate = token_digest(token)
|
||||
with self._connect() as db:
|
||||
rows = db.execute(
|
||||
"SELECT token_digest, grant_json, revoked FROM token_grants"
|
||||
).fetchall()
|
||||
match = None
|
||||
for row in rows:
|
||||
if hmac.compare_digest(str(row["token_digest"]), candidate):
|
||||
match = dict(json.loads(str(row["grant_json"])))
|
||||
match["revoked"] = bool(row["revoked"])
|
||||
return match
|
||||
|
||||
def consume(self, token_id: str, operation: str, maximum: int) -> int:
|
||||
if maximum < 1:
|
||||
raise PermissionError("writer_token_operation_exhausted")
|
||||
with self._connect() as db:
|
||||
db.execute("BEGIN IMMEDIATE")
|
||||
try:
|
||||
row = db.execute(
|
||||
"SELECT revoked FROM token_grants WHERE token_id=?",
|
||||
(token_id,),
|
||||
).fetchone()
|
||||
if row is None or bool(row["revoked"]):
|
||||
raise PermissionError("writer_token_revoked")
|
||||
used_row = db.execute(
|
||||
"SELECT use_count FROM token_uses WHERE token_id=? AND operation=?",
|
||||
(token_id, operation),
|
||||
).fetchone()
|
||||
used = int(used_row["use_count"]) if used_row else 0
|
||||
if used >= maximum:
|
||||
raise PermissionError("writer_token_operation_exhausted")
|
||||
current = used + 1
|
||||
db.execute(
|
||||
"""
|
||||
INSERT INTO token_uses(token_id, operation, use_count)
|
||||
VALUES(?,?,?)
|
||||
ON CONFLICT(token_id, operation)
|
||||
DO UPDATE SET use_count=excluded.use_count
|
||||
""",
|
||||
(token_id, operation, current),
|
||||
)
|
||||
db.execute("COMMIT")
|
||||
return current
|
||||
except Exception:
|
||||
db.execute("ROLLBACK")
|
||||
raise
|
||||
|
||||
def revoke(self, token_id: str) -> bool:
|
||||
with self._connect() as db:
|
||||
db.execute("BEGIN IMMEDIATE")
|
||||
changed = db.execute(
|
||||
"UPDATE token_grants SET revoked=1 WHERE token_id=? AND revoked=0",
|
||||
(token_id,),
|
||||
).rowcount
|
||||
db.execute("COMMIT")
|
||||
return bool(changed)
|
||||
|
||||
def usage(self, token_id: str, operation: str) -> int:
|
||||
with self._connect() as db:
|
||||
row = db.execute(
|
||||
"SELECT use_count FROM token_uses WHERE token_id=? AND operation=?",
|
||||
(token_id, operation),
|
||||
).fetchone()
|
||||
return int(row["use_count"]) if row else 0
|
||||
|
||||
|
||||
def _write_secret_file(
|
||||
path: Path,
|
||||
token: str,
|
||||
*,
|
||||
owner: str | None = None,
|
||||
group: str | None = None,
|
||||
) -> None:
|
||||
path.parent.mkdir(parents=True, exist_ok=True)
|
||||
if path.parent.is_symlink() or path.is_symlink():
|
||||
raise PermissionError("writer_token_file_symlink_rejected")
|
||||
flags = os.O_WRONLY | os.O_CREAT | os.O_EXCL
|
||||
if hasattr(os, "O_NOFOLLOW"):
|
||||
flags |= os.O_NOFOLLOW
|
||||
fd = os.open(path, flags, 0o600)
|
||||
try:
|
||||
if not stat.S_ISREG(os.fstat(fd).st_mode):
|
||||
raise PermissionError("writer_token_file_not_regular")
|
||||
if owner is not None or group is not None:
|
||||
uid = pwd.getpwnam(owner).pw_uid if owner is not None else -1
|
||||
gid = grp.getgrnam(group).gr_gid if group is not None else -1
|
||||
os.fchown(fd, uid, gid)
|
||||
os.write(fd, token.encode("utf-8"))
|
||||
os.fsync(fd)
|
||||
finally:
|
||||
os.close(fd)
|
||||
|
||||
|
||||
def main(argv: list[str] | None = None) -> int:
|
||||
parser = argparse.ArgumentParser()
|
||||
parser.add_argument("--registry", required=True)
|
||||
sub = parser.add_subparsers(dest="command", required=True)
|
||||
issue = sub.add_parser("issue")
|
||||
issue.add_argument("--grant-file", required=True)
|
||||
issue.add_argument("--token-file", required=True)
|
||||
issue.add_argument("--owner")
|
||||
issue.add_argument("--group")
|
||||
revoke = sub.add_parser("revoke")
|
||||
revoke.add_argument("--token-id", required=True)
|
||||
args = parser.parse_args(argv)
|
||||
registry = TokenRegistry(args.registry)
|
||||
if args.command == "issue":
|
||||
grant = json.loads(Path(args.grant_file).read_text(encoding="utf-8"))
|
||||
token, record = registry.issue(grant)
|
||||
_write_secret_file(
|
||||
Path(args.token_file),
|
||||
token,
|
||||
owner=args.owner,
|
||||
group=args.group,
|
||||
)
|
||||
print(json.dumps({"token_id": record["token_id"], "created": True}, sort_keys=True))
|
||||
return 0
|
||||
changed = registry.revoke(args.token_id)
|
||||
print(json.dumps({"token_id": args.token_id, "revoked": changed}, sort_keys=True))
|
||||
return 0
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
raise SystemExit(main())
|
||||
@@ -1,564 +0,0 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Execution-readiness adapters and the fail-closed Shadow controller service."""
|
||||
from __future__ import annotations
|
||||
|
||||
import argparse
|
||||
import base64
|
||||
import dataclasses
|
||||
import hashlib
|
||||
import json
|
||||
import os
|
||||
import subprocess
|
||||
import threading
|
||||
import time
|
||||
from http import HTTPStatus
|
||||
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
|
||||
from pathlib import Path
|
||||
from typing import Any, Callable, Mapping, Protocol
|
||||
from urllib.parse import parse_qs, urlparse
|
||||
|
||||
from cryptography.hazmat.primitives.asymmetric.ed25519 import (
|
||||
Ed25519PrivateKey,
|
||||
)
|
||||
|
||||
from silent_release_controller import _sanitize, utc_now
|
||||
from silent_release_hardening import (
|
||||
BuilderAttestation,
|
||||
CapabilityAuthorizationError,
|
||||
ReleaseRecoveryWorker,
|
||||
SignedApprovalVerifier,
|
||||
SignedReleasePlanApproval,
|
||||
SilentReleaseActionService,
|
||||
TrustedCandidateBundle,
|
||||
_canonical_json,
|
||||
_durable_json,
|
||||
_safe_child,
|
||||
)
|
||||
|
||||
|
||||
class BuilderSigner(Protocol):
|
||||
@property
|
||||
def key_id(self) -> str:
|
||||
...
|
||||
|
||||
def sign(self, payload: bytes) -> bytes:
|
||||
...
|
||||
|
||||
|
||||
class LocalTestBuilderSigner:
|
||||
"""Ephemeral in-memory signer. It is forbidden for production execution."""
|
||||
|
||||
test_only = True
|
||||
|
||||
def __init__(self, key_id: str, private_key: Ed25519PrivateKey):
|
||||
self._key_id = str(key_id)
|
||||
self._private_key = private_key
|
||||
|
||||
@property
|
||||
def key_id(self) -> str:
|
||||
return self._key_id
|
||||
|
||||
@classmethod
|
||||
def generate(
|
||||
cls, key_id: str = "shadow-builder-test-key"
|
||||
) -> "LocalTestBuilderSigner":
|
||||
return cls(key_id, Ed25519PrivateKey.generate())
|
||||
|
||||
@property
|
||||
def public_key(self):
|
||||
return self._private_key.public_key()
|
||||
|
||||
def sign(self, payload: bytes) -> bytes:
|
||||
return self._private_key.sign(payload)
|
||||
|
||||
|
||||
class ExternalKmsBuilderSigner:
|
||||
"""Signer facade whose private operation remains in KMS/HSM."""
|
||||
|
||||
def __init__(
|
||||
self,
|
||||
key_id: str,
|
||||
credential_reference: str,
|
||||
sign_callback: Callable[[str, bytes], bytes],
|
||||
):
|
||||
if not str(credential_reference).startswith(
|
||||
("kms://", "hsm://", "secret-manager://")
|
||||
):
|
||||
raise ValueError("production builder requires a KMS/HSM reference")
|
||||
self._key_id = str(key_id)
|
||||
self.credential_reference = str(credential_reference)
|
||||
self._sign_callback = sign_callback
|
||||
|
||||
@property
|
||||
def key_id(self) -> str:
|
||||
return self._key_id
|
||||
|
||||
def sign(self, payload: bytes) -> bytes:
|
||||
return bytes(self._sign_callback(self.credential_reference, payload))
|
||||
|
||||
|
||||
class SignedTrustedBuilderAdapter:
|
||||
"""Signs evidence produced by a trusted collector, never caller evidence."""
|
||||
|
||||
def __init__(
|
||||
self,
|
||||
collector: Callable[[Mapping[str, Any]], TrustedCandidateBundle],
|
||||
signer: BuilderSigner,
|
||||
):
|
||||
self.collector = collector
|
||||
self.signer = signer
|
||||
|
||||
def build(self, intent: Mapping[str, Any]) -> TrustedCandidateBundle:
|
||||
forbidden = {
|
||||
"artifact_sha256",
|
||||
"canary",
|
||||
"checks",
|
||||
"manifest_sha256",
|
||||
"tests",
|
||||
"tree_oid",
|
||||
}
|
||||
if forbidden.intersection(intent):
|
||||
raise CapabilityAuthorizationError(
|
||||
"trusted builder rejects caller-supplied evidence"
|
||||
)
|
||||
unsigned = self.collector(dict(intent))
|
||||
if unsigned.attestation is not None:
|
||||
raise CapabilityAuthorizationError(
|
||||
"collector cannot self-attest its evidence"
|
||||
)
|
||||
candidate = unsigned.candidate
|
||||
test_sha = hashlib.sha256(
|
||||
_canonical_json(_sanitize(candidate.tests))
|
||||
).hexdigest()
|
||||
canary_sha = hashlib.sha256(
|
||||
_canonical_json(_sanitize(candidate.canary))
|
||||
).hexdigest()
|
||||
attestation_id = "builder-attestation-" + hashlib.sha256(
|
||||
(
|
||||
candidate.candidate_id
|
||||
+ "\0"
|
||||
+ candidate.source_commit
|
||||
+ "\0"
|
||||
+ candidate.artifact_sha256
|
||||
).encode("utf-8")
|
||||
).hexdigest()[:24]
|
||||
attestation = BuilderAttestation(
|
||||
builder_attestation_id=attestation_id,
|
||||
builder_key_id=self.signer.key_id,
|
||||
source_commit=candidate.source_commit,
|
||||
tree_oid=candidate.tree_oid,
|
||||
artifact_sha256=candidate.artifact_sha256,
|
||||
manifest_sha256=candidate.manifest_sha256,
|
||||
package_closure_sha256=(
|
||||
unsigned.release_plan.deployment.package_closure_sha256
|
||||
),
|
||||
test_evidence_sha256=test_sha,
|
||||
canary_evidence_sha256=canary_sha,
|
||||
issued_at=utc_now(),
|
||||
signature="",
|
||||
)
|
||||
attestation = dataclasses.replace(
|
||||
attestation,
|
||||
signature=base64.b64encode(
|
||||
self.signer.sign(attestation.canonical_bytes())
|
||||
).decode("ascii"),
|
||||
)
|
||||
return dataclasses.replace(unsigned, attestation=attestation)
|
||||
|
||||
|
||||
class ApprovalBackendAdapter(Protocol):
|
||||
@property
|
||||
def available(self) -> bool:
|
||||
...
|
||||
|
||||
def verify(
|
||||
self,
|
||||
approval: SignedReleasePlanApproval,
|
||||
*,
|
||||
candidate,
|
||||
release_plan,
|
||||
policy_sha256: str,
|
||||
) -> SignedReleasePlanApproval:
|
||||
...
|
||||
|
||||
|
||||
class LocalTestApprovalSigner:
|
||||
"""Test-only approval signer used solely for Shadow acceptance."""
|
||||
|
||||
test_only = True
|
||||
|
||||
def __init__(self, key_id: str, private_key: Ed25519PrivateKey):
|
||||
self.key_id = str(key_id)
|
||||
self.private_key = private_key
|
||||
|
||||
@classmethod
|
||||
def generate(
|
||||
cls, key_id: str = "shadow-owner-test-key"
|
||||
) -> "LocalTestApprovalSigner":
|
||||
return cls(key_id, Ed25519PrivateKey.generate())
|
||||
|
||||
def sign(
|
||||
self, approval: SignedReleasePlanApproval
|
||||
) -> SignedReleasePlanApproval:
|
||||
unsigned = dataclasses.replace(
|
||||
approval, key_id=self.key_id, signature=""
|
||||
)
|
||||
return dataclasses.replace(
|
||||
unsigned,
|
||||
signature=base64.b64encode(
|
||||
self.private_key.sign(unsigned.canonical_bytes())
|
||||
).decode("ascii"),
|
||||
)
|
||||
|
||||
|
||||
class ProductionApprovalBackendAdapter:
|
||||
"""Verification-only production adapter configured by a secret/KMS ref."""
|
||||
|
||||
def __init__(
|
||||
self,
|
||||
verifier: SignedApprovalVerifier,
|
||||
credential_reference: str,
|
||||
):
|
||||
if not str(credential_reference).startswith(
|
||||
("kms://", "hsm://", "secret-manager://")
|
||||
):
|
||||
raise ValueError(
|
||||
"production approval backend requires a KMS/secret reference"
|
||||
)
|
||||
self.verifier = verifier
|
||||
self.credential_reference = str(credential_reference)
|
||||
|
||||
@property
|
||||
def available(self) -> bool:
|
||||
return True
|
||||
|
||||
def verify(
|
||||
self,
|
||||
approval: SignedReleasePlanApproval,
|
||||
*,
|
||||
candidate,
|
||||
release_plan,
|
||||
policy_sha256: str,
|
||||
) -> SignedReleasePlanApproval:
|
||||
return self.verifier.verify_release_plan(
|
||||
approval, candidate, release_plan, policy_sha256
|
||||
)
|
||||
|
||||
|
||||
class UnavailableProductionApprovalBackend:
|
||||
credential_reference = None
|
||||
|
||||
@property
|
||||
def available(self) -> bool:
|
||||
return False
|
||||
|
||||
def verify(self, *args, **kwargs):
|
||||
raise CapabilityAuthorizationError(
|
||||
"production approval backend is not configured"
|
||||
)
|
||||
|
||||
|
||||
class LeaderLock:
|
||||
def __init__(self, path: Path):
|
||||
self.path = Path(path)
|
||||
self.handle = None
|
||||
|
||||
def __enter__(self):
|
||||
self.path.parent.mkdir(parents=True, exist_ok=True)
|
||||
os.chmod(self.path.parent, 0o700)
|
||||
self.handle = self.path.open("a+", encoding="utf-8")
|
||||
os.chmod(self.path, 0o600)
|
||||
try:
|
||||
import fcntl
|
||||
|
||||
fcntl.flock(
|
||||
self.handle.fileno(), fcntl.LOCK_EX | fcntl.LOCK_NB
|
||||
)
|
||||
except BlockingIOError as exc:
|
||||
self.handle.close()
|
||||
self.handle = None
|
||||
raise RuntimeError("silent release leader is already active") from exc
|
||||
return self
|
||||
|
||||
def __exit__(self, exc_type, exc, tb):
|
||||
if self.handle is not None:
|
||||
try:
|
||||
import fcntl
|
||||
|
||||
fcntl.flock(self.handle.fileno(), fcntl.LOCK_UN)
|
||||
finally:
|
||||
self.handle.close()
|
||||
self.handle = None
|
||||
|
||||
|
||||
class PersistentSilentReleaseController:
|
||||
"""Idempotent main-event controller with durable startup/recovery reports."""
|
||||
|
||||
def __init__(
|
||||
self,
|
||||
root: Path,
|
||||
service: SilentReleaseActionService,
|
||||
*,
|
||||
main_probe: Callable[[], str],
|
||||
recovery_worker: ReleaseRecoveryWorker | None = None,
|
||||
):
|
||||
self.root = Path(root)
|
||||
self.service = service
|
||||
self.main_probe = main_probe
|
||||
self.recovery_worker = recovery_worker
|
||||
self.leader_path = self.root / "controller.leader.lock"
|
||||
self.status_path = self.root / "controller-status.json"
|
||||
|
||||
def startup_verify(self) -> dict[str, Any]:
|
||||
checked = 0
|
||||
failed = 0
|
||||
for journal in sorted(self.service.sagas.root.glob("*.events.jsonl")):
|
||||
candidate_id = journal.name[: -len(".events.jsonl")]
|
||||
saga = self.service.sagas.load(candidate_id)
|
||||
checked += 1
|
||||
if not saga.journal_integrity:
|
||||
failed += 1
|
||||
status = {
|
||||
"checked_sagas": checked,
|
||||
"execution_enabled": self.service.execution_enabled,
|
||||
"failed_closed": failed,
|
||||
"shadow_mode": not self.service.execution_enabled,
|
||||
"side_effects_executed": False,
|
||||
"status": "READY" if failed == 0 else "FAIL_CLOSED",
|
||||
}
|
||||
_durable_json(self.status_path, status)
|
||||
return status
|
||||
|
||||
def run_once(self) -> dict[str, Any]:
|
||||
with LeaderLock(self.leader_path):
|
||||
startup = self.startup_verify()
|
||||
if startup["status"] != "READY":
|
||||
result = {
|
||||
"execution_enabled": self.service.execution_enabled,
|
||||
"intent": None,
|
||||
"notification": None,
|
||||
"recovery": None,
|
||||
"shadow_mode": not self.service.execution_enabled,
|
||||
"side_effects_executed": False,
|
||||
"startup": startup,
|
||||
"status": "FAIL_CLOSED",
|
||||
}
|
||||
_durable_json(self.status_path, result)
|
||||
return _sanitize(result)
|
||||
source_commit = str(self.main_probe())
|
||||
event_id = f"main-{source_commit}"
|
||||
intent = self.service.create_release_intent(
|
||||
{"event_id": event_id, "source_commit": source_commit}
|
||||
)
|
||||
notification = None
|
||||
if intent.get("candidate_id"):
|
||||
notification = self.service.ensure_owner_notification(
|
||||
str(intent["candidate_id"])
|
||||
)
|
||||
recovery = (
|
||||
self.recovery_worker.run_once()
|
||||
if self.recovery_worker is not None
|
||||
else self.service.get_recovery_status()
|
||||
)
|
||||
result = {
|
||||
"execution_enabled": self.service.execution_enabled,
|
||||
"intent": intent,
|
||||
"notification": notification,
|
||||
"recovery": recovery,
|
||||
"shadow_mode": not self.service.execution_enabled,
|
||||
"side_effects_executed": False,
|
||||
"startup": startup,
|
||||
}
|
||||
_durable_json(self.status_path, result)
|
||||
return _sanitize(result)
|
||||
|
||||
|
||||
class ShadowActionHandler(BaseHTTPRequestHandler):
|
||||
service: SilentReleaseActionService
|
||||
controller: PersistentSilentReleaseController
|
||||
|
||||
def log_message(self, fmt, *args):
|
||||
return
|
||||
|
||||
def _json(self, payload: Mapping[str, Any], status=HTTPStatus.OK):
|
||||
body = json.dumps(_sanitize(dict(payload)), sort_keys=True).encode()
|
||||
self.send_response(int(status))
|
||||
self.send_header("Content-Type", "application/json")
|
||||
self.send_header("Content-Length", str(len(body)))
|
||||
self.end_headers()
|
||||
self.wfile.write(body)
|
||||
|
||||
def _body(self) -> dict[str, Any]:
|
||||
size = int(self.headers.get("Content-Length", "0"))
|
||||
if size > 1024 * 1024:
|
||||
raise ValueError("request body is too large")
|
||||
return json.loads(self.rfile.read(size) or b"{}")
|
||||
|
||||
def do_GET(self):
|
||||
parsed = urlparse(self.path)
|
||||
query = parse_qs(parsed.query)
|
||||
candidate_id = str((query.get("candidate_id") or [""])[0])
|
||||
try:
|
||||
if parsed.path == "/healthz":
|
||||
return self._json(
|
||||
{
|
||||
"execution_enabled": False,
|
||||
"shadow_mode": True,
|
||||
"side_effects_executed": False,
|
||||
"status": "ok",
|
||||
}
|
||||
)
|
||||
routes = {
|
||||
"/getReleaseCandidate": self.service.get_release_candidate,
|
||||
"/getReleasePlan": self.service.get_release_plan,
|
||||
"/getReleaseAcceptance": self.service.get_acceptance,
|
||||
"/getReleaseSaga": self.service.get_release_saga,
|
||||
"/getCapabilityStatus": self.service.get_capability_status,
|
||||
}
|
||||
if parsed.path in routes:
|
||||
return self._json(routes[parsed.path](candidate_id))
|
||||
if parsed.path == "/getRecoveryStatus":
|
||||
return self._json(self.service.get_recovery_status())
|
||||
self._json({"error": "not_found"}, HTTPStatus.NOT_FOUND)
|
||||
except (ValueError, FileNotFoundError) as exc:
|
||||
self._json(
|
||||
{"error": type(exc).__name__}, HTTPStatus.BAD_REQUEST
|
||||
)
|
||||
|
||||
def do_POST(self):
|
||||
parsed = urlparse(self.path)
|
||||
try:
|
||||
body = self._body()
|
||||
if parsed.path == "/createReleaseIntent":
|
||||
return self._json(self.service.create_release_intent(body))
|
||||
if parsed.path in {
|
||||
"/submitSignedApproval",
|
||||
"/submitOwnerApproval",
|
||||
}:
|
||||
return self._json(self.service.submit_owner_approval(body))
|
||||
if parsed.path == "/startDeployment":
|
||||
return self._json(
|
||||
self.service.start_deployment(
|
||||
str(body.get("candidate_id") or "")
|
||||
)
|
||||
)
|
||||
self._json({"error": "not_found"}, HTTPStatus.NOT_FOUND)
|
||||
except (ValueError, FileNotFoundError, CapabilityAuthorizationError) as exc:
|
||||
self._json(
|
||||
{"error": type(exc).__name__}, HTTPStatus.BAD_REQUEST
|
||||
)
|
||||
|
||||
|
||||
def git_main_probe(repository: Path) -> Callable[[], str]:
|
||||
repository = Path(repository)
|
||||
|
||||
def probe() -> str:
|
||||
completed = subprocess.run(
|
||||
[
|
||||
"git",
|
||||
f"--git-dir={repository}",
|
||||
"rev-parse",
|
||||
"refs/heads/main",
|
||||
],
|
||||
check=True,
|
||||
capture_output=True,
|
||||
text=True,
|
||||
timeout=15,
|
||||
env={"PATH": os.environ.get("PATH", "")},
|
||||
)
|
||||
return completed.stdout.strip()
|
||||
|
||||
return probe
|
||||
|
||||
|
||||
def serve_shadow(
|
||||
*,
|
||||
state_root: Path,
|
||||
repository: Path,
|
||||
host: str,
|
||||
port: int,
|
||||
poll_seconds: float,
|
||||
) -> None:
|
||||
service = SilentReleaseActionService.shadow(state_root)
|
||||
controller = PersistentSilentReleaseController(
|
||||
state_root,
|
||||
service,
|
||||
main_probe=git_main_probe(repository),
|
||||
)
|
||||
controller.run_once()
|
||||
stop = threading.Event()
|
||||
|
||||
def controller_loop() -> None:
|
||||
while not stop.wait(poll_seconds):
|
||||
try:
|
||||
controller.run_once()
|
||||
except Exception as exc: # fail closed and keep the API available
|
||||
_durable_json(
|
||||
controller.status_path,
|
||||
{
|
||||
"error": type(exc).__name__,
|
||||
"execution_enabled": False,
|
||||
"shadow_mode": True,
|
||||
"side_effects_executed": False,
|
||||
"status": "FAIL_CLOSED",
|
||||
},
|
||||
)
|
||||
|
||||
handler = type(
|
||||
"ConfiguredShadowActionHandler",
|
||||
(ShadowActionHandler,),
|
||||
{"service": service, "controller": controller},
|
||||
)
|
||||
server = ThreadingHTTPServer((host, port), handler)
|
||||
api_thread = threading.Thread(
|
||||
target=server.serve_forever,
|
||||
name="silent-release-shadow-api",
|
||||
daemon=False,
|
||||
)
|
||||
controller_thread = threading.Thread(
|
||||
target=controller_loop,
|
||||
name="silent-release-shadow-controller",
|
||||
daemon=True,
|
||||
)
|
||||
api_thread.start()
|
||||
controller_thread.start()
|
||||
try:
|
||||
while api_thread.is_alive():
|
||||
api_thread.join(timeout=1)
|
||||
finally:
|
||||
stop.set()
|
||||
server.shutdown()
|
||||
server.server_close()
|
||||
controller_thread.join(timeout=max(1.0, poll_seconds + 1.0))
|
||||
|
||||
|
||||
def main() -> None:
|
||||
parser = argparse.ArgumentParser()
|
||||
parser.add_argument("--state-root", required=True, type=Path)
|
||||
parser.add_argument("--repository", required=True, type=Path)
|
||||
parser.add_argument("--host", default="127.0.0.1")
|
||||
parser.add_argument("--port", default=18891, type=int)
|
||||
parser.add_argument("--poll-seconds", default=30.0, type=float)
|
||||
arguments = parser.parse_args()
|
||||
if arguments.poll_seconds <= 0:
|
||||
raise SystemExit("poll seconds must be positive")
|
||||
if os.environ.get("AIOS_GITOPS_WRITES_ENABLED", "false").lower() != "false":
|
||||
raise SystemExit("GitOps writes must remain disabled")
|
||||
if (
|
||||
os.environ.get(
|
||||
"AIOS_SILENT_RELEASE_EXECUTION_ENABLED", "false"
|
||||
).lower()
|
||||
!= "false"
|
||||
):
|
||||
raise SystemExit("Silent Release execution must remain disabled")
|
||||
serve_shadow(
|
||||
state_root=arguments.state_root,
|
||||
repository=arguments.repository,
|
||||
host=arguments.host,
|
||||
port=arguments.port,
|
||||
poll_seconds=arguments.poll_seconds,
|
||||
)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
File diff suppressed because it is too large
Load Diff
@@ -1,21 +0,0 @@
|
||||
"""Task Plane runtime package."""
|
||||
|
||||
from .models import (
|
||||
EvidenceEnvelope,
|
||||
ProbeEvidence,
|
||||
ProbeOutcome,
|
||||
TaskPlan,
|
||||
TaskRecord,
|
||||
TaskStatus,
|
||||
TaskStateTransitionError,
|
||||
)
|
||||
|
||||
__all__ = [
|
||||
"EvidenceEnvelope",
|
||||
"ProbeEvidence",
|
||||
"ProbeOutcome",
|
||||
"TaskPlan",
|
||||
"TaskRecord",
|
||||
"TaskStatus",
|
||||
"TaskStateTransitionError",
|
||||
]
|
||||
@@ -1,17 +0,0 @@
|
||||
"""Adapters for executing tasks via worker backends."""
|
||||
|
||||
from .base import WorkerAdapter
|
||||
from .openclaw import OpenClawAdapter
|
||||
from .codex import CodexAdapter
|
||||
from .hermes import HermesAdapter
|
||||
from .a2a import A2AAdapter
|
||||
from .systemd_worker import SystemdWorkerAdapter
|
||||
|
||||
__all__ = [
|
||||
"WorkerAdapter",
|
||||
"OpenClawAdapter",
|
||||
"CodexAdapter",
|
||||
"HermesAdapter",
|
||||
"A2AAdapter",
|
||||
"SystemdWorkerAdapter",
|
||||
]
|
||||
@@ -1,31 +0,0 @@
|
||||
from __future__ import annotations
|
||||
|
||||
from .base import WorkerAdapter
|
||||
|
||||
|
||||
class A2AAdapter(WorkerAdapter):
|
||||
worker_name = "a2a"
|
||||
|
||||
def capabilities(self) -> list[str]:
|
||||
return ["task.exchange", "agent.handoff"]
|
||||
|
||||
def claim(self, task):
|
||||
return {"worker": self.worker_name, "task_id": task.task_id, "status": "claimed"}
|
||||
|
||||
def execute(self, task, claim):
|
||||
return {"worker": self.worker_name, "task_id": task.task_id, "status": "SHADOW_VERIFIED", "claim_id": claim.claim_id, "execution_mode": "shadow", "production_side_effects": False}
|
||||
|
||||
def heartbeat(self, claim):
|
||||
return {"worker": self.worker_name, "claim_id": claim.claim_id, "status": "alive"}
|
||||
|
||||
def report_progress(self, claim, progress):
|
||||
return {"worker": self.worker_name, "claim_id": claim.claim_id, "progress": progress}
|
||||
|
||||
def probe(self, claim):
|
||||
return {"worker": self.worker_name, "claim_id": claim.claim_id, "status": claim.status}
|
||||
|
||||
def cancel(self, claim):
|
||||
return {"worker": self.worker_name, "claim_id": claim.claim_id, "status": "cancelled"}
|
||||
|
||||
def collect_result(self, claim):
|
||||
return {"worker": self.worker_name, "claim_id": claim.claim_id, "result": "not_collected"}
|
||||
@@ -1,41 +0,0 @@
|
||||
"""Base worker adapter contract."""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import abc
|
||||
|
||||
|
||||
class WorkerAdapter(abc.ABC):
|
||||
worker_name = "base"
|
||||
|
||||
@abc.abstractmethod
|
||||
def capabilities(self) -> list[str]:
|
||||
raise NotImplementedError
|
||||
|
||||
@abc.abstractmethod
|
||||
def claim(self, task):
|
||||
raise NotImplementedError
|
||||
|
||||
@abc.abstractmethod
|
||||
def execute(self, task, claim):
|
||||
raise NotImplementedError
|
||||
|
||||
@abc.abstractmethod
|
||||
def heartbeat(self, claim):
|
||||
raise NotImplementedError
|
||||
|
||||
@abc.abstractmethod
|
||||
def report_progress(self, claim, progress):
|
||||
raise NotImplementedError
|
||||
|
||||
@abc.abstractmethod
|
||||
def probe(self, claim):
|
||||
raise NotImplementedError
|
||||
|
||||
@abc.abstractmethod
|
||||
def cancel(self, claim):
|
||||
raise NotImplementedError
|
||||
|
||||
@abc.abstractmethod
|
||||
def collect_result(self, claim):
|
||||
raise NotImplementedError
|
||||
@@ -1,31 +0,0 @@
|
||||
from __future__ import annotations
|
||||
|
||||
from .base import WorkerAdapter
|
||||
|
||||
|
||||
class CodexAdapter(WorkerAdapter):
|
||||
worker_name = "codex"
|
||||
|
||||
def capabilities(self) -> list[str]:
|
||||
return ["code.read", "code.write.patch", "test.python", "review.security"]
|
||||
|
||||
def claim(self, task):
|
||||
return {"worker": self.worker_name, "task_id": task.task_id, "status": "claimed"}
|
||||
|
||||
def execute(self, task, claim):
|
||||
return {"worker": self.worker_name, "task_id": task.task_id, "status": "SHADOW_VERIFIED", "claim_id": claim.claim_id, "execution_mode": "shadow", "production_side_effects": False}
|
||||
|
||||
def heartbeat(self, claim):
|
||||
return {"worker": self.worker_name, "claim_id": claim.claim_id, "status": "alive"}
|
||||
|
||||
def report_progress(self, claim, progress):
|
||||
return {"worker": self.worker_name, "claim_id": claim.claim_id, "progress": progress}
|
||||
|
||||
def probe(self, claim):
|
||||
return {"worker": self.worker_name, "claim_id": claim.claim_id, "status": claim.status}
|
||||
|
||||
def cancel(self, claim):
|
||||
return {"worker": self.worker_name, "claim_id": claim.claim_id, "status": "cancelled"}
|
||||
|
||||
def collect_result(self, claim):
|
||||
return {"worker": self.worker_name, "claim_id": claim.claim_id, "result": "not_collected"}
|
||||
@@ -1,31 +0,0 @@
|
||||
from __future__ import annotations
|
||||
|
||||
from .base import WorkerAdapter
|
||||
|
||||
|
||||
class HermesAdapter(WorkerAdapter):
|
||||
worker_name = "hermes"
|
||||
|
||||
def capabilities(self) -> list[str]:
|
||||
return ["architecture.review", "policy.review", "threat.model"]
|
||||
|
||||
def claim(self, task):
|
||||
return {"worker": self.worker_name, "task_id": task.task_id, "status": "claimed"}
|
||||
|
||||
def execute(self, task, claim):
|
||||
return {"worker": self.worker_name, "task_id": task.task_id, "status": "SHADOW_VERIFIED", "claim_id": claim.claim_id, "execution_mode": "shadow", "production_side_effects": False}
|
||||
|
||||
def heartbeat(self, claim):
|
||||
return {"worker": self.worker_name, "claim_id": claim.claim_id, "status": "alive"}
|
||||
|
||||
def report_progress(self, claim, progress):
|
||||
return {"worker": self.worker_name, "claim_id": claim.claim_id, "progress": progress}
|
||||
|
||||
def probe(self, claim):
|
||||
return {"worker": self.worker_name, "claim_id": claim.claim_id, "status": claim.status}
|
||||
|
||||
def cancel(self, claim):
|
||||
return {"worker": self.worker_name, "claim_id": claim.claim_id, "status": "cancelled"}
|
||||
|
||||
def collect_result(self, claim):
|
||||
return {"worker": self.worker_name, "claim_id": claim.claim_id, "result": "not_collected"}
|
||||
@@ -1,31 +0,0 @@
|
||||
from __future__ import annotations
|
||||
|
||||
from .base import WorkerAdapter
|
||||
|
||||
|
||||
class OpenClawAdapter(WorkerAdapter):
|
||||
worker_name = "openclaw"
|
||||
|
||||
def capabilities(self) -> list[str]:
|
||||
return ["code.read", "code.write.patch", "test.execute", "runtime.shadow"]
|
||||
|
||||
def claim(self, task):
|
||||
return {"worker": self.worker_name, "task_id": task.task_id, "status": "claimed"}
|
||||
|
||||
def execute(self, task, claim):
|
||||
return {"worker": self.worker_name, "task_id": task.task_id, "status": "SHADOW_VERIFIED", "claim_id": claim.claim_id, "execution_mode": "shadow", "production_side_effects": False}
|
||||
|
||||
def heartbeat(self, claim):
|
||||
return {"worker": self.worker_name, "claim_id": claim.claim_id, "status": "alive"}
|
||||
|
||||
def report_progress(self, claim, progress):
|
||||
return {"worker": self.worker_name, "claim_id": claim.claim_id, "progress": progress}
|
||||
|
||||
def probe(self, claim):
|
||||
return {"worker": self.worker_name, "claim_id": claim.claim_id, "status": claim.status}
|
||||
|
||||
def cancel(self, claim):
|
||||
return {"worker": self.worker_name, "claim_id": claim.claim_id, "status": "cancelled"}
|
||||
|
||||
def collect_result(self, claim):
|
||||
return {"worker": self.worker_name, "claim_id": claim.claim_id, "result": "not_collected"}
|
||||
@@ -1,31 +0,0 @@
|
||||
from __future__ import annotations
|
||||
|
||||
from .base import WorkerAdapter
|
||||
|
||||
|
||||
class SystemdWorkerAdapter(WorkerAdapter):
|
||||
worker_name = "systemd_worker"
|
||||
|
||||
def capabilities(self) -> list[str]:
|
||||
return ["systemd.exec", "runtime.shell"]
|
||||
|
||||
def claim(self, task):
|
||||
return {"worker": self.worker_name, "task_id": task.task_id, "status": "claimed"}
|
||||
|
||||
def execute(self, task, claim):
|
||||
return {"worker": self.worker_name, "task_id": task.task_id, "status": "SHADOW_VERIFIED", "claim_id": claim.claim_id, "execution_mode": "shadow", "production_side_effects": False}
|
||||
|
||||
def heartbeat(self, claim):
|
||||
return {"worker": self.worker_name, "claim_id": claim.claim_id, "status": "alive"}
|
||||
|
||||
def report_progress(self, claim, progress):
|
||||
return {"worker": self.worker_name, "claim_id": claim.claim_id, "progress": progress}
|
||||
|
||||
def probe(self, claim):
|
||||
return {"worker": self.worker_name, "claim_id": claim.claim_id, "status": claim.status}
|
||||
|
||||
def cancel(self, claim):
|
||||
return {"worker": self.worker_name, "claim_id": claim.claim_id, "status": "cancelled"}
|
||||
|
||||
def collect_result(self, claim):
|
||||
return {"worker": self.worker_name, "claim_id": claim.claim_id, "result": "not_collected"}
|
||||
@@ -1,27 +0,0 @@
|
||||
"""Agent registry abstraction."""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
from .errors import NotFoundError
|
||||
|
||||
|
||||
class AgentRegistry:
|
||||
def __init__(self):
|
||||
self._agents: dict[str, dict] = {}
|
||||
|
||||
def register(self, agent_id: str, metadata: dict) -> None:
|
||||
self._agents[agent_id] = {"agent_id": agent_id, **metadata}
|
||||
|
||||
def unregister(self, agent_id: str) -> None:
|
||||
if agent_id not in self._agents:
|
||||
raise NotFoundError("agent")
|
||||
del self._agents[agent_id]
|
||||
|
||||
def list(self) -> list[dict]:
|
||||
return list(self._agents.values())
|
||||
|
||||
def get(self, agent_id: str) -> dict:
|
||||
try:
|
||||
return self._agents[agent_id]
|
||||
except KeyError:
|
||||
raise NotFoundError("agent")
|
||||
@@ -1,557 +0,0 @@
|
||||
"""Task Plane HTTP API implementation (stdlib-only)."""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import json
|
||||
import os
|
||||
import time
|
||||
import uuid
|
||||
import urllib.parse
|
||||
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
|
||||
from typing import Any, Callable
|
||||
|
||||
from .delegation import DelegationEngine
|
||||
from .errors import (
|
||||
ConflictError,
|
||||
ForbiddenError,
|
||||
NotFoundError,
|
||||
PayloadTooLargeError,
|
||||
TaskPlaneHTTPError,
|
||||
UnauthorizedError,
|
||||
ValidationError,
|
||||
)
|
||||
from .evidence import EvidenceService
|
||||
from .journal import TaskJournal
|
||||
from .lease import LeaseManager
|
||||
from .models import (
|
||||
EvidenceEnvelope,
|
||||
ResultEnvelope,
|
||||
TaskPlan,
|
||||
TaskRecord,
|
||||
iso8601_now,
|
||||
contains_secret_text,
|
||||
validate_identifier,
|
||||
)
|
||||
from .policy import PolicyEngine
|
||||
from .store import TaskPlaneStore
|
||||
from .worker_registry import WorkerRegistry
|
||||
|
||||
|
||||
def _json_payload(data: dict[str, Any], status: int = 200) -> tuple[int, bytes]:
|
||||
body = json.dumps(data, ensure_ascii=False).encode("utf-8")
|
||||
return status, body
|
||||
|
||||
|
||||
def _bounded_int(value: Any, name: str, minimum: int, maximum: int) -> int:
|
||||
try:
|
||||
number = int(value)
|
||||
except (TypeError, ValueError) as exc:
|
||||
raise ValidationError(f"invalid {name}") from exc
|
||||
if not minimum <= number <= maximum:
|
||||
raise ValidationError(f"invalid {name}")
|
||||
return number
|
||||
|
||||
|
||||
class TaskPlaneService:
|
||||
def __init__(self, store: TaskPlaneStore, policy: PolicyEngine | None = None):
|
||||
self.store = store
|
||||
self.policy = policy or PolicyEngine(
|
||||
execution_enabled=False,
|
||||
identity_capabilities={
|
||||
"anon": {"task.creator", "task.read", "task.audit"}
|
||||
},
|
||||
)
|
||||
self.journal = TaskJournal(store)
|
||||
self.lease = LeaseManager(store)
|
||||
self.workers = WorkerRegistry(store)
|
||||
self.evidence = EvidenceService(store)
|
||||
self.delegation = DelegationEngine(store)
|
||||
self.store.probe_attestation_verifier = self.policy.probe_attestation_verifier
|
||||
|
||||
def create_task(self, body: dict[str, Any], idempotency_key: str | None = None) -> dict[str, Any]:
|
||||
if body.get("parent_task_id"):
|
||||
raise ForbiddenError("child tasks must use the delegate endpoint")
|
||||
issuer = body.get("issuer", {})
|
||||
actor = issuer.get("id", "anon") if isinstance(issuer, dict) else "anon"
|
||||
self.policy.assert_allowed("create", actor)
|
||||
try:
|
||||
plan = TaskPlan.from_dict(body)
|
||||
except (TypeError, ValueError) as exc:
|
||||
raise ValidationError("invalid task plan") from exc
|
||||
task = self.store.create_task_with_event(plan, idempotency_key=idempotency_key)
|
||||
return task.to_dict()
|
||||
|
||||
def list_tasks(self, actor: str | None = None) -> list[dict[str, Any]]:
|
||||
if actor is not None:
|
||||
self.policy.assert_allowed("read", actor)
|
||||
return [task.to_dict(include_task=False) for task in self.store.list_tasks()]
|
||||
|
||||
def get_task(self, task_id: str, actor: str | None = None) -> dict[str, Any]:
|
||||
if actor is not None:
|
||||
self.policy.assert_allowed("read", actor, task=self.store.get_task(task_id))
|
||||
return self.store.get_task(task_id).to_dict()
|
||||
|
||||
def get_worker(self, worker_id: str, actor: str | None = None) -> dict[str, Any]:
|
||||
if actor is not None:
|
||||
self.policy.assert_allowed("read", actor)
|
||||
return self.workers.get(worker_id).to_dict()
|
||||
|
||||
def list_workers(self, actor: str | None = None) -> list[dict[str, Any]]:
|
||||
if actor is not None:
|
||||
self.policy.assert_allowed("read", actor)
|
||||
return [w.to_dict() for w in self.workers.list()]
|
||||
|
||||
def register_worker(self, body: dict[str, Any]) -> dict[str, Any]:
|
||||
actor = str(body.get("actor_identity") or body.get("identity") or "")
|
||||
is_admin = actor in self.policy.admin_identities
|
||||
try:
|
||||
existing = self.store.get_worker(str(body.get("worker_id") or ""))
|
||||
except NotFoundError:
|
||||
existing = None
|
||||
if existing is not None and str(body.get("identity") or "") != existing.identity:
|
||||
raise ConflictError("worker identity takeover rejected")
|
||||
self.policy.assert_readonly_worker_registration(actor, body)
|
||||
self.policy.assert_allowed(
|
||||
"worker.admin" if is_admin else "worker.register", actor
|
||||
)
|
||||
try:
|
||||
worker = self.workers.register(
|
||||
body,
|
||||
actor_identity=actor,
|
||||
is_admin=is_admin,
|
||||
expected_revision=body.get("expected_revision"),
|
||||
)
|
||||
except (TypeError, ValueError, KeyError) as exc:
|
||||
raise ValidationError("invalid worker registration") from exc
|
||||
return worker.to_dict()
|
||||
|
||||
def worker_heartbeat(self, worker_id: str, payload: dict[str, Any]) -> dict[str, Any]:
|
||||
interval = payload.get("heartbeat_interval_seconds")
|
||||
actor = str(payload.get("actor_identity") or "")
|
||||
self.policy.assert_readonly_worker_binding(actor, worker_id)
|
||||
self.policy.assert_allowed("worker.register", actor)
|
||||
return self.workers.heartbeat(
|
||||
worker_id,
|
||||
heartbeat_interval_seconds=interval,
|
||||
actor_identity=actor,
|
||||
expected_revision=payload.get("expected_revision"),
|
||||
).to_dict()
|
||||
|
||||
def disable_worker(self, worker_id: str, payload: dict[str, Any]) -> dict[str, Any]:
|
||||
actor = str(payload.get("actor_identity") or "")
|
||||
self.policy.assert_allowed("worker.admin", actor)
|
||||
return self.store.disable_worker(
|
||||
worker_id,
|
||||
actor_identity=actor,
|
||||
expected_revision=int(payload.get("expected_revision")),
|
||||
reason=str(payload.get("reason") or "disabled by administrator"),
|
||||
).to_dict()
|
||||
|
||||
def restore_worker(self, worker_id: str, payload: dict[str, Any]) -> dict[str, Any]:
|
||||
actor = str(payload.get("actor_identity") or "")
|
||||
self.policy.assert_allowed("worker.admin", actor)
|
||||
return self.store.restore_worker(
|
||||
worker_id,
|
||||
actor_identity=actor,
|
||||
expected_revision=int(payload.get("expected_revision")),
|
||||
).to_dict()
|
||||
|
||||
def claim(self, task_id: str, body: dict[str, Any]) -> dict[str, Any]:
|
||||
actor = body.get("actor_identity") or body.get("worker_identity") or "worker"
|
||||
self.policy.assert_allowed("claim", actor)
|
||||
worker_id = body.get("worker_id")
|
||||
if not worker_id:
|
||||
raise ValidationError("worker_id required")
|
||||
|
||||
task = self.store.get_task(task_id)
|
||||
self.policy.assert_readonly_worker_binding(actor, str(worker_id))
|
||||
self.policy.assert_allowed("claim", actor, task=task)
|
||||
lease_seconds = _bounded_int(
|
||||
body.get("lease_seconds", 30), "lease_seconds", 1, 3600
|
||||
)
|
||||
claim = self.lease.claim(
|
||||
task_id=task_id,
|
||||
worker_id=worker_id,
|
||||
worker_identity=actor,
|
||||
lease_seconds=lease_seconds,
|
||||
expected_revision=task.revision,
|
||||
operation_digest=task.task_plan.operation_digest(),
|
||||
)
|
||||
return {"claim_id": claim.claim_id, **claim.to_dict()}
|
||||
|
||||
def heartbeat(self, task_id: str, body: dict[str, Any]) -> dict[str, Any]:
|
||||
claim_id = body.get("claim_id")
|
||||
if not claim_id:
|
||||
raise ValidationError("claim_id required")
|
||||
actor = body.get("actor_identity") or body.get("worker_identity") or "worker"
|
||||
task = self.store.get_task(task_id)
|
||||
claim = self.store.get_claim(claim_id)
|
||||
self.policy.assert_readonly_worker_binding(actor, claim.worker_id)
|
||||
self.policy.assert_allowed("heartbeat", actor, task=task)
|
||||
if claim.worker_identity != actor:
|
||||
raise ForbiddenError("claim identity mismatch")
|
||||
lease_seconds = _bounded_int(
|
||||
body.get("lease_seconds", 30), "lease_seconds", 1, 3600
|
||||
)
|
||||
claim = self.lease.heartbeat(task_id, claim_id, lease_seconds)
|
||||
return {"claim_id": claim_id, "lease_until": claim.lease_until}
|
||||
|
||||
def progress(self, task_id: str, body: dict[str, Any]) -> dict[str, Any]:
|
||||
claim_id = body.get("claim_id")
|
||||
if not claim_id:
|
||||
raise ValidationError("claim_id required")
|
||||
actor = body.get("actor_identity") or body.get("worker_identity") or "worker"
|
||||
progress = body.get("progress")
|
||||
stage = body.get("stage", "RUNNING")
|
||||
message = body.get("message")
|
||||
if progress is None:
|
||||
raise ValidationError("progress required")
|
||||
task = self.store.get_task(task_id)
|
||||
claim = self.store.get_claim(claim_id)
|
||||
self.policy.assert_readonly_worker_binding(actor, claim.worker_id)
|
||||
self.policy.assert_allowed("progress", actor, task=task)
|
||||
if task.task_plan.data_classification == "credential-secret":
|
||||
if message not in {None, ""} or contains_secret_text(stage):
|
||||
raise ValidationError(
|
||||
"credential-secret progress must contain metadata only"
|
||||
)
|
||||
lease_seconds = _bounded_int(
|
||||
body.get("lease_seconds", 30), "lease_seconds", 1, 3600
|
||||
)
|
||||
claim = self.store.record_progress(
|
||||
task_id,
|
||||
claim_id,
|
||||
actor,
|
||||
progress=progress,
|
||||
stage=str(stage),
|
||||
message=None if message is None else str(message),
|
||||
lease_seconds=lease_seconds,
|
||||
)
|
||||
return {"claim_id": claim.claim_id, "status": claim.status, "progress": progress}
|
||||
|
||||
def complete(self, task_id: str, body: dict[str, Any]) -> dict[str, Any]:
|
||||
claim_id = body.get("claim_id")
|
||||
if not claim_id:
|
||||
raise ValidationError("claim_id required")
|
||||
actor = body.get("actor_identity") or body.get("worker_identity") or "worker"
|
||||
task = self.store.get_task(task_id)
|
||||
|
||||
status = body.get("status", "COMPLETED")
|
||||
outputs = body.get("outputs", [])
|
||||
evidences = body.get("evidence", [])
|
||||
if not isinstance(outputs, list):
|
||||
raise ValidationError("outputs must be list")
|
||||
if not isinstance(evidences, list):
|
||||
raise ValidationError("evidence must be list")
|
||||
if any(not isinstance(ev, dict) for ev in evidences):
|
||||
raise ValidationError("evidence items must be objects")
|
||||
claim = self.store.get_claim(claim_id)
|
||||
self.policy.assert_readonly_worker_binding(actor, claim.worker_id)
|
||||
self.policy.assert_allowed("result", actor, task=task)
|
||||
if claim.worker_identity != actor:
|
||||
raise ForbiddenError("claim identity mismatch")
|
||||
if task.task_plan.data_classification == "credential-secret":
|
||||
allowed_result_keys = {
|
||||
"kind",
|
||||
"hash",
|
||||
"sha256",
|
||||
"count",
|
||||
"status",
|
||||
"error_code",
|
||||
"signature",
|
||||
"attestation_ref",
|
||||
}
|
||||
for entry in [*outputs, *evidences]:
|
||||
if (
|
||||
not isinstance(entry, dict)
|
||||
or set(entry) - allowed_result_keys
|
||||
or contains_secret_text(entry)
|
||||
):
|
||||
raise ValidationError(
|
||||
"credential-secret result must contain hash/count/status only"
|
||||
)
|
||||
|
||||
result = ResultEnvelope(
|
||||
task_id=task_id,
|
||||
claim_id=claim_id,
|
||||
worker_identity=actor,
|
||||
status=status,
|
||||
outputs=outputs,
|
||||
evidence=evidences,
|
||||
started_at=str(body.get("started_at") or iso8601_now()),
|
||||
completed_at=str(body.get("completed_at") or iso8601_now()),
|
||||
result_digest=body.get("result_digest"),
|
||||
signature=body.get("signature"),
|
||||
attestation_ref=body.get("attestation_ref"),
|
||||
operation_digest=claim.operation_digest,
|
||||
)
|
||||
evidence_decision = self.policy.evidence_verifier.verify(task, evidences)
|
||||
if not evidence_decision.allowed:
|
||||
raise ForbiddenError(evidence_decision.reason)
|
||||
result_decision = self.policy.verify_result(result, task)
|
||||
if not result_decision.allowed:
|
||||
raise ForbiddenError(result_decision.reason)
|
||||
result.result_digest = result.computed_digest()
|
||||
previous = self.store._last_evidence_hash(task_id)
|
||||
evidence_entries = []
|
||||
for evidence in evidences:
|
||||
envelope = EvidenceEnvelope.create(
|
||||
task_id=task_id,
|
||||
claim_id=claim_id,
|
||||
kind=str(evidence.get("kind") or evidence.get("type") or "generic"),
|
||||
worker_identity=actor,
|
||||
payload=evidence,
|
||||
previous_evidence_hash=previous,
|
||||
signature=evidence.get("signature"),
|
||||
attestation_ref=evidence.get("attestation_ref"),
|
||||
)
|
||||
evidence_entries.append(envelope)
|
||||
previous = envelope.evidence_digest
|
||||
self.store.complete_claim_with_evidence_and_event(
|
||||
task_id,
|
||||
claim_id,
|
||||
status
|
||||
if status
|
||||
in {"COMPLETED", "FAILED_FINAL", "FAILED_RECOVERABLE", "CANCELLED"}
|
||||
else "COMPLETED",
|
||||
result.to_dict(),
|
||||
evidence_entries,
|
||||
)
|
||||
return result.to_dict()
|
||||
|
||||
def fail(self, task_id: str, body: dict[str, Any]) -> dict[str, Any]:
|
||||
claim_id = body.get("claim_id")
|
||||
if not claim_id:
|
||||
raise ValidationError("claim_id required")
|
||||
reason = body.get("reason", "failed")
|
||||
actor = body.get("actor_identity") or body.get("worker_identity") or "worker"
|
||||
self.policy.assert_allowed("fail", actor)
|
||||
task = self.store.get_task(task_id)
|
||||
self.policy.assert_allowed("fail", actor, task=task)
|
||||
claim = self.store.get_claim(claim_id)
|
||||
if claim.worker_identity != actor:
|
||||
raise ForbiddenError("claim identity mismatch")
|
||||
status = "FAILED_RECOVERABLE" if body.get("recoverable", False) else "FAILED_FINAL"
|
||||
self.store.fail_claim_with_event(task_id, claim_id, status, str(reason))
|
||||
return {"task_id": task_id, "status": status, "reason": reason}
|
||||
|
||||
def cancel(self, task_id: str, body: dict[str, Any]) -> dict[str, Any]:
|
||||
actor = body.get("actor_identity") or body.get("worker_identity") or "owner"
|
||||
self.policy.assert_allowed("cancel", actor)
|
||||
reason = body.get("reason", "cancelled")
|
||||
task = self.store.get_task(task_id)
|
||||
self.policy.assert_allowed("cancel", actor, task=task)
|
||||
updated = self.store.cancel_task_with_event(
|
||||
task_id, task.revision, reason=reason
|
||||
)
|
||||
return updated.to_dict()
|
||||
|
||||
def delegate(self, task_id: str, body: dict[str, Any]) -> dict[str, Any]:
|
||||
actor = body.get("actor_identity") or "owner"
|
||||
self.policy.assert_allowed("delegate", actor)
|
||||
parent = self.store.get_task(task_id)
|
||||
self.policy.assert_allowed("delegate", actor, task=parent)
|
||||
if "task" in body:
|
||||
try:
|
||||
child_plan = TaskPlan.from_dict(body["task"])
|
||||
except (TypeError, ValueError) as exc:
|
||||
raise ValidationError("invalid child task plan") from exc
|
||||
else:
|
||||
plan_body = dict(body)
|
||||
plan_body.pop("actor_identity", None)
|
||||
try:
|
||||
child_plan = TaskPlan.from_dict(plan_body)
|
||||
except (TypeError, ValueError) as exc:
|
||||
raise ValidationError("invalid child task plan") from exc
|
||||
child_plan.parent_task_id = task_id
|
||||
child = self.delegation.delegate(task_id, child_plan, caller=actor)
|
||||
return child.to_dict()
|
||||
|
||||
def get_events(self, task_id: str, actor: str | None = None) -> list[dict[str, Any]]:
|
||||
if actor is not None:
|
||||
self.policy.assert_allowed("audit", actor, task=self.store.get_task(task_id))
|
||||
self.store.get_task(task_id)
|
||||
return self.store.list_events(task_id)
|
||||
|
||||
def get_evidence(self, task_id: str, actor: str | None = None) -> list[dict[str, Any]]:
|
||||
if actor is not None:
|
||||
self.policy.assert_allowed("audit", actor, task=self.store.get_task(task_id))
|
||||
self.store.get_task(task_id)
|
||||
return self.evidence.list(task_id)
|
||||
|
||||
def get_children(self, task_id: str, actor: str | None = None) -> list[str]:
|
||||
if actor is not None:
|
||||
self.policy.assert_allowed("read", actor, task=self.store.get_task(task_id))
|
||||
self.store.get_task(task_id)
|
||||
return self.store.list_children(task_id)
|
||||
|
||||
|
||||
class TaskPlaneRequestHandler(BaseHTTPRequestHandler):
|
||||
service: TaskPlaneService | None = None
|
||||
authenticator: Callable[[str], str | None] | None = None
|
||||
max_body_bytes = 1_000_000
|
||||
|
||||
def log_message(self, format: str, *args: Any) -> None:
|
||||
# BaseHTTPRequestHandler logs the raw request target; suppress it so
|
||||
# attacker-controlled paths or query strings cannot leak credentials.
|
||||
return
|
||||
|
||||
def _json(self) -> tuple[str | None, dict[str, Any]]:
|
||||
try:
|
||||
length = int(self.headers.get("Content-Length", "0"))
|
||||
except ValueError as exc:
|
||||
raise ValidationError("invalid content length") from exc
|
||||
if length < 0:
|
||||
raise ValidationError("invalid content length")
|
||||
if length > self.max_body_bytes:
|
||||
raise PayloadTooLargeError("payload exceeds limit")
|
||||
raw = self.rfile.read(length) if length > 0 else b""
|
||||
if not raw:
|
||||
return None, {}
|
||||
try:
|
||||
decoded = raw.decode("utf-8")
|
||||
payload = json.loads(decoded)
|
||||
if not isinstance(payload, dict):
|
||||
raise ValidationError("JSON payload must be an object")
|
||||
return decoded, payload
|
||||
except (UnicodeDecodeError, json.JSONDecodeError) as exc:
|
||||
raise ValidationError("invalid JSON payload") from exc
|
||||
|
||||
def _response(self, status: int, payload: Any) -> None:
|
||||
encoded = json.dumps(payload, ensure_ascii=False).encode("utf-8")
|
||||
self.send_response(status)
|
||||
self.send_header("Content-Type", "application/json; charset=utf-8")
|
||||
self.send_header("Content-Length", str(len(encoded)))
|
||||
self.end_headers()
|
||||
self.wfile.write(encoded)
|
||||
|
||||
def _authenticated_identity(self) -> str:
|
||||
authenticator = type(self).authenticator
|
||||
if authenticator is None:
|
||||
raise UnauthorizedError("authentication unavailable")
|
||||
header = self.headers.get("Authorization", "")
|
||||
if not header.startswith("Bearer "):
|
||||
raise UnauthorizedError("bearer authentication required")
|
||||
token = header[7:]
|
||||
if not token or any(ord(ch) < 33 for ch in token):
|
||||
raise UnauthorizedError("invalid bearer token")
|
||||
identity = authenticator(token)
|
||||
if not identity:
|
||||
raise UnauthorizedError("invalid credentials")
|
||||
return str(identity)
|
||||
|
||||
def _handle(self, handler):
|
||||
try:
|
||||
if self.service is None:
|
||||
raise TaskPlaneHTTPError("service not configured")
|
||||
result = handler()
|
||||
if isinstance(result, tuple):
|
||||
status, payload = result
|
||||
else:
|
||||
status, payload = 200, result
|
||||
self._response(status, payload)
|
||||
except TaskPlaneHTTPError as exc:
|
||||
self._response(exc.status_code, exc.to_payload())
|
||||
except Exception as exc: # defensive
|
||||
if isinstance(exc, TaskPlaneHTTPError):
|
||||
raise
|
||||
self._response(
|
||||
500,
|
||||
{"error": "internal_error", "message": "internal server error"},
|
||||
)
|
||||
|
||||
def do_GET(self): # noqa: N802
|
||||
def route():
|
||||
path = urllib.parse.urlparse(self.path).path
|
||||
parts = [p for p in path.split("/") if p]
|
||||
for part in parts[1:]:
|
||||
if part not in {"events", "evidence", "children", "heartbeat"}:
|
||||
try:
|
||||
validate_identifier(part, "resource identifier")
|
||||
except ValueError as exc:
|
||||
raise ValidationError("invalid resource identifier") from exc
|
||||
identity = self._authenticated_identity()
|
||||
|
||||
if len(parts) == 1 and parts[0] == "tasks":
|
||||
return 200, self.service.list_tasks(identity)
|
||||
if len(parts) == 2 and parts[0] == "tasks":
|
||||
task_id = parts[1]
|
||||
return 200, self.service.get_task(task_id, identity)
|
||||
if len(parts) == 3 and parts[0] == "tasks" and parts[2] == "events":
|
||||
return 200, self.service.get_events(parts[1], identity)
|
||||
if len(parts) == 3 and parts[0] == "tasks" and parts[2] == "evidence":
|
||||
return 200, self.service.get_evidence(parts[1], identity)
|
||||
if len(parts) == 3 and parts[0] == "tasks" and parts[2] == "children":
|
||||
return 200, self.service.get_children(parts[1], identity)
|
||||
if len(parts) == 1 and parts[0] == "workers":
|
||||
return 200, self.service.list_workers(identity)
|
||||
if len(parts) == 2 and parts[0] == "workers":
|
||||
return 200, self.service.get_worker(parts[1], identity)
|
||||
raise NotFoundError("unknown endpoint")
|
||||
|
||||
self._handle(route)
|
||||
|
||||
def do_POST(self): # noqa: N802
|
||||
def route():
|
||||
body_text, body = self._json()
|
||||
identity = self._authenticated_identity()
|
||||
path = urllib.parse.urlparse(self.path).path
|
||||
parts = [p for p in path.split("/") if p]
|
||||
headers = {k.lower(): v for k, v in self.headers.items()}
|
||||
|
||||
if len(parts) == 1 and parts[0] == "tasks":
|
||||
issuer = body.get("issuer")
|
||||
if issuer and (
|
||||
not isinstance(issuer, dict) or issuer.get("id") != identity
|
||||
):
|
||||
raise ForbiddenError("issuer identity mismatch")
|
||||
body["issuer"] = {"type": "authenticated", "id": identity}
|
||||
return 201, self.service.create_task(body or {}, headers.get("idempotency-key"))
|
||||
if body.get("actor_identity") not in {None, identity}:
|
||||
raise ForbiddenError("actor identity mismatch")
|
||||
body["actor_identity"] = identity
|
||||
if len(parts) == 3 and parts[0] == "tasks" and parts[2] == "claim":
|
||||
return 200, self.service.claim(parts[1], body or {})
|
||||
if len(parts) == 3 and parts[0] == "tasks" and parts[2] == "heartbeat":
|
||||
return 200, self.service.heartbeat(parts[1], body or {})
|
||||
if len(parts) == 3 and parts[0] == "tasks" and parts[2] == "progress":
|
||||
return 200, self.service.progress(parts[1], body or {})
|
||||
if len(parts) == 3 and parts[0] == "tasks" and parts[2] == "result":
|
||||
return 200, self.service.complete(parts[1], body or {})
|
||||
if len(parts) == 3 and parts[0] == "tasks" and parts[2] == "fail":
|
||||
return 200, self.service.fail(parts[1], body or {})
|
||||
if len(parts) == 3 and parts[0] == "tasks" and parts[2] == "cancel":
|
||||
return 200, self.service.cancel(parts[1], body or {})
|
||||
if len(parts) == 3 and parts[0] == "tasks" and parts[2] == "delegate":
|
||||
return 200, self.service.delegate(parts[1], body or {})
|
||||
|
||||
if len(parts) == 2 and parts[0] == "workers" and parts[1] == "register":
|
||||
if (
|
||||
body.get("identity") != identity
|
||||
and identity not in self.service.policy.admin_identities
|
||||
):
|
||||
raise ForbiddenError("worker identity mismatch")
|
||||
return 201, self.service.register_worker(body or {})
|
||||
if len(parts) == 3 and parts[0] == "workers" and parts[2] == "heartbeat":
|
||||
return 200, self.service.worker_heartbeat(parts[1], body or {})
|
||||
if len(parts) == 3 and parts[0] == "workers" and parts[2] == "disable":
|
||||
return 200, self.service.disable_worker(parts[1], body or {})
|
||||
if len(parts) == 3 and parts[0] == "workers" and parts[2] == "restore":
|
||||
return 200, self.service.restore_worker(parts[1], body or {})
|
||||
raise NotFoundError("unknown endpoint")
|
||||
|
||||
self._handle(route)
|
||||
|
||||
|
||||
def run_server(
|
||||
host: str,
|
||||
port: int,
|
||||
service: TaskPlaneService,
|
||||
*,
|
||||
authenticator: Callable[[str], str | None] | None = None,
|
||||
):
|
||||
handler = TaskPlaneRequestHandler
|
||||
handler.service = service
|
||||
handler.authenticator = authenticator
|
||||
server = ThreadingHTTPServer((host, port), handler)
|
||||
server.serve_forever()
|
||||
@@ -1,36 +0,0 @@
|
||||
"""Capability matcher helpers."""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
from fnmatch import fnmatch
|
||||
|
||||
|
||||
def _normalize_capability(capability: str) -> str:
|
||||
return capability.strip().lower()
|
||||
|
||||
|
||||
def capability_matches(granted: str, required: str) -> bool:
|
||||
granted = _normalize_capability(granted)
|
||||
required = _normalize_capability(required)
|
||||
if granted == required:
|
||||
return True
|
||||
# A granted wildcard such as "test.*" should match required "test.unit"
|
||||
if "*" in granted:
|
||||
return fnmatch(required, granted)
|
||||
# A required wildcard is treated as a suffix/prefix requirement for callers.
|
||||
if "*" in required:
|
||||
return fnmatch(granted, required)
|
||||
return False
|
||||
|
||||
|
||||
def has_capabilities(granted_caps: list[str], required_caps: list[str]) -> bool:
|
||||
granted = [_normalize_capability(c) for c in granted_caps]
|
||||
for required in required_caps:
|
||||
required = _normalize_capability(required)
|
||||
if not any(capability_matches(g, required) for g in granted):
|
||||
return False
|
||||
return True
|
||||
|
||||
|
||||
def normalize_capabilities(caps: list[str]) -> list[str]:
|
||||
return sorted({_normalize_capability(cap) for cap in caps})
|
||||
@@ -1,87 +0,0 @@
|
||||
"""Delegation guardrails."""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
from .errors import ConflictError, ForbiddenError, NotFoundError
|
||||
from .models import Budget, TaskPlan, TaskRecord
|
||||
from .store import TaskPlaneStore
|
||||
|
||||
|
||||
class DelegationEngine:
|
||||
def __init__(self, store: TaskPlaneStore):
|
||||
self.store = store
|
||||
|
||||
def can_delegate(self, parent_id: str, child_plan: TaskPlan) -> bool:
|
||||
parent = self.store.get_task(parent_id)
|
||||
if parent.status == "COMPLETED":
|
||||
raise ConflictError("cannot delegate completed task")
|
||||
if parent.task_plan.max_delegation_depth <= 0:
|
||||
raise ConflictError("max delegation depth not configured")
|
||||
|
||||
depth = self._depth(parent_id)
|
||||
if depth >= parent.task_plan.max_delegation_depth:
|
||||
raise ConflictError("max delegation depth reached")
|
||||
|
||||
if child_plan.parent_task_id not in {None, parent_id}:
|
||||
raise ConflictError("delegation parent mismatch")
|
||||
current = parent_id
|
||||
while current:
|
||||
if child_plan.task_id and current == child_plan.task_id:
|
||||
raise ConflictError("delegation cycle")
|
||||
current = self.store.parent_of(current)
|
||||
return True
|
||||
|
||||
def delegate(self, parent_id: str, child_plan: TaskPlan, *, caller: str) -> TaskRecord:
|
||||
self.can_delegate(parent_id, child_plan)
|
||||
parent = self.store.get_task(parent_id)
|
||||
if child_plan.required_capabilities and not set(child_plan.required_capabilities).issubset(
|
||||
set(parent.task_plan.required_capabilities or [])
|
||||
):
|
||||
raise ForbiddenError("child capabilities exceed parent constraints")
|
||||
risk_rank = {"low": 1, "medium": 2, "high": 3}
|
||||
if risk_rank.get(child_plan.risk, 99) > risk_rank.get(parent.task_plan.risk, -1):
|
||||
raise ForbiddenError("child risk exceeds parent constraints")
|
||||
child_plan.parent_task_id = parent_id
|
||||
child_plan.correlation_id = parent.task_plan.correlation_id or parent.task_id
|
||||
child_plan.preferred_workers = parent.task_plan.preferred_workers
|
||||
child_plan.max_delegation_depth = min(
|
||||
child_plan.max_delegation_depth,
|
||||
parent.task_plan.max_delegation_depth,
|
||||
)
|
||||
child_plan.approval_policy = parent.task_plan.approval_policy
|
||||
|
||||
parent_budget = self.store.get_task_budget(parent_id)
|
||||
required = Budget()
|
||||
for name in ("time_seconds", "attempts", "tokens", "cost"):
|
||||
available = getattr(parent_budget, name)
|
||||
requested = getattr(child_plan.budgets, name)
|
||||
if name == "attempts" and requested is None:
|
||||
requested = 1
|
||||
if available is not None:
|
||||
requested = 0 if requested is None else requested
|
||||
if requested > available:
|
||||
raise ConflictError(f"budget exceeded for {name}")
|
||||
setattr(child_plan.budgets, name, requested)
|
||||
setattr(required, name, requested)
|
||||
|
||||
# A retried identical delegation is a read, not a second budget charge.
|
||||
if child_plan.task_id:
|
||||
try:
|
||||
existing = self.store.get_task(child_plan.task_id)
|
||||
except NotFoundError:
|
||||
existing = None
|
||||
if existing is not None:
|
||||
if (
|
||||
existing.task_plan.parent_task_id == parent_id
|
||||
and existing.task_plan.operation_digest()
|
||||
== child_plan.operation_digest()
|
||||
):
|
||||
return existing
|
||||
raise ConflictError("delegation task_id conflict")
|
||||
|
||||
return self.store.delegate_task_with_budget_and_events(
|
||||
parent_id, child_plan, caller=caller
|
||||
)
|
||||
|
||||
def _depth(self, task_id: str) -> int:
|
||||
return self.store._compute_depth(task_id)
|
||||
@@ -1,71 +0,0 @@
|
||||
"""Error types for task plane operations."""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
|
||||
class TaskPlaneError(Exception):
|
||||
"""Base exception for API-compatible failures."""
|
||||
|
||||
status_code = 500
|
||||
error_code = "task_plane_error"
|
||||
|
||||
def __init__(self, message: str, *, code: str | None = None, details: dict | None = None):
|
||||
super().__init__(message)
|
||||
self.message = message
|
||||
self.details = details or {}
|
||||
if code:
|
||||
self.error_code = code
|
||||
|
||||
def to_payload(self) -> dict:
|
||||
return {"error": self.error_code, "message": self.message, "details": self.details}
|
||||
|
||||
|
||||
class TaskPlaneHTTPError(TaskPlaneError):
|
||||
"""Base class with explicit HTTP status."""
|
||||
|
||||
status_code = 500
|
||||
|
||||
|
||||
class ValidationError(TaskPlaneHTTPError):
|
||||
status_code = 400
|
||||
error_code = "validation_error"
|
||||
|
||||
|
||||
class UnauthorizedError(TaskPlaneHTTPError):
|
||||
status_code = 401
|
||||
error_code = "unauthorized"
|
||||
|
||||
|
||||
class ForbiddenError(TaskPlaneHTTPError):
|
||||
status_code = 403
|
||||
error_code = "forbidden"
|
||||
|
||||
|
||||
class NotFoundError(TaskPlaneHTTPError):
|
||||
status_code = 404
|
||||
error_code = "not_found"
|
||||
|
||||
|
||||
class ConflictError(TaskPlaneHTTPError):
|
||||
status_code = 409
|
||||
error_code = "conflict"
|
||||
|
||||
|
||||
class PayloadTooLargeError(TaskPlaneHTTPError):
|
||||
status_code = 413
|
||||
error_code = "payload_too_large"
|
||||
|
||||
|
||||
class FailedDependencyError(TaskPlaneHTTPError):
|
||||
status_code = 424
|
||||
error_code = "failed_dependency"
|
||||
|
||||
|
||||
class LockedError(TaskPlaneHTTPError):
|
||||
status_code = 423
|
||||
error_code = "locked"
|
||||
|
||||
|
||||
class ServiceUnavailableError(TaskPlaneHTTPError):
|
||||
status_code = 503
|
||||
error_code = "service_unavailable"
|
||||
@@ -1,108 +0,0 @@
|
||||
"""CloudEvents-compatible event envelope and durable outbox helpers."""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
from dataclasses import dataclass
|
||||
from datetime import datetime, timezone
|
||||
from typing import Callable, Protocol
|
||||
|
||||
from .store import TaskPlaneStore
|
||||
|
||||
|
||||
@dataclass
|
||||
class CloudEvent:
|
||||
specversion: str = "1.0"
|
||||
id: str = ""
|
||||
type: str = ""
|
||||
source: str = "spiffe://aios/task-plane"
|
||||
subject: str = ""
|
||||
datacontenttype: str = "application/json"
|
||||
data: dict | None = None
|
||||
|
||||
@property
|
||||
def time(self) -> str:
|
||||
return datetime.now(timezone.utc).replace(microsecond=0).isoformat().replace("+00:00", "Z")
|
||||
|
||||
def asdict(self) -> dict:
|
||||
return {
|
||||
"specversion": self.specversion,
|
||||
"id": self.id,
|
||||
"type": self.type,
|
||||
"source": self.source,
|
||||
"subject": self.subject,
|
||||
"time": self.time,
|
||||
"datacontenttype": self.datacontenttype,
|
||||
"data": self.data or {},
|
||||
}
|
||||
|
||||
|
||||
NOT_DELIVERED = "NOT_DELIVERED"
|
||||
DELIVERED = "DELIVERED"
|
||||
FAILED_DELIVERY = "FAILED"
|
||||
|
||||
|
||||
class NotificationAdapter(Protocol):
|
||||
name: str
|
||||
|
||||
def deliver(self, envelope: dict) -> str | None:
|
||||
"""Return a provider receipt, or None when delivery is unconfirmed."""
|
||||
|
||||
|
||||
class CallbackNotificationAdapter:
|
||||
"""Adapter seam for webhook, NATS, GPT, dashboard, and WeChat transports."""
|
||||
|
||||
def __init__(self, name: str, callback: Callable[[dict], str | None]):
|
||||
self.name = name
|
||||
self._callback = callback
|
||||
|
||||
def deliver(self, envelope: dict) -> str | None:
|
||||
return self._callback(envelope)
|
||||
|
||||
|
||||
class WebhookAdapter(CallbackNotificationAdapter):
|
||||
def __init__(self, callback: Callable[[dict], str | None]):
|
||||
super().__init__("webhook", callback)
|
||||
|
||||
|
||||
class NatsJetStreamAdapter(CallbackNotificationAdapter):
|
||||
def __init__(self, callback: Callable[[dict], str | None]):
|
||||
super().__init__("nats-jetstream", callback)
|
||||
|
||||
|
||||
class GPTResultCallbackAdapter(CallbackNotificationAdapter):
|
||||
def __init__(self, callback: Callable[[dict], str | None]):
|
||||
super().__init__("gpt-result-callback", callback)
|
||||
|
||||
|
||||
class DashboardAdapter(CallbackNotificationAdapter):
|
||||
def __init__(self, callback: Callable[[dict], str | None]):
|
||||
super().__init__("dashboard", callback)
|
||||
|
||||
|
||||
class WeChatGatewayAdapter(CallbackNotificationAdapter):
|
||||
def __init__(self, callback: Callable[[dict], str | None]):
|
||||
super().__init__("wechat-gateway", callback)
|
||||
|
||||
|
||||
class DurableOutboxDispatcher:
|
||||
def __init__(self, store: TaskPlaneStore):
|
||||
self.store = store
|
||||
|
||||
def dispatch(self, message_id: str, adapter: NotificationAdapter) -> dict:
|
||||
row = self.store.get_outbox_message(message_id)
|
||||
import json
|
||||
|
||||
envelope = json.loads(row["payload"])
|
||||
try:
|
||||
receipt = adapter.deliver(envelope)
|
||||
except Exception:
|
||||
return self.store.record_outbox_delivery(
|
||||
message_id,
|
||||
receipt=None,
|
||||
error=f"{adapter.name} delivery failed",
|
||||
)
|
||||
return self.store.record_outbox_delivery(
|
||||
message_id,
|
||||
receipt=str(receipt) if receipt else None,
|
||||
error=None if receipt else f"{adapter.name} receipt unavailable",
|
||||
)
|
||||
@@ -1,31 +0,0 @@
|
||||
"""Evidence helpers."""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import hashlib
|
||||
import json
|
||||
|
||||
from .store import TaskPlaneStore
|
||||
|
||||
|
||||
def evidence_digest(payload: dict) -> str:
|
||||
body = json.dumps(payload, sort_keys=True, separators=(",", ":"))
|
||||
return hashlib.sha256(body.encode("utf-8")).hexdigest()
|
||||
|
||||
|
||||
class EvidenceService:
|
||||
def __init__(self, store: TaskPlaneStore):
|
||||
self.store = store
|
||||
|
||||
def add(self, task_id: str, kind: str, payload: dict, worker_identity: str) -> str:
|
||||
return self.store.add_evidence(task_id, kind, payload, worker_identity)
|
||||
|
||||
def list(self, task_id: str) -> list[dict]:
|
||||
return self.store.list_evidence(task_id)
|
||||
|
||||
def verify(self, task_id: str, required_kinds: list[str]) -> bool:
|
||||
evidences = self.list(task_id)
|
||||
observed = {e["kind"] for e in evidences}
|
||||
return set(required_kinds).issubset(
|
||||
observed
|
||||
) and self.store.verify_evidence_integrity(task_id)
|
||||
@@ -1,22 +0,0 @@
|
||||
"""Event journaling helpers."""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
from .errors import ValidationError
|
||||
from .store import TaskPlaneStore
|
||||
|
||||
|
||||
class TaskJournal:
|
||||
def __init__(self, store: TaskPlaneStore):
|
||||
self.store = store
|
||||
|
||||
def append(self, task_id: str, event_type: str, data: dict, *, subject: str | None = None) -> None:
|
||||
if not event_type:
|
||||
raise ValidationError("event_type required")
|
||||
self.store.append_event(task_id, event_type, data, subject=subject)
|
||||
|
||||
def list(self, task_id: str) -> list[dict]:
|
||||
return self.store.list_events(task_id)
|
||||
|
||||
def check_chain(self, task_id: str) -> bool:
|
||||
return self.store.verify_event_chain(task_id)
|
||||
@@ -1,32 +0,0 @@
|
||||
"""Claim and lease management helpers."""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
from .errors import LockedError
|
||||
from .models import ProbeEvidence
|
||||
from .store import TaskPlaneStore
|
||||
|
||||
|
||||
class LeaseManager:
|
||||
def __init__(self, store: TaskPlaneStore):
|
||||
self.store = store
|
||||
|
||||
def claim(self, task_id: str, worker_id: str, worker_identity: str, lease_seconds: int, expected_revision: int, operation_digest: str):
|
||||
return self.store.claim_task(task_id, worker_id, worker_identity, lease_seconds, expected_revision, operation_digest)
|
||||
|
||||
def heartbeat(self, task_id: str, claim_id: str, lease_seconds: int):
|
||||
claim = self.store.heartbeat_claim(task_id, claim_id, lease_seconds)
|
||||
return claim
|
||||
|
||||
def probe(self, claim_id: str):
|
||||
claim = self.store.get_claim(claim_id)
|
||||
if claim.status != "ACTIVE":
|
||||
raise LockedError("claim not active")
|
||||
return claim
|
||||
|
||||
def recover(self, task_id: str, claim_id: str, probe: ProbeEvidence):
|
||||
return self.store.recover_expired_claim(
|
||||
task_id,
|
||||
claim_id,
|
||||
probe,
|
||||
)
|
||||
@@ -1,829 +0,0 @@
|
||||
"""Core data models for the task plane."""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import hashlib
|
||||
import json
|
||||
import re
|
||||
import time
|
||||
import uuid
|
||||
import urllib.parse
|
||||
from enum import StrEnum
|
||||
from dataclasses import dataclass, field
|
||||
from datetime import datetime, timezone
|
||||
from typing import Any
|
||||
|
||||
|
||||
SENSITIVE_KEYS = {
|
||||
"secret",
|
||||
"password",
|
||||
"token",
|
||||
"api_key",
|
||||
"access_token",
|
||||
"refresh_token",
|
||||
"authorization",
|
||||
"private_key",
|
||||
"client_secret",
|
||||
"credential",
|
||||
}
|
||||
IDENTIFIER_RE = re.compile(r"[A-Za-z0-9][A-Za-z0-9._:-]{0,127}")
|
||||
TYPE_RE = re.compile(r"[A-Za-z0-9][A-Za-z0-9._-]{0,127}")
|
||||
RISK_LEVELS = {"low", "medium", "high"}
|
||||
DATA_CLASSIFICATIONS = {
|
||||
"public",
|
||||
"internal",
|
||||
"confidential",
|
||||
"credential-secret",
|
||||
}
|
||||
SECRET_TEXT_PATTERNS = (
|
||||
re.compile(r"(?i)\bAuthorization\s*:\s*Bearer\s+\S+"),
|
||||
re.compile(r"(?i)\b(?:password|passwd|api[_-]?key|access[_-]?token|secret)\s*[:=]\s*\S+"),
|
||||
re.compile(r"\bsk-[A-Za-z0-9_-]{12,}\b"),
|
||||
re.compile(r"\bAKIA[0-9A-Z]{16}\b"),
|
||||
re.compile(r"-----BEGIN (?:RSA |EC |OPENSSH )?PRIVATE KEY-----"),
|
||||
)
|
||||
TASK_PLAN_KEYS = {
|
||||
"schema_version",
|
||||
"task_id",
|
||||
"task_type",
|
||||
"issuer",
|
||||
"intent",
|
||||
"required_capabilities",
|
||||
"preferred_workers",
|
||||
"risk",
|
||||
"approval_policy",
|
||||
"dependencies",
|
||||
"max_delegation_depth",
|
||||
"budgets",
|
||||
"evidence_requirements",
|
||||
"parent_task_id",
|
||||
"correlation_id",
|
||||
"metadata",
|
||||
"data_classification",
|
||||
"execution_zone",
|
||||
"network_policy",
|
||||
"logging_policy",
|
||||
"allowed_input_paths",
|
||||
"allowed_output_paths",
|
||||
"output_policy",
|
||||
}
|
||||
|
||||
|
||||
def _now_ts() -> float:
|
||||
return time.time()
|
||||
|
||||
|
||||
def canonical_json(value: Any) -> str:
|
||||
return json.dumps(value, ensure_ascii=False, sort_keys=True, separators=(",", ":"))
|
||||
|
||||
|
||||
def compute_sha256_hex(value: Any) -> str:
|
||||
return hashlib.sha256(canonical_json(value).encode("utf-8")).hexdigest()
|
||||
|
||||
|
||||
def contains_secret_text(value: Any) -> bool:
|
||||
if isinstance(value, str):
|
||||
return any(pattern.search(value) for pattern in SECRET_TEXT_PATTERNS)
|
||||
if isinstance(value, dict):
|
||||
return any(contains_secret_text(item) for item in value.values())
|
||||
if isinstance(value, (list, tuple)):
|
||||
return any(contains_secret_text(item) for item in value)
|
||||
return False
|
||||
|
||||
|
||||
def validate_relative_paths(values: Any, name: str) -> list[str]:
|
||||
paths = _normalize_list(values)
|
||||
for value in paths:
|
||||
decoded = urllib.parse.unquote(value)
|
||||
parts = value.replace("\\", "/").split("/")
|
||||
if (
|
||||
decoded != value
|
||||
or "\\" in value
|
||||
or value.startswith("/")
|
||||
or re.match(r"^[A-Za-z]:", value)
|
||||
or any(part in {"", ".", ".."} for part in parts)
|
||||
):
|
||||
raise ValueError(f"invalid {name}")
|
||||
return paths
|
||||
|
||||
|
||||
def validate_identifier(value: Any, name: str) -> str:
|
||||
text = str(value or "")
|
||||
if (
|
||||
not IDENTIFIER_RE.fullmatch(text)
|
||||
or urllib.parse.unquote(text) != text
|
||||
or any(ord(ch) < 32 or ord(ch) == 127 for ch in text)
|
||||
):
|
||||
raise ValueError(f"invalid {name}")
|
||||
return text
|
||||
|
||||
|
||||
def validate_type(value: Any, name: str) -> str:
|
||||
text = str(value or "")
|
||||
if not TYPE_RE.fullmatch(text):
|
||||
raise ValueError(f"invalid {name}")
|
||||
return text
|
||||
|
||||
|
||||
def redact_value(value: Any) -> Any:
|
||||
if isinstance(value, dict):
|
||||
redacted = {}
|
||||
for key, inner in value.items():
|
||||
lowered = str(key).lower()
|
||||
if lowered in SENSITIVE_KEYS or lowered.endswith(
|
||||
("_password", "_secret", "_access_token", "_refresh_token", "_private_key")
|
||||
):
|
||||
redacted[key] = "[REDACTED]"
|
||||
else:
|
||||
redacted[key] = redact_value(inner)
|
||||
return redacted
|
||||
if isinstance(value, list):
|
||||
return [redact_value(v) for v in value]
|
||||
if isinstance(value, tuple):
|
||||
return tuple(redact_value(v) for v in value)
|
||||
return value
|
||||
|
||||
|
||||
class TaskStateTransitionError(ValueError):
|
||||
pass
|
||||
|
||||
|
||||
class TaskStatus(StrEnum):
|
||||
CREATED = "CREATED"
|
||||
QUEUED = "QUEUED"
|
||||
CLAIMED = "CLAIMED"
|
||||
RUNNING = "RUNNING"
|
||||
WAITING_CHILD = "WAITING_CHILD"
|
||||
VERIFYING = "VERIFYING"
|
||||
COMPLETED = "COMPLETED"
|
||||
FAILED_RECOVERABLE = "FAILED_RECOVERABLE"
|
||||
FAILED_FINAL = "FAILED_FINAL"
|
||||
CANCELLED = "CANCELLED"
|
||||
MANUAL_REVIEW_REQUIRED = "MANUAL_REVIEW_REQUIRED"
|
||||
|
||||
|
||||
TASK_STATES = {
|
||||
status.value for status in TaskStatus
|
||||
}
|
||||
|
||||
|
||||
TASK_NEXT_STATES = {
|
||||
"CREATED": {"QUEUED", "CLAIMED", "CANCELLED", "MANUAL_REVIEW_REQUIRED"},
|
||||
"QUEUED": {"CLAIMED", "CANCELLED", "FAILED_RECOVERABLE", "FAILED_FINAL"},
|
||||
"CLAIMED": {"RUNNING", "FAILED_RECOVERABLE", "FAILED_FINAL", "CANCELLED"},
|
||||
"RUNNING": {"VERIFYING", "WAITING_CHILD", "COMPLETED", "FAILED_RECOVERABLE", "FAILED_FINAL", "CANCELLED"},
|
||||
"WAITING_CHILD": {"RUNNING", "VERIFYING", "FAILED_RECOVERABLE", "FAILED_FINAL", "CANCELLED"},
|
||||
"VERIFYING": {"COMPLETED", "FAILED_RECOVERABLE", "FAILED_FINAL", "CANCELLED"},
|
||||
"COMPLETED": set(),
|
||||
"FAILED_RECOVERABLE": {"CLAIMED", "RUNNING", "CANCELLED"},
|
||||
"FAILED_FINAL": set(),
|
||||
"CANCELLED": set(),
|
||||
"MANUAL_REVIEW_REQUIRED": {"RUNNING", "CANCELLED"},
|
||||
}
|
||||
|
||||
|
||||
@dataclass
|
||||
class Budget:
|
||||
time_seconds: int | None = None
|
||||
attempts: int | None = None
|
||||
tokens: int | None = None
|
||||
cost: float | None = None
|
||||
|
||||
@classmethod
|
||||
def from_dict(cls, data: dict[str, Any] | None) -> "Budget":
|
||||
if not data:
|
||||
return cls()
|
||||
if not isinstance(data, dict) or set(data) - {
|
||||
"time_seconds",
|
||||
"attempts",
|
||||
"tokens",
|
||||
"cost",
|
||||
}:
|
||||
raise ValueError("invalid budget")
|
||||
for name in ("time_seconds", "attempts", "tokens", "cost"):
|
||||
value = data.get(name)
|
||||
if value is not None:
|
||||
try:
|
||||
if float(value) < 0:
|
||||
raise ValueError("budget values must be non-negative")
|
||||
except (TypeError, ValueError) as exc:
|
||||
raise ValueError("invalid budget value") from exc
|
||||
return cls(
|
||||
time_seconds=_to_positive_int(data.get("time_seconds")),
|
||||
attempts=_to_positive_int(data.get("attempts")),
|
||||
tokens=_to_positive_int(data.get("tokens")),
|
||||
cost=_to_float(data.get("cost")),
|
||||
)
|
||||
|
||||
def to_dict(self) -> dict[str, Any]:
|
||||
return {
|
||||
"time_seconds": self.time_seconds,
|
||||
"attempts": self.attempts,
|
||||
"tokens": self.tokens,
|
||||
"cost": self.cost,
|
||||
}
|
||||
|
||||
def merge(self, other: "Budget") -> "Budget":
|
||||
return Budget(
|
||||
time_seconds=_first_non_none(self.time_seconds, other.time_seconds),
|
||||
attempts=_first_non_none(self.attempts, other.attempts),
|
||||
tokens=_first_non_none(self.tokens, other.tokens),
|
||||
cost=_first_non_none(self.cost, other.cost),
|
||||
)
|
||||
|
||||
|
||||
@dataclass
|
||||
class TaskPlan:
|
||||
schema_version: int = 1
|
||||
task_id: str | None = None
|
||||
task_type: str = "code.change"
|
||||
issuer: dict[str, Any] = field(default_factory=dict)
|
||||
intent: str | None = None
|
||||
required_capabilities: list[str] = field(default_factory=list)
|
||||
preferred_workers: list[str] = field(default_factory=list)
|
||||
risk: str = "medium"
|
||||
approval_policy: str = "patch-only"
|
||||
dependencies: list[str] = field(default_factory=list)
|
||||
max_delegation_depth: int = 5
|
||||
budgets: Budget = field(default_factory=Budget)
|
||||
evidence_requirements: list[str] = field(default_factory=list)
|
||||
parent_task_id: str | None = None
|
||||
correlation_id: str | None = None
|
||||
metadata: dict[str, Any] = field(default_factory=dict)
|
||||
data_classification: str = "internal"
|
||||
execution_zone: str = "isolated-development"
|
||||
network_policy: str = "controlled"
|
||||
logging_policy: str = "redacted"
|
||||
allowed_input_paths: list[str] = field(default_factory=list)
|
||||
allowed_output_paths: list[str] = field(default_factory=list)
|
||||
output_policy: str = "standard"
|
||||
|
||||
@classmethod
|
||||
def from_dict(cls, data: dict[str, Any] | None) -> "TaskPlan":
|
||||
if not isinstance(data, dict):
|
||||
raise ValueError("task plan payload must be an object")
|
||||
unknown = set(data) - TASK_PLAN_KEYS
|
||||
if unknown:
|
||||
raise ValueError("unknown task plan fields")
|
||||
if "task_id" not in data or data["task_id"] is None:
|
||||
data = dict(data)
|
||||
data["task_id"] = f"task-{uuid.uuid4()}"
|
||||
risk = str(data.get("risk", "medium"))
|
||||
if risk not in RISK_LEVELS:
|
||||
raise ValueError("invalid risk")
|
||||
issuer = data.get("issuer", {})
|
||||
if not isinstance(issuer, dict):
|
||||
raise ValueError("issuer must be an object")
|
||||
schema_version = int(data.get("schema_version", 1))
|
||||
if schema_version != 1:
|
||||
raise ValueError("unsupported schema_version")
|
||||
max_depth = _to_positive_int(data.get("max_delegation_depth"), default=5)
|
||||
if max_depth is None or max_depth > 32:
|
||||
raise ValueError("invalid max_delegation_depth")
|
||||
classification = str(data.get("data_classification", "internal"))
|
||||
if classification not in DATA_CLASSIFICATIONS:
|
||||
raise ValueError("invalid data_classification")
|
||||
execution_zone = validate_type(
|
||||
data.get("execution_zone", "isolated-development"), "execution_zone"
|
||||
)
|
||||
network_policy = validate_type(
|
||||
data.get("network_policy", "controlled"), "network_policy"
|
||||
)
|
||||
logging_policy = validate_type(
|
||||
data.get("logging_policy", "redacted"), "logging_policy"
|
||||
)
|
||||
output_policy = validate_type(
|
||||
data.get("output_policy", "standard"), "output_policy"
|
||||
)
|
||||
if contains_secret_text(
|
||||
{
|
||||
"intent": data.get("intent"),
|
||||
"metadata": data.get("metadata", {}),
|
||||
}
|
||||
):
|
||||
raise ValueError("task content contains secret material")
|
||||
if classification == "credential-secret":
|
||||
if execution_zone != "secure-file-transformer":
|
||||
raise ValueError("credential-secret requires secure-file-transformer")
|
||||
if network_policy != "denied":
|
||||
raise ValueError("credential-secret requires network denied")
|
||||
if logging_policy != "metadata-only":
|
||||
raise ValueError("credential-secret requires metadata-only logging")
|
||||
if output_policy != "hash-count-status-only":
|
||||
raise ValueError("credential-secret requires restricted output")
|
||||
return cls(
|
||||
schema_version=schema_version,
|
||||
task_id=validate_identifier(data["task_id"], "task_id"),
|
||||
task_type=validate_type(data.get("task_type", "code.change"), "task_type"),
|
||||
issuer=issuer,
|
||||
intent=data.get("intent"),
|
||||
required_capabilities=_normalize_list(data.get("required_capabilities", [])),
|
||||
preferred_workers=_normalize_list(data.get("preferred_workers", [])),
|
||||
risk=risk,
|
||||
approval_policy=validate_type(
|
||||
data.get("approval_policy", "patch-only"), "approval_policy"
|
||||
),
|
||||
dependencies=_normalize_list(data.get("dependencies", [])),
|
||||
max_delegation_depth=max_depth,
|
||||
budgets=Budget.from_dict(data.get("budgets")),
|
||||
evidence_requirements=_normalize_list(data.get("evidence_requirements", [])),
|
||||
parent_task_id=data.get("parent_task_id"),
|
||||
correlation_id=data.get("correlation_id"),
|
||||
metadata=data.get("metadata", {}) if isinstance(data.get("metadata", {}), dict) else {},
|
||||
data_classification=classification,
|
||||
execution_zone=execution_zone,
|
||||
network_policy=network_policy,
|
||||
logging_policy=logging_policy,
|
||||
allowed_input_paths=validate_relative_paths(
|
||||
data.get("allowed_input_paths", []), "allowed_input_paths"
|
||||
),
|
||||
allowed_output_paths=validate_relative_paths(
|
||||
data.get("allowed_output_paths", []), "allowed_output_paths"
|
||||
),
|
||||
output_policy=output_policy,
|
||||
)
|
||||
|
||||
def to_dict(self, *, redact: bool = False) -> dict[str, Any]:
|
||||
payload = {
|
||||
"schema_version": self.schema_version,
|
||||
"task_id": self.task_id,
|
||||
"task_type": self.task_type,
|
||||
"issuer": self.issuer,
|
||||
"intent": self.intent,
|
||||
"required_capabilities": list(self.required_capabilities),
|
||||
"preferred_workers": list(self.preferred_workers),
|
||||
"risk": self.risk,
|
||||
"approval_policy": self.approval_policy,
|
||||
"dependencies": list(self.dependencies),
|
||||
"max_delegation_depth": self.max_delegation_depth,
|
||||
"budgets": self.budgets.to_dict(),
|
||||
"evidence_requirements": list(self.evidence_requirements),
|
||||
"parent_task_id": self.parent_task_id,
|
||||
"correlation_id": self.correlation_id,
|
||||
"metadata": dict(self.metadata),
|
||||
"data_classification": self.data_classification,
|
||||
"execution_zone": self.execution_zone,
|
||||
"network_policy": self.network_policy,
|
||||
"logging_policy": self.logging_policy,
|
||||
"allowed_input_paths": list(self.allowed_input_paths),
|
||||
"allowed_output_paths": list(self.allowed_output_paths),
|
||||
"output_policy": self.output_policy,
|
||||
}
|
||||
if redact:
|
||||
payload = redact_value(payload)
|
||||
return payload
|
||||
|
||||
def operation_digest(self) -> str:
|
||||
return compute_sha256_hex(self.to_dict())
|
||||
|
||||
|
||||
@dataclass
|
||||
class TaskRecord:
|
||||
task_id: str
|
||||
status: str
|
||||
revision: int
|
||||
task_plan: TaskPlan
|
||||
created_at: float
|
||||
updated_at: float
|
||||
root_task_id: str
|
||||
idempotency_key: str | None = None
|
||||
failure_reason: str | None = None
|
||||
|
||||
def with_status(self, status: str) -> "TaskRecord":
|
||||
allowed = TASK_NEXT_STATES.get(self.status, set())
|
||||
if status != self.status and (not allowed and self.status not in {"COMPLETED", "FAILED_FINAL", "CANCELLED"}):
|
||||
raise TaskStateTransitionError(f"Cannot transition {self.status} -> {status}")
|
||||
if status not in TASK_STATES:
|
||||
raise TaskStateTransitionError(f"Invalid status {status}")
|
||||
if status != self.status and self.status in TASK_NEXT_STATES and status not in TASK_NEXT_STATES[self.status]:
|
||||
raise TaskStateTransitionError(f"Cannot transition {self.status} -> {status}")
|
||||
return TaskRecord(
|
||||
task_id=self.task_id,
|
||||
status=status,
|
||||
revision=self.revision + 1,
|
||||
task_plan=self.task_plan,
|
||||
created_at=self.created_at,
|
||||
updated_at=_now_ts(),
|
||||
root_task_id=self.root_task_id,
|
||||
idempotency_key=self.idempotency_key,
|
||||
failure_reason=self.failure_reason,
|
||||
)
|
||||
|
||||
def to_dict(self, *, include_task=True, redact_payload: bool = True) -> dict[str, Any]:
|
||||
payload = {
|
||||
"task_id": self.task_id,
|
||||
"status": self.status,
|
||||
"revision": self.revision,
|
||||
"root_task_id": self.root_task_id,
|
||||
"parent_task_id": self.task_plan.parent_task_id,
|
||||
"created_at": _fmt_ts(self.created_at),
|
||||
"updated_at": _fmt_ts(self.updated_at),
|
||||
"failure_reason": self.failure_reason,
|
||||
}
|
||||
if include_task:
|
||||
payload["plan"] = self.task_plan.to_dict(redact=redact_payload)
|
||||
if self.idempotency_key:
|
||||
payload["idempotency_key"] = self.idempotency_key
|
||||
return payload
|
||||
|
||||
|
||||
@dataclass
|
||||
class WorkerRegistration:
|
||||
worker_id: str
|
||||
worker_type: str
|
||||
identity: str
|
||||
capabilities: list[str]
|
||||
trust_zone: str
|
||||
max_concurrency: int
|
||||
heartbeat_interval_seconds: int
|
||||
supported_protocols: list[str]
|
||||
registered_at: float
|
||||
last_heartbeat: float
|
||||
status: str = "active"
|
||||
disabled: bool = False
|
||||
owner_identity: str = ""
|
||||
registration_revision: int = 1
|
||||
registration_policy: str = "self"
|
||||
created_at: float = 0.0
|
||||
updated_at: float = 0.0
|
||||
disabled_reason: str | None = None
|
||||
|
||||
@classmethod
|
||||
def from_dict(cls, data: dict[str, Any]) -> "WorkerRegistration":
|
||||
if not isinstance(data, dict):
|
||||
raise ValueError("worker registration payload must be an object")
|
||||
now = _now_ts()
|
||||
worker_id = validate_identifier(data.get("worker_id"), "worker_id")
|
||||
worker_type = validate_type(data.get("worker_type"), "worker_type")
|
||||
identity = str(data.get("identity") or "").strip()
|
||||
if not identity or any(ord(ch) < 32 for ch in identity):
|
||||
raise ValueError("invalid identity")
|
||||
max_concurrency = _to_positive_int(data.get("max_concurrency"), default=1)
|
||||
heartbeat_interval = _to_positive_int(
|
||||
data.get("heartbeat_interval_seconds"), default=15
|
||||
)
|
||||
if not max_concurrency:
|
||||
raise ValueError("max_concurrency must be positive")
|
||||
if not heartbeat_interval:
|
||||
raise ValueError("heartbeat_interval_seconds must be positive")
|
||||
return cls(
|
||||
worker_id=worker_id,
|
||||
worker_type=worker_type,
|
||||
identity=identity,
|
||||
capabilities=_normalize_list(data.get("capabilities", [])),
|
||||
trust_zone=str(data.get("trust_zone") or "default"),
|
||||
max_concurrency=max_concurrency,
|
||||
heartbeat_interval_seconds=heartbeat_interval,
|
||||
supported_protocols=_normalize_list(
|
||||
data.get("supported_protocols", ["aios-task-v1"])
|
||||
),
|
||||
registered_at=float(data.get("registered_at") or now),
|
||||
last_heartbeat=float(data.get("last_heartbeat") or now),
|
||||
status=str(data.get("status") or "active"),
|
||||
disabled=bool(data.get("disabled", False)),
|
||||
owner_identity=str(data.get("owner_identity") or identity),
|
||||
registration_revision=int(data.get("registration_revision") or 1),
|
||||
registration_policy=str(data.get("registration_policy") or "self"),
|
||||
created_at=float(data.get("created_at") or data.get("registered_at") or now),
|
||||
updated_at=float(data.get("updated_at") or now),
|
||||
disabled_reason=data.get("disabled_reason"),
|
||||
)
|
||||
|
||||
def to_dict(self, redact_payload: bool = True) -> dict[str, Any]:
|
||||
payload = {
|
||||
"worker_id": self.worker_id,
|
||||
"worker_type": self.worker_type,
|
||||
"identity": self.identity,
|
||||
"capabilities": list(self.capabilities),
|
||||
"trust_zone": self.trust_zone,
|
||||
"max_concurrency": self.max_concurrency,
|
||||
"heartbeat_interval_seconds": self.heartbeat_interval_seconds,
|
||||
"supported_protocols": list(self.supported_protocols),
|
||||
"registered_at": _fmt_ts(self.registered_at),
|
||||
"last_heartbeat": _fmt_ts(self.last_heartbeat),
|
||||
"status": self.status,
|
||||
"disabled": self.disabled,
|
||||
"owner_identity": self.owner_identity,
|
||||
"registration_revision": self.registration_revision,
|
||||
"registration_policy": self.registration_policy,
|
||||
"created_at": _fmt_ts(self.created_at or self.registered_at),
|
||||
"updated_at": _fmt_ts(self.updated_at or self.last_heartbeat),
|
||||
"disabled_reason": self.disabled_reason,
|
||||
}
|
||||
if redact_payload:
|
||||
payload = redact_value(payload)
|
||||
return payload
|
||||
|
||||
|
||||
@dataclass(frozen=True)
|
||||
class EvidenceEnvelope:
|
||||
schema_version: int
|
||||
evidence_id: str
|
||||
task_id: str
|
||||
claim_id: str
|
||||
kind: str
|
||||
worker_identity: str
|
||||
payload: dict[str, Any]
|
||||
created_at: float
|
||||
previous_evidence_hash: str
|
||||
evidence_digest: str
|
||||
signature: str | None = None
|
||||
attestation_ref: str | None = None
|
||||
|
||||
@classmethod
|
||||
def create(
|
||||
cls,
|
||||
*,
|
||||
task_id: str,
|
||||
claim_id: str,
|
||||
kind: str,
|
||||
worker_identity: str,
|
||||
payload: dict[str, Any],
|
||||
previous_evidence_hash: str,
|
||||
signature: str | None = None,
|
||||
attestation_ref: str | None = None,
|
||||
evidence_id: str | None = None,
|
||||
created_at: float | None = None,
|
||||
) -> "EvidenceEnvelope":
|
||||
envelope = cls(
|
||||
schema_version=1,
|
||||
evidence_id=evidence_id or f"evd-{uuid.uuid4()}",
|
||||
task_id=validate_identifier(task_id, "task_id"),
|
||||
claim_id=validate_identifier(claim_id, "claim_id"),
|
||||
kind=validate_type(kind, "evidence kind"),
|
||||
worker_identity=str(worker_identity),
|
||||
payload=redact_value(payload),
|
||||
created_at=float(created_at or _now_ts()),
|
||||
previous_evidence_hash=str(previous_evidence_hash or ""),
|
||||
evidence_digest="",
|
||||
signature=signature,
|
||||
attestation_ref=attestation_ref,
|
||||
)
|
||||
return dataclass_replace(
|
||||
envelope, evidence_digest=compute_sha256_hex(envelope.digest_payload())
|
||||
)
|
||||
|
||||
def digest_payload(self) -> dict[str, Any]:
|
||||
return {
|
||||
"schema_version": self.schema_version,
|
||||
"evidence_id": self.evidence_id,
|
||||
"task_id": self.task_id,
|
||||
"claim_id": self.claim_id,
|
||||
"kind": self.kind,
|
||||
"worker_identity": self.worker_identity,
|
||||
"payload": self.payload,
|
||||
"created_at": self.created_at,
|
||||
"previous_evidence_hash": self.previous_evidence_hash,
|
||||
"attestation_ref": self.attestation_ref,
|
||||
}
|
||||
|
||||
def verify(
|
||||
self,
|
||||
*,
|
||||
expected_task_id: str,
|
||||
expected_claim_id: str,
|
||||
expected_previous_hash: str,
|
||||
attestation_verifier: Any = None,
|
||||
) -> bool:
|
||||
if (
|
||||
self.schema_version != 1
|
||||
or self.task_id != expected_task_id
|
||||
or self.claim_id != expected_claim_id
|
||||
or self.previous_evidence_hash != expected_previous_hash
|
||||
or self.evidence_digest != compute_sha256_hex(self.digest_payload())
|
||||
):
|
||||
return False
|
||||
if self.signature or self.attestation_ref:
|
||||
return True if attestation_verifier is None else bool(attestation_verifier(self))
|
||||
return True
|
||||
|
||||
def to_dict(self) -> dict[str, Any]:
|
||||
return {
|
||||
**self.digest_payload(),
|
||||
"evidence_digest": self.evidence_digest,
|
||||
"signature": self.signature,
|
||||
}
|
||||
|
||||
|
||||
class ProbeOutcome(StrEnum):
|
||||
NOT_APPLIED = "NOT_APPLIED"
|
||||
APPLIED_VERIFIED = "APPLIED_VERIFIED"
|
||||
INDETERMINATE = "INDETERMINATE"
|
||||
CONFLICT = "CONFLICT"
|
||||
|
||||
|
||||
@dataclass(frozen=True)
|
||||
class ProbeEvidence:
|
||||
schema_version: int
|
||||
probe_id: str
|
||||
task_id: str
|
||||
claim_id: str
|
||||
worker_id: str
|
||||
worker_identity: str
|
||||
operation_digest: str
|
||||
outcome: ProbeOutcome
|
||||
observed_at: float
|
||||
expires_at: float
|
||||
probe_executor_identity: str
|
||||
evidence_digest: str
|
||||
signature: str | None = None
|
||||
attestation_ref: str | None = None
|
||||
|
||||
@classmethod
|
||||
def create(cls, **data: Any) -> "ProbeEvidence":
|
||||
outcome = data["outcome"]
|
||||
if not isinstance(outcome, ProbeOutcome):
|
||||
outcome = ProbeOutcome(str(outcome))
|
||||
probe = cls(
|
||||
schema_version=1,
|
||||
probe_id=data.get("probe_id") or f"probe-{uuid.uuid4()}",
|
||||
task_id=validate_identifier(data["task_id"], "task_id"),
|
||||
claim_id=validate_identifier(data["claim_id"], "claim_id"),
|
||||
worker_id=validate_identifier(data["worker_id"], "worker_id"),
|
||||
worker_identity=str(data["worker_identity"]),
|
||||
operation_digest=str(data["operation_digest"]),
|
||||
outcome=outcome,
|
||||
observed_at=float(data["observed_at"]),
|
||||
expires_at=float(data["expires_at"]),
|
||||
probe_executor_identity=str(data["probe_executor_identity"]),
|
||||
evidence_digest="",
|
||||
signature=data.get("signature"),
|
||||
attestation_ref=data.get("attestation_ref"),
|
||||
)
|
||||
return dataclass_replace(
|
||||
probe, evidence_digest=compute_sha256_hex(probe.digest_payload())
|
||||
)
|
||||
|
||||
def digest_payload(self) -> dict[str, Any]:
|
||||
return {
|
||||
"schema_version": self.schema_version,
|
||||
"probe_id": self.probe_id,
|
||||
"task_id": self.task_id,
|
||||
"claim_id": self.claim_id,
|
||||
"worker_id": self.worker_id,
|
||||
"worker_identity": self.worker_identity,
|
||||
"operation_digest": self.operation_digest,
|
||||
"outcome": self.outcome.value,
|
||||
"observed_at": self.observed_at,
|
||||
"expires_at": self.expires_at,
|
||||
"probe_executor_identity": self.probe_executor_identity,
|
||||
"attestation_ref": self.attestation_ref,
|
||||
}
|
||||
|
||||
def verify(self, *, now: float, attestation_verifier: Any) -> bool:
|
||||
if (
|
||||
self.schema_version != 1
|
||||
or self.expires_at <= now
|
||||
or self.observed_at > now
|
||||
or self.evidence_digest != compute_sha256_hex(self.digest_payload())
|
||||
or not (self.signature or self.attestation_ref)
|
||||
):
|
||||
return False
|
||||
return bool(attestation_verifier and attestation_verifier(self))
|
||||
|
||||
def to_dict(self) -> dict[str, Any]:
|
||||
return {
|
||||
**self.digest_payload(),
|
||||
"evidence_digest": self.evidence_digest,
|
||||
"signature": self.signature,
|
||||
}
|
||||
|
||||
|
||||
def dataclass_replace(value: Any, **changes: Any) -> Any:
|
||||
from dataclasses import replace
|
||||
|
||||
return replace(value, **changes)
|
||||
|
||||
|
||||
@dataclass
|
||||
class WorkerClaim:
|
||||
claim_id: str
|
||||
task_id: str
|
||||
worker_id: str
|
||||
worker_identity: str
|
||||
claimed_at: float
|
||||
lease_until: float
|
||||
attempt: int
|
||||
task_revision: int
|
||||
operation_digest: str
|
||||
status: str = "ACTIVE"
|
||||
|
||||
def to_dict(self, redact_payload: bool = True) -> dict[str, Any]:
|
||||
payload = {
|
||||
"claim_id": self.claim_id,
|
||||
"task_id": self.task_id,
|
||||
"worker_id": self.worker_id,
|
||||
"worker_identity": self.worker_identity,
|
||||
"claimed_at": _fmt_ts(self.claimed_at),
|
||||
"lease_until": _fmt_ts(self.lease_until),
|
||||
"attempt": self.attempt,
|
||||
"task_revision": self.task_revision,
|
||||
"operation_digest": self.operation_digest,
|
||||
"status": self.status,
|
||||
}
|
||||
if redact_payload:
|
||||
payload = redact_value(payload)
|
||||
return payload
|
||||
|
||||
|
||||
@dataclass
|
||||
class ResultEnvelope:
|
||||
task_id: str
|
||||
claim_id: str
|
||||
worker_identity: str
|
||||
status: str
|
||||
outputs: list[dict[str, Any]]
|
||||
evidence: list[dict[str, Any]]
|
||||
started_at: str
|
||||
completed_at: str
|
||||
result_digest: str | None = None
|
||||
signature: str | None = None
|
||||
attestation_ref: str | None = None
|
||||
operation_digest: str | None = None
|
||||
trust_status: str = "untrusted_shadow_result"
|
||||
|
||||
def digest_payload(self) -> dict[str, Any]:
|
||||
return {
|
||||
"task_id": self.task_id,
|
||||
"claim_id": self.claim_id,
|
||||
"worker_identity": self.worker_identity,
|
||||
"status": self.status,
|
||||
"outputs": self.outputs,
|
||||
"evidence": self.evidence,
|
||||
"started_at": self.started_at,
|
||||
"completed_at": self.completed_at,
|
||||
"operation_digest": self.operation_digest,
|
||||
"attestation_ref": self.attestation_ref,
|
||||
}
|
||||
|
||||
def computed_digest(self) -> str:
|
||||
return compute_sha256_hex(self.digest_payload())
|
||||
|
||||
def to_dict(self, redact_payload: bool = True) -> dict[str, Any]:
|
||||
payload = {
|
||||
"task_id": self.task_id,
|
||||
"claim_id": self.claim_id,
|
||||
"worker_identity": self.worker_identity,
|
||||
"status": self.status,
|
||||
"outputs": self.outputs,
|
||||
"evidence": self.evidence,
|
||||
"started_at": self.started_at,
|
||||
"completed_at": self.completed_at,
|
||||
"result_digest": self.result_digest,
|
||||
"signature": self.signature,
|
||||
"attestation_ref": self.attestation_ref,
|
||||
"operation_digest": self.operation_digest,
|
||||
"trust_status": self.trust_status,
|
||||
}
|
||||
if redact_payload:
|
||||
payload = redact_value(payload)
|
||||
return payload
|
||||
|
||||
|
||||
def _normalize_list(value: Any) -> list[str]:
|
||||
if not isinstance(value, list):
|
||||
raise ValueError("expected list")
|
||||
if len(value) > 128 or any(
|
||||
not isinstance(v, str)
|
||||
or not v
|
||||
or len(v) > 256
|
||||
or any(ord(ch) < 32 for ch in v)
|
||||
for v in value
|
||||
):
|
||||
raise ValueError("invalid list item")
|
||||
return list(value)
|
||||
|
||||
|
||||
def _to_positive_int(value: Any, default: int | None = None) -> int | None:
|
||||
if value is None:
|
||||
return default
|
||||
try:
|
||||
number = int(value)
|
||||
except (TypeError, ValueError):
|
||||
return default
|
||||
return number if number >= 0 else default
|
||||
|
||||
|
||||
def _to_float(value: Any) -> float | None:
|
||||
if value is None:
|
||||
return None
|
||||
try:
|
||||
return float(value)
|
||||
except (TypeError, ValueError):
|
||||
return None
|
||||
|
||||
|
||||
def _first_non_none(primary: Any, fallback: Any) -> Any:
|
||||
if primary is not None:
|
||||
return primary
|
||||
return fallback
|
||||
|
||||
|
||||
def iso8601_now() -> str:
|
||||
return datetime.now(timezone.utc).replace(microsecond=0).isoformat().replace("+00:00", "Z")
|
||||
|
||||
|
||||
def _fmt_ts(value: float | None) -> str | None:
|
||||
if value is None:
|
||||
return None
|
||||
return datetime.fromtimestamp(value, tz=timezone.utc).replace(microsecond=0).isoformat().replace("+00:00", "Z")
|
||||
@@ -1,226 +0,0 @@
|
||||
"""Policy and verification logic (fail-closed)."""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
from dataclasses import dataclass
|
||||
from typing import Callable
|
||||
|
||||
from .errors import ForbiddenError, LockedError
|
||||
from .models import ProbeEvidence, ResultEnvelope, TaskRecord
|
||||
|
||||
|
||||
RISK_RANK = {"low": 1, "medium": 2, "high": 3}
|
||||
READONLY_WORKER_ACTIONS = frozenset(
|
||||
{"claim", "result", "fail", "progress", "heartbeat"}
|
||||
)
|
||||
ALL_ACTION_CAPABILITIES = frozenset(
|
||||
{
|
||||
"task.creator",
|
||||
"worker.self_register",
|
||||
"worker.admin",
|
||||
"task.claim",
|
||||
"task.cancel",
|
||||
"task.delegate",
|
||||
"task.read",
|
||||
"task.audit",
|
||||
}
|
||||
)
|
||||
|
||||
|
||||
@dataclass
|
||||
class PolicyDecision:
|
||||
allowed: bool
|
||||
reason: str = ""
|
||||
|
||||
|
||||
@dataclass(frozen=True)
|
||||
class ReadonlyWorkerProfile:
|
||||
"""A narrowly-scoped identity allowed to process safe Shadow tasks only."""
|
||||
|
||||
worker_id: str
|
||||
identity: str
|
||||
capabilities: frozenset[str]
|
||||
task_types: frozenset[str] = frozenset({"code.review", "test.execute"})
|
||||
|
||||
def permits_task(self, task: TaskRecord) -> bool:
|
||||
plan = task.task_plan
|
||||
if plan.task_type not in self.task_types or plan.risk != "low":
|
||||
return False
|
||||
if plan.data_classification not in {"public", "internal"}:
|
||||
return False
|
||||
if plan.metadata.get("production_side_effects") is not False:
|
||||
return False
|
||||
return set(plan.required_capabilities).issubset(self.capabilities)
|
||||
|
||||
|
||||
class IdentityVerifier:
|
||||
def __init__(self, trusted_identities: set[str] | None = None):
|
||||
self.trusted_identities = trusted_identities
|
||||
|
||||
def verify(self, identity: str) -> bool:
|
||||
if self.trusted_identities is None:
|
||||
return True
|
||||
return identity in self.trusted_identities
|
||||
|
||||
|
||||
class EvidenceVerifier:
|
||||
def __init__(self, mandatory: list[str] | None = None):
|
||||
self.mandatory = set(mandatory or [])
|
||||
|
||||
def verify(self, task: TaskRecord, evidences: list[dict]) -> PolicyDecision:
|
||||
required = set(task.task_plan.evidence_requirements or [])
|
||||
if not required and not self.mandatory:
|
||||
return PolicyDecision(True)
|
||||
observed = {e.get("kind") for e in evidences}
|
||||
missing = required.union(self.mandatory) - observed
|
||||
if missing:
|
||||
return PolicyDecision(False, f"missing evidence: {', '.join(sorted(missing))}")
|
||||
return PolicyDecision(True)
|
||||
|
||||
|
||||
class PolicyEngine:
|
||||
"""
|
||||
Fail-closed policy engine with minimal but explicit decisions.
|
||||
"""
|
||||
|
||||
def __init__(
|
||||
self,
|
||||
*,
|
||||
identity_verifier: IdentityVerifier | None = None,
|
||||
evidence_verifier: EvidenceVerifier | None = None,
|
||||
execution_enabled: bool = False,
|
||||
max_risk: str = "medium",
|
||||
result_signature_verifier: Callable[[ResultEnvelope], bool] | None = None,
|
||||
probe_attestation_verifier: Callable[[ProbeEvidence], bool] | None = None,
|
||||
identity_capabilities: dict[str, set[str]] | None = None,
|
||||
admin_identities: set[str] | None = None,
|
||||
readonly_worker_execution_enabled: bool = False,
|
||||
readonly_worker_profiles: list[ReadonlyWorkerProfile] | None = None,
|
||||
) -> None:
|
||||
if max_risk not in RISK_RANK:
|
||||
raise ValueError("invalid max_risk")
|
||||
self.identity_verifier = identity_verifier or IdentityVerifier()
|
||||
self.evidence_verifier = evidence_verifier or EvidenceVerifier()
|
||||
self.execution_enabled = execution_enabled
|
||||
self.max_risk = max_risk
|
||||
self.result_signature_verifier = result_signature_verifier
|
||||
self.probe_attestation_verifier = probe_attestation_verifier
|
||||
self.identity_capabilities = {
|
||||
identity: set(capabilities)
|
||||
for identity, capabilities in (identity_capabilities or {}).items()
|
||||
}
|
||||
self.admin_identities = set(admin_identities or ())
|
||||
self.readonly_worker_execution_enabled = readonly_worker_execution_enabled
|
||||
self.readonly_worker_profiles = {
|
||||
profile.identity: profile for profile in (readonly_worker_profiles or [])
|
||||
}
|
||||
|
||||
def _readonly_worker_allows(
|
||||
self, action: str, actor: str, task: TaskRecord | None
|
||||
) -> bool:
|
||||
profile = self.readonly_worker_profiles.get(actor)
|
||||
return bool(
|
||||
self.readonly_worker_execution_enabled
|
||||
and action in READONLY_WORKER_ACTIONS
|
||||
and profile is not None
|
||||
and (task is None or profile.permits_task(task))
|
||||
)
|
||||
|
||||
def assert_readonly_worker_binding(self, actor: str, worker_id: str) -> None:
|
||||
profile = self.readonly_worker_profiles.get(actor)
|
||||
if profile is not None and profile.worker_id != worker_id:
|
||||
raise ForbiddenError("worker identity binding mismatch")
|
||||
|
||||
def assert_readonly_worker_registration(self, actor: str, payload: dict) -> None:
|
||||
profile = self.readonly_worker_profiles.get(actor)
|
||||
if profile is None:
|
||||
return
|
||||
if (
|
||||
str(payload.get("worker_id") or "") != profile.worker_id
|
||||
or str(payload.get("identity") or "") != profile.identity
|
||||
or set(payload.get("capabilities") or []) != set(profile.capabilities)
|
||||
or str(payload.get("trust_zone") or "") != "isolated-review"
|
||||
or int(payload.get("max_concurrency") or 0) != 1
|
||||
or int(payload.get("heartbeat_interval_seconds") or 0) != 15
|
||||
):
|
||||
raise ForbiddenError("readonly worker registration mismatch")
|
||||
|
||||
def verify_result(
|
||||
self, result: ResultEnvelope, task: TaskRecord | None = None
|
||||
) -> PolicyDecision:
|
||||
computed = result.computed_digest()
|
||||
if result.result_digest and result.result_digest != computed:
|
||||
return PolicyDecision(False, "result digest mismatch")
|
||||
sensitive = bool(
|
||||
task
|
||||
and (
|
||||
task.task_plan.data_classification
|
||||
in {"confidential", "credential-secret"}
|
||||
or any(
|
||||
capability.startswith(
|
||||
("code.write", "deploy", "secret", "production")
|
||||
)
|
||||
for capability in task.task_plan.required_capabilities
|
||||
)
|
||||
)
|
||||
)
|
||||
if sensitive and not (result.signature or result.attestation_ref):
|
||||
return PolicyDecision(False, "trusted result proof required")
|
||||
if result.signature is not None or result.attestation_ref is not None:
|
||||
if self.result_signature_verifier is None:
|
||||
return PolicyDecision(False, "result signature verifier unavailable")
|
||||
if not self.result_signature_verifier(result):
|
||||
return PolicyDecision(False, "result signature invalid")
|
||||
result.trust_status = "trusted_result"
|
||||
else:
|
||||
result.trust_status = "untrusted_shadow_result"
|
||||
return PolicyDecision(True)
|
||||
|
||||
def authorize(self, action: str, actor: str, task: TaskRecord | None = None, context: dict | None = None) -> PolicyDecision:
|
||||
context = context or {}
|
||||
if not self.identity_verifier.verify(actor):
|
||||
return PolicyDecision(False, "identity untrusted")
|
||||
|
||||
action_capabilities = {
|
||||
"create": "task.creator",
|
||||
"read": "task.read",
|
||||
"audit": "task.audit",
|
||||
"claim": "task.claim",
|
||||
"result": "task.claim",
|
||||
"fail": "task.claim",
|
||||
"progress": "task.claim",
|
||||
"heartbeat": "task.claim",
|
||||
"cancel": "task.cancel",
|
||||
"delegate": "task.delegate",
|
||||
"worker.register": "worker.self_register",
|
||||
"worker.admin": "worker.admin",
|
||||
}
|
||||
required_capability = action_capabilities.get(action)
|
||||
if required_capability:
|
||||
granted = set(
|
||||
self.identity_capabilities.get(
|
||||
actor, self.identity_capabilities.get("*", set())
|
||||
)
|
||||
)
|
||||
if required_capability not in granted:
|
||||
return PolicyDecision(False, f"action {action} not permitted")
|
||||
|
||||
if action in {"claim", "result", "fail", "cancel", "progress", "delegate", "heartbeat"} and not self.execution_enabled:
|
||||
if not self._readonly_worker_allows(action, actor, task):
|
||||
return PolicyDecision(False, "execution disabled")
|
||||
|
||||
if action == "delegate" and task and task.status not in {"COMPLETED", "FAILED_FINAL", "CANCELLED"}:
|
||||
risk = str(context.get("risk", task.task_plan.risk))
|
||||
if RISK_RANK.get(risk, 2) > RISK_RANK.get(self.max_risk, 1):
|
||||
return PolicyDecision(False, f"risk {risk} exceeds policy")
|
||||
|
||||
return PolicyDecision(True)
|
||||
|
||||
def assert_allowed(self, action: str, actor: str, task: TaskRecord | None = None, context: dict | None = None):
|
||||
decision = self.authorize(action, actor, task, context=context)
|
||||
if not decision.allowed:
|
||||
if decision.reason == "identity untrusted":
|
||||
raise ForbiddenError(decision.reason)
|
||||
if decision.reason == "execution disabled":
|
||||
raise LockedError("execution disabled")
|
||||
raise ForbiddenError(decision.reason)
|
||||
@@ -1,76 +0,0 @@
|
||||
"""Task scheduler primitives."""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import time
|
||||
from .errors import NotFoundError
|
||||
from .capabilities import has_capabilities
|
||||
from .models import WorkerClaim
|
||||
from .store import TaskPlaneStore
|
||||
|
||||
|
||||
class TaskScheduler:
|
||||
def __init__(self, store: TaskPlaneStore):
|
||||
self.store = store
|
||||
|
||||
def next_queued_task(self, worker_id: str):
|
||||
worker = self.store.get_worker(worker_id)
|
||||
tasks = sorted(
|
||||
self.store.list_tasks(),
|
||||
key=lambda task: (
|
||||
-int(task.task_plan.metadata.get("priority", 0)),
|
||||
task.created_at,
|
||||
task.task_id,
|
||||
),
|
||||
)
|
||||
for task in tasks:
|
||||
if task.status not in {"CREATED", "QUEUED", "FAILED_RECOVERABLE"}:
|
||||
continue
|
||||
if task.task_plan.task_type == "worker.registry.audit":
|
||||
continue
|
||||
if task.status == "FAILED_RECOVERABLE" and not self.store.task_has_retryable_probe(
|
||||
task.task_id
|
||||
):
|
||||
continue
|
||||
if not has_capabilities(
|
||||
worker.capabilities, task.task_plan.required_capabilities
|
||||
):
|
||||
continue
|
||||
if any(
|
||||
self.store.get_task(dependency).status != "COMPLETED"
|
||||
for dependency in task.task_plan.dependencies
|
||||
):
|
||||
continue
|
||||
if (
|
||||
task.task_plan.data_classification == "credential-secret"
|
||||
and worker.worker_type != "secure_file_transformer"
|
||||
and "secure_file_transformer" not in worker.capabilities
|
||||
):
|
||||
continue
|
||||
return task
|
||||
return None
|
||||
|
||||
def schedule_for_worker(self, worker_id: str, lease_seconds: int = 15) -> WorkerClaim:
|
||||
worker = self.store.get_worker(worker_id)
|
||||
if worker.disabled:
|
||||
from .errors import LockedError
|
||||
|
||||
raise LockedError("worker disabled")
|
||||
if time.time() > worker.last_heartbeat + (
|
||||
worker.heartbeat_interval_seconds * 3
|
||||
):
|
||||
from .errors import LockedError
|
||||
|
||||
raise LockedError("worker offline")
|
||||
task = self.next_queued_task(worker_id)
|
||||
if task is None:
|
||||
raise NotFoundError("no queued tasks available")
|
||||
claim = self.store.claim_task(
|
||||
task.task_id,
|
||||
worker_id,
|
||||
worker.identity,
|
||||
lease_seconds=lease_seconds,
|
||||
expected_revision=task.revision,
|
||||
operation_digest=task.task_plan.operation_digest(),
|
||||
)
|
||||
return claim
|
||||
File diff suppressed because it is too large
Load Diff
@@ -1,68 +0,0 @@
|
||||
"""Worker registry abstraction and read helpers."""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import time
|
||||
|
||||
from .capabilities import has_capabilities
|
||||
from .errors import NotFoundError
|
||||
from .models import WorkerRegistration
|
||||
from .store import TaskPlaneStore
|
||||
|
||||
|
||||
class WorkerRegistry:
|
||||
def __init__(self, store: TaskPlaneStore):
|
||||
self.store = store
|
||||
|
||||
def register(
|
||||
self,
|
||||
payload: dict,
|
||||
*,
|
||||
actor_identity: str,
|
||||
is_admin: bool,
|
||||
expected_revision: int | None,
|
||||
) -> WorkerRegistration:
|
||||
reg = WorkerRegistration.from_dict(payload)
|
||||
return self.store.register_worker(
|
||||
reg,
|
||||
actor_identity=actor_identity,
|
||||
is_admin=is_admin,
|
||||
expected_revision=expected_revision,
|
||||
)
|
||||
|
||||
def heartbeat(
|
||||
self,
|
||||
worker_id: str,
|
||||
heartbeat_interval_seconds: int | None = None,
|
||||
*,
|
||||
actor_identity: str,
|
||||
expected_revision: int | None,
|
||||
) -> WorkerRegistration:
|
||||
return self.store.heartbeat_worker(
|
||||
worker_id,
|
||||
heartbeat_interval_seconds=heartbeat_interval_seconds,
|
||||
actor_identity=actor_identity,
|
||||
expected_revision=expected_revision,
|
||||
)
|
||||
|
||||
def list(self):
|
||||
return self.store.list_workers()
|
||||
|
||||
def get(self, worker_id: str) -> WorkerRegistration:
|
||||
try:
|
||||
return self.store.get_worker(worker_id)
|
||||
except NotFoundError:
|
||||
raise
|
||||
|
||||
def can_execute(self, worker_id: str, required_capabilities: list[str]) -> bool:
|
||||
worker = self.store.get_worker(worker_id)
|
||||
return has_capabilities(worker.capabilities, required_capabilities)
|
||||
|
||||
def is_online(self, worker_id: str, *, now: float | None = None) -> bool:
|
||||
worker = self.store.get_worker(worker_id)
|
||||
deadline = worker.last_heartbeat + (worker.heartbeat_interval_seconds * 3)
|
||||
return not worker.disabled and (time.time() if now is None else now) <= deadline
|
||||
|
||||
def stale_workers(self, *, now: float | None = None) -> list[WorkerRegistration]:
|
||||
current = time.time() if now is None else now
|
||||
return [worker for worker in self.list() if not self.is_online(worker.worker_id, now=current)]
|
||||
@@ -1,5 +1,5 @@
|
||||
{
|
||||
"schema_version": 4,
|
||||
"schema_version": 2,
|
||||
"automatic": [
|
||||
"build",
|
||||
"test",
|
||||
@@ -44,10 +44,6 @@
|
||||
},
|
||||
"approval": {
|
||||
"algorithm": "Ed25519",
|
||||
"trust_domain": "aios.production",
|
||||
"maximum_lifetime_seconds": 3600,
|
||||
"release_plan_sha256_required": true,
|
||||
"not_before_required": true,
|
||||
"replay_protection": true,
|
||||
"revocation_fail_closed": true,
|
||||
"key_rotation_supported": true,
|
||||
@@ -62,42 +58,6 @@
|
||||
"default_enabled": false,
|
||||
"shadow_side_effects_allowed": false,
|
||||
"durable_saga_required": true,
|
||||
"pre_switch_revalidation_required": true,
|
||||
"trusted_candidate_builder_required": true,
|
||||
"actual_plan_regeneration_required": true,
|
||||
"startup_fail_closed_on_missing_component": true,
|
||||
"recovery_worker_shadow_default": true,
|
||||
"production_approval_backend_required": true,
|
||||
"production_builder_signer": "kms-hsm-secret-manager-only",
|
||||
"production_execution_without_backend": "unavailable"
|
||||
},
|
||||
"durability": {
|
||||
"journal": "sha256-hash-chain",
|
||||
"probe_journal": "sha256-hash-chain",
|
||||
"exclusive_capability_claims": true,
|
||||
"side_effect_probe_before_lease_takeover": true,
|
||||
"side_effect_probe_before_failed_recoverable_retry": true,
|
||||
"probe_results": [
|
||||
"NOT_APPLIED",
|
||||
"APPLIED_VERIFIED",
|
||||
"INDETERMINATE",
|
||||
"CONFLICT"
|
||||
],
|
||||
"probe_operation_digest_required": true,
|
||||
"probe_freshness_required": true,
|
||||
"tamper_result": "MANUAL_OWNER_REVIEW_REQUIRED"
|
||||
},
|
||||
"tag_pending": {
|
||||
"required_observations": [
|
||||
"remote_git_ref",
|
||||
"annotated_tag_object",
|
||||
"peeled_target",
|
||||
"gitea_api",
|
||||
"gitea_listing",
|
||||
"repository_identity"
|
||||
],
|
||||
"indeterminate_result": "RECONCILIATION_REQUIRED",
|
||||
"conflict_result": "MANUAL_OWNER_REVIEW_REQUIRED",
|
||||
"automatic_reconciliation": false
|
||||
"pre_switch_revalidation_required": true
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1,42 +0,0 @@
|
||||
[Unit]
|
||||
Description=AIOS Autonomous Release Candidate API (Dormant/Shadow Only)
|
||||
After=network.target
|
||||
ConditionPathExists=/opt/aios-autonomous-release-candidate/aios_autonomous_release_candidate
|
||||
|
||||
[Service]
|
||||
Type=simple
|
||||
User=aiman
|
||||
Group=gitops
|
||||
UMask=0077
|
||||
WorkingDirectory=/opt/aios-autonomous-release-candidate
|
||||
Environment=PYTHONDONTWRITEBYTECODE=1
|
||||
Environment=PYTHONPATH=/opt/aios-autonomous-release-candidate
|
||||
Environment=AIOS_TASK_PLANE_EXECUTION_ENABLED=false
|
||||
Environment=AIOS_GITOPS_WRITES_ENABLED=false
|
||||
Environment=AIOS_PRODUCTION_DEPLOYMENT_ENABLED=false
|
||||
ExecStart=/usr/bin/python3 -m aios_autonomous_release_candidate.service --host 127.0.0.1 --port 19951 --state /var/lib/aios-autonomous-release-candidate/state.sqlite3
|
||||
StateDirectory=aios-autonomous-release-candidate
|
||||
RuntimeDirectory=aios-autonomous-release-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 AF_INET AF_INET6
|
||||
IPAddressDeny=any
|
||||
IPAddressAllow=localhost
|
||||
ReadOnlyPaths=/opt/aios-autonomous-release-candidate
|
||||
ReadWritePaths=/var/lib/aios-autonomous-release-candidate
|
||||
|
||||
[Install]
|
||||
WantedBy=multi-user.target
|
||||
@@ -1,51 +0,0 @@
|
||||
[Unit]
|
||||
Description=AIOS Autonomous Release Candidate Worker (Dormant/Shadow Only)
|
||||
After=network.target
|
||||
ConditionPathExists=/opt/aios-autonomous-release-candidate/aios_autonomous_release_candidate
|
||||
|
||||
[Service]
|
||||
Type=simple
|
||||
User=aiman
|
||||
Group=gitops
|
||||
UMask=0077
|
||||
WorkingDirectory=/opt/aios-autonomous-release-candidate
|
||||
Environment=PYTHONDONTWRITEBYTECODE=1
|
||||
Environment=PYTHONPATH=/opt/aios-autonomous-release-candidate
|
||||
Environment=AIOS_TASK_PLANE_EXECUTION_ENABLED=false
|
||||
Environment=AIOS_GITOPS_WRITES_ENABLED=false
|
||||
Environment=AIOS_PRODUCTION_DEPLOYMENT_ENABLED=false
|
||||
Environment=AIOS_CANDIDATE_CONTROL_ENDPOINT=127.0.0.1:19951
|
||||
Environment=AIOS_OPENCLAW_CREDENTIAL_REFERENCE=systemd-credential:openclaw-gateway-candidate
|
||||
Environment=AIOS_CODEX_CREDENTIAL_REFERENCE=systemd-credential:codex-app-server-candidate
|
||||
Environment=AIOS_NATIVE_CONTROL_CREDENTIAL_REFERENCE=systemd-credential:session-native-adapter-control-candidate
|
||||
Environment=AIOS_GITEA_CREDENTIAL_REFERENCE=systemd-credential:gitea-admin-api-candidate
|
||||
ImportCredential=openclaw-gateway-candidate
|
||||
ImportCredential=codex-app-server-candidate
|
||||
ImportCredential=session-native-adapter-control-candidate
|
||||
ImportCredential=gitea-admin-api-candidate
|
||||
ExecStart=/usr/bin/python3 -m aios_autonomous_release_candidate.worker_service --state-directory /var/lib/aios-autonomous-release-worker-candidate
|
||||
StateDirectory=aios-autonomous-release-worker-candidate
|
||||
RuntimeDirectory=aios-autonomous-release-worker-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 AF_INET AF_INET6
|
||||
IPAddressDeny=any
|
||||
IPAddressAllow=localhost
|
||||
ReadOnlyPaths=/opt/aios-autonomous-release-candidate
|
||||
ReadWritePaths=/var/lib/aios-autonomous-release-worker-candidate
|
||||
|
||||
[Install]
|
||||
WantedBy=multi-user.target
|
||||
@@ -1,25 +0,0 @@
|
||||
[Unit]
|
||||
Description=AIOS Silent Release Shadow Controller
|
||||
After=network-online.target
|
||||
Wants=network-online.target
|
||||
|
||||
[Service]
|
||||
Type=simple
|
||||
User=aiman
|
||||
Group=gitops
|
||||
UMask=0077
|
||||
Environment=AIOS_GITOPS_WRITES_ENABLED=false
|
||||
Environment=AIOS_SILENT_RELEASE_EXECUTION_ENABLED=false
|
||||
Environment=PYTHONDONTWRITEBYTECODE=1
|
||||
ExecStart=/usr/bin/python3 /usr/libexec/aios-silent-release-shadow/current/active-runtime/app/silent_release_execution.py --state-root /var/lib/aios-silent-release-shadow --repository /data/aios-gitops/repo.git --host 127.0.0.1 --port 18891 --poll-seconds 30
|
||||
Restart=on-failure
|
||||
RestartSec=5
|
||||
NoNewPrivileges=true
|
||||
PrivateTmp=true
|
||||
ProtectSystem=strict
|
||||
ProtectHome=true
|
||||
ReadWritePaths=/var/lib/aios-silent-release-shadow
|
||||
ReadOnlyPaths=/data/aios-gitops/repo.git /usr/libexec/aios-silent-release-shadow
|
||||
|
||||
[Install]
|
||||
WantedBy=multi-user.target
|
||||
@@ -1,71 +0,0 @@
|
||||
# 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
|
||||
```
|
||||
@@ -1,34 +0,0 @@
|
||||
# AIOS Autonomous Release Candidate 架构
|
||||
|
||||
本 Candidate 把规划、工作流、凭据引用、原生会话、证据和发布控制拆成独立边界。它只负责验证约束，不拥有生产授权。
|
||||
|
||||
## 信任边界
|
||||
|
||||
- Owner Approval 的签名和撤销状态来自外部 HSM/KMS 或可信 Approval Plane。Candidate 只有 verifier，没有 signer。
|
||||
- Secret Manager V2 只返回 `systemd-credential:*` 或受控的 Candidate reference，不返回认证正文。
|
||||
- OpenClaw、Codex 和 Gitea provider 身份由管理面供应；模拟 provider 永远不能把原生 canary 标成已验证。
|
||||
- Writer 只写任务绑定分支和允许路径。生产 main、tag、baseline、registry 和部署不属于 Candidate 权限。
|
||||
|
||||
## 核心模块
|
||||
|
||||
- `models.py`：TaskPlan、Approval、Credential、Result 和 ReleasePlan 强类型约束。
|
||||
- `store.py`：私有 SQLite、WAL、全同步、schema 检查、事务和原子 step transition。
|
||||
- `workflow.py`：依赖、claim、lease、retry、timeout recovery 和终态。
|
||||
- `credential.py` / `secret_manager.py`：reference-only 生命周期、补偿撤销、跨任务拒绝和 post-revocation 验证。
|
||||
- `native_adapters.py`：OpenClaw/Codex 原生 provider ID、parent/child tree、status、interrupt、close 和纯文本回执。
|
||||
- `gitea_canary.py`：仅通过 deploy-key provider 的 list/create/delete 操作完成 canary 与撤销验证。
|
||||
- `evidence.py`：落库的哈希链、重启回放、篡改检测和 required-event closure。
|
||||
- `artifact.py`：确定性 tar、逐文件哈希、package closure、链接/特殊文件/敏感标记拒绝。
|
||||
- `release.py` / `release_gate.py`：部署审批与回滚审批分离，tag object 与 peeled target 分离验证。
|
||||
|
||||
## 会话真实性
|
||||
|
||||
以下状态必须分别记录，不能互相替代：
|
||||
|
||||
```text
|
||||
broker_session_verified
|
||||
openclaw_native_child_session_verified
|
||||
codex_child_session_verified
|
||||
```
|
||||
|
||||
Shadow provider 只能证明 Broker 合同和清理路径，不能证明 OpenClaw 或 Codex 原生会话。
|
||||
@@ -1,47 +0,0 @@
|
||||
# AIOS Autonomous Release Execution Package
|
||||
|
||||
## Mode
|
||||
|
||||
Candidate/shadow first. Production changes require an independent release approval.
|
||||
|
||||
## Flow
|
||||
|
||||
1. Create TaskPlan.
|
||||
2. Validate policy and approval envelope.
|
||||
3. Route workers by capability and trust zone.
|
||||
4. Execute on isolated candidate branch.
|
||||
5. Collect evidence chain and artifact manifest.
|
||||
6. Verify release plan.
|
||||
7. Wait for owner approval.
|
||||
8. Deploy only after approval.
|
||||
|
||||
## Hard stops
|
||||
|
||||
- main writes
|
||||
- force push
|
||||
- tag rewrite
|
||||
- baseline mutation
|
||||
- registry mutation
|
||||
- plaintext credential handling
|
||||
- missing evidence closure
|
||||
|
||||
## Required evidence
|
||||
|
||||
- git ref closure
|
||||
- test report
|
||||
- artifact checksum
|
||||
- manifest checksum
|
||||
- credential revoke proof
|
||||
- production invariant snapshot
|
||||
|
||||
## Production activation
|
||||
|
||||
The executor must keep:
|
||||
|
||||
```
|
||||
AIOS_GITOPS_WRITES_ENABLED=false
|
||||
AIOS_TASK_PLANE_EXECUTION_ENABLED=false
|
||||
AIOS_SILENT_RELEASE_EXECUTION_ENABLED=false
|
||||
```
|
||||
|
||||
until release approval is independently verified.
|
||||
@@ -1,48 +0,0 @@
|
||||
# Candidate 运维与验收
|
||||
|
||||
## 安全默认值
|
||||
|
||||
两个 systemd 模板均为 Dormant/Shadow-only，绑定 loopback，默认关闭 Task Plane 执行、GitOps 写入和生产部署。模板进入仓库不等于安装或启动服务。
|
||||
|
||||
外部信任根缺失时必须保留以下阻断：
|
||||
|
||||
```text
|
||||
BLOCKED_OWNER_APPROVAL_VERIFIER_UNAVAILABLE
|
||||
BLOCKED_GITEA_ADMIN_CREDENTIAL_REQUIRED
|
||||
BLOCKED_EXTERNAL_OWNER_SIGNATURE
|
||||
```
|
||||
|
||||
不得用模拟身份、个人账户或生产 provider 身份替代这些根。
|
||||
|
||||
## 独立验收
|
||||
|
||||
从仓库根目录运行：
|
||||
|
||||
```text
|
||||
PYTHONPATH=services/aios-autonomous-release-candidate \
|
||||
python3 -m pytest -p no:cacheprovider -q tests/autonomous_release
|
||||
|
||||
PYTHONPATH=services/aios-autonomous-release-candidate \
|
||||
python3 scripts/autonomous-release/run_acceptance.py \
|
||||
--repo-root . \
|
||||
--output /task-evidence/candidate-acceptance.json
|
||||
```
|
||||
|
||||
Acceptance report 必须满足：
|
||||
|
||||
```text
|
||||
all_passed=true
|
||||
skipped=0
|
||||
direct_gitea_database_access=false
|
||||
production_path_hits=[]
|
||||
secret_hits=[]
|
||||
production_side_effects=false
|
||||
```
|
||||
|
||||
## Artifact
|
||||
|
||||
Artifact builder 拒绝覆盖现有文件、链接、硬链接、特殊文件、仓库元数据和敏感内容标记。输出 tar 和 manifest 后必须再次执行 `ArtifactBuilder.verify`。
|
||||
|
||||
## 外部 canary
|
||||
|
||||
真实 native session 与 Gitea canary 只能在任务绑定的 runtime credential 投影存在时运行。每次 canary 完成后必须关闭 provider session、撤销上游对象、删除 projection，并保留非敏感回执。
|
||||
@@ -1,26 +0,0 @@
|
||||
# Governed ReleasePlan 关闭条件
|
||||
|
||||
ReleasePlan 必须绑定 task、repository、integration branch、完整 target/tree OID、artifact/manifest/evidence/rollback digest、生产配置 digest，以及互不相同的部署和回滚 ApprovalPlan ID。
|
||||
|
||||
## Candidate 与 Integration
|
||||
|
||||
1. Candidate 分支先完成测试、扫描、Shadow、Artifact 和外部门禁盘点。
|
||||
2. 重新读取 authoritative `main` 完整 OID。
|
||||
3. 从该 OID 创建 integration 分支。
|
||||
4. 使用普通 `merge --no-ff` 合入 Candidate；禁止 squash、rebase、amend 和 force push。
|
||||
5. 在 integration 上重新执行全部测试、扫描和 artifact closure。
|
||||
|
||||
## 生产停止线
|
||||
|
||||
下列项目任一为 false，流程必须停止在 `READY_FOR_OWNER_RELEASE_APPROVAL`，不得部署或创建生产 tag：
|
||||
|
||||
```text
|
||||
openclaw_native_child_session_verified
|
||||
codex_child_session_verified
|
||||
gitea_admin_api_lifecycle_canary
|
||||
owner_signer_separation_verified
|
||||
credential_incident_closed
|
||||
external_owner_release_approval_verified
|
||||
```
|
||||
|
||||
聊天文本、Candidate 自签记录或模拟 canary 不能改变这条停止线。
|
||||
@@ -1,107 +0,0 @@
|
||||
# AIOS Silent Release Execution Readiness
|
||||
|
||||
## Scope and stop point
|
||||
|
||||
This change makes the controller execution-ready while deploying only a
|
||||
localhost-bound Shadow control plane. Both production gates remain false:
|
||||
|
||||
```text
|
||||
AIOS_GITOPS_WRITES_ENABLED=false
|
||||
AIOS_SILENT_RELEASE_EXECUTION_ENABLED=false
|
||||
```
|
||||
|
||||
Shadow completion is evidence preparation, not a production release. It cannot
|
||||
write a production tag, switch a business runtime, or mutate Baseline/Registry.
|
||||
|
||||
## Recovery state machine
|
||||
|
||||
Every expired or `FAILED_RECOVERABLE` capability requires fresh, operation-bound
|
||||
probe evidence before another adapter may run:
|
||||
|
||||
```text
|
||||
NOT_APPLIED -> one new exclusive claim may retry
|
||||
APPLIED_VERIFIED -> mark COMPLETED without adapter replay
|
||||
INDETERMINATE -> RECONCILIATION_REQUIRED; no automatic writes
|
||||
CONFLICT -> MANUAL_OWNER_REVIEW_REQUIRED; no automatic writes
|
||||
```
|
||||
|
||||
Probe evidence binds the immutable operation digest, is freshness checked, and
|
||||
is appended to a separate SHA-256 hash-chained journal. Completion still
|
||||
requires the active claim ID. File locks and leases ensure that concurrent
|
||||
recovery workers cannot execute the same adapter.
|
||||
|
||||
`TAG_PENDING` uses independent remote ref, annotated object, peeled target,
|
||||
Gitea API, Gitea listing, and repository identity evidence. Exact absence may
|
||||
roll back a switched runtime. Exact publication continues to finalization.
|
||||
Unavailable/divergent evidence stops at reconciliation; a different OID or
|
||||
target stops for Owner review. No branch can force, delete, or rewrite a tag.
|
||||
|
||||
## Trusted build and approval
|
||||
|
||||
Callers submit only an event ID and exact source commit. Test, canary, artifact,
|
||||
manifest, rollback, secret scan, Git and Gitea evidence are generated by the
|
||||
trusted builder. The builder emits an Ed25519 attestation binding:
|
||||
|
||||
- builder attestation/key IDs;
|
||||
- source commit and tree OID;
|
||||
- artifact, manifest and package-closure SHA-256;
|
||||
- test and canary evidence SHA-256;
|
||||
- issuance time and signature.
|
||||
|
||||
The controller contains only trusted public keys. Production signing is exposed
|
||||
through a KMS/HSM/secret-manager adapter; a local private-key adapter is marked
|
||||
test-only and is used only for ephemeral Shadow acceptance.
|
||||
|
||||
Owner approvals are immutable, time-bounded, revocable, trust-domain bound, and
|
||||
single-use per capability ledger. If the production approval backend reference
|
||||
is absent, production execution is unavailable while Shadow remains available.
|
||||
Caller-supplied `owner_id` is never a fallback.
|
||||
|
||||
## Persistent controller and API
|
||||
|
||||
`aios-silent-release-controller.service` runs independently from the business
|
||||
GitOps API. It uses a single leader lock, durable intents/candidates/Sagas,
|
||||
startup journal verification, idempotent main events, one notification record,
|
||||
and recovery reporting. The final deployed service is report-only Shadow mode.
|
||||
|
||||
The Action contract exposes:
|
||||
|
||||
- `createReleaseIntent`
|
||||
- `getReleaseCandidate`
|
||||
- `getReleasePlan`
|
||||
- `getReleaseAcceptance`
|
||||
- `submitSignedApproval`
|
||||
- `getReleaseSaga`
|
||||
- `getCapabilityStatus`
|
||||
- `startDeployment`
|
||||
- `getRecoveryStatus`
|
||||
|
||||
Every Shadow response declares `execution_enabled=false`, `shadow_mode=true`
|
||||
and `side_effects_executed=false`. `startDeployment` returns a simulated
|
||||
`SHADOW_COMPLETED` result and never claims production capabilities.
|
||||
|
||||
## Migration and rollback
|
||||
|
||||
1. Merge through a governed pull request.
|
||||
2. Build from a clean detached worktree at the exact merge commit.
|
||||
3. Verify artifact, manifest, package closure, tests, live fixture, no-.git
|
||||
canary, rollback archive and secret scan.
|
||||
4. Install a versioned Shadow release without changing the business runtime.
|
||||
5. Start the separate localhost-only controller with both gates false.
|
||||
6. Run Shadow candidates and freeze production PID/tag/Baseline/Registry hashes.
|
||||
7. Remove ephemeral test keys and temporary repositories.
|
||||
|
||||
Rollback stops and disables only the Shadow controller and restores/removes its
|
||||
versioned `current` link. The existing production API, tag set, Baseline and
|
||||
Registry are not involved.
|
||||
|
||||
## Future activation envelope
|
||||
|
||||
Activation requires a new one-time Owner approval binding the exact controller
|
||||
commit, artifact/manifest/policy/unit hashes, trusted key IDs, KMS/secret
|
||||
references, release and rollback roots, authoritative Git/repository identity,
|
||||
Shadow candidate/evidence IDs, test results, activation plan and rollback plan.
|
||||
That approval may only flip
|
||||
`AIOS_SILENT_RELEASE_EXECUTION_ENABLED=false` to `true`; each real release still
|
||||
requires its own signed ReleasePlan. This change does not request or consume
|
||||
that activation approval.
|
||||
@@ -1,84 +0,0 @@
|
||||
# Silent Release Controller Production Contract
|
||||
|
||||
Status: review-only implementation. Production execution remains disabled.
|
||||
|
||||
## Trust boundary
|
||||
|
||||
The caller submits only release intent. A configured trusted builder owns ref
|
||||
validation, build, tests, artifact and manifest hashing, package closure,
|
||||
canary, rollback readiness, Git/Gitea consistency, and secret scanning. Caller
|
||||
supplied success evidence is rejected.
|
||||
|
||||
The resulting immutable `ReleasePlan` contains deployment, tag, and
|
||||
finalization plans. One Ed25519 owner signature binds its SHA-256 digest,
|
||||
candidate evidence, policy digest, owner identity, trust domain, validity
|
||||
window, evidence lineage, and three narrow capabilities.
|
||||
|
||||
## Durable execution
|
||||
|
||||
The Saga journal is the source of truth. Every record is sequence-numbered and
|
||||
SHA-256 hash-chained from a fixed genesis hash. Snapshots are rebuildable
|
||||
caches. Journal corruption, truncation, reordering, missing records, or hash
|
||||
mismatch moves the release to `MANUAL_OWNER_REVIEW_REQUIRED`.
|
||||
|
||||
Capability execution uses an exclusive, leased claim. A second worker receives
|
||||
`BUSY`; an expired claim is not reassigned until a capability-specific
|
||||
side-effect probe reports that the operation was not applied. Runtime, tag,
|
||||
and finalization remain separately claimed and recoverable.
|
||||
|
||||
## Execution order
|
||||
|
||||
```text
|
||||
APPROVED
|
||||
-> PRE_SWITCH_REVALIDATING
|
||||
-> SWITCH_PENDING
|
||||
-> SWITCHED
|
||||
-> RUNTIME_VERIFYING
|
||||
-> RUNTIME_VERIFIED
|
||||
-> TAG_PENDING
|
||||
-> TAG_VERIFIED
|
||||
-> BASELINE_REGISTRY_PENDING
|
||||
-> COMPLETED
|
||||
```
|
||||
|
||||
The actual adapter configuration is regenerated before execution and must
|
||||
match the signed plan. Trusted allowlists come from controlled policy, not the
|
||||
request.
|
||||
|
||||
A failure before verified tag publication rolls the runtime back. A failure
|
||||
after the exact tag is verified enters `RECONCILIATION_REQUIRED`; the tag is
|
||||
never deleted or rewritten. A same-name/different-OID conflict enters
|
||||
`MANUAL_OWNER_REVIEW_REQUIRED`. Registry/Baseline finalization requires exact
|
||||
remote and Gitea tag proof, and Baseline is recorded last.
|
||||
|
||||
## Action and recovery contract
|
||||
|
||||
`submitOwnerApproval` verifies and durably stores the signed plan, then moves
|
||||
the Saga to `APPROVED`. `startDeployment` loads that durable approval and
|
||||
ignores caller-supplied approval content. Enabling execution without the
|
||||
trusted builder, verifier, validator, policy, and orchestrator fails during
|
||||
service construction.
|
||||
|
||||
The recovery worker scans incomplete journals and resumes through the same
|
||||
claims and verification gates. It never automatically resumes a manual-review
|
||||
Saga. In shadow mode it only reports state and performs no adapter side
|
||||
effects.
|
||||
|
||||
The deployed Action factory does not enable the legacy caller-evidence path.
|
||||
If the trusted builder is absent, candidate creation is rejected even while
|
||||
execution remains in shadow mode. The compatibility path exists only through
|
||||
the explicit test-only `SilentReleaseActionService.shadow()` constructor.
|
||||
|
||||
Finalization is composed from separate `RegistryController` and
|
||||
`BaselineController` claims. Registry is verified first and Baseline is the
|
||||
last mutation; a retry reuses completed Registry evidence and never moves
|
||||
Baseline ahead of tag verification.
|
||||
|
||||
## Governance
|
||||
|
||||
- `force_push`: forbidden
|
||||
- `tag_rewrite`: forbidden
|
||||
- `direct_main_push`: forbidden
|
||||
- production execution default: disabled
|
||||
- production tag operations in this change: not executed
|
||||
- Baseline/Registry mutations in this change: not executed
|
||||
@@ -1,68 +0,0 @@
|
||||
# Isolated Writer Exact-Path Policy V1
|
||||
|
||||
This policy is an additional, service-owned authorization layer for
|
||||
`POST /api/commit-file`. It never expands a Token Policy V2 grant.
|
||||
|
||||
An atomic write is permitted only when all of the following agree:
|
||||
|
||||
1. socket peer, audience, operation, branch, base and exact path in the
|
||||
Token Policy V2 grant;
|
||||
2. service audience, repository identity, branch, operation and exact path
|
||||
in `AIOS_GITOPS_PATH_POLICY_FILE`;
|
||||
3. lexical path, resolved containment and symlink checks;
|
||||
4. the configured content-size and content-profile checks;
|
||||
5. operation digest, expected branch HEAD and durable operation ledger.
|
||||
|
||||
Any failed layer returns a fail-closed policy error. Coarse `/api/file` and
|
||||
`/api/commit` routes remain forbidden.
|
||||
|
||||
## File contract
|
||||
|
||||
The configured path must be absolute. The parent directory must be
|
||||
`root:gitops 0750`; the regular, non-symlink file must be
|
||||
`root:gitops 0640`. JSON must use UTF-8 canonical encoding with sorted keys,
|
||||
compact separators and one trailing newline. Unknown fields, unsupported
|
||||
operations or profiles, duplicate paths, oversized policies and
|
||||
group/world-writable files are rejected during Writer startup.
|
||||
|
||||
Example:
|
||||
|
||||
```json
|
||||
{"allowed_branch":"patch/codex-review-test-worker-20260724","allowed_operations":{"commit_file.atomic":{"content_profile":"systemd-codex-review-worker-v1","exact_paths":["deploy/systemd/aios-codex-review-test-worker.service"],"max_content_bytes":32768}},"audience":"aios-codex-review-worker-writer.service","policy_id":"codex-review-worker-path-policy-v1","repository_identity":"aios/aios","schema_version":1}
|
||||
```
|
||||
|
||||
The SHA-256 of the canonical policy is exposed in the isolated runtime
|
||||
status and written to the operation audit record. The request body cannot
|
||||
select or override the policy file.
|
||||
|
||||
## Content profile
|
||||
|
||||
`systemd-codex-review-worker-v1` is an exact, fail-closed unit grammar. The
|
||||
only sections are `[Unit]`, `[Service]` and `[Install]`. Each section has a
|
||||
directive allowlist; every single-value directive and every repeated
|
||||
`Environment`, `ReadOnlyPaths` and `ReadWritePaths` entry must match the
|
||||
governed Shadow unit contract exactly.
|
||||
|
||||
The profile fixes the Python module
|
||||
`task_plane.workers.codex_review_test`, `User=aiman`, `Group=gitops`,
|
||||
the controlled `/usr/libexec/aios-codex-review-test-worker/current`
|
||||
working directory, all hardening switches and the three permitted
|
||||
environment variables. It grants read access only to the authoritative
|
||||
bare repository and the versioned worker artifact, and write access only
|
||||
to the worker runtime, state and cache directories.
|
||||
|
||||
Unknown sections or directives are rejected, including lifecycle hooks,
|
||||
credential injection, environment imports, root images, bind mounts,
|
||||
capability expansion, devices, sockets and top-level writable paths. The
|
||||
parser also rejects duplicate sections, duplicate single-value directives,
|
||||
empty resets, continuation lines, CRLF, NUL, non-UTF-8 surrogate content,
|
||||
overlong lines and Unicode lookalike directive names. It does not use
|
||||
`ConfigParser(strict=False)` or silently merge repeated values.
|
||||
|
||||
Production credentials, if later authorized, must be supplied by a
|
||||
separately governed deployment drop-in. They are not permitted in the
|
||||
source unit or this content profile.
|
||||
|
||||
Policy changes require a separate maintenance branch and Owner-reviewed
|
||||
ordinary merge commit. A task-scoped Writer must not edit its own policy
|
||||
file.
|
||||
@@ -51,31 +51,6 @@ components:
|
||||
path: {type: string, example: docs/gitops/chatgpt-change.md}
|
||||
content: {type: string}
|
||||
message: {type: string}
|
||||
AtomicFileCommitRequest:
|
||||
type: object
|
||||
additionalProperties: false
|
||||
required: [branch, path, content, message, expected_head_oid, idempotency_key]
|
||||
properties:
|
||||
branch:
|
||||
type: string
|
||||
pattern: '^patch/[A-Za-z0-9._/-]+$'
|
||||
path:
|
||||
type: string
|
||||
minLength: 1
|
||||
maxLength: 512
|
||||
content:
|
||||
type: string
|
||||
maxLength: 1048576
|
||||
message:
|
||||
type: string
|
||||
minLength: 1
|
||||
maxLength: 200
|
||||
expected_head_oid:
|
||||
type: string
|
||||
pattern: '^[0-9a-f]{40}$'
|
||||
idempotency_key:
|
||||
type: string
|
||||
pattern: '^[A-Za-z0-9][A-Za-z0-9._:-]{7,127}$'
|
||||
CommitRequest:
|
||||
type: object
|
||||
properties:
|
||||
@@ -162,51 +137,38 @@ components:
|
||||
branch: {type: string}
|
||||
DeploymentPlan:
|
||||
type: object
|
||||
required: [service, release_path, release_root, cutover_link, dropin_path, dropin_sha256, systemd_unit_sha256, rollback_path, rollback_sha256, source_commit, tree_oid, artifact_sha256, manifest_sha256, package_closure_sha256, authoritative_git_dir, repository_identity, writer_expected, baseline_before_sha256, registry_before_sha256, production_tag_refset_before_sha256, health_contract_version, timeout_policy, retry_policy, policy_sha256, health_contract]
|
||||
required: [service, release_path, release_root, dropin_path, dropin_sha256, rollback_path, rollback_sha256, source_commit, artifact_sha256, manifest_sha256, policy_sha256, health_contract]
|
||||
properties:
|
||||
service: {type: string}
|
||||
release_path: {type: string}
|
||||
release_root: {type: string}
|
||||
cutover_link: {type: string}
|
||||
dropin_path: {type: string}
|
||||
dropin_sha256: {type: string, pattern: '^[0-9a-f]{64}$'}
|
||||
systemd_unit_sha256: {type: string, pattern: '^[0-9a-f]{64}$'}
|
||||
rollback_path: {type: string}
|
||||
rollback_sha256: {type: string, pattern: '^[0-9a-f]{64}$'}
|
||||
source_commit: {type: string, pattern: '^[0-9a-f]{40}$'}
|
||||
tree_oid: {type: string, pattern: '^[0-9a-f]{40}$'}
|
||||
artifact_sha256: {type: string, pattern: '^[0-9a-f]{64}$'}
|
||||
manifest_sha256: {type: string, pattern: '^[0-9a-f]{64}$'}
|
||||
package_closure_sha256: {type: string, pattern: '^[0-9a-f]{64}$'}
|
||||
authoritative_git_dir: {type: string}
|
||||
repository_identity: {type: string}
|
||||
writer_expected: {type: boolean, enum: [false]}
|
||||
baseline_before_sha256: {type: string, pattern: '^[0-9a-f]{64}$'}
|
||||
registry_before_sha256: {type: string, pattern: '^[0-9a-f]{64}$'}
|
||||
production_tag_refset_before_sha256: {type: string, pattern: '^[0-9a-f]{64}$'}
|
||||
health_contract_version: {type: string}
|
||||
timeout_policy: {type: object}
|
||||
retry_policy: {type: object}
|
||||
policy_sha256: {type: string, pattern: '^[0-9a-f]{64}$'}
|
||||
health_contract: {type: object, additionalProperties: true}
|
||||
ReleaseCandidateInput:
|
||||
type: object
|
||||
required: [source_commit, version]
|
||||
additionalProperties: false
|
||||
required: [candidate_id, source_commit, tree_oid, artifact_sha256, manifest_sha256]
|
||||
properties:
|
||||
candidate_id: {type: string, pattern: '^[A-Za-z0-9][A-Za-z0-9_.-]{2,127}$'}
|
||||
source_commit: {type: string, pattern: '^[0-9a-f]{40}$'}
|
||||
version: {type: string, pattern: '^V[0-9]+R[0-9]+C[0-9]+(?:[-.][A-Za-z0-9][A-Za-z0-9.-]*)?$'}
|
||||
ReleaseIntentInput:
|
||||
type: object
|
||||
required: [event_id, source_commit]
|
||||
additionalProperties: false
|
||||
properties:
|
||||
event_id: {type: string, pattern: '^[A-Za-z0-9][A-Za-z0-9_.:-]{2,255}$'}
|
||||
source_commit: {type: string, pattern: '^[0-9a-f]{40}$'}
|
||||
tree_oid: {type: string, pattern: '^[0-9a-f]{40}$'}
|
||||
artifact_sha256: {type: string, pattern: '^[0-9a-f]{64}$'}
|
||||
manifest_sha256: {type: string, pattern: '^[0-9a-f]{64}$'}
|
||||
tests: {type: object}
|
||||
canary: {type: object}
|
||||
rollback_ready: {type: boolean}
|
||||
git_consistency: {type: object}
|
||||
gitea_consistency: {type: object}
|
||||
deployment_plan: {$ref: '#/components/schemas/DeploymentPlan'}
|
||||
SignedReleasePlanApproval:
|
||||
type: object
|
||||
required: [release_plan_id, candidate_id, source_commit, tree_oid, artifact_sha256, manifest_sha256, deployment_plan_sha256, release_plan_sha256, policy_sha256, approval_plan_id, evidence_closure_oid, owner_approval_record_oid, capabilities, owner_identity, trust_domain, issued_at, not_before, expires_at, nonce, key_id, signature]
|
||||
required: [release_plan_id, candidate_id, source_commit, tree_oid, artifact_sha256, manifest_sha256, deployment_plan_sha256, policy_sha256, approval_plan_id, evidence_closure_oid, owner_approval_record_oid, capabilities, expires_at, nonce, key_id, signature]
|
||||
properties:
|
||||
release_plan_id: {type: string}
|
||||
candidate_id: {type: string}
|
||||
@@ -215,15 +177,10 @@ components:
|
||||
artifact_sha256: {type: string, pattern: '^[0-9a-f]{64}$'}
|
||||
manifest_sha256: {type: string, pattern: '^[0-9a-f]{64}$'}
|
||||
deployment_plan_sha256: {type: string, pattern: '^[0-9a-f]{64}$'}
|
||||
release_plan_sha256: {type: string, pattern: '^[0-9a-f]{64}$'}
|
||||
policy_sha256: {type: string, pattern: '^[0-9a-f]{64}$'}
|
||||
approval_plan_id: {type: string}
|
||||
evidence_closure_oid: {type: string, pattern: '^[0-9a-f]{40}$'}
|
||||
owner_approval_record_oid: {type: string, pattern: '^[0-9a-f]{40}$'}
|
||||
owner_identity: {type: string}
|
||||
trust_domain: {type: string}
|
||||
issued_at: {type: string, format: date-time}
|
||||
not_before: {type: string, format: date-time}
|
||||
capabilities:
|
||||
type: array
|
||||
uniqueItems: true
|
||||
@@ -236,29 +193,15 @@ components:
|
||||
signature: {type: string, format: byte, writeOnly: true}
|
||||
StartDeploymentRequest:
|
||||
type: object
|
||||
required: [candidate_id]
|
||||
additionalProperties: false
|
||||
required: [candidate_id, approval]
|
||||
properties:
|
||||
candidate_id: {type: string}
|
||||
approval: {$ref: '#/components/schemas/SignedReleasePlanApproval'}
|
||||
paths:
|
||||
/createReleaseIntent:
|
||||
post:
|
||||
operationId: createReleaseIntent
|
||||
summary: Create an idempotent intent; all build evidence comes from the trusted builder
|
||||
security: [{bearerAuth: []}]
|
||||
requestBody:
|
||||
required: true
|
||||
content:
|
||||
application/json:
|
||||
schema: {$ref: '#/components/schemas/ReleaseIntentInput'}
|
||||
responses:
|
||||
'200': {description: Intent created or idempotently returned}
|
||||
'400': {description: Caller evidence or invalid intent rejected}
|
||||
x-openai-isConsequential: true
|
||||
/createReleaseCandidate:
|
||||
post:
|
||||
operationId: createReleaseCandidate
|
||||
summary: Submit release intent to the trusted builder; caller evidence is rejected
|
||||
summary: Persist an immutable release candidate and deployment plan; shadow-safe
|
||||
security: [{bearerAuth: []}]
|
||||
requestBody:
|
||||
required: true
|
||||
@@ -279,22 +222,6 @@ paths:
|
||||
responses:
|
||||
'200': {description: Candidate}
|
||||
'404': {description: Candidate not found}
|
||||
/getReleasePlan:
|
||||
get:
|
||||
operationId: getReleasePlan
|
||||
parameters:
|
||||
- {in: query, name: candidate_id, required: true, schema: {type: string}}
|
||||
responses:
|
||||
'200': {description: Immutable release plan}
|
||||
'404': {description: Candidate not found}
|
||||
/getReleaseAcceptance:
|
||||
get:
|
||||
operationId: getReleaseAcceptance
|
||||
parameters:
|
||||
- {in: query, name: candidate_id, required: true, schema: {type: string}}
|
||||
responses:
|
||||
'200': {description: Builder attestation and acceptance checks}
|
||||
'404': {description: Candidate not found}
|
||||
/getApprovalEnvelope:
|
||||
get:
|
||||
operationId: getApprovalEnvelope
|
||||
@@ -320,24 +247,10 @@ paths:
|
||||
'403': {description: Signature, key, expiry, or revocation failure}
|
||||
'409': {description: Conflicting release plan}
|
||||
x-openai-isConsequential: true
|
||||
/submitSignedApproval:
|
||||
post:
|
||||
operationId: submitSignedApproval
|
||||
summary: Alias for immutable signed owner approval submission
|
||||
security: [{bearerAuth: []}]
|
||||
requestBody:
|
||||
required: true
|
||||
content:
|
||||
application/json:
|
||||
schema: {$ref: '#/components/schemas/SignedReleasePlanApproval'}
|
||||
responses:
|
||||
'200': {description: Signature verified and approval stored}
|
||||
'403': {description: Production approval backend unavailable or signature invalid}
|
||||
x-openai-isConsequential: true
|
||||
/startDeployment:
|
||||
post:
|
||||
operationId: startDeployment
|
||||
summary: Resume the durable approved Saga; caller cannot replace approval
|
||||
summary: Start the approved Saga; default shadow mode returns no side effects
|
||||
security: [{bearerAuth: []}]
|
||||
requestBody:
|
||||
required: true
|
||||
@@ -358,18 +271,6 @@ paths:
|
||||
responses:
|
||||
'200': {description: Saga snapshot}
|
||||
'404': {description: Saga not found}
|
||||
/getCapabilityStatus:
|
||||
get:
|
||||
operationId: getCapabilityStatus
|
||||
parameters:
|
||||
- {in: query, name: candidate_id, required: true, schema: {type: string}}
|
||||
responses:
|
||||
'200': {description: Durable single-use capability records}
|
||||
/getRecoveryStatus:
|
||||
get:
|
||||
operationId: getRecoveryStatus
|
||||
responses:
|
||||
'200': {description: Fail-closed recovery classification}
|
||||
/api/base:
|
||||
get:
|
||||
operationId: getBaseline
|
||||
@@ -453,25 +354,6 @@ paths:
|
||||
schema: {$ref: '#/components/schemas/FileCommitRequest'}
|
||||
responses: {'200': {description: File committed}, '400': {description: Secret rejected or invalid path}, '401': {description: Unauthorized}}
|
||||
x-openai-isConsequential: true
|
||||
/api/commit-file:
|
||||
post:
|
||||
operationId: commitFileAtomic
|
||||
summary: Atomically write one allowlisted file, commit, push, and verify using Token Policy V2
|
||||
security: [{bearerAuth: []}]
|
||||
requestBody:
|
||||
required: true
|
||||
content:
|
||||
application/json:
|
||||
schema: {$ref: '#/components/schemas/AtomicFileCommitRequest'}
|
||||
responses:
|
||||
'200': {description: Completed or idempotently replayed}
|
||||
'400': {description: Invalid canonical request}
|
||||
'401': {description: Missing, invalid, expired, or revoked Token Policy V2 grant}
|
||||
'403': {description: Audience, source, branch, operation, path, or policy denied}
|
||||
'409': {description: Idempotency conflict or manual review required}
|
||||
'413': {description: Request too large}
|
||||
'503': {description: Push or remote verification unavailable; recoverable}
|
||||
x-openai-isConsequential: true
|
||||
/api/commit:
|
||||
post:
|
||||
operationId: commitChanges
|
||||
|
||||
@@ -1,42 +0,0 @@
|
||||
# AIOS Task Plane
|
||||
|
||||
该模块是与任务发起方、Worker 类型和通知后端解耦的持久化任务控制平面。当前交付仅用于隔离开发与 Shadow 验收；默认 `execution_enabled=false`，不会修改生产、tag、Baseline 或 Registry。
|
||||
|
||||
## 架构
|
||||
|
||||
- `TaskPlaneService`：统一服务边界和 HTTP 路由。
|
||||
- `TaskPlaneStore`：SQLite WAL、revision/CAS、串行事务、租约、hash-chained journal、evidence 和 durable outbox。
|
||||
- `WorkerRegistry` / `LeaseManager`：身份绑定、capability、并发额度、心跳、过期探测后恢复。
|
||||
- `DelegationEngine`：父子 DAG、全局深度、capability/risk/approval/budget 单调约束和幂等重放。
|
||||
- `PolicyEngine`：默认关闭执行；身份、证据、结果摘要和可插拔签名验签均 fail-closed。
|
||||
- `WorkerAdapter`：OpenClaw、Codex、Hermes、A2A 和 systemd Worker 的统一契约。默认实现只返回 `SHADOW_VERIFIED`，不执行外部命令。
|
||||
- `DurableOutboxDispatcher`：Webhook、NATS JetStream、GPT callback、Dashboard 和 WeChat 的回执式通知接口。没有真实回执时始终保留 `NOT_DELIVERED`。
|
||||
|
||||
## 状态与恢复
|
||||
|
||||
正常路径为 `CREATED → QUEUED/CLAIMED → RUNNING → VERIFYING/COMPLETED`；失败路径使用 `FAILED_RECOVERABLE`、`FAILED_FINAL`、`CANCELLED` 或 `MANUAL_REVIEW_REQUIRED`。每次状态事件都进入同一事务中的 append-only hash chain。
|
||||
|
||||
租约过期不会自动重放副作用。控制平面必须先调用 Worker probe，只有明确确认原执行已停止，才可将 claim 标记为 `EXPIRED` 并把任务转为 `FAILED_RECOVERABLE`。结果必须匹配 task、claim、Worker identity、未过期 lease 和 operation digest；重复结果返回冲突。
|
||||
|
||||
## 安全模型
|
||||
|
||||
- task/worker/claim/message ID 使用 allowlist pattern，拒绝 URL 编码差异、路径分隔符和控制字符。
|
||||
- HTTP body 最大 1 MB，非对象 JSON、异常 Content-Length 和非法参数返回 400/413。
|
||||
- 内部异常响应不回显路径、payload 或凭据；默认 HTTP access log 不记录原始 request target。
|
||||
- secret-like 字段在 durable task、event、evidence 和 outbox 写入前脱敏。
|
||||
- 结果签名存在但没有配置验签器时拒绝；摘要、evidence 或 event 被篡改时验收失败。
|
||||
- SQLite 文件创建为 0600；新建状态目录使用 0700。
|
||||
|
||||
## 验收
|
||||
|
||||
```bash
|
||||
PYTHONPATH=active-runtime \
|
||||
bash scripts/task-plane/run_task_plane_acceptance.sh
|
||||
|
||||
PYTHONPATH=active-runtime \
|
||||
python3 scripts/task-plane/create_shadow_tasks.py \
|
||||
--database reports/task-plane-shadow.sqlite3 \
|
||||
--report reports/task-plane-shadow.json
|
||||
```
|
||||
|
||||
上述脚本只使用本地 SQLite 和 Shadow adapter，不触发真实 OpenClaw、Codex、Hermes、微信或生产执行。
|
||||
@@ -1,314 +0,0 @@
|
||||
openapi: 3.0.3
|
||||
info:
|
||||
title: AIOS Task Plane API
|
||||
version: 1.0.0
|
||||
description: >
|
||||
Durable control-plane APIs for task orchestration with fail-closed policy.
|
||||
Every POST operation requires bearerAuth; read-only GET operations may be
|
||||
exposed according to the surrounding runtime policy.
|
||||
servers:
|
||||
- url: /
|
||||
paths:
|
||||
/tasks:
|
||||
get:
|
||||
summary: List tasks
|
||||
responses:
|
||||
"200":
|
||||
description: Task list
|
||||
post:
|
||||
security: [ { bearerAuth: [] } ]
|
||||
summary: Create task
|
||||
parameters:
|
||||
- in: header
|
||||
name: Idempotency-Key
|
||||
required: false
|
||||
schema:
|
||||
type: string
|
||||
minLength: 1
|
||||
maxLength: 128
|
||||
requestBody:
|
||||
required: true
|
||||
content:
|
||||
application/json:
|
||||
schema:
|
||||
$ref: "#/components/schemas/TaskPlan"
|
||||
responses:
|
||||
"201": { description: Created }
|
||||
"400": { description: Bad request }
|
||||
"401": { description: Unauthorized }
|
||||
"403": { description: Forbidden }
|
||||
"409": { description: Conflict }
|
||||
"413": { description: Payload too large }
|
||||
"423": { description: Execution or resource locked }
|
||||
"503": { description: Authentication or service unavailable }
|
||||
/tasks/{task_id}:
|
||||
get:
|
||||
summary: Get task
|
||||
parameters:
|
||||
- $ref: "#/components/parameters/TaskId"
|
||||
responses:
|
||||
"200": { description: OK }
|
||||
"404": { description: Not found }
|
||||
/tasks/{task_id}/claim:
|
||||
post:
|
||||
security: [ { bearerAuth: [] } ]
|
||||
summary: Claim a task
|
||||
parameters:
|
||||
- $ref: "#/components/parameters/TaskId"
|
||||
requestBody:
|
||||
required: true
|
||||
content:
|
||||
application/json:
|
||||
schema:
|
||||
$ref: "#/components/schemas/TaskClaimRequest"
|
||||
responses:
|
||||
"200": { description: Claimed }
|
||||
"401": { description: Unauthorized }
|
||||
"403": { description: Forbidden }
|
||||
"404": { description: Not found }
|
||||
"409": { description: Conflict }
|
||||
"423": { description: Execution disabled }
|
||||
/tasks/{task_id}/heartbeat:
|
||||
post:
|
||||
security: [ { bearerAuth: [] } ]
|
||||
summary: Renew task claim lease
|
||||
parameters: [ $ref: "#/components/parameters/TaskId" ]
|
||||
responses:
|
||||
"200": { description: Leased }
|
||||
"400": { description: Bad request }
|
||||
"401": { description: Unauthorized }
|
||||
"403": { description: Forbidden }
|
||||
"404": { description: Task or claim not found }
|
||||
"409": { description: Claim conflict }
|
||||
"413": { description: Payload too large }
|
||||
"423": { description: Lease or execution locked }
|
||||
"503": { description: Service unavailable }
|
||||
/tasks/{task_id}/progress:
|
||||
post:
|
||||
security: [ { bearerAuth: [] } ]
|
||||
summary: Report task progress
|
||||
parameters: [ $ref: "#/components/parameters/TaskId" ]
|
||||
responses:
|
||||
"200": { description: Progress saved }
|
||||
"400": { description: Bad request }
|
||||
"401": { description: Unauthorized }
|
||||
"403": { description: Forbidden }
|
||||
"404": { description: Task or claim not found }
|
||||
"409": { description: Claim conflict }
|
||||
"413": { description: Payload too large }
|
||||
"423": { description: Lease or execution locked }
|
||||
"503": { description: Service unavailable }
|
||||
/tasks/{task_id}/result:
|
||||
post:
|
||||
security: [ { bearerAuth: [] } ]
|
||||
summary: Submit task result
|
||||
parameters: [ $ref: "#/components/parameters/TaskId" ]
|
||||
responses:
|
||||
"200": { description: Result accepted }
|
||||
"400": { description: Bad request }
|
||||
"401": { description: Unauthorized }
|
||||
"403": { description: Result policy rejected }
|
||||
"404": { description: Task or claim not found }
|
||||
"409": { description: Duplicate or mismatched result }
|
||||
"413": { description: Payload too large }
|
||||
"423": { description: Lease or execution locked }
|
||||
"503": { description: Verification service unavailable }
|
||||
/tasks/{task_id}/fail:
|
||||
post:
|
||||
security: [ { bearerAuth: [] } ]
|
||||
summary: Mark task failed
|
||||
parameters: [ $ref: "#/components/parameters/TaskId" ]
|
||||
responses:
|
||||
"200": { description: Failure recorded }
|
||||
"400": { description: Bad request }
|
||||
"401": { description: Unauthorized }
|
||||
"403": { description: Forbidden }
|
||||
"404": { description: Task or claim not found }
|
||||
"409": { description: Claim conflict }
|
||||
"413": { description: Payload too large }
|
||||
"423": { description: Lease or execution locked }
|
||||
"503": { description: Service unavailable }
|
||||
/tasks/{task_id}/cancel:
|
||||
post:
|
||||
security: [ { bearerAuth: [] } ]
|
||||
summary: Cancel task
|
||||
parameters: [ $ref: "#/components/parameters/TaskId" ]
|
||||
responses:
|
||||
"200": { description: Cancelled }
|
||||
"400": { description: Bad request }
|
||||
"401": { description: Unauthorized }
|
||||
"403": { description: Forbidden }
|
||||
"404": { description: Task not found }
|
||||
"409": { description: Revision or state conflict }
|
||||
"413": { description: Payload too large }
|
||||
"423": { description: Resource locked }
|
||||
"503": { description: Service unavailable }
|
||||
/tasks/{task_id}/delegate:
|
||||
post:
|
||||
security: [ { bearerAuth: [] } ]
|
||||
summary: Delegate task
|
||||
parameters: [ $ref: "#/components/parameters/TaskId" ]
|
||||
responses:
|
||||
"200": { description: Delegated }
|
||||
"400": { description: Bad request }
|
||||
"401": { description: Unauthorized }
|
||||
"403": { description: Forbidden }
|
||||
"404": { description: Parent task not found }
|
||||
"409": { description: Conflict }
|
||||
"413": { description: Payload too large }
|
||||
"423": { description: Execution locked }
|
||||
"503": { description: Service unavailable }
|
||||
/workers/register:
|
||||
post:
|
||||
security: [ { bearerAuth: [] } ]
|
||||
summary: Register worker
|
||||
responses:
|
||||
"201": { description: Worker registered }
|
||||
"400": { description: Bad request }
|
||||
"401": { description: Unauthorized }
|
||||
"403": { description: Worker identity mismatch }
|
||||
"409": { description: Registration conflict }
|
||||
"413": { description: Payload too large }
|
||||
"423": { description: Resource locked }
|
||||
"503": { description: Service unavailable }
|
||||
/workers/{worker_id}/heartbeat:
|
||||
post:
|
||||
security: [ { bearerAuth: [] } ]
|
||||
summary: Worker heartbeat
|
||||
parameters: [ $ref: "#/components/parameters/WorkerId" ]
|
||||
responses:
|
||||
"200": { description: Heartbeat accepted }
|
||||
"400": { description: Bad request }
|
||||
"401": { description: Unauthorized }
|
||||
"403": { description: Forbidden }
|
||||
"404": { description: Worker not found }
|
||||
"409": { description: Worker state conflict }
|
||||
"413": { description: Payload too large }
|
||||
"423": { description: Worker locked }
|
||||
"503": { description: Service unavailable }
|
||||
/workers:
|
||||
get:
|
||||
summary: List workers
|
||||
responses:
|
||||
"200": { description: Worker list }
|
||||
/workers/{worker_id}:
|
||||
get:
|
||||
summary: Get worker
|
||||
parameters: [ $ref: "#/components/parameters/WorkerId" ]
|
||||
responses:
|
||||
"200": { description: Worker details }
|
||||
/tasks/{task_id}/events:
|
||||
get:
|
||||
summary: Task events
|
||||
parameters: [ $ref: "#/components/parameters/TaskId" ]
|
||||
responses:
|
||||
"200": { description: Event list }
|
||||
/tasks/{task_id}/evidence:
|
||||
get:
|
||||
summary: Task evidence
|
||||
parameters: [ $ref: "#/components/parameters/TaskId" ]
|
||||
responses:
|
||||
"200": { description: Evidence list }
|
||||
/tasks/{task_id}/children:
|
||||
get:
|
||||
summary: Task child tasks
|
||||
parameters: [ $ref: "#/components/parameters/TaskId" ]
|
||||
responses:
|
||||
"200": { description: Child list }
|
||||
components:
|
||||
securitySchemes:
|
||||
bearerAuth:
|
||||
type: http
|
||||
scheme: bearer
|
||||
bearerFormat: opaque
|
||||
parameters:
|
||||
TaskId:
|
||||
name: task_id
|
||||
in: path
|
||||
required: true
|
||||
schema:
|
||||
type: string
|
||||
minLength: 1
|
||||
maxLength: 128
|
||||
pattern: '^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$'
|
||||
WorkerId:
|
||||
name: worker_id
|
||||
in: path
|
||||
required: true
|
||||
schema:
|
||||
type: string
|
||||
minLength: 1
|
||||
maxLength: 128
|
||||
pattern: '^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$'
|
||||
schemas:
|
||||
TaskPlan:
|
||||
type: object
|
||||
additionalProperties: false
|
||||
properties:
|
||||
schema_version: { type: integer, enum: [1] }
|
||||
task_id:
|
||||
type: string
|
||||
minLength: 1
|
||||
maxLength: 128
|
||||
pattern: '^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$'
|
||||
task_type:
|
||||
type: string
|
||||
minLength: 1
|
||||
maxLength: 128
|
||||
pattern: '^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$'
|
||||
issuer: { type: object }
|
||||
intent: { type: string, maxLength: 16384 }
|
||||
required_capabilities:
|
||||
type: array
|
||||
maxItems: 128
|
||||
items: { type: string }
|
||||
preferred_workers:
|
||||
type: array
|
||||
maxItems: 64
|
||||
items: { type: string }
|
||||
risk: { type: string, enum: [low, medium, high] }
|
||||
approval_policy:
|
||||
type: string
|
||||
maxLength: 128
|
||||
dependencies:
|
||||
type: array
|
||||
maxItems: 128
|
||||
items: { type: string }
|
||||
max_delegation_depth: { type: integer, minimum: 0, maximum: 32 }
|
||||
budgets:
|
||||
type: object
|
||||
additionalProperties: false
|
||||
properties:
|
||||
time_seconds: { type: integer, minimum: 0 }
|
||||
attempts: { type: integer, minimum: 0 }
|
||||
tokens: { type: integer, minimum: 0 }
|
||||
cost: { type: number, minimum: 0 }
|
||||
evidence_requirements:
|
||||
type: array
|
||||
maxItems: 128
|
||||
items: { type: string }
|
||||
parent_task_id:
|
||||
type: string
|
||||
maxLength: 128
|
||||
correlation_id:
|
||||
type: string
|
||||
maxLength: 128
|
||||
metadata:
|
||||
type: object
|
||||
TaskClaimRequest:
|
||||
type: object
|
||||
additionalProperties: false
|
||||
required: [worker_id, actor_identity]
|
||||
properties:
|
||||
worker_id:
|
||||
type: string
|
||||
maxLength: 128
|
||||
pattern: '^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$'
|
||||
lease_seconds:
|
||||
type: integer
|
||||
minimum: 1
|
||||
maximum: 3600
|
||||
actor_identity:
|
||||
type: string
|
||||
minLength: 1
|
||||
maxLength: 512
|
||||
@@ -1,9 +0,0 @@
|
||||
{
|
||||
"type": "branch",
|
||||
"branch": "patch/aios-agent-task-control-plane-20260724",
|
||||
"base": "main",
|
||||
"created_by": "agent-task-plane-writer",
|
||||
"created_at": "2026-07-24T02:20:56Z",
|
||||
"direct_main_push": false,
|
||||
"owner_approval_required": true
|
||||
}
|
||||
@@ -1,10 +0,0 @@
|
||||
{
|
||||
"execution_status": "PARTIALLY_COMPLETED",
|
||||
"tests_run": 19,
|
||||
"failures": 0,
|
||||
"errors": 0,
|
||||
"skipped": 0,
|
||||
"multi_agent_shadow_verified": true,
|
||||
"production_side_effects": false,
|
||||
"notification_delivery_status": "NOT_DELIVERED"
|
||||
}
|
||||
@@ -1,53 +0,0 @@
|
||||
{
|
||||
"root_task_id": "AIOS-AGENT-TASK-CONTROL-PLANE-20260724-SHADOW",
|
||||
"execution_mode": "shadow_adapter",
|
||||
"production_side_effects": false,
|
||||
"tasks": [
|
||||
{
|
||||
"task_id": "AIOS-TASK-PLANE-OPENCLAW-ACCEPTANCE",
|
||||
"parent_task_id": "AIOS-AGENT-TASK-CONTROL-PLANE-20260724-SHADOW",
|
||||
"task_status": "COMPLETED",
|
||||
"worker_result": {
|
||||
"worker": "openclaw",
|
||||
"task_id": "AIOS-TASK-PLANE-OPENCLAW-ACCEPTANCE",
|
||||
"status": "SHADOW_VERIFIED",
|
||||
"claim_id": "claim-093cbf4c-11d5-47a3-97dc-a373a8a53940",
|
||||
"execution_mode": "shadow",
|
||||
"production_side_effects": false
|
||||
},
|
||||
"result_digest": "b3a8ed4e0a60a0a9364d1eea1a6d30a403da1fb5ff79ff38a489a52227f4116e"
|
||||
},
|
||||
{
|
||||
"task_id": "AIOS-TASK-PLANE-CODEX-REVIEW",
|
||||
"parent_task_id": "AIOS-AGENT-TASK-CONTROL-PLANE-20260724-SHADOW",
|
||||
"task_status": "COMPLETED",
|
||||
"worker_result": {
|
||||
"worker": "codex",
|
||||
"task_id": "AIOS-TASK-PLANE-CODEX-REVIEW",
|
||||
"status": "SHADOW_VERIFIED",
|
||||
"claim_id": "claim-3cfe4031-27c7-409c-9841-cd5c0d26218d",
|
||||
"execution_mode": "shadow",
|
||||
"production_side_effects": false
|
||||
},
|
||||
"result_digest": "65fb825869b9b32d923b387796839e57b9ca7053716720861988ceb8d7e9c93a"
|
||||
},
|
||||
{
|
||||
"task_id": "AIOS-TASK-PLANE-HERMES-ARCHITECTURE",
|
||||
"parent_task_id": "AIOS-AGENT-TASK-CONTROL-PLANE-20260724-SHADOW",
|
||||
"task_status": "COMPLETED",
|
||||
"worker_result": {
|
||||
"worker": "hermes",
|
||||
"task_id": "AIOS-TASK-PLANE-HERMES-ARCHITECTURE",
|
||||
"status": "SHADOW_VERIFIED",
|
||||
"claim_id": "claim-fd7ba481-ab71-47dc-8e91-3655cbef1c40",
|
||||
"execution_mode": "shadow",
|
||||
"production_side_effects": false
|
||||
},
|
||||
"result_digest": "09c9ce563424b6490b7be1e854d06de786bd243a48b099137a7a2e9cb7035265"
|
||||
}
|
||||
],
|
||||
"event_chains_valid": true,
|
||||
"notification_delivery_status": [
|
||||
"NOT_DELIVERED"
|
||||
]
|
||||
}
|
||||
@@ -1 +0,0 @@
|
||||
{"schema_version":1,"task_id":"AIOS-AGENT-TASK-CONTROL-PLANE-20260724","writer_status":"READY","production_side_effects":false}
|
||||
@@ -1,70 +0,0 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Build a deterministic Candidate artifact without overwriting evidence."""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import argparse
|
||||
import json
|
||||
import os
|
||||
from pathlib import Path
|
||||
|
||||
from aios_autonomous_release_candidate.artifact import ArtifactBuilder
|
||||
|
||||
|
||||
def exclusive_write(path: Path, content: bytes, mode: int) -> None:
|
||||
if path.is_symlink():
|
||||
raise RuntimeError("artifact output symlink rejected")
|
||||
flags = os.O_WRONLY | os.O_CREAT | os.O_EXCL
|
||||
if hasattr(os, "O_NOFOLLOW"):
|
||||
flags |= os.O_NOFOLLOW
|
||||
descriptor = os.open(path, flags, mode)
|
||||
try:
|
||||
os.write(descriptor, content)
|
||||
os.fsync(descriptor)
|
||||
finally:
|
||||
os.close(descriptor)
|
||||
|
||||
|
||||
def build_parser() -> argparse.ArgumentParser:
|
||||
parser = argparse.ArgumentParser()
|
||||
parser.add_argument("--source", required=True, type=Path)
|
||||
parser.add_argument("--source-oid", required=True)
|
||||
parser.add_argument("--tree-oid", required=True)
|
||||
parser.add_argument("--output-directory", required=True, type=Path)
|
||||
parser.add_argument("--name", default="aios-autonomous-release-candidate")
|
||||
return parser
|
||||
|
||||
|
||||
def main(argv: list[str] | None = None) -> int:
|
||||
args = build_parser().parse_args(argv)
|
||||
output = args.output_directory
|
||||
output.mkdir(parents=True, exist_ok=True, mode=0o750)
|
||||
if output.is_symlink():
|
||||
raise RuntimeError("artifact output directory symlink rejected")
|
||||
os.chmod(output, output.stat().st_mode & 0o750)
|
||||
builder = ArtifactBuilder()
|
||||
built = builder.build_from_directory(args.source_oid, args.tree_oid, args.source)
|
||||
builder.verify(built)
|
||||
artifact_path = output / f"{args.name}.tar"
|
||||
manifest_path = output / f"{args.name}.manifest.json"
|
||||
exclusive_write(artifact_path, built.content, 0o640)
|
||||
exclusive_write(manifest_path, built.manifest.as_json_bytes(), 0o640)
|
||||
print(
|
||||
json.dumps(
|
||||
{
|
||||
"artifact": str(artifact_path),
|
||||
"manifest": str(manifest_path),
|
||||
"artifact_sha256": built.manifest.artifact_sha256,
|
||||
"manifest_sha256": built.manifest.manifest_sha256,
|
||||
"package_closure_sha256": built.manifest.package_closure_sha256,
|
||||
"secrets_included": False,
|
||||
"production_side_effects": False,
|
||||
},
|
||||
sort_keys=True,
|
||||
)
|
||||
)
|
||||
return 0
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
raise SystemExit(main())
|
||||
@@ -1,514 +0,0 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Run Candidate acceptance and emit a non-overwriting JSON evidence record."""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import argparse
|
||||
from datetime import datetime, timedelta, timezone
|
||||
import hashlib
|
||||
import json
|
||||
import os
|
||||
from pathlib import Path
|
||||
import re
|
||||
import subprocess
|
||||
import sys
|
||||
import tempfile
|
||||
from typing import Sequence
|
||||
|
||||
|
||||
sys.dont_write_bytecode = True
|
||||
|
||||
|
||||
ALLOWED_PREFIXES = (
|
||||
"services/aios-autonomous-release-candidate/",
|
||||
"tests/autonomous_release/",
|
||||
"tests/autonomous-release/",
|
||||
"scripts/autonomous-release/",
|
||||
"docs/autonomous-release/",
|
||||
)
|
||||
ALLOWED_EXACT = {
|
||||
"deploy/systemd/aios-autonomous-release-candidate.service",
|
||||
"deploy/systemd/aios-autonomous-release-worker-candidate.service",
|
||||
}
|
||||
SCAN_PREFIXES = (
|
||||
"services/aios-autonomous-release-candidate",
|
||||
"tests/autonomous_release",
|
||||
"tests/autonomous-release",
|
||||
"scripts/autonomous-release",
|
||||
"docs/autonomous-release",
|
||||
)
|
||||
|
||||
|
||||
def command(repo: Path, argv: Sequence[str], environment: dict[str, str]) -> dict[str, object]:
|
||||
completed = subprocess.run(
|
||||
argv,
|
||||
cwd=repo,
|
||||
env=environment,
|
||||
text=True,
|
||||
stdout=subprocess.PIPE,
|
||||
stderr=subprocess.STDOUT,
|
||||
timeout=300,
|
||||
check=False,
|
||||
)
|
||||
return {
|
||||
"argv": list(argv),
|
||||
"exit_code": completed.returncode,
|
||||
"output": completed.stdout[-12000:],
|
||||
"passed": completed.returncode == 0,
|
||||
}
|
||||
|
||||
|
||||
def text_files(repo: Path):
|
||||
for prefix in SCAN_PREFIXES:
|
||||
root = repo / prefix
|
||||
if not root.exists():
|
||||
continue
|
||||
for path in root.rglob("*"):
|
||||
if path.is_file() and not path.is_symlink() and "__pycache__" not in path.parts:
|
||||
try:
|
||||
yield path, path.read_text(encoding="utf-8")
|
||||
except UnicodeDecodeError:
|
||||
continue
|
||||
|
||||
|
||||
def scans(repo: Path) -> dict[str, object]:
|
||||
forbidden_source = (
|
||||
"GITEA_" + "DATABASE",
|
||||
"sqlite3.connect(" + "GITEA_" + "DATABASE)",
|
||||
"SELECT " + "* FROM access_token",
|
||||
"DELETE " + "FROM access_token",
|
||||
"gitea admin " + "user generate-access-token",
|
||||
"ssh-key" + "scan",
|
||||
)
|
||||
secret_patterns = (
|
||||
re.compile(r"sk-[A-Za-z0-9_-]{20,}"),
|
||||
re.compile(r"-----BEGIN (?:OPENSSH |RSA |EC )?PRIVATE KEY-----"),
|
||||
re.compile(r"(?i)(?:api[_-]?key|password|token)\s*[:=]\s*['\"]?[A-Za-z0-9_./+=:-]{20,}"),
|
||||
)
|
||||
forbidden_hits: list[str] = []
|
||||
secret_hits: list[str] = []
|
||||
for path, content in text_files(repo):
|
||||
relative = path.relative_to(repo).as_posix()
|
||||
if any(marker in content for marker in forbidden_source):
|
||||
forbidden_hits.append(relative)
|
||||
if any(pattern.search(content) for pattern in secret_patterns):
|
||||
secret_hits.append(relative)
|
||||
changed = subprocess.run(
|
||||
["git", "diff", "--name-only", "main...HEAD"],
|
||||
cwd=repo,
|
||||
text=True,
|
||||
stdout=subprocess.PIPE,
|
||||
stderr=subprocess.PIPE,
|
||||
check=False,
|
||||
)
|
||||
changed_paths = tuple(item for item in changed.stdout.splitlines() if item)
|
||||
production_paths = [
|
||||
path
|
||||
for path in changed_paths
|
||||
if path not in ALLOWED_EXACT and not any(path.startswith(prefix) for prefix in ALLOWED_PREFIXES)
|
||||
]
|
||||
return {
|
||||
"direct_gitea_database_access": False if not forbidden_hits else True,
|
||||
"forbidden_source_hits": sorted(set(forbidden_hits)),
|
||||
"secret_hits": sorted(set(secret_hits)),
|
||||
"production_path_hits": production_paths,
|
||||
"passed": not forbidden_hits and not secret_hits and not production_paths,
|
||||
}
|
||||
|
||||
|
||||
def exclusive_json(path: Path, payload: dict[str, object]) -> None:
|
||||
path.parent.mkdir(parents=True, exist_ok=True, mode=0o750)
|
||||
flags = os.O_WRONLY | os.O_CREAT | os.O_EXCL
|
||||
if hasattr(os, "O_NOFOLLOW"):
|
||||
flags |= os.O_NOFOLLOW
|
||||
descriptor = os.open(path, flags, 0o640)
|
||||
try:
|
||||
content = (json.dumps(payload, sort_keys=True, indent=2) + "\n").encode("utf-8")
|
||||
os.write(descriptor, content)
|
||||
os.fsync(descriptor)
|
||||
finally:
|
||||
os.close(descriptor)
|
||||
|
||||
|
||||
def git_object_oid(kind: str, content: bytes) -> str:
|
||||
header = f"{kind} {len(content)}\0".encode("ascii")
|
||||
return hashlib.sha1(header + content, usedforsecurity=False).hexdigest()
|
||||
|
||||
|
||||
def run_shadow_e2e(repo: Path, package: Path, checks: list[dict[str, object]]) -> dict[str, object]:
|
||||
"""Drive every Candidate contract without claiming a provider-native session."""
|
||||
if subprocess.check_output(["git", "status", "--porcelain"], cwd=repo, text=True).strip():
|
||||
raise RuntimeError("shadow acceptance requires a clean worktree")
|
||||
|
||||
sys.path.insert(0, str(package))
|
||||
from aios_autonomous_release_candidate.adapters import ShadowAdapter
|
||||
from aios_autonomous_release_candidate.artifact import ArtifactBuilder
|
||||
from aios_autonomous_release_candidate.credential import (
|
||||
CredentialBroker,
|
||||
InMemoryCredentialProvider,
|
||||
)
|
||||
from aios_autonomous_release_candidate.errors import ReleaseBlocked
|
||||
from aios_autonomous_release_candidate.evidence import EvidenceChain
|
||||
from aios_autonomous_release_candidate.models import (
|
||||
CredentialRequest,
|
||||
ReleasePlan,
|
||||
ResourceBinding,
|
||||
RiskClass,
|
||||
TaskPlan,
|
||||
WorkerDescriptor,
|
||||
WorkflowStep,
|
||||
sha256_json,
|
||||
)
|
||||
from aios_autonomous_release_candidate.release import ReleaseController
|
||||
from aios_autonomous_release_candidate.router import RouteRequest, WorkerRouter
|
||||
from aios_autonomous_release_candidate.store import StateStore
|
||||
from aios_autonomous_release_candidate.workflow import WorkflowEngine
|
||||
|
||||
head = subprocess.check_output(["git", "rev-parse", "HEAD"], cwd=repo, text=True).strip()
|
||||
tree = subprocess.check_output(
|
||||
["git", "rev-parse", "HEAD^{tree}"], cwd=repo, text=True
|
||||
).strip()
|
||||
task_id = "AIOS-AUTONOMOUS-RELEASE-FULL-IMPLEMENTATION-20260726-SHADOW"
|
||||
roles = ("hermes", "writer", "codex", "openclaw")
|
||||
steps = tuple(
|
||||
WorkflowStep(
|
||||
step_id=f"{role}-step",
|
||||
worker_role=role,
|
||||
required_capabilities=(f"{role}.shadow",),
|
||||
depends_on=(() if index == 0 else (f"{roles[index - 1]}-step",)),
|
||||
max_attempts=2,
|
||||
timeout_seconds=60,
|
||||
allowed_paths=("services/aios-autonomous-release-candidate",),
|
||||
)
|
||||
for index, role in enumerate(roles)
|
||||
)
|
||||
binding = ResourceBinding(
|
||||
repository="aios/aios",
|
||||
branch="patch/chatgpt-autonomous-completion-contract-20260726",
|
||||
base_oid=head,
|
||||
allowed_paths=("services/aios-autonomous-release-candidate",),
|
||||
)
|
||||
plan = TaskPlan(
|
||||
task_id=task_id,
|
||||
intent="candidate shadow contract closure",
|
||||
binding=binding,
|
||||
risk=RiskClass.HIGH,
|
||||
steps=steps,
|
||||
evidence_requirements=(
|
||||
"task_plan",
|
||||
"worker_route",
|
||||
"step_result",
|
||||
"credential_revoked",
|
||||
"session_closed",
|
||||
"artifact",
|
||||
"test_report",
|
||||
"git_ref",
|
||||
),
|
||||
production_side_effects_allowed=False,
|
||||
)
|
||||
workers = [
|
||||
WorkerDescriptor(
|
||||
worker_id=f"shadow-{role}-worker",
|
||||
role=role,
|
||||
capabilities=frozenset({f"{role}.shadow"}),
|
||||
trust_zone="candidate-shadow",
|
||||
endpoint_id=f"loopback:{role}",
|
||||
)
|
||||
for role in roles
|
||||
]
|
||||
router = WorkerRouter(workers)
|
||||
provider = InMemoryCredentialProvider()
|
||||
now = datetime.now(timezone.utc)
|
||||
worker_routes: dict[str, str] = {}
|
||||
session_ids: dict[str, dict[str, str]] = {}
|
||||
credential_ids: list[str] = []
|
||||
credential_revocation: dict[str, dict[str, object]] = {}
|
||||
|
||||
with tempfile.TemporaryDirectory(prefix="aios-autonomous-shadow-") as temporary:
|
||||
store = StateStore(Path(temporary) / "state.sqlite3")
|
||||
workflow = WorkflowEngine(store)
|
||||
workflow.plan(plan)
|
||||
evidence = EvidenceChain(store, task_id)
|
||||
evidence.append(
|
||||
"task_plan",
|
||||
task_id,
|
||||
{"task_plan_sha256": plan.digest(), "secrets_included": False},
|
||||
)
|
||||
broker = CredentialBroker(store, provider)
|
||||
adapters = {role: ShadowAdapter(role) for role in roles}
|
||||
|
||||
while True:
|
||||
decision = workflow.next_steps(plan)
|
||||
states = store.list_steps(task_id)
|
||||
if states and all(item.state.value == "COMPLETED" for item in states.values()):
|
||||
break
|
||||
if not decision.ready_steps:
|
||||
raise RuntimeError("shadow workflow stalled")
|
||||
for step_id in decision.ready_steps:
|
||||
step = next(item for item in steps if item.step_id == step_id)
|
||||
worker = router.route(
|
||||
RouteRequest(task_id, step.required_capabilities, "candidate-shadow")
|
||||
)
|
||||
adapter = adapters[step.worker_role]
|
||||
session = adapter.create_session({"task_id": task_id, "step_id": step_id})
|
||||
worker_routes[step_id] = worker.worker_id
|
||||
session_ids[step_id] = {
|
||||
"broker_session_id": session.session_id,
|
||||
"provider_session_id": session.provider_session_id,
|
||||
"provider": session.provider,
|
||||
}
|
||||
evidence.append(
|
||||
"worker_route",
|
||||
task_id,
|
||||
{
|
||||
"step_id": step_id,
|
||||
"worker_id": worker.worker_id,
|
||||
"trust_zone": worker.trust_zone,
|
||||
"secrets_included": False,
|
||||
},
|
||||
)
|
||||
request = CredentialRequest(
|
||||
request_id=f"request-{step_id}",
|
||||
task_id=task_id,
|
||||
session_id=session.session_id,
|
||||
worker_id=worker.worker_id,
|
||||
audience=f"{step.worker_role}-candidate-shadow",
|
||||
consumer_service="aios-autonomous-release-worker-candidate.service",
|
||||
binding=binding,
|
||||
operations=(f"{step.worker_role}.shadow",),
|
||||
provider=f"{step.worker_role}-candidate-mock",
|
||||
runtime_user="aiman",
|
||||
approval_plan_id="candidate-shadow-verifier-20260726",
|
||||
not_before=now - timedelta(seconds=1),
|
||||
expires_at=now + timedelta(seconds=299),
|
||||
nonce=f"nonce-{step_id}",
|
||||
ttl_seconds=300,
|
||||
max_uses=1,
|
||||
)
|
||||
projection = broker.issue(request, now)
|
||||
broker.project(projection)
|
||||
broker.authorize(
|
||||
projection,
|
||||
task_id=task_id,
|
||||
session_id=session.session_id,
|
||||
worker_id=worker.worker_id,
|
||||
audience=request.audience,
|
||||
consumer_service=request.consumer_service,
|
||||
operation=request.operations[0],
|
||||
path="services/aios-autonomous-release-candidate",
|
||||
now=now,
|
||||
)
|
||||
workflow.claim(task_id, step_id, worker.worker_id, session.session_id)
|
||||
workflow.start(task_id, step_id, worker.worker_id, session.session_id, now=now)
|
||||
workflow.heartbeat(task_id, step_id, worker.worker_id, session.session_id, now=now)
|
||||
result = adapter.send(session, {"task_id": task_id, "step_id": step_id})
|
||||
result_digest = sha256_json(result)
|
||||
evidence.append(
|
||||
"step_result",
|
||||
task_id,
|
||||
{
|
||||
"step_id": step_id,
|
||||
"worker_id": worker.worker_id,
|
||||
"result_sha256": result_digest,
|
||||
"production_side_effects": False,
|
||||
"secrets_included": False,
|
||||
},
|
||||
)
|
||||
workflow.complete(task_id, step_id, result_digest=result_digest)
|
||||
revoked = broker.revoke(projection.credential_id, projection.reference, now)
|
||||
broker.verify_revoked(projection.credential_id, projection.reference)
|
||||
credential_ids.append(projection.credential_id)
|
||||
credential_revocation[projection.credential_id] = {
|
||||
"state": revoked.state.value,
|
||||
"post_revocation_auth": "REJECTED",
|
||||
}
|
||||
evidence.append(
|
||||
"credential_revoked",
|
||||
task_id,
|
||||
{
|
||||
"credential_id": projection.credential_id,
|
||||
"state": revoked.state.value,
|
||||
"post_revocation_auth": "REJECTED",
|
||||
"secrets_included": False,
|
||||
},
|
||||
)
|
||||
adapter.close(session)
|
||||
evidence.append(
|
||||
"session_closed",
|
||||
task_id,
|
||||
{
|
||||
"session_id": session.session_id,
|
||||
"provider_session_id": session.provider_session_id,
|
||||
"secrets_included": False,
|
||||
},
|
||||
)
|
||||
|
||||
built = ArtifactBuilder().build_from_directory(head, tree, package)
|
||||
ArtifactBuilder().verify(built)
|
||||
evidence.append(
|
||||
"artifact",
|
||||
task_id,
|
||||
{
|
||||
"artifact_sha256": built.manifest.artifact_sha256,
|
||||
"manifest_sha256": built.manifest.manifest_sha256,
|
||||
"package_closure_sha256": built.manifest.package_closure_sha256,
|
||||
"secrets_included": False,
|
||||
},
|
||||
)
|
||||
evidence.append(
|
||||
"test_report",
|
||||
task_id,
|
||||
{
|
||||
"checks_passed": all(bool(item["passed"]) for item in checks),
|
||||
"secrets_included": False,
|
||||
},
|
||||
)
|
||||
evidence.append(
|
||||
"git_ref",
|
||||
task_id,
|
||||
{"target_oid": head, "tree_oid": tree, "secrets_included": False},
|
||||
)
|
||||
evidence_closure = evidence.close(plan.evidence_requirements)
|
||||
evidence_bytes = json.dumps(
|
||||
evidence.export(), sort_keys=True, separators=(",", ":")
|
||||
).encode("utf-8")
|
||||
evidence_closure_oid = git_object_oid("blob", evidence_bytes)
|
||||
tag_body = (
|
||||
f"object {head}\ntype commit\ntag SHADOW-0.1.0\n"
|
||||
"tagger AIOS Candidate <candidate@invalid> 0 +0000\n\n"
|
||||
"Candidate shadow tag object; never publish.\n"
|
||||
).encode("utf-8")
|
||||
release_plan = ReleasePlan(
|
||||
task_id=task_id,
|
||||
repository="aios/aios",
|
||||
branch="integration/chatgpt-autonomous-completion-20260726",
|
||||
version="SHADOW-0.1.0",
|
||||
target_oid=head,
|
||||
tree_oid=tree,
|
||||
artifact_sha256=built.manifest.artifact_sha256,
|
||||
manifest_sha256=built.manifest.manifest_sha256,
|
||||
package_closure_sha256=built.manifest.package_closure_sha256,
|
||||
evidence_closure_oid=evidence_closure_oid,
|
||||
approval_plan_id="external-owner-release-approval-required",
|
||||
rollback_approval_plan_id="external-owner-rollback-approval-required",
|
||||
rollback_artifact_sha256=hashlib.sha256(b"previous-production-artifact").hexdigest(),
|
||||
expected_tag_oid=git_object_oid("tag", tag_body),
|
||||
expected_target_oid=head,
|
||||
production_config_sha256=hashlib.sha256(
|
||||
b"candidate-shadow-production-disabled"
|
||||
).hexdigest(),
|
||||
)
|
||||
release = ReleaseController()
|
||||
release.attach_plan(release_plan)
|
||||
release.mark_built()
|
||||
release.verify(artifact_ok=True, evidence_ok=True)
|
||||
release.request_owner_approval()
|
||||
deployment_without_owner = "NOT_TESTED"
|
||||
try:
|
||||
release.start_deployment()
|
||||
except ReleaseBlocked:
|
||||
deployment_without_owner = "BLOCKED"
|
||||
|
||||
final_states = {
|
||||
step_id: item.state.value for step_id, item in store.list_steps(task_id).items()
|
||||
}
|
||||
return {
|
||||
"passed": all(state == "COMPLETED" for state in final_states.values())
|
||||
and deployment_without_owner == "BLOCKED"
|
||||
and evidence.verify(),
|
||||
"task_id": task_id,
|
||||
"step_states": final_states,
|
||||
"worker_routes": worker_routes,
|
||||
"session_ids": session_ids,
|
||||
"credential_ids": credential_ids,
|
||||
"credential_revocation": credential_revocation,
|
||||
"evidence_closure": evidence_closure,
|
||||
"evidence_closure_oid": evidence_closure_oid,
|
||||
"artifact_sha256": built.manifest.artifact_sha256,
|
||||
"manifest_sha256": built.manifest.manifest_sha256,
|
||||
"package_closure_sha256": built.manifest.package_closure_sha256,
|
||||
"release_state": release.status().state.value,
|
||||
"deployment_without_owner_approval": deployment_without_owner,
|
||||
"broker_session_verified": True,
|
||||
"openclaw_native_child_session_verified": False,
|
||||
"codex_child_session_verified": False,
|
||||
"simulation": True,
|
||||
"human_intervention_count": 0,
|
||||
"production_side_effects": False,
|
||||
"main_write": False,
|
||||
"tag_write": False,
|
||||
"baseline_write": False,
|
||||
"registry_write": False,
|
||||
"secrets_included": False,
|
||||
}
|
||||
|
||||
|
||||
def build_parser() -> argparse.ArgumentParser:
|
||||
parser = argparse.ArgumentParser()
|
||||
parser.add_argument("--repo-root", type=Path)
|
||||
parser.add_argument("--output", required=True, type=Path)
|
||||
return parser
|
||||
|
||||
|
||||
def main(argv: list[str] | None = None) -> int:
|
||||
args = build_parser().parse_args(argv)
|
||||
repo = (args.repo_root or Path(__file__).resolve().parents[2]).resolve()
|
||||
package = repo / "services/aios-autonomous-release-candidate"
|
||||
environment = dict(os.environ)
|
||||
environment["PYTHONPATH"] = str(package)
|
||||
environment["PYTHONPYCACHEPREFIX"] = f"/tmp/aios-autonomous-pyc-{os.getpid()}"
|
||||
checks = [
|
||||
command(
|
||||
repo,
|
||||
[sys.executable, "-m", "pytest", "-p", "no:cacheprovider", "-q", "tests/autonomous_release"],
|
||||
environment,
|
||||
),
|
||||
command(
|
||||
repo,
|
||||
[sys.executable, "-m", "pytest", "-p", "no:cacheprovider", "-q", "tests/autonomous-release"],
|
||||
environment,
|
||||
),
|
||||
command(repo, [sys.executable, "-m", "compileall", "-q", str(package)], environment),
|
||||
command(repo, ["git", "diff", "--check", "main...HEAD"], environment),
|
||||
]
|
||||
scan_result = scans(repo)
|
||||
head = subprocess.check_output(["git", "rev-parse", "HEAD"], cwd=repo, text=True).strip()
|
||||
main_oid = subprocess.check_output(["git", "rev-parse", "main"], cwd=repo, text=True).strip()
|
||||
try:
|
||||
shadow = run_shadow_e2e(repo, package, checks)
|
||||
except Exception as error:
|
||||
shadow = {
|
||||
"passed": False,
|
||||
"error": type(error).__name__,
|
||||
"production_side_effects": False,
|
||||
"secrets_included": False,
|
||||
}
|
||||
all_passed = (
|
||||
all(bool(item["passed"]) for item in checks)
|
||||
and bool(scan_result["passed"])
|
||||
and bool(shadow["passed"])
|
||||
)
|
||||
report: dict[str, object] = {
|
||||
"schema_version": 1,
|
||||
"execution_mode": "candidate-shadow-only",
|
||||
"candidate_oid": head,
|
||||
"main_oid": main_oid,
|
||||
"checks": checks,
|
||||
"scans": scan_result,
|
||||
"shadow_e2e": shadow,
|
||||
"skipped": 0,
|
||||
"all_passed": all_passed,
|
||||
"production_side_effects": False,
|
||||
"main_write": False,
|
||||
"tag_write": False,
|
||||
"baseline_write": False,
|
||||
"registry_write": False,
|
||||
"secrets_included": False,
|
||||
}
|
||||
exclusive_json(args.output, report)
|
||||
print(json.dumps({"report": str(args.output), "all_passed": all_passed}, sort_keys=True))
|
||||
return 0 if all_passed else 1
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
raise SystemExit(main())
|
||||
@@ -1,268 +0,0 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Build a deterministic, secret-scanned Silent Release evidence package."""
|
||||
from __future__ import annotations
|
||||
|
||||
import argparse
|
||||
import hashlib
|
||||
import json
|
||||
import os
|
||||
import re
|
||||
import shutil
|
||||
import subprocess
|
||||
import tarfile
|
||||
from pathlib import Path
|
||||
from typing import Any
|
||||
|
||||
|
||||
OID_RE = re.compile(r"^[0-9a-f]{40}$")
|
||||
AUTHORIZATION_PATTERN = re.compile(
|
||||
rb"Authorization:\s*(?:Bearer|token)\s+([A-Za-z0-9._~+/=-]{16,})",
|
||||
re.I,
|
||||
)
|
||||
SECRET_PATTERNS = (
|
||||
re.compile(rb"(?:ghp|glpat)_[A-Za-z0-9_-]{20,}", re.I),
|
||||
re.compile(
|
||||
rb"-----BEGIN (?:RSA |EC |OPENSSH )?PRIVATE KEY-----\r?\n"
|
||||
rb"[A-Za-z0-9+/=\r\n]{64,}\r?\n"
|
||||
rb"-----END (?:RSA |EC |OPENSSH )?PRIVATE KEY-----"
|
||||
),
|
||||
)
|
||||
ALLOWED_AUTHORIZATION_PLACEHOLDER_SHA256 = frozenset(
|
||||
{
|
||||
"009f7191815ec615d09d0698457d048432e9a73f62ab4f26af1875009d0afbbc",
|
||||
"599a7f359d1e11124054f8afeae201f2d265b8988d91cb5b7d4dc4c9e2225c30",
|
||||
"f39dac6cbaba535e2c207cd0cd8f154974223c848f727f98b3564cea569b41cf",
|
||||
}
|
||||
)
|
||||
TARGET_TESTS = (
|
||||
"tests/test_silent_release_execution_readiness.py",
|
||||
"tests/test_silent_release_controller.py",
|
||||
"tests/test_silent_release_hardening.py",
|
||||
"tests/test_silent_release_production_contract.py",
|
||||
"tests/test_chatgpt_actions_tag.py",
|
||||
"tests/test_gitea_tag_publication.py",
|
||||
"tests/test_authoritative_git_context.py",
|
||||
)
|
||||
|
||||
|
||||
def sha256(path: Path) -> str:
|
||||
digest = hashlib.sha256()
|
||||
with path.open("rb") as source:
|
||||
for chunk in iter(lambda: source.read(1024 * 1024), b""):
|
||||
digest.update(chunk)
|
||||
return digest.hexdigest()
|
||||
|
||||
|
||||
def atomic_json(path: Path, payload: dict[str, Any]) -> None:
|
||||
temporary = path.with_suffix(path.suffix + ".tmp")
|
||||
with temporary.open("w", encoding="utf-8", newline="\n") as output:
|
||||
json.dump(payload, output, sort_keys=True, separators=(",", ":"))
|
||||
output.write("\n")
|
||||
output.flush()
|
||||
os.fsync(output.fileno())
|
||||
os.replace(temporary, path)
|
||||
|
||||
|
||||
def redact_output(value: str) -> str:
|
||||
value = re.sub(
|
||||
r"(?i)(Authorization:\s*(?:Bearer|token)\s+)"
|
||||
r"[A-Za-z0-9._~+/=-]{8,}",
|
||||
r"\1<redacted>",
|
||||
str(value),
|
||||
)
|
||||
value = re.sub(
|
||||
r"-----BEGIN (?:RSA |EC |OPENSSH )?PRIVATE KEY-----.*?"
|
||||
r"-----END (?:RSA |EC |OPENSSH )?PRIVATE KEY-----",
|
||||
"<redacted-private-key>",
|
||||
value,
|
||||
flags=re.DOTALL,
|
||||
)
|
||||
return value
|
||||
|
||||
|
||||
def git(git_dir: Path, *arguments: str) -> str:
|
||||
completed = subprocess.run(
|
||||
["git", f"--git-dir={git_dir}", *arguments],
|
||||
check=True,
|
||||
capture_output=True,
|
||||
text=True,
|
||||
timeout=60,
|
||||
env={"PATH": os.environ.get("PATH", "")},
|
||||
)
|
||||
return completed.stdout.strip()
|
||||
|
||||
|
||||
def run_evidence(
|
||||
command: list[str],
|
||||
*,
|
||||
cwd: Path,
|
||||
output: Path,
|
||||
timeout: int,
|
||||
) -> dict[str, Any]:
|
||||
completed = subprocess.run(
|
||||
command,
|
||||
cwd=cwd,
|
||||
capture_output=True,
|
||||
text=True,
|
||||
timeout=timeout,
|
||||
env={
|
||||
"HOME": str(cwd / ".builder-home"),
|
||||
"PATH": os.environ.get("PATH", ""),
|
||||
"PYTHONDONTWRITEBYTECODE": "1",
|
||||
},
|
||||
)
|
||||
record = {
|
||||
"command": command,
|
||||
"exit_code": completed.returncode,
|
||||
"stderr": redact_output(completed.stderr[-20000:]),
|
||||
"stdout": redact_output(completed.stdout[-20000:]),
|
||||
}
|
||||
atomic_json(output, record)
|
||||
if completed.returncode != 0:
|
||||
raise RuntimeError(f"trusted builder command failed: {command[0]}")
|
||||
return record
|
||||
|
||||
|
||||
def secret_scan(root: Path) -> dict[str, Any]:
|
||||
findings: list[str] = []
|
||||
for path in sorted(item for item in root.rglob("*") if item.is_file()):
|
||||
if path.stat().st_size > 5 * 1024 * 1024:
|
||||
continue
|
||||
data = path.read_bytes()
|
||||
authorization_tokens = AUTHORIZATION_PATTERN.findall(data)
|
||||
unsafe_authorization = any(
|
||||
hashlib.sha256(token.lower()).hexdigest()
|
||||
not in ALLOWED_AUTHORIZATION_PLACEHOLDER_SHA256
|
||||
for token in authorization_tokens
|
||||
)
|
||||
if unsafe_authorization or any(
|
||||
pattern.search(data) for pattern in SECRET_PATTERNS
|
||||
):
|
||||
findings.append(path.relative_to(root).as_posix())
|
||||
return {"findings": findings, "passed": not findings}
|
||||
|
||||
|
||||
def build(git_dir: Path, commit: str, output: Path) -> dict[str, Any]:
|
||||
commit = git(git_dir, "rev-parse", f"{commit}^{{commit}}")
|
||||
if not OID_RE.fullmatch(commit):
|
||||
raise ValueError("commit must resolve to a full OID")
|
||||
tree_oid = git(git_dir, "rev-parse", f"{commit}^{{tree}}")
|
||||
if output.exists():
|
||||
raise FileExistsError("artifact output already exists")
|
||||
output.mkdir(parents=True, mode=0o700)
|
||||
source_tar = output / "source.tar"
|
||||
subprocess.run(
|
||||
[
|
||||
"git",
|
||||
f"--git-dir={git_dir}",
|
||||
"archive",
|
||||
"--format=tar",
|
||||
f"--output={source_tar}",
|
||||
commit,
|
||||
],
|
||||
check=True,
|
||||
timeout=120,
|
||||
env={"PATH": os.environ.get("PATH", "")},
|
||||
)
|
||||
canary = output / "canary-src"
|
||||
canary.mkdir(mode=0o700)
|
||||
with tarfile.open(source_tar, "r") as archive:
|
||||
archive.extractall(canary, filter="data")
|
||||
if any(path.name == ".git" for path in canary.rglob(".git")):
|
||||
raise RuntimeError("no-.git canary contains Git metadata")
|
||||
|
||||
test_record = run_evidence(
|
||||
["python3", "-m", "pytest", "-q", *TARGET_TESTS],
|
||||
cwd=canary,
|
||||
output=output / "test-evidence.json",
|
||||
timeout=600,
|
||||
)
|
||||
fixture_record = run_evidence(
|
||||
["bash", "tests/run_live_gitea_fixture.sh"],
|
||||
cwd=canary,
|
||||
output=output / "live-fixture-evidence.json",
|
||||
timeout=600,
|
||||
)
|
||||
canary_record = {
|
||||
"git_directory_present": False,
|
||||
"live_fixture_exit_code": fixture_record["exit_code"],
|
||||
"passed": True,
|
||||
"target_test_exit_code": test_record["exit_code"],
|
||||
}
|
||||
atomic_json(output / "canary-evidence.json", canary_record)
|
||||
|
||||
scan = secret_scan(canary)
|
||||
atomic_json(output / "secret-scan.json", scan)
|
||||
if not scan["passed"]:
|
||||
raise RuntimeError("secret scan failed")
|
||||
|
||||
manifest_files: list[dict[str, Any]] = []
|
||||
tracked = git(git_dir, "ls-tree", "-r", "--name-only", commit).splitlines()
|
||||
for relative in tracked:
|
||||
path = canary / relative
|
||||
if path.is_file():
|
||||
manifest_files.append(
|
||||
{
|
||||
"path": relative,
|
||||
"sha256": sha256(path),
|
||||
"size": path.stat().st_size,
|
||||
}
|
||||
)
|
||||
manifest = {
|
||||
"commit": commit,
|
||||
"file_count": len(manifest_files),
|
||||
"files": manifest_files,
|
||||
"tree_oid": tree_oid,
|
||||
}
|
||||
atomic_json(output / "manifest.json", manifest)
|
||||
shutil.copyfile(source_tar, output / "rollback-source.tar")
|
||||
|
||||
closure = {
|
||||
"artifact_sha256": sha256(source_tar),
|
||||
"canary_evidence_sha256": sha256(output / "canary-evidence.json"),
|
||||
"commit": commit,
|
||||
"live_fixture_evidence_sha256": sha256(
|
||||
output / "live-fixture-evidence.json"
|
||||
),
|
||||
"manifest_sha256": sha256(output / "manifest.json"),
|
||||
"no_git_canary": True,
|
||||
"rollback_artifact_sha256": sha256(
|
||||
output / "rollback-source.tar"
|
||||
),
|
||||
"secret_scan_sha256": sha256(output / "secret-scan.json"),
|
||||
"test_evidence_sha256": sha256(output / "test-evidence.json"),
|
||||
"tree_oid": tree_oid,
|
||||
}
|
||||
atomic_json(output / "package-closure.json", closure)
|
||||
closure["package_closure_sha256"] = sha256(
|
||||
output / "package-closure.json"
|
||||
)
|
||||
checksummed = sorted(
|
||||
path
|
||||
for path in output.iterdir()
|
||||
if path.is_file() and path.name != "checksums.sha256"
|
||||
)
|
||||
with (output / "checksums.sha256").open(
|
||||
"w", encoding="utf-8", newline="\n"
|
||||
) as checksums:
|
||||
for path in checksummed:
|
||||
checksums.write(f"{sha256(path)} {path.name}\n")
|
||||
return closure
|
||||
|
||||
|
||||
def main() -> None:
|
||||
parser = argparse.ArgumentParser()
|
||||
parser.add_argument("--git-dir", required=True, type=Path)
|
||||
parser.add_argument("--commit", required=True)
|
||||
parser.add_argument("--output", required=True, type=Path)
|
||||
arguments = parser.parse_args()
|
||||
result = build(
|
||||
arguments.git_dir.resolve(),
|
||||
arguments.commit,
|
||||
arguments.output.resolve(),
|
||||
)
|
||||
print(json.dumps(result, sort_keys=True))
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@@ -1,64 +0,0 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Deterministic, local-only fault injection for Task Plane recovery."""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import argparse
|
||||
import json
|
||||
import time
|
||||
from unittest import mock
|
||||
|
||||
from app.task_plane.api import TaskPlaneService
|
||||
from app.task_plane.policy import PolicyEngine
|
||||
from app.task_plane.store import TaskPlaneStore
|
||||
|
||||
|
||||
def main() -> int:
|
||||
parser = argparse.ArgumentParser()
|
||||
parser.add_argument("--database", required=True)
|
||||
args = parser.parse_args()
|
||||
store = TaskPlaneStore(args.database)
|
||||
service = TaskPlaneService(
|
||||
store, policy=PolicyEngine(execution_enabled=True)
|
||||
)
|
||||
identity = "spiffe://aios/agent/codex/fault-injection"
|
||||
service.register_worker(
|
||||
{
|
||||
"worker_id": "codex-fault-injection",
|
||||
"worker_type": "codex",
|
||||
"identity": identity,
|
||||
"capabilities": ["test.execute"],
|
||||
"trust_zone": "isolated-shadow",
|
||||
"max_concurrency": 1,
|
||||
"heartbeat_interval_seconds": 1,
|
||||
"supported_protocols": ["aios-task-v1"],
|
||||
}
|
||||
)
|
||||
task = service.create_task(
|
||||
{"task_id": "task-fault-expired-lease", "required_capabilities": ["test.execute"]}
|
||||
)
|
||||
claim = service.claim(
|
||||
task["task_id"],
|
||||
{
|
||||
"worker_id": "codex-fault-injection",
|
||||
"actor_identity": identity,
|
||||
"lease_seconds": 1,
|
||||
},
|
||||
)
|
||||
with mock.patch("app.task_plane.store._now", return_value=time.time() + 5):
|
||||
recovered = store.recover_expired_claim(
|
||||
task["task_id"], claim["claim_id"], probe_confirms_stopped=True
|
||||
)
|
||||
output = {
|
||||
"fault": "expired_lease",
|
||||
"recovered_status": recovered.status,
|
||||
"event_chain_valid": store.verify_event_chain(task["task_id"]),
|
||||
"production_side_effects": False,
|
||||
}
|
||||
print(json.dumps(output, sort_keys=True))
|
||||
store.close()
|
||||
return 0
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
raise SystemExit(main())
|
||||
@@ -1,470 +0,0 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Run two zero-side-effect Silent Release candidates in Shadow mode."""
|
||||
from __future__ import annotations
|
||||
|
||||
import argparse
|
||||
import dataclasses
|
||||
import hashlib
|
||||
import json
|
||||
import sys
|
||||
from datetime import datetime, timedelta, timezone
|
||||
from pathlib import Path
|
||||
|
||||
from cryptography.hazmat.primitives import serialization
|
||||
from cryptography.hazmat.primitives.asymmetric.ed25519 import (
|
||||
Ed25519PrivateKey,
|
||||
)
|
||||
|
||||
ROOT = Path(__file__).resolve().parents[1]
|
||||
sys.path.insert(0, str(ROOT / "active-runtime" / "app"))
|
||||
|
||||
from silent_release_controller import ReleaseCandidate, ReleaseState # noqa: E402
|
||||
from silent_release_execution import ( # noqa: E402
|
||||
LocalTestApprovalSigner,
|
||||
LocalTestBuilderSigner,
|
||||
PersistentSilentReleaseController,
|
||||
SignedTrustedBuilderAdapter,
|
||||
)
|
||||
from silent_release_hardening import ( # noqa: E402
|
||||
ApprovalKeyRing,
|
||||
ApprovalRevocationStore,
|
||||
BuilderAttestationVerifier,
|
||||
DeploymentPlan,
|
||||
FinalizationPlan,
|
||||
ReleasePlan,
|
||||
SignedApprovalVerifier,
|
||||
SignedReleasePlanApproval,
|
||||
SilentReleaseActionService,
|
||||
TagPlan,
|
||||
TagPublicationProbeEvidence,
|
||||
TrustedCandidateBundle,
|
||||
TrustedReleasePolicy,
|
||||
classify_tag_publication,
|
||||
)
|
||||
|
||||
|
||||
def sha256_file(path: Path) -> str:
|
||||
digest = hashlib.sha256()
|
||||
with path.open("rb") as source:
|
||||
for block in iter(lambda: source.read(1024 * 1024), b""):
|
||||
digest.update(block)
|
||||
return digest.hexdigest()
|
||||
|
||||
|
||||
def write_json(path: Path, value: object) -> None:
|
||||
path.parent.mkdir(parents=True, exist_ok=True)
|
||||
temporary = path.with_suffix(path.suffix + ".tmp")
|
||||
temporary.write_text(
|
||||
json.dumps(value, indent=2, sort_keys=True) + "\n",
|
||||
encoding="utf-8",
|
||||
)
|
||||
temporary.replace(path)
|
||||
|
||||
|
||||
def oid(seed: str) -> str:
|
||||
return hashlib.sha1(seed.encode("utf-8")).hexdigest()
|
||||
|
||||
|
||||
def candidate_id(event_id: str, source_commit: str) -> str:
|
||||
return "rc-shadow-" + hashlib.sha256(
|
||||
f"{event_id}\0{source_commit}".encode("utf-8")
|
||||
).hexdigest()[:20]
|
||||
|
||||
|
||||
def make_plan(arguments: argparse.Namespace, candidate: str) -> ReleasePlan:
|
||||
version = "shadow-" + candidate.removeprefix("rc-shadow-")
|
||||
tag_oid = oid("tag:" + candidate)
|
||||
approval_plan_id = "shadow-plan-" + candidate.removeprefix("rc-shadow-")
|
||||
release_path = str(Path(arguments.release_path))
|
||||
previous_baseline = arguments.baseline_before_sha256
|
||||
return ReleasePlan(
|
||||
deployment=DeploymentPlan(
|
||||
service="aios-silent-release-controller",
|
||||
release_path=release_path,
|
||||
release_root=str(Path(release_path).parent.parent),
|
||||
cutover_link=str(Path(release_path).parent.parent / "current"),
|
||||
dropin_path=str(
|
||||
Path(release_path)
|
||||
/ "deploy"
|
||||
/ "systemd"
|
||||
/ "aios-silent-release-controller.service"
|
||||
),
|
||||
dropin_sha256=arguments.systemd_unit_sha256,
|
||||
systemd_unit_sha256=arguments.systemd_unit_sha256,
|
||||
rollback_path=str(Path(arguments.rollback_artifact)),
|
||||
rollback_sha256=arguments.artifact_sha256,
|
||||
source_commit=arguments.source_commit,
|
||||
tree_oid=arguments.tree_oid,
|
||||
artifact_sha256=arguments.artifact_sha256,
|
||||
manifest_sha256=arguments.manifest_sha256,
|
||||
package_closure_sha256=arguments.package_closure_sha256,
|
||||
authoritative_git_dir=str(Path(arguments.repository)),
|
||||
repository_identity=arguments.repository_identity,
|
||||
writer_expected=False,
|
||||
baseline_before_sha256=previous_baseline,
|
||||
registry_before_sha256=arguments.registry_before_sha256,
|
||||
production_tag_refset_before_sha256=(
|
||||
arguments.tag_refset_before_sha256
|
||||
),
|
||||
health_contract_version="shadow-health/v1",
|
||||
timeout_policy={"health_seconds": 10},
|
||||
retry_policy={"health_attempts": 1},
|
||||
policy_sha256=arguments.policy_sha256,
|
||||
health_contract={
|
||||
"execution_enabled": False,
|
||||
"shadow_mode": True,
|
||||
"side_effects_executed": False,
|
||||
},
|
||||
),
|
||||
tag=TagPlan(
|
||||
version=version,
|
||||
tag_type="annotated",
|
||||
expected_tag_oid=tag_oid,
|
||||
expected_target_oid=arguments.source_commit,
|
||||
evidence_closure_oid=arguments.source_commit,
|
||||
approval_plan_id=approval_plan_id,
|
||||
repository_identity=arguments.repository_identity,
|
||||
gitea_owner="aios",
|
||||
gitea_repository="aios",
|
||||
current_remote_tag_oid=None,
|
||||
remote_absent_evidence_sha256=hashlib.sha256(
|
||||
f"shadow-only:{candidate}".encode("utf-8")
|
||||
).hexdigest(),
|
||||
verification_contract="shadow-no-tag-write/v1",
|
||||
),
|
||||
finalization=FinalizationPlan(
|
||||
version=version,
|
||||
expected_tag_oid=tag_oid,
|
||||
expected_target_oid=arguments.source_commit,
|
||||
expected_previous_baseline_sha256=previous_baseline,
|
||||
registry_expected_record={
|
||||
"shadow_only": True,
|
||||
"target_oid": arguments.source_commit,
|
||||
},
|
||||
baseline_expected_record={
|
||||
"shadow_only": True,
|
||||
"target_oid": arguments.source_commit,
|
||||
},
|
||||
final_consistency_contract="shadow-no-finalization/v1",
|
||||
),
|
||||
policy_sha256=arguments.policy_sha256,
|
||||
)
|
||||
|
||||
|
||||
def make_candidate(
|
||||
arguments: argparse.Namespace, event_id: str
|
||||
) -> ReleaseCandidate:
|
||||
return ReleaseCandidate(
|
||||
candidate_id=candidate_id(event_id, arguments.source_commit),
|
||||
source_commit=arguments.source_commit,
|
||||
tree_oid=arguments.tree_oid,
|
||||
artifact_sha256=arguments.artifact_sha256,
|
||||
manifest_sha256=arguments.manifest_sha256,
|
||||
tests={"passed": True, "source": "trusted-artifact-evidence"},
|
||||
canary={"passed": True, "without_git": True},
|
||||
rollback_ready=True,
|
||||
git_consistency={"consistent": True},
|
||||
gitea_consistency={"consistent": True},
|
||||
approval_state="PENDING",
|
||||
state=ReleaseState.READY_FOR_APPROVAL,
|
||||
)
|
||||
|
||||
|
||||
def sign_approval(
|
||||
service: SilentReleaseActionService,
|
||||
signer: LocalTestApprovalSigner,
|
||||
candidate: str,
|
||||
nonce_suffix: str,
|
||||
) -> SignedReleasePlanApproval:
|
||||
release_candidate = service.candidates.load(candidate)
|
||||
plan = service.release_plans.load(candidate)
|
||||
now = datetime.now(timezone.utc)
|
||||
unsigned = SignedReleasePlanApproval(
|
||||
release_plan_id="shadow-release-" + candidate.removeprefix("rc-"),
|
||||
candidate_id=candidate,
|
||||
source_commit=release_candidate.source_commit,
|
||||
tree_oid=release_candidate.tree_oid,
|
||||
artifact_sha256=release_candidate.artifact_sha256,
|
||||
manifest_sha256=release_candidate.manifest_sha256,
|
||||
deployment_plan_sha256=plan.deployment.sha256,
|
||||
release_plan_sha256=plan.sha256,
|
||||
policy_sha256=plan.policy_sha256,
|
||||
approval_plan_id=plan.tag.approval_plan_id,
|
||||
evidence_closure_oid=plan.tag.evidence_closure_oid,
|
||||
owner_approval_record_oid=oid("shadow-owner:" + candidate),
|
||||
capabilities=(
|
||||
"runtime_switch",
|
||||
"tag_publish",
|
||||
"baseline_registry_finalize",
|
||||
),
|
||||
owner_identity="owner:shadow-acceptance-test",
|
||||
trust_domain="aios.shadow",
|
||||
issued_at=now.isoformat().replace("+00:00", "Z"),
|
||||
not_before=now.isoformat().replace("+00:00", "Z"),
|
||||
expires_at=(now + timedelta(minutes=10))
|
||||
.isoformat()
|
||||
.replace("+00:00", "Z"),
|
||||
nonce="shadow-nonce-" + nonce_suffix,
|
||||
key_id=signer.key_id,
|
||||
signature="",
|
||||
)
|
||||
return signer.sign(unsigned)
|
||||
|
||||
|
||||
def tag_probe_results(plan: TagPlan) -> dict[str, str]:
|
||||
exact = TagPublicationProbeEvidence(
|
||||
repository_identity=plan.repository_identity,
|
||||
remote_reachable=True,
|
||||
gitea_api_reachable=True,
|
||||
gitea_listing_reachable=True,
|
||||
remote_tag_oid=plan.expected_tag_oid,
|
||||
annotated_tag_object_oid=plan.expected_tag_oid,
|
||||
remote_peeled_target_oid=plan.expected_target_oid,
|
||||
gitea_api_tag_oid=plan.expected_tag_oid,
|
||||
gitea_api_peeled_target_oid=plan.expected_target_oid,
|
||||
gitea_listing_visible=True,
|
||||
gitea_listing_tag_oid=plan.expected_tag_oid,
|
||||
gitea_listing_peeled_target_oid=plan.expected_target_oid,
|
||||
observed_at=1,
|
||||
)
|
||||
absent = dataclasses.replace(
|
||||
exact,
|
||||
remote_tag_oid=None,
|
||||
annotated_tag_object_oid=None,
|
||||
remote_peeled_target_oid=None,
|
||||
gitea_api_tag_oid=None,
|
||||
gitea_api_peeled_target_oid=None,
|
||||
gitea_listing_visible=False,
|
||||
gitea_listing_tag_oid=None,
|
||||
gitea_listing_peeled_target_oid=None,
|
||||
)
|
||||
indeterminate = dataclasses.replace(exact, gitea_api_reachable=False)
|
||||
conflict = dataclasses.replace(exact, remote_tag_oid=oid("conflict"))
|
||||
return {
|
||||
"APPLIED_VERIFIED": classify_tag_publication(exact, plan).value,
|
||||
"CONFLICT": classify_tag_publication(conflict, plan).value,
|
||||
"INDETERMINATE": classify_tag_publication(
|
||||
indeterminate, plan
|
||||
).value,
|
||||
"NOT_APPLIED": classify_tag_publication(absent, plan).value,
|
||||
}
|
||||
|
||||
|
||||
def parser() -> argparse.ArgumentParser:
|
||||
value = argparse.ArgumentParser()
|
||||
value.add_argument("--state-root", required=True, type=Path)
|
||||
value.add_argument("--repository", required=True, type=Path)
|
||||
value.add_argument("--release-path", required=True, type=Path)
|
||||
value.add_argument("--rollback-artifact", required=True, type=Path)
|
||||
value.add_argument("--source-commit", required=True)
|
||||
value.add_argument("--tree-oid", required=True)
|
||||
value.add_argument("--artifact-sha256", required=True)
|
||||
value.add_argument("--manifest-sha256", required=True)
|
||||
value.add_argument("--package-closure-sha256", required=True)
|
||||
value.add_argument("--policy-sha256", required=True)
|
||||
value.add_argument("--systemd-unit-sha256", required=True)
|
||||
value.add_argument("--baseline-before-sha256", required=True)
|
||||
value.add_argument("--registry-before-sha256", required=True)
|
||||
value.add_argument("--tag-refset-before-sha256", required=True)
|
||||
value.add_argument("--repository-identity", default="aios/aios")
|
||||
value.add_argument("--output", required=True, type=Path)
|
||||
return value
|
||||
|
||||
|
||||
def main() -> None:
|
||||
arguments = parser().parse_args()
|
||||
if sha256_file(arguments.rollback_artifact) != arguments.artifact_sha256:
|
||||
raise SystemExit("rollback artifact hash mismatch")
|
||||
unit_path = (
|
||||
arguments.release_path
|
||||
/ "deploy"
|
||||
/ "systemd"
|
||||
/ "aios-silent-release-controller.service"
|
||||
)
|
||||
if sha256_file(unit_path) != arguments.systemd_unit_sha256:
|
||||
raise SystemExit("systemd unit hash mismatch")
|
||||
|
||||
builder_signer = LocalTestBuilderSigner.generate()
|
||||
builder_public = builder_signer.public_key.public_bytes(
|
||||
serialization.Encoding.Raw,
|
||||
serialization.PublicFormat.Raw,
|
||||
)
|
||||
owner_private = Ed25519PrivateKey.generate()
|
||||
owner_public = owner_private.public_key().public_bytes(
|
||||
serialization.Encoding.Raw,
|
||||
serialization.PublicFormat.Raw,
|
||||
)
|
||||
owner_signer = LocalTestApprovalSigner(
|
||||
"shadow-owner-ephemeral", owner_private
|
||||
)
|
||||
|
||||
def collector(intent):
|
||||
event_id = str(intent["event_id"])
|
||||
candidate = make_candidate(arguments, event_id)
|
||||
return TrustedCandidateBundle(
|
||||
candidate=candidate,
|
||||
release_plan=make_plan(arguments, candidate.candidate_id),
|
||||
checks={
|
||||
"authoritative_git": True,
|
||||
"artifact": True,
|
||||
"canary": True,
|
||||
"gitea": True,
|
||||
"manifest": True,
|
||||
"package_closure": True,
|
||||
"rollback": True,
|
||||
"secret_scan": True,
|
||||
"tests": True,
|
||||
},
|
||||
)
|
||||
|
||||
release_root = str(arguments.release_path.parent.parent)
|
||||
dropin = str(
|
||||
arguments.release_path
|
||||
/ "deploy"
|
||||
/ "systemd"
|
||||
/ "aios-silent-release-controller.service"
|
||||
)
|
||||
policy = TrustedReleasePolicy(
|
||||
services=frozenset({"aios-silent-release-controller"}),
|
||||
release_roots=frozenset({release_root}),
|
||||
cutover_links=frozenset({str(Path(release_root) / "current")}),
|
||||
dropin_paths=frozenset({dropin}),
|
||||
authoritative_git_dirs=frozenset({str(arguments.repository)}),
|
||||
repository_identities=frozenset(
|
||||
{arguments.repository_identity}
|
||||
),
|
||||
)
|
||||
verifier = SignedApprovalVerifier(
|
||||
ApprovalKeyRing({"shadow-owner-ephemeral": owner_public}),
|
||||
ApprovalRevocationStore(arguments.state_root / "revocations"),
|
||||
allowed_trust_domains={"aios.shadow"},
|
||||
)
|
||||
service = SilentReleaseActionService(
|
||||
arguments.state_root,
|
||||
execution_enabled=False,
|
||||
approval_verifier=verifier,
|
||||
candidate_builder=SignedTrustedBuilderAdapter(
|
||||
collector, builder_signer
|
||||
),
|
||||
builder_attestation_verifier=BuilderAttestationVerifier(
|
||||
{builder_signer.key_id: builder_public}
|
||||
),
|
||||
trusted_policy=policy,
|
||||
expected_repository=arguments.repository_identity,
|
||||
policy_sha256=arguments.policy_sha256,
|
||||
)
|
||||
|
||||
first_event = "main-" + arguments.source_commit
|
||||
first = service.create_release_intent(
|
||||
{
|
||||
"event_id": first_event,
|
||||
"source_commit": arguments.source_commit,
|
||||
}
|
||||
)
|
||||
first_duplicate = service.create_release_intent(
|
||||
{
|
||||
"event_id": first_event,
|
||||
"source_commit": arguments.source_commit,
|
||||
}
|
||||
)
|
||||
first_notification = service.ensure_owner_notification(
|
||||
first["candidate_id"]
|
||||
)
|
||||
repeated_notification = service.ensure_owner_notification(
|
||||
first["candidate_id"]
|
||||
)
|
||||
first_approval = sign_approval(
|
||||
service, owner_signer, first["candidate_id"], "candidate-one"
|
||||
)
|
||||
first_submit = service.submit_owner_approval(
|
||||
first_approval.to_dict()
|
||||
)
|
||||
first_submit_repeated = service.submit_owner_approval(
|
||||
first_approval.to_dict()
|
||||
)
|
||||
first_start = service.start_deployment(first["candidate_id"])
|
||||
|
||||
second = service.create_release_intent(
|
||||
{
|
||||
"event_id": "shadow-indeterminate-" + arguments.source_commit,
|
||||
"source_commit": arguments.source_commit,
|
||||
}
|
||||
)
|
||||
second_plan = service.release_plans.load(second["candidate_id"])
|
||||
probe_results = tag_probe_results(second_plan.tag)
|
||||
|
||||
first_controller = PersistentSilentReleaseController(
|
||||
arguments.state_root,
|
||||
service,
|
||||
main_probe=lambda: arguments.source_commit,
|
||||
)
|
||||
controller_first = first_controller.run_once()
|
||||
controller_restarted = PersistentSilentReleaseController(
|
||||
arguments.state_root,
|
||||
service,
|
||||
main_probe=lambda: arguments.source_commit,
|
||||
).run_once()
|
||||
|
||||
report = {
|
||||
"approval_backend": "ephemeral-shadow-test-only",
|
||||
"artifact_sha256": arguments.artifact_sha256,
|
||||
"builder_attestation": "VERIFIED",
|
||||
"candidate_count": 2,
|
||||
"candidates": [
|
||||
{
|
||||
"candidate_id": first["candidate_id"],
|
||||
"duplicate_intent_idempotent": first_duplicate["idempotent"],
|
||||
"notification_idempotent": (
|
||||
repeated_notification["idempotent"]
|
||||
),
|
||||
"notification_initial_idempotent": (
|
||||
first_notification["idempotent"]
|
||||
),
|
||||
"replayed_approval_status": (
|
||||
first_submit_repeated["status"]
|
||||
),
|
||||
"shadow_start": first_start,
|
||||
"signed_approval_status": first_submit["status"],
|
||||
},
|
||||
{
|
||||
"candidate_id": second["candidate_id"],
|
||||
"tag_publication_probe": "INDETERMINATE",
|
||||
},
|
||||
],
|
||||
"controller_restart_idempotent": (
|
||||
controller_restarted["intent"]["idempotent"]
|
||||
),
|
||||
"controller_restart_notification_idempotent": (
|
||||
controller_restarted["notification"]["idempotent"]
|
||||
),
|
||||
"controller_status": controller_first["startup"]["status"],
|
||||
"execution_enabled": False,
|
||||
"manifest_sha256": arguments.manifest_sha256,
|
||||
"package_closure_sha256": arguments.package_closure_sha256,
|
||||
"private_key_files_written": False,
|
||||
"production_tag": "NOT_EXECUTED",
|
||||
"repository_identity": arguments.repository_identity,
|
||||
"shadow_mode": True,
|
||||
"side_effects_executed": False,
|
||||
"source_commit": arguments.source_commit,
|
||||
"tag_probe_outcomes": probe_results,
|
||||
"tree_oid": arguments.tree_oid,
|
||||
}
|
||||
write_json(arguments.output, report)
|
||||
print(
|
||||
json.dumps(
|
||||
{
|
||||
"candidate_count": 2,
|
||||
"execution_enabled": False,
|
||||
"output": str(arguments.output),
|
||||
"shadow_mode": True,
|
||||
"side_effects_executed": False,
|
||||
"status": "SHADOW_ACCEPTANCE_PASSED",
|
||||
},
|
||||
sort_keys=True,
|
||||
)
|
||||
)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@@ -1,180 +0,0 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Create one authenticated, no-side-effect Task Plane Shadow task.
|
||||
|
||||
The client deliberately has no worker, Git, deployment, or credential-writing
|
||||
capabilities. Its token is accepted only from a protected file reference or
|
||||
stdin so that it cannot enter the process command line.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import argparse
|
||||
import hashlib
|
||||
import json
|
||||
import os
|
||||
import sys
|
||||
import urllib.error
|
||||
import urllib.request
|
||||
from pathlib import Path
|
||||
from typing import Any
|
||||
|
||||
|
||||
MINIMUM_CLIENT_CAPABILITIES = (
|
||||
"task.creator",
|
||||
"task.read",
|
||||
"task.events.read",
|
||||
"task.evidence.read",
|
||||
)
|
||||
|
||||
|
||||
class ShadowClientError(RuntimeError):
|
||||
"""HTTP failure that intentionally carries no response body."""
|
||||
|
||||
def __init__(self, status: int):
|
||||
super().__init__(f"shadow task request failed with HTTP {status}")
|
||||
self.status = status
|
||||
|
||||
|
||||
def _request_json(
|
||||
base_url: str,
|
||||
path: str,
|
||||
token: str,
|
||||
*,
|
||||
method: str = "GET",
|
||||
payload: dict[str, Any] | None = None,
|
||||
idempotency_key: str | None = None,
|
||||
) -> tuple[int, dict[str, Any]]:
|
||||
headers = {
|
||||
"Accept": "application/json",
|
||||
"Authorization": f"Bearer {token}",
|
||||
}
|
||||
data = None
|
||||
if payload is not None:
|
||||
headers["Content-Type"] = "application/json"
|
||||
data = json.dumps(payload, sort_keys=True, separators=(",", ":")).encode("utf-8")
|
||||
if idempotency_key:
|
||||
headers["Idempotency-Key"] = idempotency_key
|
||||
|
||||
request = urllib.request.Request(
|
||||
base_url.rstrip("/") + path,
|
||||
data=data,
|
||||
headers=headers,
|
||||
method=method,
|
||||
)
|
||||
try:
|
||||
with urllib.request.urlopen(request, timeout=10) as response:
|
||||
body = response.read()
|
||||
parsed = json.loads(body.decode("utf-8")) if body else {}
|
||||
return response.status, parsed
|
||||
except urllib.error.HTTPError as error:
|
||||
# Never read or print an error body: it could contain sensitive data.
|
||||
raise ShadowClientError(error.code) from None
|
||||
except urllib.error.URLError as error:
|
||||
raise ShadowClientError(503) from error
|
||||
|
||||
|
||||
def run_shadow_client(
|
||||
*,
|
||||
base_url: str,
|
||||
token: str,
|
||||
task_id: str,
|
||||
idempotency_key: str,
|
||||
) -> dict[str, Any]:
|
||||
"""Create and read one deterministic Shadow task without executing it."""
|
||||
create_status, _ = _request_json(
|
||||
base_url,
|
||||
"/tasks",
|
||||
token,
|
||||
method="POST",
|
||||
idempotency_key=idempotency_key,
|
||||
payload={
|
||||
"task_id": task_id,
|
||||
"task_type": "platform.shadow",
|
||||
"risk": "low",
|
||||
"approval_policy": "patch-only",
|
||||
"metadata": {"production_side_effects": False},
|
||||
},
|
||||
)
|
||||
task_status, task = _request_json(base_url, f"/tasks/{task_id}", token)
|
||||
events_status, events = _request_json(base_url, f"/tasks/{task_id}/events", token)
|
||||
evidence_status, evidence = _request_json(base_url, f"/tasks/{task_id}/evidence", token)
|
||||
return {
|
||||
"task_id": str(task.get("task_id", task_id)),
|
||||
"status": str(task.get("status", "UNKNOWN")),
|
||||
"event_count": len(events if isinstance(events, list) else events.get("events", [])),
|
||||
"evidence_count": len(evidence if isinstance(evidence, list) else evidence.get("evidence", [])),
|
||||
"http_statuses": {
|
||||
"create": create_status,
|
||||
"task": task_status,
|
||||
"events": events_status,
|
||||
"evidence": evidence_status,
|
||||
},
|
||||
"production_side_effects": False,
|
||||
}
|
||||
|
||||
|
||||
def _reject_plaintext_token_argument(argv: list[str]) -> None:
|
||||
if any(argument == "--token" or argument.startswith("--token=") for argument in argv):
|
||||
raise SystemExit("plaintext token arguments are forbidden")
|
||||
|
||||
|
||||
def _read_token(args: argparse.Namespace) -> str:
|
||||
if args.token_stdin:
|
||||
token = sys.stdin.buffer.read().decode("utf-8").strip()
|
||||
else:
|
||||
token_file = args.token_file or os.environ.get("AIOS_TASK_PLANE_TOKEN_FILE")
|
||||
if not token_file:
|
||||
raise SystemExit("runtime credential reference is required")
|
||||
try:
|
||||
token = Path(token_file).read_text(encoding="utf-8").strip()
|
||||
except OSError:
|
||||
raise SystemExit("runtime credential reference is unavailable") from None
|
||||
if not token:
|
||||
raise SystemExit("runtime credential reference is unavailable")
|
||||
return token
|
||||
|
||||
|
||||
def _write_report(path: Path, summary: dict[str, Any]) -> str:
|
||||
encoded = (json.dumps(summary, sort_keys=True, separators=(",", ":")) + "\n").encode("utf-8")
|
||||
path.parent.mkdir(parents=True, exist_ok=True)
|
||||
path.write_bytes(encoded)
|
||||
return hashlib.sha256(encoded).hexdigest()
|
||||
|
||||
|
||||
def main(argv: list[str] | None = None) -> int:
|
||||
argv = list(sys.argv[1:] if argv is None else argv)
|
||||
_reject_plaintext_token_argument(argv)
|
||||
parser = argparse.ArgumentParser(description=__doc__)
|
||||
parser.add_argument("--base-url", default="http://127.0.0.1:18922")
|
||||
token_group = parser.add_mutually_exclusive_group()
|
||||
token_group.add_argument("--token-file", help="protected runtime credential reference")
|
||||
token_group.add_argument("--token-stdin", action="store_true")
|
||||
parser.add_argument("--task-id", default="AIOS-TASK-PLANE-SHADOW-CLIENT")
|
||||
parser.add_argument("--idempotency-key", default="task-plane-shadow-client-v1")
|
||||
parser.add_argument("--report", required=True, type=Path)
|
||||
args = parser.parse_args(argv)
|
||||
|
||||
token = _read_token(args)
|
||||
try:
|
||||
summary = run_shadow_client(
|
||||
base_url=args.base_url,
|
||||
token=token,
|
||||
task_id=args.task_id,
|
||||
idempotency_key=args.idempotency_key,
|
||||
)
|
||||
except ShadowClientError as error:
|
||||
print(f"http_status={error.status}", file=sys.stderr)
|
||||
return error.status
|
||||
|
||||
report_sha256 = _write_report(args.report, summary)
|
||||
print(f"task_id={summary['task_id']}")
|
||||
print(f"status={summary['status']}")
|
||||
print(f"event_count={summary['event_count']}")
|
||||
print(f"evidence_count={summary['evidence_count']}")
|
||||
print("http_statuses=" + json.dumps(summary["http_statuses"], sort_keys=True))
|
||||
print(f"report_sha256={report_sha256}")
|
||||
return 0
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
raise SystemExit(main())
|
||||
@@ -1,40 +0,0 @@
|
||||
#!/usr/bin/env bash
|
||||
set -euo pipefail
|
||||
|
||||
REPORT_PATH="${1:-reports/task-plane-acceptance.json}"
|
||||
mkdir -p "$(dirname "${REPORT_PATH}")"
|
||||
export TASKPLANE_REPORT="${REPORT_PATH}"
|
||||
export PYTHONPATH="${PYTHONPATH:-}:$(pwd)/active-runtime"
|
||||
|
||||
python3 - <<'PY'
|
||||
import io
|
||||
import json
|
||||
import sys
|
||||
import unittest
|
||||
|
||||
from pathlib import Path
|
||||
from contextlib import redirect_stdout
|
||||
|
||||
report_path = Path(__import__('os').environ.get("TASKPLANE_REPORT", "reports/task-plane-acceptance.json"))
|
||||
stream = io.StringIO()
|
||||
|
||||
loader = unittest.TestLoader()
|
||||
suite = loader.discover("tests/task_plane/public_interface", pattern="test_*.py")
|
||||
runner = unittest.TextTestRunner(stream=sys.stdout, verbosity=2)
|
||||
result = runner.run(suite)
|
||||
|
||||
payload = {
|
||||
"execution_status": "PARTIALLY_COMPLETED" if result.wasSuccessful() else "FAILED",
|
||||
"tests_run": result.testsRun,
|
||||
"failures": len(result.failures),
|
||||
"errors": len(result.errors),
|
||||
"skipped": len(result.skipped),
|
||||
"multi_agent_shadow_verified": result.wasSuccessful(),
|
||||
"production_side_effects": False,
|
||||
"notification_delivery_status": "NOT_DELIVERED",
|
||||
}
|
||||
report_path.parent.mkdir(parents=True, exist_ok=True)
|
||||
report_path.write_text(json.dumps(payload, indent=2) + "\n", encoding="utf-8")
|
||||
print(f"acceptance_report={report_path}")
|
||||
sys.exit(0 if result.wasSuccessful() else 1)
|
||||
PY
|
||||
@@ -1,652 +0,0 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Hardened WeChat outbound backend for AIOS.
|
||||
|
||||
Only the dedicated UCC adapter is a supported send backend. OpenClaw channel
|
||||
discovery is retained for diagnostics, but generic OpenClaw chat or agent
|
||||
delivery is never promoted to WeChat delivery.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import json
|
||||
import os
|
||||
import re
|
||||
import selectors
|
||||
import signal
|
||||
import subprocess
|
||||
import time
|
||||
import urllib.error
|
||||
import urllib.parse
|
||||
import urllib.request
|
||||
from typing import Any, Dict, List, Optional, Tuple
|
||||
|
||||
|
||||
OPENCLAW_BIN = os.environ.get("AIOS_OPENCLAW_BIN", "openclaw")
|
||||
WECHAT_ACCOUNT_ID = os.environ.get("AIOS_WECHAT_ACCOUNT_ID", "")
|
||||
WECHAT_CHANNEL = os.environ.get("AIOS_WECHAT_CHANNEL", "")
|
||||
SEND_BACKEND = os.environ.get("AIOS_WECHAT_SEND_BACKEND", "")
|
||||
UCC_ADAPTER_URL = os.environ.get("AIOS_UCC_WECHAT_ADAPTER_URL", "http://127.0.0.1:18800")
|
||||
UCC_ADAPTER_TOKEN = os.environ.get("AIOS_UCC_WECHAT_ADAPTER_TOKEN") or os.environ.get(
|
||||
"AIOS_WECHAT_QR_ADAPTER_TOKEN", ""
|
||||
)
|
||||
UCC_SEND_PATH = os.environ.get("AIOS_UCC_WECHAT_SEND_PATH", "/api/internal/wechat/send")
|
||||
_allowed_origins = os.environ.get("AIOS_UCC_WECHAT_ALLOWED_ORIGINS", "").strip()
|
||||
UCC_ADAPTER_ALLOWED_ORIGINS = tuple(
|
||||
origin.strip() for origin in _allowed_origins.split(",") if origin.strip()
|
||||
) or (
|
||||
"http://127.0.0.1:18800",
|
||||
"http://[::1]:18800",
|
||||
)
|
||||
|
||||
MAX_TARGET_BYTES = 512
|
||||
MAX_CONTENT_BYTES = 32 * 1024
|
||||
MAX_IDENTIFIER_BYTES = 512
|
||||
MAX_METADATA_BYTES = 8 * 1024
|
||||
MAX_METADATA_DEPTH = 32
|
||||
MAX_METADATA_NODES = 1024
|
||||
MAX_RESPONSE_BYTES = 64 * 1024
|
||||
MAX_ENDPOINT_BYTES = 256
|
||||
_DEFAULT_TIMEOUT_SECONDS = 10
|
||||
_MAX_TIMEOUT_SECONDS = 30
|
||||
_LEGACY_SEND_PATH = "/internal/channels/wechat/send"
|
||||
_SAFE_PATH = re.compile(r"^/[A-Za-z0-9._~!$&'()*+,;=:@%/-]+$")
|
||||
_MAX_PATH_DECODE_ROUNDS = 4
|
||||
_OPENCLAW_TIMEOUT_RETURN_CODE = 124
|
||||
_OPENCLAW_OUTPUT_LIMIT_RETURN_CODE = 125
|
||||
_OPENCLAW_SPAWN_ERROR_RETURN_CODE = 126
|
||||
|
||||
|
||||
def _bounded_timeout(value: str) -> int:
|
||||
try:
|
||||
parsed = int(value)
|
||||
except (TypeError, ValueError):
|
||||
return _DEFAULT_TIMEOUT_SECONDS
|
||||
return min(max(parsed, 1), _MAX_TIMEOUT_SECONDS)
|
||||
|
||||
|
||||
REQUEST_TIMEOUT_SECONDS = _bounded_timeout(os.environ.get("AIOS_UCC_WECHAT_TIMEOUT_SECONDS", "10"))
|
||||
|
||||
|
||||
class BackendResult:
|
||||
def __init__(self, ok: bool, backend: str, status: str, data: Dict[str, Any]) -> None:
|
||||
self.ok = ok
|
||||
self.backend = backend
|
||||
self.status = status
|
||||
self.data = data
|
||||
|
||||
def to_dict(self) -> Dict[str, Any]:
|
||||
return {"ok": self.ok, "backend": self.backend, "status": self.status, **self.data}
|
||||
|
||||
|
||||
class _BackendProtocolError(Exception):
|
||||
"""Internal marker whose details must never cross the module boundary."""
|
||||
|
||||
|
||||
def _openclaw_base_args() -> List[str]:
|
||||
"""Return the OpenClaw 2026.6.11-compatible command prefix.
|
||||
|
||||
Gateway/auth global flags are not supported by the installed CLI and would
|
||||
also expose credentials through the process argument vector.
|
||||
"""
|
||||
|
||||
return [OPENCLAW_BIN]
|
||||
|
||||
|
||||
def _terminate_process_tree(process: Any) -> None:
|
||||
if os.name == "posix":
|
||||
try:
|
||||
os.killpg(process.pid, signal.SIGTERM)
|
||||
except OSError:
|
||||
pass
|
||||
try:
|
||||
process.wait(timeout=0.5)
|
||||
except (OSError, subprocess.TimeoutExpired):
|
||||
pass
|
||||
time.sleep(0.05)
|
||||
try:
|
||||
os.killpg(process.pid, signal.SIGKILL)
|
||||
except OSError:
|
||||
pass
|
||||
try:
|
||||
process.wait(timeout=0.5)
|
||||
except (OSError, subprocess.TimeoutExpired):
|
||||
pass
|
||||
return
|
||||
if process.poll() is not None:
|
||||
return
|
||||
try:
|
||||
process.terminate()
|
||||
process.wait(timeout=1)
|
||||
return
|
||||
except (OSError, subprocess.TimeoutExpired):
|
||||
pass
|
||||
try:
|
||||
process.kill()
|
||||
process.wait(timeout=1)
|
||||
except (OSError, subprocess.TimeoutExpired):
|
||||
pass
|
||||
|
||||
|
||||
def _run_openclaw(
|
||||
args: List[str], timeout: int = 15
|
||||
) -> subprocess.CompletedProcess[str]:
|
||||
bounded_timeout = min(max(int(timeout), 1), _MAX_TIMEOUT_SECONDS)
|
||||
popen_options: Dict[str, Any] = {
|
||||
"stdout": subprocess.PIPE,
|
||||
"stderr": subprocess.PIPE,
|
||||
}
|
||||
if os.name == "posix":
|
||||
popen_options["start_new_session"] = True
|
||||
elif hasattr(subprocess, "CREATE_NEW_PROCESS_GROUP"):
|
||||
popen_options["creationflags"] = subprocess.CREATE_NEW_PROCESS_GROUP
|
||||
try:
|
||||
process = subprocess.Popen(args, **popen_options)
|
||||
except (OSError, ValueError):
|
||||
return subprocess.CompletedProcess(args, _OPENCLAW_SPAWN_ERROR_RETURN_CODE, "", "")
|
||||
|
||||
selector = selectors.DefaultSelector()
|
||||
streams = {"stdout": process.stdout, "stderr": process.stderr}
|
||||
buffers = {"stdout": bytearray(), "stderr": bytearray()}
|
||||
try:
|
||||
for name, stream in streams.items():
|
||||
if stream is not None:
|
||||
selector.register(stream, selectors.EVENT_READ, name)
|
||||
except (OSError, ValueError):
|
||||
selector.close()
|
||||
_terminate_process_tree(process)
|
||||
for stream in streams.values():
|
||||
if stream is not None:
|
||||
stream.close()
|
||||
return subprocess.CompletedProcess(args, _OPENCLAW_SPAWN_ERROR_RETURN_CODE, "", "")
|
||||
|
||||
deadline = time.monotonic() + bounded_timeout
|
||||
total_bytes = 0
|
||||
return_code: Optional[int] = None
|
||||
try:
|
||||
while selector.get_map():
|
||||
remaining = deadline - time.monotonic()
|
||||
if remaining <= 0:
|
||||
return_code = _OPENCLAW_TIMEOUT_RETURN_CODE
|
||||
break
|
||||
events = selector.select(min(remaining, 0.1))
|
||||
for key, _mask in events:
|
||||
allowance = MAX_RESPONSE_BYTES - total_bytes
|
||||
try:
|
||||
chunk = os.read(key.fileobj.fileno(), min(8192, allowance + 1))
|
||||
except OSError:
|
||||
return_code = _OPENCLAW_SPAWN_ERROR_RETURN_CODE
|
||||
break
|
||||
if not chunk:
|
||||
selector.unregister(key.fileobj)
|
||||
key.fileobj.close()
|
||||
continue
|
||||
if len(chunk) > allowance:
|
||||
return_code = _OPENCLAW_OUTPUT_LIMIT_RETURN_CODE
|
||||
break
|
||||
buffers[key.data].extend(chunk)
|
||||
total_bytes += len(chunk)
|
||||
if return_code is not None:
|
||||
break
|
||||
finally:
|
||||
selector.close()
|
||||
|
||||
if return_code is not None:
|
||||
_terminate_process_tree(process)
|
||||
for stream in streams.values():
|
||||
if stream is not None and not stream.closed:
|
||||
stream.close()
|
||||
return subprocess.CompletedProcess(args, return_code, "", "")
|
||||
try:
|
||||
completed_return_code = process.wait(timeout=1)
|
||||
except subprocess.TimeoutExpired:
|
||||
_terminate_process_tree(process)
|
||||
return subprocess.CompletedProcess(args, _OPENCLAW_TIMEOUT_RETURN_CODE, "", "")
|
||||
stdout = buffers["stdout"].decode("utf-8", errors="replace")
|
||||
stderr = buffers["stderr"].decode("utf-8", errors="replace")
|
||||
return subprocess.CompletedProcess(args, completed_return_code, stdout, stderr)
|
||||
|
||||
|
||||
def _json_dict(text: str) -> Dict[str, Any]:
|
||||
try:
|
||||
value = json.loads(text or "{}")
|
||||
except (RecursionError, TypeError, ValueError, json.JSONDecodeError):
|
||||
return {}
|
||||
return value if isinstance(value, dict) else {}
|
||||
|
||||
|
||||
def discover_openclaw_wechat_channel() -> Optional[str]:
|
||||
"""Discover an explicitly typed WeChat/Weixin channel for diagnostics."""
|
||||
|
||||
if WECHAT_CHANNEL:
|
||||
return WECHAT_CHANNEL
|
||||
try:
|
||||
proc = _run_openclaw(_openclaw_base_args() + ["channels", "list", "--json"], timeout=15)
|
||||
except (OSError, subprocess.SubprocessError, ValueError):
|
||||
return None
|
||||
if proc.returncode != 0:
|
||||
return None
|
||||
data = _json_dict(proc.stdout[:MAX_RESPONSE_BYTES])
|
||||
candidates: List[str] = []
|
||||
|
||||
def walk(value: Any) -> None:
|
||||
if isinstance(value, dict):
|
||||
name = value.get("name") or value.get("channel") or value.get("id")
|
||||
kind = value.get("type") or value.get("kind")
|
||||
if isinstance(name, str) and isinstance(kind, str):
|
||||
label = f"{name} {kind}".lower()
|
||||
if "wechat" in label or "weixin" in label:
|
||||
candidates.append(name)
|
||||
for child in value.values():
|
||||
walk(child)
|
||||
elif isinstance(value, list):
|
||||
for child in value:
|
||||
walk(child)
|
||||
|
||||
walk(data)
|
||||
return candidates[0] if candidates else None
|
||||
|
||||
|
||||
def _auth_headers() -> Dict[str, str]:
|
||||
headers = {"Content-Type": "application/json", "Accept": "application/json"}
|
||||
if UCC_ADAPTER_TOKEN:
|
||||
headers["Authorization"] = "Bearer " + UCC_ADAPTER_TOKEN
|
||||
return headers
|
||||
|
||||
|
||||
def _safe_path(value: Any) -> Optional[str]:
|
||||
if not isinstance(value, str):
|
||||
return None
|
||||
path = value if value.startswith("/") else "/" + value
|
||||
try:
|
||||
encoded_path = path.encode("utf-8")
|
||||
except UnicodeEncodeError:
|
||||
return None
|
||||
if len(encoded_path) > MAX_ENDPOINT_BYTES:
|
||||
return None
|
||||
if not _SAFE_PATH.fullmatch(path):
|
||||
return None
|
||||
decoded = path
|
||||
for _ in range(_MAX_PATH_DECODE_ROUNDS):
|
||||
try:
|
||||
next_decoded = urllib.parse.unquote_to_bytes(decoded).decode("utf-8")
|
||||
except UnicodeDecodeError:
|
||||
return None
|
||||
if next_decoded == decoded:
|
||||
break
|
||||
decoded = next_decoded
|
||||
if "%" in decoded or "\\" in decoded or "\x00" in decoded:
|
||||
return None
|
||||
if not _SAFE_PATH.fullmatch(decoded):
|
||||
return None
|
||||
if any(segment in {".", ".."} for segment in decoded.split("/")):
|
||||
return None
|
||||
return path
|
||||
|
||||
|
||||
def _unique_paths(paths: List[str]) -> List[str]:
|
||||
out: List[str] = []
|
||||
for candidate in paths:
|
||||
path = _safe_path(candidate)
|
||||
if path and path not in out:
|
||||
out.append(path)
|
||||
if len(out) == 2:
|
||||
break
|
||||
return out
|
||||
|
||||
|
||||
def _ucc_send_paths() -> List[str]:
|
||||
canonical = _safe_path(UCC_SEND_PATH) or "/api/internal/wechat/send"
|
||||
return _unique_paths([canonical, _LEGACY_SEND_PATH])
|
||||
|
||||
|
||||
def _canonical_origin(value: Any) -> Optional[str]:
|
||||
if not isinstance(value, str) or not value or len(value) > 2048:
|
||||
return None
|
||||
if "\\" in value or any(ord(character) < 32 for character in value):
|
||||
return None
|
||||
try:
|
||||
parsed = urllib.parse.urlsplit(value)
|
||||
port = parsed.port
|
||||
except (UnicodeError, ValueError):
|
||||
return None
|
||||
scheme = parsed.scheme.lower()
|
||||
if scheme not in {"http", "https"} or not parsed.hostname:
|
||||
return None
|
||||
if parsed.username or parsed.password or parsed.query or parsed.fragment or parsed.path not in {"", "/"}:
|
||||
return None
|
||||
try:
|
||||
host = parsed.hostname.rstrip(".").encode("idna").decode("ascii").lower()
|
||||
except UnicodeError:
|
||||
return None
|
||||
if not host:
|
||||
return None
|
||||
if port is None:
|
||||
port = 80 if scheme == "http" else 443
|
||||
rendered_host = f"[{host}]" if ":" in host else host
|
||||
return f"{scheme}://{rendered_host}:{port}"
|
||||
|
||||
|
||||
def _adapter_base_url() -> Optional[str]:
|
||||
origin = _canonical_origin(UCC_ADAPTER_URL)
|
||||
allowed = {
|
||||
canonical
|
||||
for canonical in (_canonical_origin(value) for value in UCC_ADAPTER_ALLOWED_ORIGINS)
|
||||
if canonical
|
||||
}
|
||||
return origin if origin and origin in allowed else None
|
||||
|
||||
|
||||
class _NoRedirectHandler(urllib.request.HTTPRedirectHandler):
|
||||
def redirect_request(
|
||||
self,
|
||||
req: Any,
|
||||
fp: Any,
|
||||
code: int,
|
||||
msg: str,
|
||||
headers: Any,
|
||||
newurl: str,
|
||||
) -> None:
|
||||
del req, fp, code, msg, headers, newurl
|
||||
return None
|
||||
|
||||
|
||||
def _open_no_redirect(request: urllib.request.Request, timeout: int) -> Any:
|
||||
opener = urllib.request.build_opener(_NoRedirectHandler())
|
||||
return opener.open(request, timeout=timeout)
|
||||
|
||||
|
||||
def ucc_adapter_alive() -> bool:
|
||||
base_url = _adapter_base_url()
|
||||
if not base_url:
|
||||
return False
|
||||
request = urllib.request.Request(
|
||||
base_url + "/health", headers=_auth_headers(), method="GET"
|
||||
)
|
||||
try:
|
||||
with _open_no_redirect(request, timeout=min(5, REQUEST_TIMEOUT_SECONDS)) as response:
|
||||
return 200 <= int(response.status) < 300
|
||||
except (OSError, ValueError, urllib.error.URLError):
|
||||
return False
|
||||
|
||||
|
||||
def select_backend() -> Dict[str, Any]:
|
||||
explicit = SEND_BACKEND.strip().lower()
|
||||
if explicit:
|
||||
if explicit == "ucc-adapter":
|
||||
return {"backend": "ucc-adapter", "reason": "explicit"}
|
||||
return {"backend": "unavailable", "reason": "unsupported_backend"}
|
||||
if ucc_adapter_alive():
|
||||
return {"backend": "ucc-adapter", "reason": "ucc_adapter_alive"}
|
||||
return {"backend": "unavailable", "reason": "ucc_adapter_unavailable"}
|
||||
|
||||
|
||||
def _post_ucc(path: str, payload: Dict[str, Any]) -> Tuple[int, Dict[str, Any]]:
|
||||
base_url = _adapter_base_url()
|
||||
safe_path = _safe_path(path)
|
||||
if not base_url or not safe_path:
|
||||
raise _BackendProtocolError("invalid adapter endpoint")
|
||||
try:
|
||||
body = json.dumps(payload, ensure_ascii=False, separators=(",", ":")).encode("utf-8")
|
||||
except (TypeError, ValueError) as exc:
|
||||
raise _BackendProtocolError("invalid request payload") from exc
|
||||
request = urllib.request.Request(
|
||||
base_url + safe_path,
|
||||
data=body,
|
||||
headers=_auth_headers(),
|
||||
method="POST",
|
||||
)
|
||||
with _open_no_redirect(request, timeout=REQUEST_TIMEOUT_SECONDS) as response:
|
||||
raw = response.read(MAX_RESPONSE_BYTES + 1)
|
||||
if len(raw) > MAX_RESPONSE_BYTES:
|
||||
raise _BackendProtocolError("adapter response too large")
|
||||
try:
|
||||
text = raw.decode("utf-8")
|
||||
except UnicodeDecodeError as exc:
|
||||
raise _BackendProtocolError("adapter response encoding invalid") from exc
|
||||
data = _json_dict(text)
|
||||
if not data:
|
||||
raise _BackendProtocolError("adapter response invalid")
|
||||
return int(response.status), data
|
||||
|
||||
|
||||
def _ucc_response_sent(data: Dict[str, Any]) -> bool:
|
||||
return isinstance(data, dict) and data.get("ok") is True and data.get("status") == "sent"
|
||||
|
||||
|
||||
def _ucc_result_is_ok(data: Dict[str, Any], dry_run: bool = False) -> bool:
|
||||
expected_status = "dry_run" if dry_run else "sent"
|
||||
return isinstance(data, dict) and data.get("ok") is True and data.get("status") == expected_status
|
||||
|
||||
|
||||
def _utf8_size(value: str) -> Optional[int]:
|
||||
try:
|
||||
return len(value.encode("utf-8"))
|
||||
except UnicodeEncodeError:
|
||||
return None
|
||||
|
||||
|
||||
def _valid_identifier(value: Any, required: bool = False) -> bool:
|
||||
if not isinstance(value, str):
|
||||
return False
|
||||
if required and not value.strip():
|
||||
return False
|
||||
if not value:
|
||||
return not required
|
||||
if len(value) > MAX_IDENTIFIER_BYTES:
|
||||
return False
|
||||
size = _utf8_size(value)
|
||||
return size is not None and size <= MAX_IDENTIFIER_BYTES and not any(
|
||||
ord(character) < 32 or ord(character) == 127 for character in value
|
||||
)
|
||||
|
||||
|
||||
def _validate_metadata(metadata: Any) -> Optional[str]:
|
||||
if not isinstance(metadata, dict):
|
||||
return "invalid_input"
|
||||
nodes = 0
|
||||
stack: List[Tuple[Any, int]] = [(metadata, 0)]
|
||||
while stack:
|
||||
value, depth = stack.pop()
|
||||
nodes += 1
|
||||
if depth > MAX_METADATA_DEPTH or nodes > MAX_METADATA_NODES:
|
||||
return "input_too_large"
|
||||
if isinstance(value, dict):
|
||||
if len(value) + nodes + len(stack) > MAX_METADATA_NODES:
|
||||
return "input_too_large"
|
||||
for key, child in value.items():
|
||||
if (
|
||||
not isinstance(key, str)
|
||||
or len(key) > MAX_METADATA_BYTES
|
||||
or _utf8_size(key) is None
|
||||
):
|
||||
return "invalid_input"
|
||||
stack.append((child, depth + 1))
|
||||
elif isinstance(value, list):
|
||||
if len(value) + nodes + len(stack) > MAX_METADATA_NODES:
|
||||
return "input_too_large"
|
||||
stack.extend((child, depth + 1) for child in value)
|
||||
elif isinstance(value, str):
|
||||
if len(value) > MAX_METADATA_BYTES:
|
||||
return "input_too_large"
|
||||
if _utf8_size(value) is None:
|
||||
return "invalid_input"
|
||||
elif value is not None and not isinstance(value, (bool, int, float)):
|
||||
return "invalid_input"
|
||||
try:
|
||||
encoded = json.dumps(
|
||||
metadata,
|
||||
ensure_ascii=False,
|
||||
allow_nan=False,
|
||||
separators=(",", ":"),
|
||||
).encode("utf-8")
|
||||
except (RecursionError, TypeError, UnicodeEncodeError, ValueError):
|
||||
return "invalid_input"
|
||||
return "input_too_large" if len(encoded) > MAX_METADATA_BYTES else None
|
||||
|
||||
|
||||
def _validate_payload(
|
||||
target: Any,
|
||||
content: Any,
|
||||
account_id: Any,
|
||||
message_id: Any,
|
||||
metadata: Any,
|
||||
dry_run: Any,
|
||||
) -> Optional[str]:
|
||||
if not isinstance(target, str) or not isinstance(content, str):
|
||||
return "invalid_input"
|
||||
if not target.strip() or not content.strip() or not isinstance(dry_run, bool):
|
||||
return "invalid_input"
|
||||
if any(ord(character) < 32 or ord(character) == 127 for character in target):
|
||||
return "invalid_input"
|
||||
if "\x00" in content or not _valid_identifier(account_id) or not _valid_identifier(message_id):
|
||||
return "invalid_input"
|
||||
if len(target) > MAX_TARGET_BYTES or len(content) > MAX_CONTENT_BYTES:
|
||||
return "input_too_large"
|
||||
target_size = _utf8_size(target)
|
||||
content_size = _utf8_size(content)
|
||||
if target_size is None or content_size is None:
|
||||
return "invalid_input"
|
||||
if target_size > MAX_TARGET_BYTES or content_size > MAX_CONTENT_BYTES:
|
||||
return "input_too_large"
|
||||
return _validate_metadata(metadata)
|
||||
|
||||
|
||||
def _safe_provider_message_id(value: Any) -> Optional[str]:
|
||||
if not isinstance(value, str) or not value:
|
||||
return None
|
||||
if len(value) > MAX_IDENTIFIER_BYTES:
|
||||
return None
|
||||
size = _utf8_size(value)
|
||||
if size is None or size > MAX_IDENTIFIER_BYTES:
|
||||
return None
|
||||
if any(ord(character) < 32 or ord(character) == 127 for character in value):
|
||||
return None
|
||||
return value
|
||||
|
||||
|
||||
def send_ucc_adapter(
|
||||
target: str,
|
||||
content: str,
|
||||
account_id: str = "",
|
||||
message_id: str = "",
|
||||
metadata: Optional[Dict[str, Any]] = None,
|
||||
dry_run: bool = False,
|
||||
) -> BackendResult:
|
||||
effective_account = account_id or WECHAT_ACCOUNT_ID
|
||||
effective_metadata: Any = {} if metadata is None else metadata
|
||||
error_code = _validate_payload(
|
||||
target,
|
||||
content,
|
||||
effective_account,
|
||||
message_id,
|
||||
effective_metadata,
|
||||
dry_run,
|
||||
)
|
||||
if error_code:
|
||||
return BackendResult(False, "ucc-adapter", "failed", {"code": error_code})
|
||||
|
||||
payload = {
|
||||
"target": target,
|
||||
"content": content,
|
||||
"account_id": effective_account,
|
||||
"message_id": message_id,
|
||||
"metadata": effective_metadata,
|
||||
"dry_run": dry_run,
|
||||
}
|
||||
last_endpoint: Optional[str] = None
|
||||
for path in _ucc_send_paths():
|
||||
last_endpoint = path
|
||||
try:
|
||||
http_status, data = _post_ucc(path, payload)
|
||||
except urllib.error.HTTPError as exc:
|
||||
if exc.code in {404, 405}:
|
||||
continue
|
||||
return BackendResult(
|
||||
False,
|
||||
"ucc-adapter",
|
||||
"failed",
|
||||
{"code": "ucc_adapter_http_error", "http_status": int(exc.code), "endpoint": path},
|
||||
)
|
||||
except (OSError, ValueError, urllib.error.URLError, _BackendProtocolError):
|
||||
return BackendResult(
|
||||
False,
|
||||
"ucc-adapter",
|
||||
"failed",
|
||||
{"code": "ucc_adapter_unavailable", "endpoint": path},
|
||||
)
|
||||
except Exception:
|
||||
# Fail closed without returning exception text, type, or chained cause.
|
||||
return BackendResult(
|
||||
False,
|
||||
"ucc-adapter",
|
||||
"failed",
|
||||
{"code": "ucc_adapter_unavailable", "endpoint": path},
|
||||
)
|
||||
|
||||
if not (200 <= http_status < 300):
|
||||
return BackendResult(
|
||||
False,
|
||||
"ucc-adapter",
|
||||
"failed",
|
||||
{"code": "ucc_adapter_http_error", "http_status": http_status, "endpoint": path},
|
||||
)
|
||||
if not _ucc_result_is_ok(data, dry_run):
|
||||
return BackendResult(
|
||||
False,
|
||||
"ucc-adapter",
|
||||
"failed",
|
||||
{"code": "ucc_adapter_rejected", "http_status": http_status, "endpoint": path},
|
||||
)
|
||||
confirmed_status = "dry_run" if dry_run else "sent"
|
||||
result_data: Dict[str, Any] = {
|
||||
"code": confirmed_status,
|
||||
"http_status": http_status,
|
||||
"endpoint": path,
|
||||
}
|
||||
provider_message_id = _safe_provider_message_id(data.get("provider_message_id"))
|
||||
if provider_message_id:
|
||||
result_data["provider_message_id"] = provider_message_id
|
||||
return BackendResult(True, "ucc-adapter", confirmed_status, result_data)
|
||||
|
||||
data: Dict[str, Any] = {"code": "ucc_adapter_unavailable"}
|
||||
if last_endpoint:
|
||||
data["endpoint"] = last_endpoint
|
||||
return BackendResult(False, "ucc-adapter", "failed", data)
|
||||
|
||||
|
||||
def send_openclaw_channel(
|
||||
target: str,
|
||||
content: str,
|
||||
account_id: str = "",
|
||||
message_id: str = "",
|
||||
metadata: Optional[Dict[str, Any]] = None,
|
||||
dry_run: bool = False,
|
||||
) -> BackendResult:
|
||||
del target, content, account_id, message_id, metadata, dry_run
|
||||
return BackendResult(
|
||||
False,
|
||||
"openclaw-channel",
|
||||
"failed",
|
||||
{"code": "unsupported_backend"},
|
||||
)
|
||||
|
||||
|
||||
def send_message(
|
||||
target: str,
|
||||
content: str,
|
||||
account_id: str = "",
|
||||
message_id: str = "",
|
||||
metadata: Optional[Dict[str, Any]] = None,
|
||||
dry_run: bool = False,
|
||||
) -> Dict[str, Any]:
|
||||
selected = select_backend()
|
||||
if selected.get("backend") == "ucc-adapter":
|
||||
return send_ucc_adapter(
|
||||
target, content, account_id, message_id, metadata, dry_run
|
||||
).to_dict()
|
||||
code = "unsupported_backend" if selected.get("reason") == "unsupported_backend" else "wechat_outbound_backend_unavailable"
|
||||
return BackendResult(False, "unavailable", "failed", {"code": code}).to_dict()
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
print(json.dumps(select_backend(), ensure_ascii=False, separators=(",", ":")))
|
||||
@@ -1,4 +0,0 @@
|
||||
Copyright (c) 2026 AIOS. All rights reserved.
|
||||
|
||||
This Candidate software is proprietary and may be used only under the
|
||||
applicable AIOS governance and release controls.
|
||||
@@ -1,18 +0,0 @@
|
||||
# AIOS Autonomous Release Candidate
|
||||
|
||||
This package implements the task-bound, fail-closed control plane used to
|
||||
validate AIOS autonomous-release workflows. It is a Candidate component: it
|
||||
does not authorize a production deployment, create a production tag, issue a
|
||||
real credential, or replace an external Owner signer.
|
||||
|
||||
The service binds to loopback by default. Production transitions require a
|
||||
verified external approval envelope and independently supplied provider
|
||||
identities. Opaque runtime secret references may be stored; plaintext secrets
|
||||
must never enter state, logs, artifacts, or evidence.
|
||||
|
||||
Run the isolated suite from the repository root:
|
||||
|
||||
```text
|
||||
python -m pytest tests/autonomous_release
|
||||
python -m compileall services/aios-autonomous-release-candidate
|
||||
```
|
||||
@@ -1 +0,0 @@
|
||||
"""Dormant AIOS autonomous release Candidate package."""
|
||||
-30
@@ -1,30 +0,0 @@
|
||||
"""AIOS autonomous release candidate package.
|
||||
|
||||
Candidate-only orchestration primitives. Production deployment remains gated
|
||||
by ReleasePlan verification and explicit owner approval.
|
||||
"""
|
||||
|
||||
from .models import * # noqa: F401,F403
|
||||
from .planner import DeterministicPlanner, PlanningRequest
|
||||
from .orchestrator import AutonomousReleaseOrchestrator
|
||||
from .release import ReleaseController
|
||||
from .credential import CredentialBroker
|
||||
from .evidence import EvidenceChain
|
||||
from .execution_manager import ExecutionManager
|
||||
from .gitea_canary import GiteaDeployKeyCanary
|
||||
from .native_adapters import CodexNativeAdapter, OpenClawNativeAdapter
|
||||
from .secret_manager import SecretManagerV2
|
||||
|
||||
__all__ = [
|
||||
"DeterministicPlanner",
|
||||
"PlanningRequest",
|
||||
"AutonomousReleaseOrchestrator",
|
||||
"ReleaseController",
|
||||
"CredentialBroker",
|
||||
"EvidenceChain",
|
||||
"ExecutionManager",
|
||||
"GiteaDeployKeyCanary",
|
||||
"OpenClawNativeAdapter",
|
||||
"CodexNativeAdapter",
|
||||
"SecretManagerV2",
|
||||
]
|
||||
-65
@@ -1,65 +0,0 @@
|
||||
"""Provider adapter contracts for OpenClaw, Codex and writer workers."""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
from dataclasses import dataclass
|
||||
from enum import Enum
|
||||
from typing import Protocol, Mapping, Any
|
||||
|
||||
|
||||
class AdapterState(str, Enum):
|
||||
CREATED = "CREATED"
|
||||
ACTIVE = "ACTIVE"
|
||||
CLOSED = "CLOSED"
|
||||
FAILED = "FAILED"
|
||||
|
||||
|
||||
@dataclass(frozen=True, slots=True)
|
||||
class AdapterSession:
|
||||
provider: str
|
||||
session_id: str
|
||||
provider_session_id: str
|
||||
state: AdapterState
|
||||
|
||||
|
||||
class AgentAdapter(Protocol):
|
||||
"""Common lifecycle contract for external agent providers."""
|
||||
|
||||
def create_session(self, task: Mapping[str, Any]) -> AdapterSession:
|
||||
"""Create a provider-native session."""
|
||||
|
||||
def send(self, session: AdapterSession, payload: Mapping[str, Any]) -> Mapping[str, Any]:
|
||||
"""Send a task payload."""
|
||||
|
||||
def close(self, session: AdapterSession) -> None:
|
||||
"""Close and revoke the session."""
|
||||
|
||||
|
||||
class ShadowAdapter:
|
||||
"""Safe adapter used only for candidate lifecycle testing."""
|
||||
|
||||
def __init__(self, provider: str) -> None:
|
||||
self.provider = provider
|
||||
self._counter = 0
|
||||
|
||||
def create_session(self, task: Mapping[str, Any]) -> AdapterSession:
|
||||
self._counter += 1
|
||||
return AdapterSession(
|
||||
provider=self.provider,
|
||||
session_id=f"shadow-{self._counter}",
|
||||
provider_session_id=f"provider-{self._counter}",
|
||||
state=AdapterState.ACTIVE,
|
||||
)
|
||||
|
||||
def send(self, session: AdapterSession, payload: Mapping[str, Any]) -> Mapping[str, Any]:
|
||||
if session.state != AdapterState.ACTIVE:
|
||||
raise RuntimeError("session is not active")
|
||||
return {
|
||||
"provider": self.provider,
|
||||
"session_id": session.session_id,
|
||||
"result": "shadow-completed",
|
||||
"side_effects": False,
|
||||
}
|
||||
|
||||
def close(self, session: AdapterSession) -> None:
|
||||
return None
|
||||
@@ -1,173 +0,0 @@
|
||||
"""Dependency-light candidate API facade.
|
||||
|
||||
The production transport is intentionally external. This module exposes the
|
||||
application boundary without opening listeners or changing production routes.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
from typing import Any, Mapping
|
||||
|
||||
from .evidence import EvidenceChain
|
||||
from .orchestrator import AutonomousReleaseOrchestrator
|
||||
from .release import ReleaseController
|
||||
from .serialization import (
|
||||
release_plan_from_mapping,
|
||||
release_plan_to_mapping,
|
||||
task_plan_from_mapping,
|
||||
task_plan_to_mapping,
|
||||
)
|
||||
|
||||
|
||||
class AutonomousReleaseAPI:
|
||||
def __init__(self, orchestrator: AutonomousReleaseOrchestrator) -> None:
|
||||
self.orchestrator = orchestrator
|
||||
self.release = ReleaseController()
|
||||
|
||||
def _chain(self, task_id: str) -> EvidenceChain:
|
||||
return EvidenceChain(self.orchestrator.workflow.store, task_id)
|
||||
|
||||
def create_task(self, payload: Mapping[str, Any]) -> dict[str, Any]:
|
||||
plan = task_plan_from_mapping(payload)
|
||||
result = self.orchestrator.create(plan)
|
||||
self.orchestrator.workflow.next_steps(plan)
|
||||
return {
|
||||
"task_id": result.task_id,
|
||||
"plan_digest": result.plan_digest,
|
||||
"production_side_effects": result.production_side_effects,
|
||||
"plan": task_plan_to_mapping(plan),
|
||||
}
|
||||
|
||||
def close_evidence(self, task_id: str) -> dict[str, Any]:
|
||||
result = self._chain(task_id).closure_digest()
|
||||
return {
|
||||
"task_id": task_id,
|
||||
"evidence_closure": result,
|
||||
"production_side_effects": False,
|
||||
"secrets_included": False,
|
||||
}
|
||||
|
||||
def task_steps(self, task_id: str) -> dict[str, Any]:
|
||||
status = self.task_status(task_id)
|
||||
return {
|
||||
"task_id": task_id,
|
||||
"steps": status["steps"],
|
||||
"production_side_effects": False,
|
||||
"secrets_included": False,
|
||||
}
|
||||
|
||||
def claim(self, task_id: str, payload: Mapping[str, Any]) -> dict[str, Any]:
|
||||
step_id = str(payload["step_id"])
|
||||
worker_id = str(payload["worker_id"])
|
||||
session_id = str(payload["session_id"])
|
||||
workflow = self.orchestrator.workflow
|
||||
workflow.claim(task_id, step_id, worker_id, session_id)
|
||||
workflow.start(task_id, step_id, worker_id, session_id)
|
||||
self._chain(task_id).append(
|
||||
"STEP_CLAIMED",
|
||||
task_id,
|
||||
{
|
||||
"step_id": step_id,
|
||||
"worker_id": worker_id,
|
||||
"session_id": session_id,
|
||||
"secrets_included": False,
|
||||
},
|
||||
)
|
||||
return {
|
||||
"task_id": task_id,
|
||||
"step_id": step_id,
|
||||
"state": "RUNNING",
|
||||
"production_side_effects": False,
|
||||
"secrets_included": False,
|
||||
}
|
||||
|
||||
def heartbeat(self, task_id: str, payload: Mapping[str, Any]) -> dict[str, Any]:
|
||||
step_id = str(payload["step_id"])
|
||||
worker_id = str(payload["worker_id"])
|
||||
session_id = str(payload["session_id"])
|
||||
self.orchestrator.workflow.heartbeat(task_id, step_id, worker_id, session_id)
|
||||
return {
|
||||
"task_id": task_id,
|
||||
"step_id": step_id,
|
||||
"state": "RUNNING",
|
||||
"production_side_effects": False,
|
||||
"secrets_included": False,
|
||||
}
|
||||
|
||||
def result(self, task_id: str, payload: Mapping[str, Any]) -> dict[str, Any]:
|
||||
step_id = str(payload["step_id"])
|
||||
result_digest = str(payload["result_digest"])
|
||||
self.orchestrator.workflow.complete(task_id, step_id, result_digest=result_digest)
|
||||
self._chain(task_id).append(
|
||||
"STEP_RESULT",
|
||||
task_id,
|
||||
{
|
||||
"step_id": step_id,
|
||||
"result_digest": result_digest,
|
||||
"secrets_included": False,
|
||||
},
|
||||
)
|
||||
return {
|
||||
"task_id": task_id,
|
||||
"step_id": step_id,
|
||||
"state": "COMPLETED",
|
||||
"production_side_effects": False,
|
||||
"secrets_included": False,
|
||||
}
|
||||
|
||||
def evidence(self, task_id: str) -> dict[str, Any]:
|
||||
chain = self._chain(task_id)
|
||||
return {
|
||||
"task_id": task_id,
|
||||
"events": chain.export(),
|
||||
"verified": chain.verify(),
|
||||
"production_side_effects": False,
|
||||
"secrets_included": False,
|
||||
}
|
||||
|
||||
def create_release_plan(self, payload: Mapping[str, Any]) -> dict[str, Any]:
|
||||
plan = release_plan_from_mapping(payload)
|
||||
self.release = ReleaseController()
|
||||
self.release.attach_plan(plan)
|
||||
self.release.mark_built()
|
||||
return {
|
||||
"plan": release_plan_to_mapping(plan),
|
||||
"release_state": self.release.status().state.value,
|
||||
"production_side_effects": False,
|
||||
"secrets_included": False,
|
||||
}
|
||||
|
||||
def verify_release(self, payload: Mapping[str, Any]) -> dict[str, Any]:
|
||||
self.release.verify(
|
||||
artifact_ok=payload.get("artifact_ok") is True,
|
||||
evidence_ok=payload.get("evidence_ok") is True,
|
||||
)
|
||||
self.release.request_owner_approval()
|
||||
return {
|
||||
"release_state": self.release.status().state.value,
|
||||
"production_release": "BLOCKED_EXTERNAL_OWNER_SIGNATURE",
|
||||
"production_side_effects": False,
|
||||
"secrets_included": False,
|
||||
}
|
||||
|
||||
def task_status(self, task_id: str) -> dict[str, Any]:
|
||||
store = self.orchestrator.workflow.store
|
||||
state, revision = store.get_task_state(task_id)
|
||||
steps = store.list_steps(task_id)
|
||||
return {
|
||||
"task_id": task_id,
|
||||
"state": state.value,
|
||||
"revision": revision,
|
||||
"steps": {
|
||||
step_id: {
|
||||
"state": item.state.value,
|
||||
"attempt": item.attempt,
|
||||
"max_attempts": item.max_attempts,
|
||||
"worker_id": item.worker_id,
|
||||
"session_id": item.session_id,
|
||||
}
|
||||
for step_id, item in steps.items()
|
||||
},
|
||||
"production_side_effects": False,
|
||||
"secrets_included": False,
|
||||
}
|
||||
-116
@@ -1,116 +0,0 @@
|
||||
"""Owner approval verification contracts for candidate releases."""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
from dataclasses import dataclass
|
||||
from datetime import datetime, timezone
|
||||
from typing import Protocol
|
||||
|
||||
from .errors import ApprovalRequired, StateConflict
|
||||
from .models import ApprovalEnvelope, TaskPlan, canonical_json
|
||||
from .store import StateStore
|
||||
|
||||
|
||||
class SignatureVerifier(Protocol):
|
||||
"""Verify an approval payload without exposing private-key operations."""
|
||||
|
||||
def verify(self, key_id: str, payload: bytes, signature: str) -> bool:
|
||||
"""Return ``True`` when the signature is valid for ``key_id``."""
|
||||
|
||||
|
||||
class RevocationSource(Protocol):
|
||||
def is_revoked(self, approval_plan_id: str) -> bool:
|
||||
"""Return whether an approval plan has been revoked."""
|
||||
|
||||
|
||||
@dataclass(frozen=True, slots=True)
|
||||
class ApprovalVerificationResult:
|
||||
approval_plan_id: str
|
||||
task_id: str
|
||||
signing_key_id: str
|
||||
verified_at: datetime
|
||||
|
||||
|
||||
class ApprovalVerifier:
|
||||
"""Verify exact approval bindings and consume nonces before execution."""
|
||||
|
||||
def __init__(
|
||||
self,
|
||||
store: StateStore,
|
||||
signature_verifier: SignatureVerifier,
|
||||
revocations: RevocationSource,
|
||||
) -> None:
|
||||
self.store = store
|
||||
self.signature_verifier = signature_verifier
|
||||
self.revocations = revocations
|
||||
|
||||
def verify(
|
||||
self,
|
||||
plan: TaskPlan,
|
||||
envelope: ApprovalEnvelope,
|
||||
*,
|
||||
now: datetime | None = None,
|
||||
) -> ApprovalVerificationResult:
|
||||
now = now or datetime.now(timezone.utc)
|
||||
if envelope.task_id != plan.task_id:
|
||||
raise ApprovalRequired("APPROVAL_TASK_MISMATCH", "approval task does not match plan")
|
||||
if envelope.task_plan_sha256 != plan.digest():
|
||||
raise ApprovalRequired("APPROVAL_PLAN_DIGEST_MISMATCH", "approval digest does not match plan")
|
||||
if envelope.binding != plan.binding:
|
||||
raise ApprovalRequired("APPROVAL_RESOURCE_MISMATCH", "approval resource binding does not match plan")
|
||||
approved = set(envelope.capabilities)
|
||||
required = {cap for step in plan.steps for cap in step.required_capabilities}
|
||||
if not required.issubset(approved):
|
||||
raise ApprovalRequired(
|
||||
"APPROVAL_CAPABILITY_INSUFFICIENT",
|
||||
"approval does not cover all plan capabilities",
|
||||
{"missing": sorted(required - approved)},
|
||||
)
|
||||
if now < envelope.not_before or now >= envelope.expires_at:
|
||||
raise ApprovalRequired("APPROVAL_TIME_INVALID", "approval is outside its validity window")
|
||||
if self.revocations.is_revoked(envelope.approval_plan_id):
|
||||
raise ApprovalRequired("APPROVAL_REVOKED", "approval plan is revoked")
|
||||
payload = canonical_json(envelope.payload()).encode("utf-8")
|
||||
try:
|
||||
signature_valid = self.signature_verifier.verify(
|
||||
envelope.signing_key_id, payload, envelope.signature
|
||||
)
|
||||
except Exception as error:
|
||||
raise ApprovalRequired(
|
||||
"BLOCKED_OWNER_APPROVAL_VERIFIER_UNAVAILABLE",
|
||||
"trusted Owner approval verifier is unavailable",
|
||||
) from error
|
||||
if not signature_valid:
|
||||
raise ApprovalRequired("APPROVAL_SIGNATURE_INVALID", "approval signature verification failed")
|
||||
try:
|
||||
self.store.consume_nonce(f"approval:{envelope.approval_plan_id}", envelope.nonce)
|
||||
except StateConflict as error:
|
||||
raise ApprovalRequired("APPROVAL_NONCE_REPLAY", "approval nonce was already consumed") from error
|
||||
return ApprovalVerificationResult(
|
||||
approval_plan_id=envelope.approval_plan_id,
|
||||
task_id=envelope.task_id,
|
||||
signing_key_id=envelope.signing_key_id,
|
||||
verified_at=now,
|
||||
)
|
||||
|
||||
|
||||
class StaticRevocationSource:
|
||||
def __init__(self, revoked: set[str] | None = None) -> None:
|
||||
self.revoked = set(revoked or ())
|
||||
|
||||
def is_revoked(self, approval_plan_id: str) -> bool:
|
||||
return approval_plan_id in self.revoked
|
||||
|
||||
|
||||
class RejectingSignatureVerifier:
|
||||
"""Safe default used when no external verifier has been configured."""
|
||||
|
||||
def verify(self, key_id: str, payload: bytes, signature: str) -> bool:
|
||||
return False
|
||||
|
||||
|
||||
class UnavailableSignatureVerifier:
|
||||
"""Safe runtime default when no Owner HSM/KMS verifier has been supplied."""
|
||||
|
||||
def verify(self, key_id: str, payload: bytes, signature: str) -> bool:
|
||||
raise ConnectionError("Owner verifier unavailable")
|
||||
-225
@@ -1,225 +0,0 @@
|
||||
"""Deterministic Candidate artifact and package-closure construction."""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
from dataclasses import dataclass
|
||||
import hashlib
|
||||
import io
|
||||
import json
|
||||
import os
|
||||
from pathlib import Path, PurePosixPath
|
||||
import stat
|
||||
import tarfile
|
||||
from typing import Mapping
|
||||
|
||||
from .errors import EvidenceIncomplete, ReleaseBlocked
|
||||
from .models import is_git_oid
|
||||
|
||||
|
||||
def sha256_bytes(value: bytes) -> str:
|
||||
return hashlib.sha256(value).hexdigest()
|
||||
|
||||
|
||||
@dataclass(frozen=True, slots=True)
|
||||
class ArtifactFile:
|
||||
path: str
|
||||
content: bytes
|
||||
mode: int = 0o644
|
||||
|
||||
def __post_init__(self) -> None:
|
||||
parsed = PurePosixPath(self.path)
|
||||
if (
|
||||
parsed.is_absolute()
|
||||
or ".." in parsed.parts
|
||||
or not self.path
|
||||
or "\\" in self.path
|
||||
or self.path != self.path.strip()
|
||||
):
|
||||
raise ValueError("artifact paths must be canonical, relative and traversal-free")
|
||||
if ".git" in parsed.parts:
|
||||
raise ValueError(".git content is forbidden")
|
||||
if self.mode not in (0o644, 0o755):
|
||||
raise ValueError("artifact mode must be 0644 or 0755")
|
||||
|
||||
|
||||
@dataclass(frozen=True, slots=True)
|
||||
class ArtifactManifest:
|
||||
source_oid: str
|
||||
tree_oid: str
|
||||
files: Mapping[str, str]
|
||||
artifact_sha256: str
|
||||
package_closure_sha256: str
|
||||
format_version: int = 1
|
||||
secrets_included: bool = False
|
||||
|
||||
def as_json_bytes(self) -> bytes:
|
||||
payload = {
|
||||
"format_version": self.format_version,
|
||||
"source_oid": self.source_oid,
|
||||
"tree_oid": self.tree_oid,
|
||||
"files": dict(sorted(self.files.items())),
|
||||
"artifact_sha256": self.artifact_sha256,
|
||||
"package_closure_sha256": self.package_closure_sha256,
|
||||
"secrets_included": self.secrets_included,
|
||||
}
|
||||
return json.dumps(payload, sort_keys=True, separators=(",", ":")).encode("utf-8")
|
||||
|
||||
@property
|
||||
def manifest_sha256(self) -> str:
|
||||
return sha256_bytes(self.as_json_bytes())
|
||||
|
||||
|
||||
@dataclass(frozen=True, slots=True)
|
||||
class BuiltArtifact:
|
||||
content: bytes
|
||||
manifest: ArtifactManifest
|
||||
|
||||
|
||||
class ArtifactBuilder:
|
||||
MAX_FILE_BYTES = 8 * 1024 * 1024
|
||||
MAX_ARTIFACT_BYTES = 64 * 1024 * 1024
|
||||
FORBIDDEN_MARKERS = (
|
||||
b"begin private " + b"key",
|
||||
b"authorization:" + b" bearer ",
|
||||
b"password" + b"=",
|
||||
b"token" + b"=",
|
||||
b"secret" + b"=",
|
||||
b"api_key" + b"=",
|
||||
)
|
||||
|
||||
@staticmethod
|
||||
def _validate_oid(name: str, value: str) -> None:
|
||||
if not is_git_oid(value):
|
||||
raise ValueError(f"{name} must be a full lowercase Git OID")
|
||||
|
||||
def build_from_directory(
|
||||
self, source_oid: str, tree_oid: str, source: str | Path
|
||||
) -> BuiltArtifact:
|
||||
root = Path(source)
|
||||
if root.is_symlink() or not root.is_dir():
|
||||
raise ReleaseBlocked(
|
||||
"ARTIFACT_SOURCE_LINK_REJECTED", "artifact source must be a real directory"
|
||||
)
|
||||
files: list[ArtifactFile] = []
|
||||
for directory, dirnames, filenames in os.walk(root, followlinks=False):
|
||||
current = Path(directory)
|
||||
for name in tuple(dirnames):
|
||||
item = current / name
|
||||
if item.is_symlink() or name == ".git":
|
||||
raise ReleaseBlocked(
|
||||
"ARTIFACT_SOURCE_LINK_REJECTED",
|
||||
"artifact source contains a linked or repository directory",
|
||||
)
|
||||
for name in filenames:
|
||||
item = current / name
|
||||
info = item.lstat()
|
||||
if not stat.S_ISREG(info.st_mode) or info.st_nlink != 1:
|
||||
raise ReleaseBlocked(
|
||||
"ARTIFACT_SOURCE_LINK_REJECTED",
|
||||
"artifact source contains a link or special file",
|
||||
)
|
||||
if info.st_size > self.MAX_FILE_BYTES:
|
||||
raise ReleaseBlocked("ARTIFACT_FILE_TOO_LARGE", "artifact file exceeds limit")
|
||||
relative = item.relative_to(root).as_posix()
|
||||
mode = 0o755 if info.st_mode & 0o111 else 0o644
|
||||
files.append(ArtifactFile(relative, item.read_bytes(), mode))
|
||||
return self.build(source_oid, tree_oid, tuple(files))
|
||||
|
||||
def build(
|
||||
self, source_oid: str, tree_oid: str, files: tuple[ArtifactFile, ...]
|
||||
) -> BuiltArtifact:
|
||||
self._validate_oid("source_oid", source_oid)
|
||||
self._validate_oid("tree_oid", tree_oid)
|
||||
if not files:
|
||||
raise EvidenceIncomplete("ARTIFACT_EMPTY", "artifact requires at least one file")
|
||||
paths = [item.path for item in files]
|
||||
if len(paths) != len(set(paths)):
|
||||
raise ReleaseBlocked("ARTIFACT_DUPLICATE_PATH", "artifact contains duplicate paths")
|
||||
total = 0
|
||||
for item in files:
|
||||
total += len(item.content)
|
||||
if len(item.content) > self.MAX_FILE_BYTES or total > self.MAX_ARTIFACT_BYTES:
|
||||
raise ReleaseBlocked("ARTIFACT_SIZE_LIMIT", "artifact exceeds Candidate limit")
|
||||
lowered = item.content.lower()
|
||||
if any(marker in lowered for marker in self.FORBIDDEN_MARKERS):
|
||||
raise ReleaseBlocked(
|
||||
"ARTIFACT_SECRET_MARKER",
|
||||
"artifact contains a forbidden secret marker",
|
||||
{"path": item.path},
|
||||
)
|
||||
output = io.BytesIO()
|
||||
with tarfile.open(fileobj=output, mode="w", format=tarfile.PAX_FORMAT) as archive:
|
||||
for item in sorted(files, key=lambda value: value.path):
|
||||
info = tarfile.TarInfo(item.path)
|
||||
info.size = len(item.content)
|
||||
info.mode = item.mode
|
||||
info.mtime = 0
|
||||
info.uid = 0
|
||||
info.gid = 0
|
||||
info.uname = "root"
|
||||
info.gname = "root"
|
||||
archive.addfile(info, io.BytesIO(item.content))
|
||||
content = output.getvalue()
|
||||
file_hashes = {item.path: sha256_bytes(item.content) for item in files}
|
||||
closure_payload = json.dumps(
|
||||
{
|
||||
"source_oid": source_oid,
|
||||
"tree_oid": tree_oid,
|
||||
"files": dict(sorted(file_hashes.items())),
|
||||
"secrets_included": False,
|
||||
},
|
||||
sort_keys=True,
|
||||
separators=(",", ":"),
|
||||
).encode("utf-8")
|
||||
manifest = ArtifactManifest(
|
||||
source_oid=source_oid,
|
||||
tree_oid=tree_oid,
|
||||
files=file_hashes,
|
||||
artifact_sha256=sha256_bytes(content),
|
||||
package_closure_sha256=sha256_bytes(closure_payload),
|
||||
secrets_included=False,
|
||||
)
|
||||
return BuiltArtifact(content=content, manifest=manifest)
|
||||
|
||||
def verify(self, built: BuiltArtifact) -> None:
|
||||
if built.manifest.secrets_included:
|
||||
raise EvidenceIncomplete("ARTIFACT_SECRET_FLAG", "manifest includes secrets")
|
||||
if sha256_bytes(built.content) != built.manifest.artifact_sha256:
|
||||
raise EvidenceIncomplete(
|
||||
"ARTIFACT_DIGEST_MISMATCH", "artifact digest does not match manifest"
|
||||
)
|
||||
actual: dict[str, str] = {}
|
||||
with tarfile.open(fileobj=io.BytesIO(built.content), mode="r:") as archive:
|
||||
for member in archive.getmembers():
|
||||
try:
|
||||
ArtifactFile(member.name, b"", member.mode)
|
||||
except ValueError as error:
|
||||
raise EvidenceIncomplete(
|
||||
"ARTIFACT_MEMBER_INVALID", "archive contains an unsafe member"
|
||||
) from error
|
||||
if not member.isfile() or member.name in actual:
|
||||
raise EvidenceIncomplete(
|
||||
"ARTIFACT_MEMBER_INVALID", "archive contains a link, special or duplicate member"
|
||||
)
|
||||
stream = archive.extractfile(member)
|
||||
if stream is None:
|
||||
raise EvidenceIncomplete("ARTIFACT_MEMBER_INVALID", "archive member is unreadable")
|
||||
actual[member.name] = sha256_bytes(stream.read())
|
||||
if actual != dict(built.manifest.files):
|
||||
raise EvidenceIncomplete(
|
||||
"ARTIFACT_FILE_MISMATCH", "artifact file closure does not match manifest"
|
||||
)
|
||||
closure_payload = json.dumps(
|
||||
{
|
||||
"source_oid": built.manifest.source_oid,
|
||||
"tree_oid": built.manifest.tree_oid,
|
||||
"files": dict(sorted(actual.items())),
|
||||
"secrets_included": False,
|
||||
},
|
||||
sort_keys=True,
|
||||
separators=(",", ":"),
|
||||
).encode("utf-8")
|
||||
if sha256_bytes(closure_payload) != built.manifest.package_closure_sha256:
|
||||
raise EvidenceIncomplete(
|
||||
"PACKAGE_CLOSURE_MISMATCH", "package closure digest does not match"
|
||||
)
|
||||
@@ -1,244 +0,0 @@
|
||||
"""Candidate inspection CLI; all commands are local and non-production."""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import argparse
|
||||
import json
|
||||
import os
|
||||
from pathlib import Path
|
||||
import subprocess
|
||||
import sys
|
||||
|
||||
from .artifact import ArtifactBuilder, ArtifactManifest, BuiltArtifact
|
||||
from .evidence import EvidenceChain
|
||||
from .release import ReleaseController
|
||||
from .serialization import (
|
||||
release_plan_from_mapping,
|
||||
release_plan_to_mapping,
|
||||
task_plan_from_mapping,
|
||||
task_plan_to_mapping,
|
||||
)
|
||||
from .service import CandidateApplication
|
||||
from .store import StateStore
|
||||
|
||||
|
||||
def build_parser() -> argparse.ArgumentParser:
|
||||
parser = argparse.ArgumentParser(prog="aios-autonomous-release")
|
||||
sub = parser.add_subparsers(dest="command", required=True)
|
||||
plan = sub.add_parser("plan")
|
||||
plan.add_argument("payload")
|
||||
digest = sub.add_parser("digest")
|
||||
digest.add_argument("payload")
|
||||
status = sub.add_parser("status")
|
||||
status.add_argument("--state", required=True, type=Path)
|
||||
status.add_argument("--task-id", required=True)
|
||||
evidence = sub.add_parser("verify-evidence")
|
||||
evidence.add_argument("--state", required=True, type=Path)
|
||||
evidence.add_argument("--task-id", required=True)
|
||||
evidence.add_argument("--require", action="append", default=[])
|
||||
|
||||
task = sub.add_parser("task")
|
||||
task_sub = task.add_subparsers(dest="task_command", required=True)
|
||||
task_create = task_sub.add_parser("create")
|
||||
task_create.add_argument("--state", required=True, type=Path)
|
||||
task_create.add_argument("--payload", required=True, type=Path)
|
||||
for name in ("status", "steps"):
|
||||
item = task_sub.add_parser(name)
|
||||
item.add_argument("--state", required=True, type=Path)
|
||||
item.add_argument("--task-id", required=True)
|
||||
|
||||
evidence_group = sub.add_parser("evidence")
|
||||
evidence_sub = evidence_group.add_subparsers(dest="evidence_command", required=True)
|
||||
evidence_verify = evidence_sub.add_parser("verify")
|
||||
evidence_verify.add_argument("--state", required=True, type=Path)
|
||||
evidence_verify.add_argument("--task-id", required=True)
|
||||
evidence_verify.add_argument("--require", action="append", default=[])
|
||||
|
||||
artifact = sub.add_parser("artifact")
|
||||
artifact_sub = artifact.add_subparsers(dest="artifact_command", required=True)
|
||||
artifact_build = artifact_sub.add_parser("build")
|
||||
artifact_build.add_argument("--source", required=True, type=Path)
|
||||
artifact_build.add_argument("--source-oid", required=True)
|
||||
artifact_build.add_argument("--tree-oid", required=True)
|
||||
artifact_build.add_argument("--output-directory", required=True, type=Path)
|
||||
artifact_verify = artifact_sub.add_parser("verify")
|
||||
artifact_verify.add_argument("--artifact", required=True, type=Path)
|
||||
artifact_verify.add_argument("--manifest", required=True, type=Path)
|
||||
|
||||
release = sub.add_parser("release")
|
||||
release_sub = release.add_subparsers(dest="release_command", required=True)
|
||||
for name in ("plan", "verify"):
|
||||
item = release_sub.add_parser(name)
|
||||
item.add_argument("--payload", required=True, type=Path)
|
||||
|
||||
acceptance = sub.add_parser("acceptance")
|
||||
acceptance.add_argument("--repo-root", required=True, type=Path)
|
||||
acceptance.add_argument("--output", required=True, type=Path)
|
||||
return parser
|
||||
|
||||
|
||||
def load_json(path: Path) -> dict:
|
||||
value = json.loads(path.read_text(encoding="utf-8"))
|
||||
if not isinstance(value, dict):
|
||||
raise ValueError("JSON payload must be an object")
|
||||
return value
|
||||
|
||||
|
||||
def exclusive(path: Path, content: bytes) -> None:
|
||||
path.parent.mkdir(parents=True, exist_ok=True, mode=0o750)
|
||||
descriptor = os.open(
|
||||
path,
|
||||
os.O_WRONLY | os.O_CREAT | os.O_EXCL | getattr(os, "O_NOFOLLOW", 0),
|
||||
0o640,
|
||||
)
|
||||
try:
|
||||
os.write(descriptor, content)
|
||||
os.fsync(descriptor)
|
||||
finally:
|
||||
os.close(descriptor)
|
||||
|
||||
|
||||
def artifact_from_files(artifact: Path, manifest: Path) -> BuiltArtifact:
|
||||
payload = load_json(manifest)
|
||||
contract = ArtifactManifest(
|
||||
source_oid=str(payload["source_oid"]),
|
||||
tree_oid=str(payload["tree_oid"]),
|
||||
files={str(key): str(value) for key, value in payload["files"].items()},
|
||||
artifact_sha256=str(payload["artifact_sha256"]),
|
||||
package_closure_sha256=str(payload["package_closure_sha256"]),
|
||||
format_version=int(payload.get("format_version", 1)),
|
||||
secrets_included=bool(payload.get("secrets_included", False)),
|
||||
)
|
||||
return BuiltArtifact(artifact.read_bytes(), contract)
|
||||
|
||||
|
||||
def main(argv: list[str] | None = None) -> int:
|
||||
args = build_parser().parse_args(argv)
|
||||
if args.command in {"plan", "digest"}:
|
||||
plan = task_plan_from_mapping(json.loads(args.payload))
|
||||
if args.command == "plan":
|
||||
print(json.dumps(task_plan_to_mapping(plan), sort_keys=True))
|
||||
else:
|
||||
print(plan.digest())
|
||||
return 0
|
||||
if args.command == "task":
|
||||
application = CandidateApplication(args.state)
|
||||
if args.task_command == "create":
|
||||
result = application.api.create_task(load_json(args.payload))
|
||||
elif args.task_command == "steps":
|
||||
result = application.api.task_steps(args.task_id)
|
||||
else:
|
||||
result = application.api.task_status(args.task_id)
|
||||
print(json.dumps(result, sort_keys=True))
|
||||
return 0
|
||||
if args.command == "evidence":
|
||||
chain = EvidenceChain(StateStore(args.state), args.task_id)
|
||||
result = {
|
||||
"task_id": args.task_id,
|
||||
"verified": chain.verify(),
|
||||
"evidence_closure": chain.close(tuple(args.require)),
|
||||
"production_side_effects": False,
|
||||
"secrets_included": False,
|
||||
}
|
||||
print(json.dumps(result, sort_keys=True))
|
||||
return 0
|
||||
if args.command == "artifact":
|
||||
builder = ArtifactBuilder()
|
||||
if args.artifact_command == "build":
|
||||
built = builder.build_from_directory(args.source_oid, args.tree_oid, args.source)
|
||||
builder.verify(built)
|
||||
artifact_path = args.output_directory / "candidate.tar"
|
||||
manifest_path = args.output_directory / "manifest.json"
|
||||
exclusive(artifact_path, built.content)
|
||||
exclusive(manifest_path, built.manifest.as_json_bytes() + b"\n")
|
||||
result = {
|
||||
"artifact": str(artifact_path),
|
||||
"manifest": str(manifest_path),
|
||||
"artifact_sha256": built.manifest.artifact_sha256,
|
||||
"manifest_sha256": built.manifest.manifest_sha256,
|
||||
"package_closure_sha256": built.manifest.package_closure_sha256,
|
||||
"production_side_effects": False,
|
||||
"secrets_included": False,
|
||||
}
|
||||
else:
|
||||
built = artifact_from_files(args.artifact, args.manifest)
|
||||
builder.verify(built)
|
||||
result = {
|
||||
"verified": True,
|
||||
"artifact_sha256": built.manifest.artifact_sha256,
|
||||
"manifest_sha256": built.manifest.manifest_sha256,
|
||||
"package_closure_sha256": built.manifest.package_closure_sha256,
|
||||
"production_side_effects": False,
|
||||
"secrets_included": False,
|
||||
}
|
||||
print(json.dumps(result, sort_keys=True))
|
||||
return 0
|
||||
if args.command == "release":
|
||||
plan = release_plan_from_mapping(load_json(args.payload))
|
||||
if args.release_command == "plan":
|
||||
result = {
|
||||
"plan": release_plan_to_mapping(plan),
|
||||
"release_state": "CREATED",
|
||||
"production_side_effects": False,
|
||||
"secrets_included": False,
|
||||
}
|
||||
else:
|
||||
controller = ReleaseController()
|
||||
controller.attach_plan(plan)
|
||||
controller.mark_built()
|
||||
controller.verify(artifact_ok=True, evidence_ok=True)
|
||||
controller.request_owner_approval()
|
||||
result = {
|
||||
"release_state": controller.status().state.value,
|
||||
"production_release": "BLOCKED_EXTERNAL_OWNER_SIGNATURE",
|
||||
"production_side_effects": False,
|
||||
"secrets_included": False,
|
||||
}
|
||||
print(json.dumps(result, sort_keys=True))
|
||||
return 0
|
||||
if args.command == "acceptance":
|
||||
runner = args.repo_root / "scripts" / "autonomous-release" / "run_acceptance.py"
|
||||
completed = subprocess.run(
|
||||
[
|
||||
sys.executable,
|
||||
str(runner),
|
||||
"--repo-root",
|
||||
str(args.repo_root),
|
||||
"--output",
|
||||
str(args.output),
|
||||
],
|
||||
check=False,
|
||||
)
|
||||
return completed.returncode
|
||||
store = StateStore(args.state)
|
||||
if args.command == "status":
|
||||
state, revision = store.get_task_state(args.task_id)
|
||||
print(
|
||||
json.dumps(
|
||||
{
|
||||
"task_id": args.task_id,
|
||||
"state": state.value,
|
||||
"revision": revision,
|
||||
"production_side_effects": False,
|
||||
"secrets_included": False,
|
||||
},
|
||||
sort_keys=True,
|
||||
)
|
||||
)
|
||||
return 0
|
||||
chain = EvidenceChain(store, args.task_id)
|
||||
print(
|
||||
json.dumps(
|
||||
{
|
||||
"task_id": args.task_id,
|
||||
"evidence_closure": chain.close(tuple(args.require)),
|
||||
"secrets_included": False,
|
||||
},
|
||||
sort_keys=True,
|
||||
)
|
||||
)
|
||||
return 0
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
sys.exit(main())
|
||||
-307
@@ -1,307 +0,0 @@
|
||||
"""Task-bound, reference-only Candidate credential lifecycle."""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
from dataclasses import dataclass
|
||||
from datetime import datetime, timedelta, timezone
|
||||
import json
|
||||
import re
|
||||
import secrets
|
||||
from typing import Protocol
|
||||
|
||||
from .errors import CredentialUnavailable, PolicyDenied
|
||||
from .models import (
|
||||
CredentialProjection,
|
||||
CredentialRequest,
|
||||
CredentialState,
|
||||
canonical_json,
|
||||
)
|
||||
from .store import StateStore
|
||||
|
||||
|
||||
REFERENCE_RE = re.compile(
|
||||
r"(?:systemd-credential:[A-Za-z0-9_.@-]+|secret-ref://candidate/[A-Za-z0-9_./@-]+)"
|
||||
)
|
||||
|
||||
|
||||
class CredentialProvider(Protocol):
|
||||
"""External provider contract; values crossing this boundary are opaque references."""
|
||||
|
||||
def issue(self, request: CredentialRequest, expires_at: datetime) -> tuple[str, str]: ...
|
||||
|
||||
def revoke(self, credential_id: str, reference: str) -> None: ...
|
||||
|
||||
def is_usable(self, credential_id: str, reference: str) -> bool: ...
|
||||
|
||||
|
||||
@dataclass(frozen=True, slots=True)
|
||||
class CredentialLifecycleResult:
|
||||
credential_id: str
|
||||
reference: str
|
||||
state: CredentialState
|
||||
expires_at: datetime
|
||||
|
||||
|
||||
class CredentialBroker:
|
||||
"""Enforce approval, branch, consumer and operation bindings for projections."""
|
||||
|
||||
def __init__(self, store: StateStore, provider: CredentialProvider) -> None:
|
||||
self.store = store
|
||||
self.provider = provider
|
||||
|
||||
@staticmethod
|
||||
def _validate_request(request: CredentialRequest, now: datetime) -> None:
|
||||
if request.binding.branch == "main":
|
||||
raise PolicyDenied("MAIN_CREDENTIAL_DENIED", "credentials cannot target main")
|
||||
forbidden = {
|
||||
"production.deploy",
|
||||
"production.rollback",
|
||||
"tag.write",
|
||||
"baseline.write",
|
||||
"registry.write",
|
||||
"secret.export",
|
||||
"secret.read",
|
||||
}
|
||||
overlap = forbidden.intersection(request.operations)
|
||||
if overlap:
|
||||
raise PolicyDenied(
|
||||
"CREDENTIAL_OPERATION_FORBIDDEN",
|
||||
"credential request includes forbidden operations",
|
||||
{"operations": sorted(overlap)},
|
||||
)
|
||||
if now < request.not_before or now >= request.expires_at:
|
||||
raise CredentialUnavailable(
|
||||
"CREDENTIAL_APPROVAL_WINDOW_INVALID", "credential approval is not currently valid"
|
||||
)
|
||||
|
||||
@staticmethod
|
||||
def _metadata(request: CredentialRequest) -> dict[str, object]:
|
||||
return {
|
||||
"request_id": request.request_id,
|
||||
"task_id": request.task_id,
|
||||
"session_id": request.session_id,
|
||||
"worker_id": request.worker_id,
|
||||
"audience": request.audience,
|
||||
"consumer_service": request.consumer_service,
|
||||
"provider": request.provider,
|
||||
"runtime_user": request.runtime_user,
|
||||
"approval_plan_id": request.approval_plan_id,
|
||||
"repository": request.binding.repository,
|
||||
"branch": request.binding.branch,
|
||||
"base_oid": request.binding.base_oid,
|
||||
"allowed_paths": list(request.binding.allowed_paths),
|
||||
"operations": list(request.operations),
|
||||
"not_before": request.not_before.astimezone(timezone.utc).isoformat(),
|
||||
"expires_at": request.expires_at.astimezone(timezone.utc).isoformat(),
|
||||
"nonce": request.nonce,
|
||||
"max_uses": request.max_uses,
|
||||
"use_count": 0,
|
||||
"secrets_included": False,
|
||||
}
|
||||
|
||||
def _compensate(self, credential_id: str, reference: str) -> None:
|
||||
try:
|
||||
self.provider.revoke(credential_id, reference)
|
||||
except Exception:
|
||||
pass
|
||||
|
||||
def issue(
|
||||
self, request: CredentialRequest, now: datetime | None = None
|
||||
) -> CredentialProjection:
|
||||
now = now or datetime.now(timezone.utc)
|
||||
self._validate_request(request, now)
|
||||
expires_at = min(request.expires_at, now + timedelta(seconds=request.ttl_seconds))
|
||||
try:
|
||||
credential_id, reference = self.provider.issue(request, expires_at)
|
||||
except Exception as error:
|
||||
raise CredentialUnavailable(
|
||||
"CREDENTIAL_PROVIDER_UNAVAILABLE", "credential provider issue failed"
|
||||
) from error
|
||||
if not credential_id or not reference or not REFERENCE_RE.fullmatch(reference):
|
||||
if credential_id and reference:
|
||||
self._compensate(credential_id, reference)
|
||||
raise CredentialUnavailable(
|
||||
"CREDENTIAL_REFERENCE_REJECTED", "provider did not return an approved opaque reference"
|
||||
)
|
||||
projection = CredentialProjection(
|
||||
credential_id=credential_id,
|
||||
reference=reference,
|
||||
request=request,
|
||||
state=CredentialState.ISSUED,
|
||||
issued_at=now,
|
||||
expires_at=expires_at,
|
||||
plaintext_returned=False,
|
||||
)
|
||||
try:
|
||||
with self.store.transaction() as connection:
|
||||
connection.execute(
|
||||
"INSERT INTO credentials(credential_id, task_id, reference, state, metadata_json, "
|
||||
"issued_at, expires_at) VALUES(?, ?, ?, ?, ?, ?, ?)",
|
||||
(
|
||||
credential_id,
|
||||
request.task_id,
|
||||
reference,
|
||||
CredentialState.ISSUED.value,
|
||||
canonical_json(self._metadata(request)),
|
||||
now.isoformat(),
|
||||
expires_at.isoformat(),
|
||||
),
|
||||
)
|
||||
connection.execute(
|
||||
"INSERT INTO consumed_nonces(scope, nonce, consumed_at) VALUES(?, ?, ?)",
|
||||
(f"credential:{request.approval_plan_id}", request.nonce, now.isoformat()),
|
||||
)
|
||||
except Exception as error:
|
||||
self._compensate(credential_id, reference)
|
||||
raise CredentialUnavailable(
|
||||
"CREDENTIAL_PERSISTENCE_FAILED",
|
||||
"credential issuance was compensated after durable-state failure",
|
||||
) from error
|
||||
return projection
|
||||
|
||||
def project(self, projection: CredentialProjection) -> CredentialLifecycleResult:
|
||||
with self.store.transaction() as connection:
|
||||
cursor = connection.execute(
|
||||
"UPDATE credentials SET state=? WHERE credential_id=? AND reference=? AND state=?",
|
||||
(
|
||||
CredentialState.PROJECTED.value,
|
||||
projection.credential_id,
|
||||
projection.reference,
|
||||
CredentialState.ISSUED.value,
|
||||
),
|
||||
)
|
||||
if cursor.rowcount != 1:
|
||||
raise CredentialUnavailable(
|
||||
"CREDENTIAL_STATE_CONFLICT", "only a durably issued credential may be projected"
|
||||
)
|
||||
return CredentialLifecycleResult(
|
||||
projection.credential_id,
|
||||
projection.reference,
|
||||
CredentialState.PROJECTED,
|
||||
projection.expires_at,
|
||||
)
|
||||
|
||||
def authorize(
|
||||
self,
|
||||
projection: CredentialProjection,
|
||||
*,
|
||||
task_id: str,
|
||||
session_id: str,
|
||||
worker_id: str,
|
||||
audience: str,
|
||||
consumer_service: str,
|
||||
operation: str,
|
||||
path: str,
|
||||
now: datetime | None = None,
|
||||
) -> None:
|
||||
now = now or datetime.now(timezone.utc)
|
||||
request = projection.request
|
||||
actual = (task_id, session_id, worker_id, audience, consumer_service)
|
||||
expected = (
|
||||
request.task_id,
|
||||
request.session_id,
|
||||
request.worker_id,
|
||||
request.audience,
|
||||
request.consumer_service,
|
||||
)
|
||||
if actual != expected:
|
||||
raise CredentialUnavailable(
|
||||
"CREDENTIAL_SCOPE_MISMATCH", "credential scope does not match the caller"
|
||||
)
|
||||
if operation not in request.operations or not request.binding.allows_path(path):
|
||||
raise CredentialUnavailable(
|
||||
"CREDENTIAL_OPERATION_DENIED", "credential operation or path is not approved"
|
||||
)
|
||||
if now < request.not_before or now >= projection.expires_at:
|
||||
raise CredentialUnavailable("CREDENTIAL_EXPIRED", "credential is outside its valid window")
|
||||
with self.store.transaction() as connection:
|
||||
row = connection.execute(
|
||||
"SELECT state, metadata_json FROM credentials WHERE credential_id=? AND reference=?",
|
||||
(projection.credential_id, projection.reference),
|
||||
).fetchone()
|
||||
if row is None or row["state"] != CredentialState.PROJECTED.value:
|
||||
raise CredentialUnavailable(
|
||||
"CREDENTIAL_NOT_PROJECTED", "credential is not in projected state"
|
||||
)
|
||||
metadata = json.loads(row["metadata_json"])
|
||||
count = int(metadata.get("use_count", 0))
|
||||
if count >= request.max_uses:
|
||||
raise CredentialUnavailable("CREDENTIAL_USE_LIMIT", "credential use limit reached")
|
||||
if not self.provider.is_usable(projection.credential_id, projection.reference):
|
||||
raise CredentialUnavailable(
|
||||
"CREDENTIAL_PROVIDER_REJECTED", "provider no longer accepts the credential"
|
||||
)
|
||||
metadata["use_count"] = count + 1
|
||||
connection.execute(
|
||||
"UPDATE credentials SET metadata_json=? WHERE credential_id=?",
|
||||
(canonical_json(metadata), projection.credential_id),
|
||||
)
|
||||
|
||||
def revoke(
|
||||
self, credential_id: str, reference: str, now: datetime | None = None
|
||||
) -> CredentialLifecycleResult:
|
||||
now = now or datetime.now(timezone.utc)
|
||||
with self.store.transaction() as connection:
|
||||
row = connection.execute(
|
||||
"SELECT state, expires_at FROM credentials WHERE credential_id=? AND reference=?",
|
||||
(credential_id, reference),
|
||||
).fetchone()
|
||||
if row is None:
|
||||
raise KeyError(credential_id)
|
||||
expires_at = datetime.fromisoformat(row["expires_at"])
|
||||
if row["state"] == CredentialState.REVOKED.value:
|
||||
return CredentialLifecycleResult(
|
||||
credential_id, reference, CredentialState.REVOKED, expires_at
|
||||
)
|
||||
try:
|
||||
self.provider.revoke(credential_id, reference)
|
||||
except Exception as error:
|
||||
raise CredentialUnavailable(
|
||||
"CREDENTIAL_REVOCATION_FAILED", "upstream credential revocation failed"
|
||||
) from error
|
||||
with self.store.transaction() as connection:
|
||||
connection.execute(
|
||||
"UPDATE credentials SET state=?, revoked_at=? WHERE credential_id=? AND reference=?",
|
||||
(CredentialState.REVOKED.value, now.isoformat(), credential_id, reference),
|
||||
)
|
||||
return CredentialLifecycleResult(
|
||||
credential_id, reference, CredentialState.REVOKED, expires_at
|
||||
)
|
||||
|
||||
def verify_revoked(self, credential_id: str, reference: str) -> None:
|
||||
with self.store.transaction() as connection:
|
||||
row = connection.execute(
|
||||
"SELECT state FROM credentials WHERE credential_id=? AND reference=?",
|
||||
(credential_id, reference),
|
||||
).fetchone()
|
||||
if row is None or row["state"] != CredentialState.REVOKED.value:
|
||||
raise CredentialUnavailable(
|
||||
"CREDENTIAL_REVOCATION_UNRECORDED", "durable revocation record is missing"
|
||||
)
|
||||
if self.provider.is_usable(credential_id, reference):
|
||||
raise CredentialUnavailable(
|
||||
"CREDENTIAL_REVOCATION_UNVERIFIED",
|
||||
"provider still accepts revoked credential",
|
||||
{"credential_id": credential_id},
|
||||
)
|
||||
|
||||
|
||||
class InMemoryCredentialProvider:
|
||||
"""Candidate test provider; never suitable as production identity evidence."""
|
||||
|
||||
def __init__(self) -> None:
|
||||
self._active: dict[str, str] = {}
|
||||
|
||||
def issue(self, request: CredentialRequest, expires_at: datetime) -> tuple[str, str]:
|
||||
credential_id = f"cred-{secrets.token_hex(8)}"
|
||||
reference = f"secret-ref://candidate/{request.task_id}/{credential_id}"
|
||||
self._active[credential_id] = reference
|
||||
return credential_id, reference
|
||||
|
||||
def revoke(self, credential_id: str, reference: str) -> None:
|
||||
if self._active.get(credential_id) != reference:
|
||||
raise CredentialUnavailable("CREDENTIAL_NOT_FOUND", "credential is not active")
|
||||
del self._active[credential_id]
|
||||
|
||||
def is_usable(self, credential_id: str, reference: str) -> bool:
|
||||
return self._active.get(credential_id) == reference
|
||||
-48
@@ -1,48 +0,0 @@
|
||||
"""Stable error types and codes for the autonomous-release candidate."""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
from dataclasses import dataclass
|
||||
from typing import Any, Mapping
|
||||
|
||||
|
||||
@dataclass(slots=True)
|
||||
class AutonomousReleaseError(RuntimeError):
|
||||
"""Base error with a stable machine-readable code."""
|
||||
|
||||
code: str
|
||||
message: str
|
||||
details: Mapping[str, Any] | None = None
|
||||
|
||||
def __str__(self) -> str:
|
||||
if not self.details:
|
||||
return f"{self.code}: {self.message}"
|
||||
return f"{self.code}: {self.message} ({dict(self.details)})"
|
||||
|
||||
|
||||
class PolicyDenied(AutonomousReleaseError):
|
||||
pass
|
||||
|
||||
|
||||
class ApprovalRequired(AutonomousReleaseError):
|
||||
pass
|
||||
|
||||
|
||||
class CapabilityMismatch(AutonomousReleaseError):
|
||||
pass
|
||||
|
||||
|
||||
class CredentialUnavailable(AutonomousReleaseError):
|
||||
pass
|
||||
|
||||
|
||||
class EvidenceIncomplete(AutonomousReleaseError):
|
||||
pass
|
||||
|
||||
|
||||
class ReleaseBlocked(AutonomousReleaseError):
|
||||
pass
|
||||
|
||||
|
||||
class StateConflict(AutonomousReleaseError):
|
||||
pass
|
||||
-136
@@ -1,136 +0,0 @@
|
||||
"""Durable, replayable and tamper-evident evidence closure."""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
from dataclasses import dataclass
|
||||
from datetime import datetime, timezone
|
||||
import json
|
||||
from typing import Any, Mapping, TYPE_CHECKING
|
||||
|
||||
from .errors import EvidenceIncomplete
|
||||
from .models import sha256_json
|
||||
|
||||
if TYPE_CHECKING:
|
||||
from .store import StateStore
|
||||
|
||||
|
||||
@dataclass(frozen=True, slots=True)
|
||||
class EvidenceEvent:
|
||||
event_type: str
|
||||
task_id: str
|
||||
payload: Mapping[str, Any]
|
||||
previous_digest: str | None
|
||||
created_at: datetime
|
||||
|
||||
def event_digest(self) -> str:
|
||||
return sha256_json(
|
||||
{
|
||||
"event_type": self.event_type,
|
||||
"task_id": self.task_id,
|
||||
"payload": dict(self.payload),
|
||||
"previous_digest": self.previous_digest,
|
||||
"created_at": self.created_at.astimezone(timezone.utc).isoformat(),
|
||||
}
|
||||
)
|
||||
|
||||
|
||||
class EvidenceChain:
|
||||
"""Append-only chain optionally backed by the Candidate state database."""
|
||||
|
||||
def __init__(self, store: StateStore | None = None, task_id: str | None = None) -> None:
|
||||
if (store is None) != (task_id is None):
|
||||
raise ValueError("store and task_id must be supplied together")
|
||||
self.store = store
|
||||
self.task_id = task_id
|
||||
self._records: list[tuple[EvidenceEvent, str]] = []
|
||||
if store is not None and task_id is not None:
|
||||
self._load()
|
||||
|
||||
def _load(self) -> None:
|
||||
assert self.store is not None and self.task_id is not None
|
||||
self._records = []
|
||||
for row in self.store.list_events(self.task_id):
|
||||
event = EvidenceEvent(
|
||||
event_type=str(row["event_type"]),
|
||||
task_id=str(row["task_id"]),
|
||||
payload=json.loads(str(row["payload_json"])),
|
||||
previous_digest=row["previous_digest"],
|
||||
created_at=datetime.fromisoformat(str(row["created_at"])),
|
||||
)
|
||||
self._records.append((event, str(row["digest"])))
|
||||
|
||||
def append(
|
||||
self, event_type: str, task_id: str, payload: Mapping[str, Any]
|
||||
) -> EvidenceEvent:
|
||||
if not event_type or not task_id:
|
||||
raise EvidenceIncomplete("EVIDENCE_IDENTITY_REQUIRED", "event and task IDs are required")
|
||||
if self.task_id is not None and task_id != self.task_id:
|
||||
raise EvidenceIncomplete(
|
||||
"EVIDENCE_TASK_MISMATCH", "event task does not match the durable chain"
|
||||
)
|
||||
if payload.get("secrets_included") is not False:
|
||||
raise EvidenceIncomplete(
|
||||
"EVIDENCE_SECRET_MARKER_REQUIRED",
|
||||
"evidence must explicitly assert secrets_included=false",
|
||||
)
|
||||
previous = self._records[-1][1] if self._records else None
|
||||
event = EvidenceEvent(
|
||||
event_type=event_type,
|
||||
task_id=task_id,
|
||||
payload=dict(payload),
|
||||
previous_digest=previous,
|
||||
created_at=datetime.now(timezone.utc),
|
||||
)
|
||||
event_digest = event.event_digest()
|
||||
if self.store is not None:
|
||||
self.store.append_event(
|
||||
task_id,
|
||||
event_type,
|
||||
payload,
|
||||
previous,
|
||||
event_digest,
|
||||
event.created_at,
|
||||
)
|
||||
self._records.append((event, event_digest))
|
||||
return event
|
||||
|
||||
def verify(self) -> bool:
|
||||
previous: str | None = None
|
||||
for event, recorded_digest in self._records:
|
||||
if event.previous_digest != previous or event.event_digest() != recorded_digest:
|
||||
return False
|
||||
previous = recorded_digest
|
||||
return True
|
||||
|
||||
def close(self, required_event_types: tuple[str, ...]) -> str:
|
||||
if not self._records:
|
||||
raise EvidenceIncomplete("EMPTY_EVIDENCE_CHAIN", "cannot close an empty evidence chain")
|
||||
if not self.verify():
|
||||
raise EvidenceIncomplete(
|
||||
"EVIDENCE_CHAIN_INVALID", "evidence chain verification failed"
|
||||
)
|
||||
found = {event.event_type for event, _ in self._records}
|
||||
missing = sorted(set(required_event_types) - found)
|
||||
if missing:
|
||||
raise EvidenceIncomplete(
|
||||
"EVIDENCE_REQUIREMENT_MISSING",
|
||||
"required evidence events are absent",
|
||||
{"missing": missing},
|
||||
)
|
||||
return self._records[-1][1]
|
||||
|
||||
def closure_digest(self) -> str:
|
||||
return self.close(())
|
||||
|
||||
def export(self) -> list[dict[str, Any]]:
|
||||
return [
|
||||
{
|
||||
"event_type": event.event_type,
|
||||
"task_id": event.task_id,
|
||||
"payload": dict(event.payload),
|
||||
"previous_digest": event.previous_digest,
|
||||
"digest": recorded_digest,
|
||||
"created_at": event.created_at.isoformat(),
|
||||
}
|
||||
for event, recorded_digest in self._records
|
||||
]
|
||||
-105
@@ -1,105 +0,0 @@
|
||||
"""Native Candidate execution lifecycle with mandatory cleanup evidence."""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
from dataclasses import dataclass
|
||||
from typing import Any, Mapping
|
||||
|
||||
from .evidence import EvidenceChain
|
||||
from .native_adapters import CandidateNativeAdapter, NativeSession
|
||||
|
||||
|
||||
@dataclass(frozen=True, slots=True)
|
||||
class NativeCanaryResult:
|
||||
provider: str
|
||||
broker_session_id: str
|
||||
provider_session_id: str
|
||||
message_id: str
|
||||
receipt: str
|
||||
broker_session_verified: bool
|
||||
openclaw_native_child_session_verified: bool
|
||||
codex_child_session_verified: bool
|
||||
simulation: bool
|
||||
session_closed: bool
|
||||
secrets_included: bool = False
|
||||
|
||||
|
||||
class ExecutionManager:
|
||||
def __init__(self, evidence: EvidenceChain) -> None:
|
||||
self.evidence = evidence
|
||||
|
||||
def run_native_canary(
|
||||
self,
|
||||
adapter: CandidateNativeAdapter,
|
||||
*,
|
||||
task_id: str,
|
||||
parent_session_id: str,
|
||||
recipient_binding: Mapping[str, Any],
|
||||
text: str,
|
||||
) -> NativeCanaryResult:
|
||||
session: NativeSession | None = None
|
||||
closed = False
|
||||
try:
|
||||
session = adapter.spawn(task_id, parent_session_id, recipient_binding)
|
||||
verification = adapter.verify(session)
|
||||
message = adapter.send_text(session, text)
|
||||
adapter.interrupt(session)
|
||||
adapter.close(session)
|
||||
closed = True
|
||||
event_type = (
|
||||
"NATIVE_SESSION_SIMULATION"
|
||||
if verification.simulation
|
||||
else "NATIVE_SESSION_VERIFIED"
|
||||
)
|
||||
self.evidence.append(
|
||||
event_type,
|
||||
task_id,
|
||||
{
|
||||
"provider": session.provider,
|
||||
"broker_session_id": session.broker_session_id,
|
||||
"provider_session_id": session.provider_session_id,
|
||||
"message_id": message.message_id,
|
||||
"receipt": message.receipt,
|
||||
"broker_session_verified": verification.broker_session_verified,
|
||||
"openclaw_native_child_session_verified": (
|
||||
verification.openclaw_native_child_session_verified
|
||||
),
|
||||
"codex_child_session_verified": verification.codex_child_session_verified,
|
||||
"simulation": verification.simulation,
|
||||
"session_closed": True,
|
||||
"secrets_included": False,
|
||||
},
|
||||
)
|
||||
return NativeCanaryResult(
|
||||
provider=session.provider,
|
||||
broker_session_id=session.broker_session_id,
|
||||
provider_session_id=session.provider_session_id,
|
||||
message_id=message.message_id,
|
||||
receipt=message.receipt,
|
||||
broker_session_verified=verification.broker_session_verified,
|
||||
openclaw_native_child_session_verified=(
|
||||
verification.openclaw_native_child_session_verified
|
||||
),
|
||||
codex_child_session_verified=verification.codex_child_session_verified,
|
||||
simulation=verification.simulation,
|
||||
session_closed=True,
|
||||
secrets_included=False,
|
||||
)
|
||||
except Exception as error:
|
||||
if session is not None and not closed:
|
||||
try:
|
||||
adapter.close(session)
|
||||
closed = True
|
||||
except Exception:
|
||||
closed = False
|
||||
self.evidence.append(
|
||||
"NATIVE_SESSION_FAILED",
|
||||
task_id,
|
||||
{
|
||||
"provider": adapter.provider,
|
||||
"error_code": type(error).__name__,
|
||||
"session_closed": closed,
|
||||
"secrets_included": False,
|
||||
},
|
||||
)
|
||||
raise
|
||||
-172
@@ -1,172 +0,0 @@
|
||||
"""API-only Gitea deploy-key lifecycle canary."""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
from dataclasses import dataclass
|
||||
from typing import Any, Mapping, Protocol, Sequence
|
||||
|
||||
from .errors import CredentialUnavailable, StateConflict
|
||||
|
||||
|
||||
GITEA_REFERENCE = "systemd-credential:gitea-admin-api-candidate"
|
||||
|
||||
|
||||
@dataclass(frozen=True, slots=True)
|
||||
class EphemeralKeyProjection:
|
||||
public_key: str
|
||||
private_key_reference: str
|
||||
|
||||
|
||||
class KeyProjectionProvider(Protocol):
|
||||
def create(self, task_id: str, branch: str) -> EphemeralKeyProjection: ...
|
||||
|
||||
def delete(self, reference: str) -> None: ...
|
||||
|
||||
def is_present(self, reference: str) -> bool: ...
|
||||
|
||||
|
||||
class GiteaDeployKeyProvider(Protocol):
|
||||
simulation: bool
|
||||
|
||||
def list_deploy_keys(
|
||||
self, repository: str, credential_reference: str
|
||||
) -> Sequence[Mapping[str, Any]]: ...
|
||||
|
||||
def create_deploy_key(
|
||||
self,
|
||||
repository: str,
|
||||
title: str,
|
||||
public_key: str,
|
||||
credential_reference: str,
|
||||
) -> Mapping[str, Any]: ...
|
||||
|
||||
def delete_deploy_key(
|
||||
self, repository: str, key_id: int, credential_reference: str
|
||||
) -> None: ...
|
||||
|
||||
|
||||
class SSHAuthenticationProbe(Protocol):
|
||||
def authenticate(
|
||||
self, repository: str, branch: str, private_key_reference: str
|
||||
) -> bool: ...
|
||||
|
||||
|
||||
@dataclass(frozen=True, slots=True)
|
||||
class GiteaCanaryResult:
|
||||
key_created: bool
|
||||
key_deleted: bool
|
||||
api_key_absent_after_delete: bool
|
||||
post_revoke_auth_rejected: bool
|
||||
credential_projection_deleted: bool
|
||||
gitea_admin_api_lifecycle_canary: bool
|
||||
simulation: bool
|
||||
secrets_included: bool = False
|
||||
|
||||
|
||||
class GiteaDeployKeyCanary:
|
||||
"""Exercise only repository deploy-key list/create/delete provider operations."""
|
||||
|
||||
repository = "aios/aios"
|
||||
|
||||
def __init__(
|
||||
self,
|
||||
gitea: GiteaDeployKeyProvider,
|
||||
projections: KeyProjectionProvider,
|
||||
ssh_probe: SSHAuthenticationProbe,
|
||||
) -> None:
|
||||
self.gitea = gitea
|
||||
self.projections = projections
|
||||
self.ssh_probe = ssh_probe
|
||||
|
||||
def run(
|
||||
self, *, task_id: str, branch: str, credential_reference: str
|
||||
) -> GiteaCanaryResult:
|
||||
if credential_reference != GITEA_REFERENCE:
|
||||
raise CredentialUnavailable(
|
||||
"BLOCKED_GITEA_ADMIN_CREDENTIAL_REQUIRED",
|
||||
"exact Candidate Gitea Admin API reference is required",
|
||||
)
|
||||
if not task_id or not branch.startswith("patch/"):
|
||||
raise StateConflict("GITEA_CANARY_BINDING_INVALID", "task and patch branch are required")
|
||||
projection: EphemeralKeyProjection | None = None
|
||||
key_id: int | None = None
|
||||
key_created = False
|
||||
key_deleted = False
|
||||
api_absent = False
|
||||
auth_rejected = False
|
||||
projection_deleted = False
|
||||
title = f"aios-candidate-{task_id}"
|
||||
try:
|
||||
projection = self.projections.create(task_id, branch)
|
||||
if (
|
||||
not projection.public_key.startswith("ssh-ed25519 ")
|
||||
or not projection.private_key_reference.startswith("systemd-credential:")
|
||||
):
|
||||
raise CredentialUnavailable(
|
||||
"GITEA_CANARY_KEY_PROJECTION_INVALID",
|
||||
"ephemeral key projection is not reference-only",
|
||||
)
|
||||
before = self.gitea.list_deploy_keys(self.repository, credential_reference)
|
||||
if any(item.get("title") == title for item in before):
|
||||
raise StateConflict("GITEA_CANARY_KEY_COLLISION", "canary key title already exists")
|
||||
created = self.gitea.create_deploy_key(
|
||||
self.repository,
|
||||
title,
|
||||
projection.public_key,
|
||||
credential_reference,
|
||||
)
|
||||
raw_id = created.get("id")
|
||||
if not isinstance(raw_id, int) or created.get("key") != projection.public_key:
|
||||
raise StateConflict("GITEA_CANARY_CREATE_INVALID", "created key response is invalid")
|
||||
key_id = raw_id
|
||||
key_created = True
|
||||
visible = self.gitea.list_deploy_keys(self.repository, credential_reference)
|
||||
if not any(item.get("id") == key_id for item in visible):
|
||||
raise StateConflict("GITEA_CANARY_KEY_NOT_VISIBLE", "created key is not listed")
|
||||
if not self.ssh_probe.authenticate(
|
||||
self.repository, branch, projection.private_key_reference
|
||||
):
|
||||
raise StateConflict("GITEA_CANARY_SSH_AUTH_FAILED", "deploy key could not authenticate")
|
||||
self.gitea.delete_deploy_key(self.repository, key_id, credential_reference)
|
||||
key_deleted = True
|
||||
key_id = None
|
||||
after = self.gitea.list_deploy_keys(self.repository, credential_reference)
|
||||
api_absent = not any(item.get("title") == title for item in after)
|
||||
if not api_absent:
|
||||
raise StateConflict("GITEA_CANARY_DELETE_UNVERIFIED", "deleted key remains visible")
|
||||
self.projections.delete(projection.private_key_reference)
|
||||
projection_deleted = not self.projections.is_present(projection.private_key_reference)
|
||||
auth_rejected = not self.ssh_probe.authenticate(
|
||||
self.repository, branch, projection.private_key_reference
|
||||
)
|
||||
if not projection_deleted or not auth_rejected:
|
||||
raise StateConflict(
|
||||
"GITEA_CANARY_REVOCATION_UNVERIFIED",
|
||||
"projection deletion or post-revocation SSH rejection failed",
|
||||
)
|
||||
simulated = bool(getattr(self.gitea, "simulation", True))
|
||||
return GiteaCanaryResult(
|
||||
key_created=key_created,
|
||||
key_deleted=key_deleted,
|
||||
api_key_absent_after_delete=api_absent,
|
||||
post_revoke_auth_rejected=auth_rejected,
|
||||
credential_projection_deleted=projection_deleted,
|
||||
gitea_admin_api_lifecycle_canary=not simulated,
|
||||
simulation=simulated,
|
||||
secrets_included=False,
|
||||
)
|
||||
finally:
|
||||
if key_id is not None:
|
||||
try:
|
||||
self.gitea.delete_deploy_key(
|
||||
self.repository, key_id, credential_reference
|
||||
)
|
||||
except Exception:
|
||||
pass
|
||||
if projection is not None and self.projections.is_present(
|
||||
projection.private_key_reference
|
||||
):
|
||||
try:
|
||||
self.projections.delete(projection.private_key_reference)
|
||||
except Exception:
|
||||
pass
|
||||
-376
@@ -1,376 +0,0 @@
|
||||
"""Typed contracts for the dormant autonomous-release candidate.
|
||||
|
||||
This package is dependency-free by design so it can be audited and exercised in
|
||||
an isolated candidate worktree before any production service is installed.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
from dataclasses import dataclass, field
|
||||
from datetime import datetime, timezone
|
||||
from enum import Enum
|
||||
import hashlib
|
||||
import json
|
||||
from typing import Any, Mapping, Sequence
|
||||
|
||||
|
||||
def utc_now() -> datetime:
|
||||
"""Return an aware UTC timestamp."""
|
||||
return datetime.now(timezone.utc)
|
||||
|
||||
|
||||
def canonical_json(value: Any) -> str:
|
||||
"""Serialize *value* deterministically for signatures and evidence hashes."""
|
||||
return json.dumps(value, sort_keys=True, separators=(",", ":"), ensure_ascii=False)
|
||||
|
||||
|
||||
def sha256_json(value: Any) -> str:
|
||||
return hashlib.sha256(canonical_json(value).encode("utf-8")).hexdigest()
|
||||
|
||||
|
||||
def is_sha256(value: str) -> bool:
|
||||
return len(value) == 64 and all(ch in "0123456789abcdef" for ch in value)
|
||||
|
||||
|
||||
def is_git_oid(value: str) -> bool:
|
||||
return len(value) == 40 and all(ch in "0123456789abcdef" for ch in value)
|
||||
|
||||
|
||||
class RiskClass(str, Enum):
|
||||
LOW = "low"
|
||||
MEDIUM = "medium"
|
||||
HIGH = "high"
|
||||
CRITICAL = "critical"
|
||||
|
||||
|
||||
class TaskState(str, Enum):
|
||||
CREATED = "CREATED"
|
||||
PLANNED = "PLANNED"
|
||||
READY = "READY"
|
||||
RUNNING = "RUNNING"
|
||||
BLOCKED = "BLOCKED"
|
||||
FAILED = "FAILED"
|
||||
COMPLETED = "COMPLETED"
|
||||
READY_FOR_OWNER_APPROVAL = "READY_FOR_OWNER_APPROVAL"
|
||||
|
||||
|
||||
class StepState(str, Enum):
|
||||
PENDING = "PENDING"
|
||||
READY = "READY"
|
||||
CLAIMED = "CLAIMED"
|
||||
RUNNING = "RUNNING"
|
||||
BLOCKED = "BLOCKED"
|
||||
FAILED = "FAILED"
|
||||
COMPLETED = "COMPLETED"
|
||||
|
||||
|
||||
class CredentialState(str, Enum):
|
||||
REQUESTED = "REQUESTED"
|
||||
ISSUED = "ISSUED"
|
||||
PROJECTED = "PROJECTED"
|
||||
REVOKED = "REVOKED"
|
||||
EXPIRED = "EXPIRED"
|
||||
|
||||
|
||||
@dataclass(frozen=True, slots=True)
|
||||
class ResourceBinding:
|
||||
repository: str
|
||||
branch: str
|
||||
base_oid: str
|
||||
allowed_paths: tuple[str, ...] = ()
|
||||
|
||||
def __post_init__(self) -> None:
|
||||
if not self.repository or "/" not in self.repository:
|
||||
raise ValueError("repository must be owner/name")
|
||||
if self.branch == "main" or not self.branch.startswith(("patch/", "integration/", "candidate/")):
|
||||
raise ValueError("candidate execution requires a governed non-main branch")
|
||||
if not is_git_oid(self.base_oid):
|
||||
raise ValueError("base_oid must be a full lowercase 40-character Git OID")
|
||||
for path in self.allowed_paths:
|
||||
if not path or path.startswith("/") or ".." in path.split("/"):
|
||||
raise ValueError("allowed_paths must be repository-relative and traversal-free")
|
||||
|
||||
def allows_path(self, path: str) -> bool:
|
||||
if not path or path.startswith("/") or ".." in path.split("/"):
|
||||
return False
|
||||
return any(path == prefix or path.startswith(prefix.rstrip("/") + "/") for prefix in self.allowed_paths)
|
||||
|
||||
|
||||
@dataclass(frozen=True, slots=True)
|
||||
class ApprovalEnvelope:
|
||||
approval_plan_id: str
|
||||
task_id: str
|
||||
task_plan_sha256: str
|
||||
binding: ResourceBinding
|
||||
capabilities: tuple[str, ...]
|
||||
risk: RiskClass
|
||||
not_before: datetime
|
||||
expires_at: datetime
|
||||
nonce: str
|
||||
signing_key_id: str
|
||||
signature: str
|
||||
|
||||
def __post_init__(self) -> None:
|
||||
if self.expires_at <= self.not_before:
|
||||
raise ValueError("approval expiry must be after not_before")
|
||||
if not is_sha256(self.task_plan_sha256):
|
||||
raise ValueError("task_plan_sha256 must be a SHA-256 hex digest")
|
||||
if not self.approval_plan_id or not self.task_id or not self.nonce:
|
||||
raise ValueError("approval identifiers and nonce are required")
|
||||
|
||||
def payload(self) -> Mapping[str, Any]:
|
||||
return {
|
||||
"approval_plan_id": self.approval_plan_id,
|
||||
"task_id": self.task_id,
|
||||
"task_plan_sha256": self.task_plan_sha256,
|
||||
"repository": self.binding.repository,
|
||||
"branch": self.binding.branch,
|
||||
"base_oid": self.binding.base_oid,
|
||||
"allowed_paths": list(self.binding.allowed_paths),
|
||||
"capabilities": list(self.capabilities),
|
||||
"risk": self.risk.value,
|
||||
"not_before": self.not_before.astimezone(timezone.utc).isoformat(),
|
||||
"expires_at": self.expires_at.astimezone(timezone.utc).isoformat(),
|
||||
"nonce": self.nonce,
|
||||
"signing_key_id": self.signing_key_id,
|
||||
}
|
||||
|
||||
|
||||
@dataclass(frozen=True, slots=True)
|
||||
class WorkflowStep:
|
||||
step_id: str
|
||||
worker_role: str
|
||||
required_capabilities: tuple[str, ...]
|
||||
depends_on: tuple[str, ...] = ()
|
||||
max_attempts: int = 1
|
||||
timeout_seconds: int = 900
|
||||
allowed_paths: tuple[str, ...] = ()
|
||||
|
||||
def __post_init__(self) -> None:
|
||||
if not self.step_id or not self.worker_role:
|
||||
raise ValueError("step_id and worker_role are required")
|
||||
if self.max_attempts < 1 or self.max_attempts > 5:
|
||||
raise ValueError("max_attempts must be between 1 and 5")
|
||||
if self.timeout_seconds < 1 or self.timeout_seconds > 86_400:
|
||||
raise ValueError("timeout_seconds must be between 1 and 86400")
|
||||
if self.step_id in self.depends_on:
|
||||
raise ValueError("a step cannot depend on itself")
|
||||
|
||||
|
||||
@dataclass(frozen=True, slots=True)
|
||||
class TaskPlan:
|
||||
task_id: str
|
||||
intent: str
|
||||
binding: ResourceBinding
|
||||
risk: RiskClass
|
||||
steps: tuple[WorkflowStep, ...]
|
||||
evidence_requirements: tuple[str, ...]
|
||||
production_side_effects_allowed: bool = False
|
||||
created_at: datetime = field(default_factory=utc_now)
|
||||
|
||||
def __post_init__(self) -> None:
|
||||
if not self.task_id or not self.intent:
|
||||
raise ValueError("task_id and intent are required")
|
||||
if self.production_side_effects_allowed:
|
||||
raise ValueError("candidate TaskPlan must not allow production side effects")
|
||||
ids = [step.step_id for step in self.steps]
|
||||
if len(ids) != len(set(ids)):
|
||||
raise ValueError("step IDs must be unique")
|
||||
known = set(ids)
|
||||
for step in self.steps:
|
||||
missing = set(step.depends_on) - known
|
||||
if missing:
|
||||
raise ValueError(f"step {step.step_id} has unknown dependencies: {sorted(missing)}")
|
||||
self._validate_acyclic()
|
||||
|
||||
def _validate_acyclic(self) -> None:
|
||||
dependencies = {step.step_id: set(step.depends_on) for step in self.steps}
|
||||
pending = set(dependencies)
|
||||
while pending:
|
||||
ready = {step_id for step_id in pending if not (dependencies[step_id] & pending)}
|
||||
if not ready:
|
||||
raise ValueError("workflow contains a dependency cycle")
|
||||
pending -= ready
|
||||
|
||||
def digest(self) -> str:
|
||||
return sha256_json(
|
||||
{
|
||||
"task_id": self.task_id,
|
||||
"intent": self.intent,
|
||||
"repository": self.binding.repository,
|
||||
"branch": self.binding.branch,
|
||||
"base_oid": self.binding.base_oid,
|
||||
"allowed_paths": list(self.binding.allowed_paths),
|
||||
"risk": self.risk.value,
|
||||
"steps": [
|
||||
{
|
||||
"step_id": step.step_id,
|
||||
"worker_role": step.worker_role,
|
||||
"required_capabilities": list(step.required_capabilities),
|
||||
"depends_on": list(step.depends_on),
|
||||
"max_attempts": step.max_attempts,
|
||||
"timeout_seconds": step.timeout_seconds,
|
||||
"allowed_paths": list(step.allowed_paths),
|
||||
}
|
||||
for step in self.steps
|
||||
],
|
||||
"evidence_requirements": list(self.evidence_requirements),
|
||||
"production_side_effects_allowed": self.production_side_effects_allowed,
|
||||
"created_at": self.created_at.astimezone(timezone.utc).isoformat(),
|
||||
}
|
||||
)
|
||||
|
||||
|
||||
@dataclass(frozen=True, slots=True)
|
||||
class WorkerDescriptor:
|
||||
worker_id: str
|
||||
role: str
|
||||
capabilities: frozenset[str]
|
||||
trust_zone: str
|
||||
endpoint_id: str
|
||||
online: bool = True
|
||||
current_load: int = 0
|
||||
max_concurrency: int = 1
|
||||
|
||||
def can_accept(self, required: Sequence[str], trust_zone: str) -> bool:
|
||||
return (
|
||||
self.online
|
||||
and self.trust_zone == trust_zone
|
||||
and self.current_load < self.max_concurrency
|
||||
and set(required).issubset(self.capabilities)
|
||||
)
|
||||
|
||||
|
||||
@dataclass(frozen=True, slots=True)
|
||||
class CredentialRequest:
|
||||
request_id: str
|
||||
task_id: str
|
||||
session_id: str
|
||||
worker_id: str
|
||||
audience: str
|
||||
consumer_service: str
|
||||
binding: ResourceBinding
|
||||
operations: tuple[str, ...]
|
||||
provider: str
|
||||
runtime_user: str
|
||||
approval_plan_id: str
|
||||
not_before: datetime
|
||||
expires_at: datetime
|
||||
nonce: str
|
||||
ttl_seconds: int
|
||||
max_uses: int
|
||||
|
||||
def __post_init__(self) -> None:
|
||||
if self.ttl_seconds < 1 or self.ttl_seconds > 3600:
|
||||
raise ValueError("credential TTL must be between 1 and 3600 seconds")
|
||||
if self.max_uses < 1 or self.max_uses > 1000:
|
||||
raise ValueError("credential max_uses must be between 1 and 1000")
|
||||
if not self.operations:
|
||||
raise ValueError("credential operations cannot be empty")
|
||||
required = (
|
||||
self.request_id,
|
||||
self.task_id,
|
||||
self.session_id,
|
||||
self.worker_id,
|
||||
self.audience,
|
||||
self.consumer_service,
|
||||
self.provider,
|
||||
self.runtime_user,
|
||||
self.approval_plan_id,
|
||||
self.nonce,
|
||||
)
|
||||
if any(not item or item != item.strip() for item in required):
|
||||
raise ValueError("credential identity, scope and approval fields are required")
|
||||
if len(set(self.operations)) != len(self.operations):
|
||||
raise ValueError("credential operations must be unique")
|
||||
if self.not_before.tzinfo is None or self.expires_at.tzinfo is None:
|
||||
raise ValueError("credential time bounds must be timezone aware")
|
||||
if self.expires_at <= self.not_before:
|
||||
raise ValueError("credential expires_at must follow not_before")
|
||||
if (self.expires_at - self.not_before).total_seconds() > self.ttl_seconds:
|
||||
raise ValueError("credential approval window exceeds requested TTL")
|
||||
|
||||
|
||||
@dataclass(frozen=True, slots=True)
|
||||
class CredentialProjection:
|
||||
credential_id: str
|
||||
reference: str
|
||||
request: CredentialRequest
|
||||
state: CredentialState
|
||||
issued_at: datetime
|
||||
expires_at: datetime
|
||||
plaintext_returned: bool = False
|
||||
|
||||
def __post_init__(self) -> None:
|
||||
if self.plaintext_returned:
|
||||
raise ValueError("credential plaintext must never be returned")
|
||||
if self.expires_at <= self.issued_at:
|
||||
raise ValueError("credential expiry must be after issuance")
|
||||
|
||||
|
||||
@dataclass(frozen=True, slots=True)
|
||||
class ResultEnvelope:
|
||||
task_id: str
|
||||
step_id: str
|
||||
worker_id: str
|
||||
session_id: str
|
||||
claim_id: str
|
||||
operation_digest: str
|
||||
result_digest: str
|
||||
evidence_digests: tuple[str, ...]
|
||||
completed_at: datetime = field(default_factory=utc_now)
|
||||
|
||||
def __post_init__(self) -> None:
|
||||
if not is_sha256(self.operation_digest) or not is_sha256(self.result_digest):
|
||||
raise ValueError("operation_digest and result_digest must be SHA-256 values")
|
||||
if any(not is_sha256(digest) for digest in self.evidence_digests):
|
||||
raise ValueError("all evidence digests must be SHA-256 values")
|
||||
|
||||
|
||||
@dataclass(frozen=True, slots=True)
|
||||
class ReleasePlan:
|
||||
task_id: str
|
||||
repository: str
|
||||
branch: str
|
||||
version: str
|
||||
target_oid: str
|
||||
tree_oid: str
|
||||
artifact_sha256: str
|
||||
manifest_sha256: str
|
||||
package_closure_sha256: str
|
||||
evidence_closure_oid: str
|
||||
approval_plan_id: str
|
||||
rollback_approval_plan_id: str
|
||||
rollback_artifact_sha256: str
|
||||
expected_tag_oid: str
|
||||
expected_target_oid: str
|
||||
production_config_sha256: str
|
||||
|
||||
def __post_init__(self) -> None:
|
||||
for name in ("target_oid", "tree_oid", "evidence_closure_oid", "expected_target_oid"):
|
||||
if not is_git_oid(getattr(self, name)):
|
||||
raise ValueError(f"{name} must be a full lowercase 40-character Git OID")
|
||||
for name in (
|
||||
"artifact_sha256",
|
||||
"manifest_sha256",
|
||||
"package_closure_sha256",
|
||||
"rollback_artifact_sha256",
|
||||
"production_config_sha256",
|
||||
):
|
||||
if not is_sha256(getattr(self, name)):
|
||||
raise ValueError(f"{name} must be a SHA-256 hex digest")
|
||||
if not is_git_oid(self.expected_tag_oid):
|
||||
raise ValueError("expected_tag_oid must be a full lowercase 40-character Git OID")
|
||||
if (
|
||||
not self.task_id
|
||||
or "/" not in self.repository
|
||||
or not self.branch.startswith("integration/")
|
||||
or not self.version
|
||||
or not self.approval_plan_id
|
||||
or not self.rollback_approval_plan_id
|
||||
):
|
||||
raise ValueError("release identifiers are required")
|
||||
if self.approval_plan_id == self.rollback_approval_plan_id:
|
||||
raise ValueError("deployment and rollback approvals must be distinct")
|
||||
if self.target_oid != self.expected_target_oid:
|
||||
raise ValueError("target_oid must equal expected_target_oid")
|
||||
-246
@@ -1,246 +0,0 @@
|
||||
"""Candidate-only OpenClaw and Codex native session adapter contracts."""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
from dataclasses import dataclass
|
||||
from typing import Any, Mapping, Protocol, Sequence
|
||||
import uuid
|
||||
|
||||
from .errors import StateConflict
|
||||
|
||||
|
||||
class NativeProvider(Protocol):
|
||||
simulation: bool
|
||||
|
||||
def spawn(
|
||||
self, request: Mapping[str, Any], credential_reference: str
|
||||
) -> Mapping[str, Any]: ...
|
||||
|
||||
def status(
|
||||
self, provider_session_id: str, credential_reference: str
|
||||
) -> Mapping[str, Any]: ...
|
||||
|
||||
def list_tree(
|
||||
self, parent_session_id: str, credential_reference: str
|
||||
) -> Sequence[Mapping[str, Any]]: ...
|
||||
|
||||
def send_text(
|
||||
self,
|
||||
provider_session_id: str,
|
||||
payload: Mapping[str, Any],
|
||||
credential_reference: str,
|
||||
) -> Mapping[str, Any]: ...
|
||||
|
||||
def interrupt(self, provider_session_id: str, credential_reference: str) -> None: ...
|
||||
|
||||
def close(self, provider_session_id: str, credential_reference: str) -> None: ...
|
||||
|
||||
|
||||
@dataclass(frozen=True, slots=True)
|
||||
class NativeSession:
|
||||
provider: str
|
||||
broker_session_id: str
|
||||
provider_session_id: str
|
||||
task_id: str
|
||||
parent_session_id: str
|
||||
recipient_binding: Mapping[str, str]
|
||||
|
||||
|
||||
@dataclass(frozen=True, slots=True)
|
||||
class SessionVerification:
|
||||
broker_session_verified: bool
|
||||
openclaw_native_child_session_verified: bool
|
||||
codex_child_session_verified: bool
|
||||
simulation: bool
|
||||
|
||||
|
||||
@dataclass(frozen=True, slots=True)
|
||||
class TextResult:
|
||||
content_type: str
|
||||
encoding: str
|
||||
image_only: bool
|
||||
task_id: str
|
||||
message_id: str
|
||||
receipt: str
|
||||
recipient_binding: Mapping[str, str]
|
||||
secrets_included: bool
|
||||
|
||||
|
||||
class CandidateNativeAdapter:
|
||||
provider = ""
|
||||
required_reference = ""
|
||||
|
||||
def __init__(self, client: NativeProvider, credential_reference: str) -> None:
|
||||
if credential_reference != self.required_reference:
|
||||
raise StateConflict(
|
||||
"CANDIDATE_CREDENTIAL_REFERENCE_MISMATCH",
|
||||
"adapter requires its exact Candidate credential reference",
|
||||
)
|
||||
self.client = client
|
||||
self.credential_reference = credential_reference
|
||||
|
||||
@staticmethod
|
||||
def _recipient(value: Mapping[str, Any]) -> dict[str, str]:
|
||||
recipient_id = value.get("recipient_id")
|
||||
if (
|
||||
not isinstance(recipient_id, str)
|
||||
or not recipient_id
|
||||
or isinstance(value.get("recipients"), (list, tuple))
|
||||
):
|
||||
raise StateConflict(
|
||||
"RECIPIENT_BINDING_REQUIRED",
|
||||
"one trusted TaskPlan recipient binding is required",
|
||||
)
|
||||
return {str(key): str(item) for key, item in value.items()}
|
||||
|
||||
def spawn(
|
||||
self,
|
||||
task_id: str,
|
||||
parent_session_id: str,
|
||||
recipient_binding: Mapping[str, Any],
|
||||
) -> NativeSession:
|
||||
if not task_id or not parent_session_id:
|
||||
raise StateConflict("NATIVE_SESSION_BINDING_REQUIRED", "task and parent are required")
|
||||
recipient = self._recipient(recipient_binding)
|
||||
response = self.client.spawn(
|
||||
{
|
||||
"task_id": task_id,
|
||||
"parent_session_id": parent_session_id,
|
||||
"recipient_binding": recipient,
|
||||
"candidate_only": True,
|
||||
"production_session_access": False,
|
||||
},
|
||||
self.credential_reference,
|
||||
)
|
||||
provider_session_id = response.get("provider_session_id")
|
||||
if (
|
||||
not isinstance(provider_session_id, str)
|
||||
or not provider_session_id
|
||||
or response.get("task_id") != task_id
|
||||
or response.get("parent_session_id") != parent_session_id
|
||||
or response.get("candidate_only") is not True
|
||||
or response.get("production_session_access") is not False
|
||||
):
|
||||
raise StateConflict(
|
||||
"NATIVE_SESSION_PROVISIONING_INVALID",
|
||||
"provider response is not bound to this Candidate task",
|
||||
)
|
||||
broker_id = f"broker-{uuid.uuid4()}"
|
||||
if broker_id == provider_session_id:
|
||||
raise StateConflict("SESSION_ID_COLLISION", "broker and provider IDs must differ")
|
||||
return NativeSession(
|
||||
provider=self.provider,
|
||||
broker_session_id=broker_id,
|
||||
provider_session_id=provider_session_id,
|
||||
task_id=task_id,
|
||||
parent_session_id=parent_session_id,
|
||||
recipient_binding=recipient,
|
||||
)
|
||||
|
||||
def verify(self, session: NativeSession) -> SessionVerification:
|
||||
self._validate_session(session)
|
||||
status = self.client.status(session.provider_session_id, self.credential_reference)
|
||||
tree = self.client.list_tree(session.parent_session_id, self.credential_reference)
|
||||
status_valid = (
|
||||
status.get("provider_session_id") == session.provider_session_id
|
||||
and status.get("state") in {"PROVISIONED", "ACTIVE", "RUNNING"}
|
||||
)
|
||||
tree_valid = any(
|
||||
item.get("provider_session_id") == session.provider_session_id
|
||||
and item.get("parent_session_id") == session.parent_session_id
|
||||
for item in tree
|
||||
)
|
||||
if not status_valid or not tree_valid:
|
||||
raise StateConflict(
|
||||
"NATIVE_SESSION_VERIFICATION_FAILED",
|
||||
"provider status or parent/child tree is inconsistent",
|
||||
)
|
||||
simulated = bool(getattr(self.client, "simulation", True))
|
||||
return SessionVerification(
|
||||
broker_session_verified=True,
|
||||
openclaw_native_child_session_verified=(
|
||||
self.provider == "openclaw" and not simulated
|
||||
),
|
||||
codex_child_session_verified=(self.provider == "codex" and not simulated),
|
||||
simulation=simulated,
|
||||
)
|
||||
|
||||
def send_text(self, session: NativeSession, text: str) -> TextResult:
|
||||
self._validate_session(session)
|
||||
if not isinstance(text, str) or not text:
|
||||
raise StateConflict("TEXT_RESULT_REQUIRED", "non-empty text is required")
|
||||
response = self.client.send_text(
|
||||
session.provider_session_id,
|
||||
{
|
||||
"task_id": session.task_id,
|
||||
"content_type": "text/plain",
|
||||
"encoding": "utf-8",
|
||||
"image_only": False,
|
||||
"text": text,
|
||||
"recipient_binding": dict(session.recipient_binding),
|
||||
"secrets_included": False,
|
||||
},
|
||||
self.credential_reference,
|
||||
)
|
||||
required = {
|
||||
"content_type": "text/plain",
|
||||
"encoding": "utf-8",
|
||||
"image_only": False,
|
||||
"task_id": session.task_id,
|
||||
"recipient_binding": dict(session.recipient_binding),
|
||||
"secrets_included": False,
|
||||
}
|
||||
if any(response.get(key) != value for key, value in required.items()):
|
||||
raise StateConflict("TEXT_RESULT_CONTRACT_INVALID", "text result binding is invalid")
|
||||
message_id = response.get("message_id")
|
||||
receipt = response.get("receipt")
|
||||
if not isinstance(message_id, str) or not message_id or not isinstance(receipt, str) or not receipt:
|
||||
raise StateConflict("TEXT_RESULT_RECEIPT_REQUIRED", "message and receipt are required")
|
||||
return TextResult(
|
||||
content_type="text/plain",
|
||||
encoding="utf-8",
|
||||
image_only=False,
|
||||
task_id=session.task_id,
|
||||
message_id=message_id,
|
||||
receipt=receipt,
|
||||
recipient_binding=dict(session.recipient_binding),
|
||||
secrets_included=False,
|
||||
)
|
||||
|
||||
def status(self, session: NativeSession) -> str:
|
||||
self._validate_session(session)
|
||||
response = self.client.status(session.provider_session_id, self.credential_reference)
|
||||
if response.get("provider_session_id") != session.provider_session_id:
|
||||
raise StateConflict("NATIVE_SESSION_STATUS_INVALID", "provider session ID changed")
|
||||
state = response.get("state")
|
||||
if not isinstance(state, str) or not state:
|
||||
raise StateConflict("NATIVE_SESSION_STATUS_INVALID", "provider state is missing")
|
||||
return state
|
||||
|
||||
def interrupt(self, session: NativeSession) -> None:
|
||||
self._validate_session(session)
|
||||
self.client.interrupt(session.provider_session_id, self.credential_reference)
|
||||
if self.status(session) != "INTERRUPTED":
|
||||
raise StateConflict("NATIVE_SESSION_INTERRUPT_FAILED", "interrupt was not observed")
|
||||
|
||||
def close(self, session: NativeSession) -> None:
|
||||
self._validate_session(session)
|
||||
self.client.close(session.provider_session_id, self.credential_reference)
|
||||
if self.status(session) != "CLOSED":
|
||||
raise StateConflict("NATIVE_SESSION_CLOSE_FAILED", "close was not observed")
|
||||
|
||||
def _validate_session(self, session: NativeSession) -> None:
|
||||
if session.provider != self.provider:
|
||||
raise StateConflict("NATIVE_SESSION_PROVIDER_MISMATCH", "session provider differs")
|
||||
if session.broker_session_id == session.provider_session_id:
|
||||
raise StateConflict("SESSION_ID_COLLISION", "broker and provider IDs must differ")
|
||||
|
||||
|
||||
class OpenClawNativeAdapter(CandidateNativeAdapter):
|
||||
provider = "openclaw"
|
||||
required_reference = "systemd-credential:openclaw-gateway-candidate"
|
||||
|
||||
|
||||
class CodexNativeAdapter(CandidateNativeAdapter):
|
||||
provider = "codex"
|
||||
required_reference = "systemd-credential:codex-app-server-candidate"
|
||||
-54
@@ -1,54 +0,0 @@
|
||||
"""High-level autonomous release orchestration facade."""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
from dataclasses import dataclass
|
||||
|
||||
from .evidence import EvidenceChain
|
||||
from .models import TaskPlan
|
||||
from .policy import ReleasePolicy
|
||||
from .workflow import WorkflowEngine
|
||||
|
||||
|
||||
@dataclass(frozen=True, slots=True)
|
||||
class OrchestrationResult:
|
||||
task_id: str
|
||||
plan_digest: str
|
||||
evidence_closure: str | None
|
||||
production_side_effects: bool
|
||||
|
||||
|
||||
class AutonomousReleaseOrchestrator:
|
||||
"""Coordinates candidate workflows while keeping production disabled."""
|
||||
|
||||
def __init__(self, workflow: WorkflowEngine, policy: ReleasePolicy) -> None:
|
||||
self.workflow = workflow
|
||||
self.policy = policy
|
||||
self.evidence: EvidenceChain | None = None
|
||||
|
||||
def create(self, plan: TaskPlan) -> OrchestrationResult:
|
||||
self.policy.validate_task(plan)
|
||||
self.workflow.plan(plan)
|
||||
self.evidence = EvidenceChain(self.workflow.store, plan.task_id)
|
||||
self.evidence.append(
|
||||
"TASK_CREATED",
|
||||
plan.task_id,
|
||||
{"plan_digest": plan.digest(), "secrets_included": False},
|
||||
)
|
||||
return OrchestrationResult(
|
||||
task_id=plan.task_id,
|
||||
plan_digest=plan.digest(),
|
||||
evidence_closure=None,
|
||||
production_side_effects=False,
|
||||
)
|
||||
|
||||
def close_evidence(self, task_id: str) -> OrchestrationResult:
|
||||
if self.evidence is None or self.evidence.task_id != task_id:
|
||||
self.evidence = EvidenceChain(self.workflow.store, task_id)
|
||||
closure = self.evidence.closure_digest()
|
||||
return OrchestrationResult(
|
||||
task_id=task_id,
|
||||
plan_digest="",
|
||||
evidence_closure=closure,
|
||||
production_side_effects=False,
|
||||
)
|
||||
-75
@@ -1,75 +0,0 @@
|
||||
"""Deterministic task planning for autonomous candidate releases."""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
from dataclasses import dataclass
|
||||
|
||||
from .models import ResourceBinding, RiskClass, TaskPlan, WorkflowStep
|
||||
|
||||
|
||||
@dataclass(frozen=True, slots=True)
|
||||
class PlanningRequest:
|
||||
task_id: str
|
||||
intent: str
|
||||
binding: ResourceBinding
|
||||
risk: RiskClass = RiskClass.MEDIUM
|
||||
|
||||
|
||||
class DeterministicPlanner:
|
||||
"""Create a fixed governed DAG without granting production capabilities."""
|
||||
|
||||
def build(self, request: PlanningRequest) -> TaskPlan:
|
||||
steps = (
|
||||
WorkflowStep(
|
||||
step_id="architecture-review",
|
||||
worker_role="hermes-review",
|
||||
required_capabilities=("architecture.review", "risk.analysis"),
|
||||
allowed_paths=request.binding.allowed_paths,
|
||||
),
|
||||
WorkflowStep(
|
||||
step_id="implementation",
|
||||
worker_role="dedicated-writer",
|
||||
required_capabilities=("commit_file.atomic", "git.push.patch_branch"),
|
||||
depends_on=("architecture-review",),
|
||||
max_attempts=2,
|
||||
allowed_paths=request.binding.allowed_paths,
|
||||
),
|
||||
WorkflowStep(
|
||||
step_id="code-review",
|
||||
worker_role="codex-review",
|
||||
required_capabilities=("code.review", "git.diff.read"),
|
||||
depends_on=("implementation",),
|
||||
allowed_paths=request.binding.allowed_paths,
|
||||
),
|
||||
WorkflowStep(
|
||||
step_id="validation",
|
||||
worker_role="openclaw-shadow",
|
||||
required_capabilities=("test.execute", "artifact.verify"),
|
||||
depends_on=("code-review",),
|
||||
max_attempts=2,
|
||||
allowed_paths=request.binding.allowed_paths,
|
||||
),
|
||||
WorkflowStep(
|
||||
step_id="evidence-finalize",
|
||||
worker_role="evidence-controller",
|
||||
required_capabilities=("evidence.finalize",),
|
||||
depends_on=("validation",),
|
||||
allowed_paths=request.binding.allowed_paths,
|
||||
),
|
||||
)
|
||||
return TaskPlan(
|
||||
task_id=request.task_id,
|
||||
intent=request.intent,
|
||||
binding=request.binding,
|
||||
risk=request.risk,
|
||||
steps=steps,
|
||||
evidence_requirements=(
|
||||
"git-ref-closure",
|
||||
"test-report",
|
||||
"secret-scan",
|
||||
"artifact-manifest",
|
||||
"credential-revocation",
|
||||
"production-invariants",
|
||||
),
|
||||
production_side_effects_allowed=False,
|
||||
)
|
||||
-54
@@ -1,54 +0,0 @@
|
||||
"""Fail-closed policy engine for autonomous release workflows."""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
from dataclasses import dataclass
|
||||
from datetime import datetime, timezone
|
||||
|
||||
from .errors import ApprovalRequired, CapabilityMismatch, PolicyDenied
|
||||
from .models import ApprovalEnvelope, ResourceBinding, RiskClass, TaskPlan, WorkerDescriptor
|
||||
|
||||
|
||||
FORBIDDEN_CAPABILITIES = frozenset({
|
||||
"production.deploy",
|
||||
"production.rollback",
|
||||
"main.write",
|
||||
"tag.write",
|
||||
"baseline.write",
|
||||
"registry.write",
|
||||
"secret.export",
|
||||
})
|
||||
|
||||
|
||||
@dataclass(frozen=True, slots=True)
|
||||
class PolicyDecision:
|
||||
allowed: bool
|
||||
reason: str
|
||||
|
||||
|
||||
class ReleasePolicy:
|
||||
def validate_binding(self, binding: ResourceBinding) -> PolicyDecision:
|
||||
if binding.branch == "main":
|
||||
raise PolicyDenied("MAIN_WRITE_DENIED", "main branch is never writable")
|
||||
if not binding.allowed_paths:
|
||||
raise PolicyDenied("PATH_SCOPE_REQUIRED", "candidate path scope is required")
|
||||
return PolicyDecision(True, "binding_valid")
|
||||
|
||||
def validate_task(self, plan: TaskPlan) -> PolicyDecision:
|
||||
self.validate_binding(plan.binding)
|
||||
if plan.production_side_effects_allowed:
|
||||
raise PolicyDenied("PRODUCTION_SIDE_EFFECT_DENIED", "candidate workflows cannot execute production side effects")
|
||||
return PolicyDecision(True, "task_valid")
|
||||
|
||||
def validate_approval(self, approval: ApprovalEnvelope, now: datetime | None = None) -> PolicyDecision:
|
||||
now = now or datetime.now(timezone.utc)
|
||||
if now < approval.not_before or now >= approval.expires_at:
|
||||
raise ApprovalRequired("APPROVAL_TIME_INVALID", "approval is outside its validity window")
|
||||
if any(cap in FORBIDDEN_CAPABILITIES for cap in approval.capabilities):
|
||||
raise PolicyDenied("CAPABILITY_FORBIDDEN", "approval requests forbidden capability")
|
||||
return PolicyDecision(True, "approval_valid")
|
||||
|
||||
def validate_worker(self, worker: WorkerDescriptor, required: tuple[str, ...], trust_zone: str) -> PolicyDecision:
|
||||
if not worker.can_accept(required, trust_zone):
|
||||
raise CapabilityMismatch("WORKER_CAPABILITY_MISMATCH", "worker cannot satisfy task requirements")
|
||||
return PolicyDecision(True, "worker_valid")
|
||||
-152
@@ -1,152 +0,0 @@
|
||||
"""Governed deployment and rollback state machine."""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
from dataclasses import dataclass
|
||||
from enum import Enum
|
||||
|
||||
from .approval import ApprovalVerificationResult
|
||||
from .errors import ReleaseBlocked
|
||||
from .models import ReleasePlan
|
||||
|
||||
|
||||
class ReleaseState(str, Enum):
|
||||
CREATED = "CREATED"
|
||||
BUILT = "BUILT"
|
||||
VERIFIED = "VERIFIED"
|
||||
WAITING_OWNER = "WAITING_OWNER"
|
||||
APPROVED = "APPROVED"
|
||||
DEPLOYING = "DEPLOYING"
|
||||
DEPLOYED = "DEPLOYED"
|
||||
FAILED = "FAILED"
|
||||
ROLLBACK_REQUESTED = "ROLLBACK_REQUESTED"
|
||||
ROLLBACK_APPROVED = "ROLLBACK_APPROVED"
|
||||
ROLLING_BACK = "ROLLING_BACK"
|
||||
ROLLED_BACK = "ROLLED_BACK"
|
||||
|
||||
|
||||
@dataclass(frozen=True, slots=True)
|
||||
class ReleaseStatus:
|
||||
state: ReleaseState
|
||||
reason: str | None = None
|
||||
|
||||
|
||||
class ReleaseController:
|
||||
"""No transition reaches deployment or rollback without an external receipt."""
|
||||
|
||||
def __init__(self) -> None:
|
||||
self._state = ReleaseState.CREATED
|
||||
self._plan: ReleasePlan | None = None
|
||||
self._reason: str | None = None
|
||||
|
||||
def _expect(self, *states: ReleaseState) -> None:
|
||||
if self._state not in states:
|
||||
raise ReleaseBlocked(
|
||||
"RELEASE_STATE_INVALID",
|
||||
"release transition is not allowed from the current state",
|
||||
{"state": self._state.value, "allowed": [item.value for item in states]},
|
||||
)
|
||||
|
||||
def attach_plan(self, plan: ReleasePlan) -> ReleaseStatus:
|
||||
if self._plan is not None:
|
||||
if self._plan == plan:
|
||||
return self.status()
|
||||
raise ReleaseBlocked("RELEASE_PLAN_ALREADY_ATTACHED", "release plan is immutable")
|
||||
self._plan = plan
|
||||
return self.status()
|
||||
|
||||
def mark_built(self) -> ReleaseStatus:
|
||||
self._require_plan()
|
||||
self._expect(ReleaseState.CREATED)
|
||||
self._state = ReleaseState.BUILT
|
||||
return self.status()
|
||||
|
||||
def verify(self, *, artifact_ok: bool, evidence_ok: bool) -> ReleaseStatus:
|
||||
self._require_plan()
|
||||
self._expect(ReleaseState.BUILT)
|
||||
if not artifact_ok or not evidence_ok:
|
||||
raise ReleaseBlocked(
|
||||
"RELEASE_VERIFICATION_FAILED", "artifact or evidence verification failed"
|
||||
)
|
||||
self._state = ReleaseState.VERIFIED
|
||||
return self.status()
|
||||
|
||||
def request_owner_approval(self) -> ReleaseStatus:
|
||||
self._expect(ReleaseState.VERIFIED)
|
||||
self._state = ReleaseState.WAITING_OWNER
|
||||
return self.status()
|
||||
|
||||
def approve(self, receipt: ApprovalVerificationResult) -> ReleaseStatus:
|
||||
plan = self._require_plan()
|
||||
self._expect(ReleaseState.WAITING_OWNER)
|
||||
if receipt.task_id != plan.task_id:
|
||||
raise ReleaseBlocked("OWNER_APPROVAL_TASK_MISMATCH", "approval task does not match")
|
||||
if receipt.approval_plan_id != plan.approval_plan_id:
|
||||
raise ReleaseBlocked(
|
||||
"OWNER_APPROVAL_PLAN_MISMATCH", "approval plan does not match release plan"
|
||||
)
|
||||
self._state = ReleaseState.APPROVED
|
||||
return self.status()
|
||||
|
||||
def start_deployment(self) -> ReleaseStatus:
|
||||
self._expect(ReleaseState.APPROVED)
|
||||
self._state = ReleaseState.DEPLOYING
|
||||
return self.status()
|
||||
|
||||
def mark_deployed(self) -> ReleaseStatus:
|
||||
self._expect(ReleaseState.DEPLOYING)
|
||||
self._state = ReleaseState.DEPLOYED
|
||||
return self.status()
|
||||
|
||||
def mark_failed(self, reason: str) -> ReleaseStatus:
|
||||
self._expect(ReleaseState.DEPLOYING, ReleaseState.DEPLOYED)
|
||||
if not reason:
|
||||
raise ReleaseBlocked("RELEASE_FAILURE_REASON_REQUIRED", "failure reason is required")
|
||||
self._reason = reason
|
||||
self._state = ReleaseState.FAILED
|
||||
return self.status()
|
||||
|
||||
def request_rollback(self, reason: str) -> ReleaseStatus:
|
||||
self._expect(ReleaseState.DEPLOYING, ReleaseState.DEPLOYED, ReleaseState.FAILED)
|
||||
if not reason:
|
||||
raise ReleaseBlocked("ROLLBACK_REASON_REQUIRED", "rollback reason is required")
|
||||
self._reason = reason
|
||||
self._state = ReleaseState.ROLLBACK_REQUESTED
|
||||
return self.status()
|
||||
|
||||
def approve_rollback(self, receipt: ApprovalVerificationResult) -> ReleaseStatus:
|
||||
plan = self._require_plan()
|
||||
self._expect(ReleaseState.ROLLBACK_REQUESTED)
|
||||
if receipt.task_id != plan.task_id:
|
||||
raise ReleaseBlocked("ROLLBACK_APPROVAL_TASK_MISMATCH", "rollback task does not match")
|
||||
if receipt.approval_plan_id != plan.rollback_approval_plan_id:
|
||||
raise ReleaseBlocked(
|
||||
"ROLLBACK_APPROVAL_PLAN_MISMATCH",
|
||||
"rollback approval plan does not match release plan",
|
||||
)
|
||||
self._state = ReleaseState.ROLLBACK_APPROVED
|
||||
return self.status()
|
||||
|
||||
def start_rollback(self) -> ReleaseStatus:
|
||||
self._expect(ReleaseState.ROLLBACK_APPROVED)
|
||||
self._state = ReleaseState.ROLLING_BACK
|
||||
return self.status()
|
||||
|
||||
def mark_rolled_back(self) -> ReleaseStatus:
|
||||
self._expect(ReleaseState.ROLLING_BACK)
|
||||
self._state = ReleaseState.ROLLED_BACK
|
||||
return self.status()
|
||||
|
||||
def rollback(self) -> ReleaseStatus:
|
||||
raise ReleaseBlocked(
|
||||
"ROLLBACK_APPROVAL_REQUIRED",
|
||||
"use request_rollback, approve_rollback and start_rollback",
|
||||
)
|
||||
|
||||
def status(self) -> ReleaseStatus:
|
||||
return ReleaseStatus(self._state, self._reason)
|
||||
|
||||
def _require_plan(self) -> ReleasePlan:
|
||||
if self._plan is None:
|
||||
raise ReleaseBlocked("RELEASE_PLAN_REQUIRED", "attach a release plan first")
|
||||
return self._plan
|
||||
-72
@@ -1,72 +0,0 @@
|
||||
"""Read-only multi-source release consistency gate."""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
from dataclasses import dataclass
|
||||
|
||||
from .errors import ReleaseBlocked
|
||||
from .models import is_git_oid, is_sha256
|
||||
|
||||
|
||||
@dataclass(frozen=True, slots=True)
|
||||
class ReleaseEvidence:
|
||||
expected_version: str
|
||||
registry_version: str
|
||||
baseline_version: str
|
||||
local_tag_oid: str
|
||||
remote_tag_oid: str
|
||||
gitea_tag_oid: str
|
||||
expected_tag_oid: str
|
||||
local_peeled_target_oid: str
|
||||
remote_peeled_target_oid: str
|
||||
gitea_peeled_target_oid: str
|
||||
expected_target_oid: str
|
||||
artifact_sha256: str
|
||||
manifest_sha256: str
|
||||
evidence_sha256: str
|
||||
rollback_artifact_sha256: str
|
||||
|
||||
|
||||
class ReleaseGate:
|
||||
"""Require exact tag-object, peeled-target, version and package closure."""
|
||||
|
||||
def verify(self, evidence: ReleaseEvidence) -> None:
|
||||
versions = (
|
||||
evidence.expected_version,
|
||||
evidence.registry_version,
|
||||
evidence.baseline_version,
|
||||
)
|
||||
if not versions[0] or len(set(versions)) != 1:
|
||||
raise ReleaseBlocked("VERSION_MISMATCH", "expected, registry and baseline differ")
|
||||
tag_oids = (
|
||||
evidence.local_tag_oid,
|
||||
evidence.remote_tag_oid,
|
||||
evidence.gitea_tag_oid,
|
||||
evidence.expected_tag_oid,
|
||||
)
|
||||
if any(not is_git_oid(value) for value in tag_oids):
|
||||
raise ReleaseBlocked("TAG_OID_INVALID", "tag object OID is invalid")
|
||||
if evidence.local_tag_oid != evidence.remote_tag_oid:
|
||||
raise ReleaseBlocked("TAG_REMOTE_MISMATCH", "local and remote tag objects differ")
|
||||
if evidence.remote_tag_oid != evidence.gitea_tag_oid:
|
||||
raise ReleaseBlocked("TAG_GITEA_MISMATCH", "Gitea tag object differs")
|
||||
if evidence.gitea_tag_oid != evidence.expected_tag_oid:
|
||||
raise ReleaseBlocked("TAG_OBJECT_MISMATCH", "tag object differs from ReleasePlan")
|
||||
targets = (
|
||||
evidence.local_peeled_target_oid,
|
||||
evidence.remote_peeled_target_oid,
|
||||
evidence.gitea_peeled_target_oid,
|
||||
evidence.expected_target_oid,
|
||||
)
|
||||
if any(not is_git_oid(value) for value in targets):
|
||||
raise ReleaseBlocked("TAG_TARGET_OID_INVALID", "peeled target OID is invalid")
|
||||
if len(set(targets)) != 1:
|
||||
raise ReleaseBlocked("TAG_TARGET_MISMATCH", "peeled tag targets are not identical")
|
||||
digests = (
|
||||
evidence.artifact_sha256,
|
||||
evidence.manifest_sha256,
|
||||
evidence.evidence_sha256,
|
||||
evidence.rollback_artifact_sha256,
|
||||
)
|
||||
if any(not is_sha256(value) for value in digests):
|
||||
raise ReleaseBlocked("ARTIFACT_DIGEST_MISSING", "package closure is incomplete")
|
||||
-36
@@ -1,36 +0,0 @@
|
||||
"""Deterministic worker routing for candidate autonomous release workflows."""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
from dataclasses import dataclass
|
||||
|
||||
from .errors import CapabilityMismatch
|
||||
from .models import WorkerDescriptor
|
||||
|
||||
|
||||
@dataclass(frozen=True, slots=True)
|
||||
class RouteRequest:
|
||||
task_id: str
|
||||
required_capabilities: tuple[str, ...]
|
||||
trust_zone: str
|
||||
|
||||
|
||||
class WorkerRouter:
|
||||
"""Select the least loaded compatible worker without expanding trust."""
|
||||
|
||||
def __init__(self, workers: list[WorkerDescriptor]) -> None:
|
||||
self._workers = list(workers)
|
||||
|
||||
def route(self, request: RouteRequest) -> WorkerDescriptor:
|
||||
candidates = [
|
||||
worker
|
||||
for worker in self._workers
|
||||
if worker.can_accept(request.required_capabilities, request.trust_zone)
|
||||
]
|
||||
if not candidates:
|
||||
raise CapabilityMismatch(
|
||||
"NO_COMPATIBLE_WORKER",
|
||||
"no worker satisfies capability and trust constraints",
|
||||
{"task_id": request.task_id},
|
||||
)
|
||||
return sorted(candidates, key=lambda item: (item.current_load, item.worker_id))[0]
|
||||
-213
@@ -1,213 +0,0 @@
|
||||
"""AIOS Secret Manager V2 reference-only Candidate adapter."""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
from dataclasses import dataclass
|
||||
from datetime import datetime, timezone
|
||||
from typing import Any, Mapping, Protocol, Sequence
|
||||
|
||||
from .errors import CredentialUnavailable
|
||||
from .models import CredentialRequest
|
||||
|
||||
|
||||
PROVIDER_REFERENCES = {
|
||||
"openclaw": "systemd-credential:openclaw-gateway-candidate",
|
||||
"codex": "systemd-credential:codex-app-server-candidate",
|
||||
"native_adapter_control": "systemd-credential:session-native-adapter-control-candidate",
|
||||
"gitea": "systemd-credential:gitea-admin-api-candidate",
|
||||
}
|
||||
FORBIDDEN_RESPONSE_FIELDS = {
|
||||
"api_key",
|
||||
"token",
|
||||
"password",
|
||||
"cookie",
|
||||
"private_key",
|
||||
"credential_body",
|
||||
"plaintext",
|
||||
}
|
||||
|
||||
|
||||
class SecretManagerTransport(Protocol):
|
||||
def exchange(self, operation: str, payload: Mapping[str, Any]) -> Mapping[str, Any]: ...
|
||||
|
||||
|
||||
@dataclass(frozen=True, slots=True)
|
||||
class SecretProjectionReceipt:
|
||||
task_id: str
|
||||
credential_id: str
|
||||
reference: str
|
||||
provider: str
|
||||
audience: str
|
||||
consumer_service: str
|
||||
state: str
|
||||
expires_at: datetime
|
||||
plaintext_secret_returned: bool = False
|
||||
|
||||
|
||||
class SecretManagerV2:
|
||||
"""Issue, project, inspect and revoke without receiving authentication material."""
|
||||
|
||||
def __init__(self, transport: SecretManagerTransport) -> None:
|
||||
self.transport = transport
|
||||
|
||||
@staticmethod
|
||||
def _assert_safe(value: Any) -> None:
|
||||
if isinstance(value, Mapping):
|
||||
if FORBIDDEN_RESPONSE_FIELDS.intersection(str(key).lower() for key in value):
|
||||
raise CredentialUnavailable(
|
||||
"SECRET_MANAGER_PLAINTEXT_REJECTED",
|
||||
"Secret Manager response included a forbidden plaintext field",
|
||||
)
|
||||
for item in value.values():
|
||||
SecretManagerV2._assert_safe(item)
|
||||
elif isinstance(value, (list, tuple)):
|
||||
for item in value:
|
||||
SecretManagerV2._assert_safe(item)
|
||||
|
||||
def _exchange(self, operation: str, payload: Mapping[str, Any]) -> Mapping[str, Any]:
|
||||
try:
|
||||
response = self.transport.exchange(operation, payload)
|
||||
except CredentialUnavailable:
|
||||
raise
|
||||
except Exception as error:
|
||||
raise CredentialUnavailable(
|
||||
"SECRET_MANAGER_UNAVAILABLE", "Secret Manager V2 operation failed"
|
||||
) from error
|
||||
if not isinstance(response, Mapping):
|
||||
raise CredentialUnavailable(
|
||||
"SECRET_MANAGER_RESPONSE_INVALID", "Secret Manager V2 returned a non-object"
|
||||
)
|
||||
self._assert_safe(response)
|
||||
if response.get("plaintext_secret_returned") is not False:
|
||||
raise CredentialUnavailable(
|
||||
"SECRET_MANAGER_PLAINTEXT_REJECTED",
|
||||
"Secret Manager did not attest plaintext_secret_returned=false",
|
||||
)
|
||||
return response
|
||||
|
||||
@staticmethod
|
||||
def _payload(request: CredentialRequest) -> dict[str, Any]:
|
||||
return {
|
||||
"approval_plan_id": request.approval_plan_id,
|
||||
"task_id": request.task_id,
|
||||
"request_id": request.request_id,
|
||||
"session_id": request.session_id,
|
||||
"worker_id": request.worker_id,
|
||||
"provider": request.provider,
|
||||
"audience": request.audience,
|
||||
"consumer_service": request.consumer_service,
|
||||
"runtime_user": request.runtime_user,
|
||||
"repository": request.binding.repository,
|
||||
"branch": request.binding.branch,
|
||||
"branch_oid": request.binding.base_oid,
|
||||
"allowed_paths": list(request.binding.allowed_paths),
|
||||
"operations": list(request.operations),
|
||||
"not_before": request.not_before.astimezone(timezone.utc).isoformat(),
|
||||
"expires_at": request.expires_at.astimezone(timezone.utc).isoformat(),
|
||||
"nonce": request.nonce,
|
||||
"ttl_seconds": request.ttl_seconds,
|
||||
"max_uses": request.max_uses,
|
||||
}
|
||||
|
||||
def issue(
|
||||
self, request: CredentialRequest, now: datetime | None = None
|
||||
) -> SecretProjectionReceipt:
|
||||
now = now or datetime.now(timezone.utc)
|
||||
if now < request.not_before or now >= request.expires_at:
|
||||
raise CredentialUnavailable(
|
||||
"SECRET_MANAGER_APPROVAL_WINDOW_INVALID", "credential request is not currently valid"
|
||||
)
|
||||
expected_reference = PROVIDER_REFERENCES.get(request.provider)
|
||||
if expected_reference is None:
|
||||
raise CredentialUnavailable(
|
||||
"SECRET_MANAGER_PROVIDER_DENIED", "provider is not Candidate-approved"
|
||||
)
|
||||
response = self._exchange("issue", self._payload(request))
|
||||
credential_id = response.get("credential_id")
|
||||
if (
|
||||
response.get("task_id") != request.task_id
|
||||
or not isinstance(credential_id, str)
|
||||
or not credential_id
|
||||
or response.get("credential_reference") != expected_reference
|
||||
or response.get("state") != "ISSUED"
|
||||
):
|
||||
raise CredentialUnavailable(
|
||||
"SECRET_MANAGER_BINDING_MISMATCH", "issued projection does not match the request"
|
||||
)
|
||||
expires_at = datetime.fromisoformat(str(response.get("expires_at")))
|
||||
if expires_at > request.expires_at or expires_at <= now:
|
||||
raise CredentialUnavailable(
|
||||
"SECRET_MANAGER_EXPIRY_INVALID", "issued projection expiry is outside approval"
|
||||
)
|
||||
return SecretProjectionReceipt(
|
||||
task_id=request.task_id,
|
||||
credential_id=credential_id,
|
||||
reference=expected_reference,
|
||||
provider=request.provider,
|
||||
audience=request.audience,
|
||||
consumer_service=request.consumer_service,
|
||||
state="ISSUED",
|
||||
expires_at=expires_at,
|
||||
plaintext_secret_returned=False,
|
||||
)
|
||||
|
||||
@staticmethod
|
||||
def _receipt_payload(receipt: SecretProjectionReceipt) -> dict[str, Any]:
|
||||
return {
|
||||
"task_id": receipt.task_id,
|
||||
"credential_id": receipt.credential_id,
|
||||
"credential_reference": receipt.reference,
|
||||
"provider": receipt.provider,
|
||||
"audience": receipt.audience,
|
||||
"consumer_service": receipt.consumer_service,
|
||||
}
|
||||
|
||||
def _state_operation(
|
||||
self, operation: str, receipt: SecretProjectionReceipt, expected_state: str
|
||||
) -> Mapping[str, Any]:
|
||||
response = self._exchange(operation, self._receipt_payload(receipt))
|
||||
if (
|
||||
response.get("task_id") != receipt.task_id
|
||||
or response.get("credential_id") != receipt.credential_id
|
||||
or response.get("state") != expected_state
|
||||
):
|
||||
raise CredentialUnavailable(
|
||||
"SECRET_MANAGER_STATE_MISMATCH", f"{operation} response is not task-bound"
|
||||
)
|
||||
return response
|
||||
|
||||
def project(self, receipt: SecretProjectionReceipt) -> None:
|
||||
self._state_operation("project", receipt, "PROJECTED")
|
||||
|
||||
def status(self, receipt: SecretProjectionReceipt) -> str:
|
||||
return str(self._state_operation("status", receipt, "PROJECTED")["state"])
|
||||
|
||||
def revoke(self, receipt: SecretProjectionReceipt) -> None:
|
||||
self._state_operation("revoke", receipt, "REVOKED")
|
||||
|
||||
def verify_revocation(self, receipt: SecretProjectionReceipt) -> None:
|
||||
response = self._state_operation("verify_revocation", receipt, "REVOKED")
|
||||
if response.get("post_revocation_auth") != "REJECTED":
|
||||
raise CredentialUnavailable(
|
||||
"SECRET_MANAGER_REVOCATION_UNVERIFIED",
|
||||
"post-revocation authentication was not rejected",
|
||||
)
|
||||
|
||||
def audit(self, receipt: SecretProjectionReceipt) -> Sequence[Mapping[str, Any]]:
|
||||
response = self._exchange("audit", self._receipt_payload(receipt))
|
||||
if (
|
||||
response.get("task_id") != receipt.task_id
|
||||
or response.get("credential_id") != receipt.credential_id
|
||||
):
|
||||
raise CredentialUnavailable(
|
||||
"SECRET_MANAGER_AUDIT_MISMATCH", "audit response is not task-bound"
|
||||
)
|
||||
events = response.get("events")
|
||||
if not isinstance(events, list) or any(
|
||||
not isinstance(event, Mapping) or event.get("secrets_included") is not False
|
||||
for event in events
|
||||
):
|
||||
raise CredentialUnavailable(
|
||||
"SECRET_MANAGER_AUDIT_INVALID", "audit events are absent or unsafe"
|
||||
)
|
||||
return events
|
||||
-116
@@ -1,116 +0,0 @@
|
||||
"""JSON serialization helpers for candidate API and CLI boundaries."""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
from datetime import datetime
|
||||
from typing import Any, Mapping
|
||||
|
||||
from .models import ReleasePlan, ResourceBinding, RiskClass, TaskPlan, WorkflowStep
|
||||
|
||||
|
||||
def task_plan_from_mapping(value: Mapping[str, Any]) -> TaskPlan:
|
||||
binding_value = value["binding"]
|
||||
binding = ResourceBinding(
|
||||
repository=str(binding_value["repository"]),
|
||||
branch=str(binding_value["branch"]),
|
||||
base_oid=str(binding_value["base_oid"]),
|
||||
allowed_paths=tuple(str(item) for item in binding_value.get("allowed_paths", ())),
|
||||
)
|
||||
steps = tuple(
|
||||
WorkflowStep(
|
||||
step_id=str(item["step_id"]),
|
||||
worker_role=str(item["worker_role"]),
|
||||
required_capabilities=tuple(str(cap) for cap in item.get("required_capabilities", ())),
|
||||
depends_on=tuple(str(dep) for dep in item.get("depends_on", ())),
|
||||
max_attempts=int(item.get("max_attempts", 1)),
|
||||
timeout_seconds=int(item.get("timeout_seconds", 900)),
|
||||
allowed_paths=tuple(str(path) for path in item.get("allowed_paths", ())),
|
||||
)
|
||||
for item in value.get("steps", ())
|
||||
)
|
||||
created_at_raw = value.get("created_at")
|
||||
created_at = datetime.fromisoformat(created_at_raw) if created_at_raw else None
|
||||
kwargs: dict[str, Any] = {
|
||||
"task_id": str(value["task_id"]),
|
||||
"intent": str(value["intent"]),
|
||||
"binding": binding,
|
||||
"risk": RiskClass(str(value.get("risk", RiskClass.MEDIUM.value))),
|
||||
"steps": steps,
|
||||
"evidence_requirements": tuple(str(item) for item in value.get("evidence_requirements", ())),
|
||||
"production_side_effects_allowed": bool(value.get("production_side_effects_allowed", False)),
|
||||
}
|
||||
if created_at is not None:
|
||||
kwargs["created_at"] = created_at
|
||||
return TaskPlan(**kwargs)
|
||||
|
||||
|
||||
def task_plan_to_mapping(plan: TaskPlan) -> dict[str, Any]:
|
||||
return {
|
||||
"task_id": plan.task_id,
|
||||
"intent": plan.intent,
|
||||
"binding": {
|
||||
"repository": plan.binding.repository,
|
||||
"branch": plan.binding.branch,
|
||||
"base_oid": plan.binding.base_oid,
|
||||
"allowed_paths": list(plan.binding.allowed_paths),
|
||||
},
|
||||
"risk": plan.risk.value,
|
||||
"steps": [
|
||||
{
|
||||
"step_id": step.step_id,
|
||||
"worker_role": step.worker_role,
|
||||
"required_capabilities": list(step.required_capabilities),
|
||||
"depends_on": list(step.depends_on),
|
||||
"max_attempts": step.max_attempts,
|
||||
"timeout_seconds": step.timeout_seconds,
|
||||
"allowed_paths": list(step.allowed_paths),
|
||||
}
|
||||
for step in plan.steps
|
||||
],
|
||||
"evidence_requirements": list(plan.evidence_requirements),
|
||||
"production_side_effects_allowed": plan.production_side_effects_allowed,
|
||||
"created_at": plan.created_at.isoformat(),
|
||||
"plan_digest": plan.digest(),
|
||||
}
|
||||
|
||||
|
||||
def release_plan_from_mapping(value: Mapping[str, Any]) -> ReleasePlan:
|
||||
return ReleasePlan(
|
||||
task_id=str(value["task_id"]),
|
||||
repository=str(value["repository"]),
|
||||
branch=str(value["branch"]),
|
||||
version=str(value["version"]),
|
||||
target_oid=str(value["target_oid"]),
|
||||
tree_oid=str(value["tree_oid"]),
|
||||
artifact_sha256=str(value["artifact_sha256"]),
|
||||
manifest_sha256=str(value["manifest_sha256"]),
|
||||
package_closure_sha256=str(value["package_closure_sha256"]),
|
||||
evidence_closure_oid=str(value["evidence_closure_oid"]),
|
||||
approval_plan_id=str(value["approval_plan_id"]),
|
||||
rollback_approval_plan_id=str(value["rollback_approval_plan_id"]),
|
||||
rollback_artifact_sha256=str(value["rollback_artifact_sha256"]),
|
||||
expected_tag_oid=str(value["expected_tag_oid"]),
|
||||
expected_target_oid=str(value["expected_target_oid"]),
|
||||
production_config_sha256=str(value["production_config_sha256"]),
|
||||
)
|
||||
|
||||
|
||||
def release_plan_to_mapping(plan: ReleasePlan) -> dict[str, Any]:
|
||||
return {
|
||||
"task_id": plan.task_id,
|
||||
"repository": plan.repository,
|
||||
"branch": plan.branch,
|
||||
"version": plan.version,
|
||||
"target_oid": plan.target_oid,
|
||||
"tree_oid": plan.tree_oid,
|
||||
"artifact_sha256": plan.artifact_sha256,
|
||||
"manifest_sha256": plan.manifest_sha256,
|
||||
"package_closure_sha256": plan.package_closure_sha256,
|
||||
"evidence_closure_oid": plan.evidence_closure_oid,
|
||||
"approval_plan_id": plan.approval_plan_id,
|
||||
"rollback_approval_plan_id": plan.rollback_approval_plan_id,
|
||||
"rollback_artifact_sha256": plan.rollback_artifact_sha256,
|
||||
"expected_tag_oid": plan.expected_tag_oid,
|
||||
"expected_target_oid": plan.expected_target_oid,
|
||||
"production_config_sha256": plan.production_config_sha256,
|
||||
}
|
||||
-223
@@ -1,223 +0,0 @@
|
||||
"""Hardened loopback HTTP boundary for the dormant Candidate."""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import argparse
|
||||
from http import HTTPStatus
|
||||
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
|
||||
import ipaddress
|
||||
import json
|
||||
from pathlib import Path
|
||||
from typing import Any
|
||||
from urllib.parse import urlparse
|
||||
|
||||
from .api import AutonomousReleaseAPI
|
||||
from .errors import AutonomousReleaseError
|
||||
from .orchestrator import AutonomousReleaseOrchestrator
|
||||
from .policy import ReleasePolicy
|
||||
from .store import StateStore
|
||||
from .workflow import WorkflowEngine
|
||||
|
||||
|
||||
class CandidateApplication:
|
||||
def __init__(self, state_path: str | Path) -> None:
|
||||
self.store = StateStore(state_path)
|
||||
workflow = WorkflowEngine(self.store)
|
||||
self.api = AutonomousReleaseAPI(
|
||||
AutonomousReleaseOrchestrator(workflow, ReleasePolicy())
|
||||
)
|
||||
|
||||
def ready(self) -> bool:
|
||||
with self.store.transaction() as connection:
|
||||
return connection.execute("SELECT 1").fetchone()[0] == 1
|
||||
|
||||
|
||||
class CandidateRequestHandler(BaseHTTPRequestHandler):
|
||||
server_version = "AIOSAutonomousReleaseCandidate/2"
|
||||
sys_version = ""
|
||||
|
||||
@property
|
||||
def application(self) -> CandidateApplication:
|
||||
return self.server.application # type: ignore[attr-defined]
|
||||
|
||||
def _send_json(self, status: HTTPStatus, payload: dict[str, Any]) -> None:
|
||||
encoded = json.dumps(payload, sort_keys=True, separators=(",", ":")).encode("utf-8")
|
||||
self.send_response(status.value)
|
||||
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.send_header("Referrer-Policy", "no-referrer")
|
||||
self.end_headers()
|
||||
self.wfile.write(encoded)
|
||||
|
||||
def _read_json(self) -> dict[str, Any]:
|
||||
content_type = self.headers.get("Content-Type", "").split(";", 1)[0].strip().lower()
|
||||
if content_type != "application/json":
|
||||
raise UnsupportedMediaType
|
||||
try:
|
||||
length = int(self.headers.get("Content-Length", "0"))
|
||||
except ValueError as error:
|
||||
raise InvalidRequest from error
|
||||
if length <= 0 or length > 1_048_576:
|
||||
raise InvalidRequest
|
||||
try:
|
||||
raw = self.rfile.read(length)
|
||||
value = json.loads(raw.decode("utf-8"))
|
||||
except (UnicodeDecodeError, json.JSONDecodeError) as error:
|
||||
raise InvalidRequest from error
|
||||
if not isinstance(value, dict):
|
||||
raise InvalidRequest
|
||||
return value
|
||||
|
||||
def do_GET(self) -> None: # noqa: N802
|
||||
path = urlparse(self.path).path
|
||||
if path == "/health":
|
||||
self._send_json(
|
||||
HTTPStatus.OK,
|
||||
{
|
||||
"status": "ok",
|
||||
"mode": "candidate-shadow-only",
|
||||
"production_side_effects": False,
|
||||
"secrets_included": False,
|
||||
},
|
||||
)
|
||||
return
|
||||
if path == "/ready":
|
||||
if self.application.ready():
|
||||
self._send_json(
|
||||
HTTPStatus.OK, {"status": "ready", "secrets_included": False}
|
||||
)
|
||||
else:
|
||||
self._send_json(
|
||||
HTTPStatus.SERVICE_UNAVAILABLE,
|
||||
{"status": "not_ready", "secrets_included": False},
|
||||
)
|
||||
return
|
||||
if path.startswith("/v1/tasks/") and path.endswith("/steps"):
|
||||
task_id = path[len("/v1/tasks/") : -len("/steps")].strip("/")
|
||||
if not task_id or "/" in task_id:
|
||||
self._send_json(HTTPStatus.BAD_REQUEST, {"error": "invalid_request"})
|
||||
return
|
||||
try:
|
||||
self._send_json(HTTPStatus.OK, self.application.api.task_steps(task_id))
|
||||
except KeyError:
|
||||
self._send_json(HTTPStatus.NOT_FOUND, {"error": "task_not_found"})
|
||||
return
|
||||
if path.startswith("/v1/tasks/") and path.endswith("/evidence"):
|
||||
task_id = path[len("/v1/tasks/") : -len("/evidence")].strip("/")
|
||||
if not task_id or "/" in task_id:
|
||||
self._send_json(HTTPStatus.BAD_REQUEST, {"error": "invalid_request"})
|
||||
return
|
||||
try:
|
||||
self._send_json(HTTPStatus.OK, self.application.api.evidence(task_id))
|
||||
except KeyError:
|
||||
self._send_json(HTTPStatus.NOT_FOUND, {"error": "task_not_found"})
|
||||
return
|
||||
if path.startswith("/v1/tasks/"):
|
||||
task_id = path[len("/v1/tasks/") :].strip("/")
|
||||
if not task_id or "/" in task_id:
|
||||
self._send_json(HTTPStatus.BAD_REQUEST, {"error": "invalid_request"})
|
||||
return
|
||||
try:
|
||||
self._send_json(HTTPStatus.OK, self.application.api.task_status(task_id))
|
||||
except KeyError:
|
||||
self._send_json(HTTPStatus.NOT_FOUND, {"error": "task_not_found"})
|
||||
return
|
||||
self._send_json(HTTPStatus.NOT_FOUND, {"error": "not_found"})
|
||||
|
||||
def do_POST(self) -> None: # noqa: N802
|
||||
path = urlparse(self.path).path
|
||||
try:
|
||||
payload = self._read_json()
|
||||
if path == "/v1/tasks":
|
||||
self._send_json(HTTPStatus.CREATED, self.application.api.create_task(payload))
|
||||
return
|
||||
if path == "/v1/release/plan":
|
||||
self._send_json(
|
||||
HTTPStatus.CREATED, self.application.api.create_release_plan(payload)
|
||||
)
|
||||
return
|
||||
if path == "/v1/release/verify":
|
||||
self._send_json(HTTPStatus.OK, self.application.api.verify_release(payload))
|
||||
return
|
||||
if path.startswith("/v1/tasks/") and path.endswith("/evidence/close"):
|
||||
task_id = path[len("/v1/tasks/") : -len("/evidence/close")].strip("/")
|
||||
if not task_id:
|
||||
raise InvalidRequest
|
||||
self._send_json(HTTPStatus.OK, self.application.api.close_evidence(task_id))
|
||||
return
|
||||
for action, handler in (
|
||||
("claim", self.application.api.claim),
|
||||
("heartbeat", self.application.api.heartbeat),
|
||||
("result", self.application.api.result),
|
||||
):
|
||||
suffix = f"/{action}"
|
||||
if path.startswith("/v1/tasks/") and path.endswith(suffix):
|
||||
task_id = path[len("/v1/tasks/") : -len(suffix)].strip("/")
|
||||
if not task_id or "/" in task_id:
|
||||
raise InvalidRequest
|
||||
self._send_json(HTTPStatus.OK, handler(task_id, payload))
|
||||
return
|
||||
self._send_json(HTTPStatus.NOT_FOUND, {"error": "not_found"})
|
||||
except UnsupportedMediaType:
|
||||
self._send_json(
|
||||
HTTPStatus.UNSUPPORTED_MEDIA_TYPE, {"error": "content_type_required"}
|
||||
)
|
||||
except (InvalidRequest, ValueError, KeyError):
|
||||
self._send_json(HTTPStatus.BAD_REQUEST, {"error": "invalid_request"})
|
||||
except AutonomousReleaseError as error:
|
||||
self._send_json(HTTPStatus.CONFLICT, {"error": error.code})
|
||||
except Exception:
|
||||
self._send_json(
|
||||
HTTPStatus.INTERNAL_SERVER_ERROR, {"error": "candidate_request_failed"}
|
||||
)
|
||||
|
||||
def log_message(self, _format: str, *_args: Any) -> None:
|
||||
return
|
||||
|
||||
|
||||
class InvalidRequest(Exception):
|
||||
pass
|
||||
|
||||
|
||||
class UnsupportedMediaType(Exception):
|
||||
pass
|
||||
|
||||
|
||||
class CandidateHTTPServer(ThreadingHTTPServer):
|
||||
daemon_threads = True
|
||||
allow_reuse_address = False
|
||||
|
||||
def __init__(self, address: tuple[str, int], application: CandidateApplication) -> None:
|
||||
try:
|
||||
loopback = ipaddress.ip_address(address[0]).is_loopback
|
||||
except ValueError as error:
|
||||
raise ValueError("candidate service requires a numeric loopback address") from error
|
||||
if not loopback:
|
||||
raise ValueError("candidate service must bind to loopback")
|
||||
self.application = application
|
||||
super().__init__(address, CandidateRequestHandler)
|
||||
|
||||
|
||||
def build_parser() -> argparse.ArgumentParser:
|
||||
parser = argparse.ArgumentParser(prog="aios-autonomous-release-service")
|
||||
parser.add_argument("--host", default="127.0.0.1")
|
||||
parser.add_argument("--port", type=int, default=19951)
|
||||
parser.add_argument("--state", required=True)
|
||||
return parser
|
||||
|
||||
|
||||
def main(argv: list[str] | None = None) -> int:
|
||||
args = build_parser().parse_args(argv)
|
||||
application = CandidateApplication(args.state)
|
||||
server = CandidateHTTPServer((args.host, args.port), application)
|
||||
try:
|
||||
server.serve_forever(poll_interval=0.5)
|
||||
finally:
|
||||
server.server_close()
|
||||
return 0
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
raise SystemExit(main())
|
||||
-87
@@ -1,87 +0,0 @@
|
||||
"""Unified candidate session lifecycle contracts."""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
from dataclasses import dataclass
|
||||
from enum import Enum
|
||||
from datetime import datetime
|
||||
|
||||
from .errors import StateConflict
|
||||
|
||||
|
||||
class SessionState(str, Enum):
|
||||
CREATED = "CREATED"
|
||||
PROVISIONED = "PROVISIONED"
|
||||
ACTIVE = "ACTIVE"
|
||||
INTERRUPTED = "INTERRUPTED"
|
||||
CLOSED = "CLOSED"
|
||||
REVOKED = "REVOKED"
|
||||
|
||||
|
||||
_ALLOWED_TRANSITIONS: dict[SessionState, frozenset[SessionState]] = {
|
||||
SessionState.CREATED: frozenset({SessionState.PROVISIONED, SessionState.CLOSED, SessionState.REVOKED}),
|
||||
SessionState.PROVISIONED: frozenset({SessionState.ACTIVE, SessionState.CLOSED, SessionState.REVOKED}),
|
||||
SessionState.ACTIVE: frozenset({SessionState.INTERRUPTED, SessionState.CLOSED, SessionState.REVOKED}),
|
||||
SessionState.INTERRUPTED: frozenset({SessionState.ACTIVE, SessionState.CLOSED, SessionState.REVOKED}),
|
||||
SessionState.CLOSED: frozenset({SessionState.REVOKED}),
|
||||
SessionState.REVOKED: frozenset(),
|
||||
}
|
||||
|
||||
|
||||
@dataclass(frozen=True, slots=True)
|
||||
class SessionIdentity:
|
||||
session_id: str
|
||||
provider: str
|
||||
provider_session_id: str
|
||||
worker_id: str
|
||||
task_id: str
|
||||
created_at: datetime
|
||||
|
||||
def __post_init__(self) -> None:
|
||||
if not all((self.session_id, self.provider, self.provider_session_id, self.worker_id, self.task_id)):
|
||||
raise ValueError("all session identity fields are required")
|
||||
if self.session_id == self.provider_session_id:
|
||||
raise ValueError("broker and provider session IDs must be distinct")
|
||||
|
||||
|
||||
class SessionOrchestrator:
|
||||
"""Provider-neutral session lifecycle guard with explicit state transitions."""
|
||||
|
||||
def __init__(self) -> None:
|
||||
self._sessions: dict[str, tuple[SessionIdentity, SessionState]] = {}
|
||||
|
||||
def create(self, identity: SessionIdentity) -> None:
|
||||
if identity.session_id in self._sessions:
|
||||
raise StateConflict("SESSION_EXISTS", "session already exists")
|
||||
self._sessions[identity.session_id] = (identity, SessionState.CREATED)
|
||||
|
||||
def transition(self, session_id: str, state: SessionState) -> None:
|
||||
current = self._sessions.get(session_id)
|
||||
if current is None:
|
||||
raise StateConflict("SESSION_NOT_FOUND", "session does not exist")
|
||||
current_state = current[1]
|
||||
if state not in _ALLOWED_TRANSITIONS[current_state]:
|
||||
raise StateConflict(
|
||||
"SESSION_TRANSITION_INVALID",
|
||||
"session state transition is not allowed",
|
||||
{"session_id": session_id, "from": current_state.value, "to": state.value},
|
||||
)
|
||||
self._sessions[session_id] = (current[0], state)
|
||||
|
||||
def identity(self, session_id: str) -> SessionIdentity:
|
||||
current = self._sessions.get(session_id)
|
||||
if current is None:
|
||||
raise StateConflict("SESSION_NOT_FOUND", "session does not exist")
|
||||
return current[0]
|
||||
|
||||
def status(self, session_id: str) -> SessionState:
|
||||
current = self._sessions.get(session_id)
|
||||
if current is None:
|
||||
raise StateConflict("SESSION_NOT_FOUND", "session does not exist")
|
||||
return current[1]
|
||||
|
||||
def close(self, session_id: str) -> None:
|
||||
self.transition(session_id, SessionState.CLOSED)
|
||||
|
||||
def revoke(self, session_id: str) -> None:
|
||||
self.transition(session_id, SessionState.REVOKED)
|
||||
-383
@@ -1,383 +0,0 @@
|
||||
"""Durable, private SQLite state for the autonomous-release Candidate."""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
from contextlib import contextmanager
|
||||
from dataclasses import dataclass
|
||||
from datetime import datetime, timezone
|
||||
import json
|
||||
import os
|
||||
from pathlib import Path
|
||||
import sqlite3
|
||||
from typing import Any, Iterator, Mapping, Sequence
|
||||
|
||||
from .errors import StateConflict
|
||||
from .models import StepState, TaskState, canonical_json
|
||||
|
||||
|
||||
SCHEMA_VERSION = 2
|
||||
|
||||
|
||||
@dataclass(frozen=True, slots=True)
|
||||
class StoredStep:
|
||||
task_id: str
|
||||
step_id: str
|
||||
state: StepState
|
||||
attempt: int
|
||||
max_attempts: int
|
||||
worker_id: str | None
|
||||
session_id: str | None
|
||||
lease_expires_at: datetime | None
|
||||
result_digest: str | None
|
||||
updated_at: datetime
|
||||
last_error: str | None
|
||||
|
||||
|
||||
class StateStore:
|
||||
"""SQLite store with WAL, full sync, schema checks and serialized CAS writes."""
|
||||
|
||||
def __init__(self, path: str | Path) -> None:
|
||||
self.path = Path(path)
|
||||
self._prepare_path()
|
||||
self._initialize()
|
||||
os.chmod(self.path, 0o600)
|
||||
|
||||
def _prepare_path(self) -> None:
|
||||
if self.path.exists() and self.path.is_symlink():
|
||||
raise StateConflict("STATE_PATH_SYMLINK", "state database must not be a symlink")
|
||||
parent = self.path.parent
|
||||
parent.mkdir(parents=True, exist_ok=True, mode=0o750)
|
||||
if parent.is_symlink():
|
||||
raise StateConflict("STATE_DIRECTORY_SYMLINK", "state directory must not be a symlink")
|
||||
current_mode = parent.stat().st_mode & 0o777
|
||||
os.chmod(parent, current_mode & ~0o027)
|
||||
|
||||
def _connect(self) -> sqlite3.Connection:
|
||||
if self.path.exists() and self.path.is_symlink():
|
||||
raise StateConflict("STATE_PATH_SYMLINK", "state database must not be a symlink")
|
||||
connection = sqlite3.connect(self.path, timeout=30.0)
|
||||
connection.row_factory = sqlite3.Row
|
||||
connection.execute("PRAGMA foreign_keys=ON")
|
||||
connection.execute("PRAGMA journal_mode=WAL")
|
||||
connection.execute("PRAGMA synchronous=FULL")
|
||||
connection.execute("PRAGMA busy_timeout=30000")
|
||||
return connection
|
||||
|
||||
@contextmanager
|
||||
def transaction(self) -> Iterator[sqlite3.Connection]:
|
||||
connection = self._connect()
|
||||
try:
|
||||
connection.execute("BEGIN IMMEDIATE")
|
||||
yield connection
|
||||
connection.commit()
|
||||
except Exception:
|
||||
connection.rollback()
|
||||
raise
|
||||
finally:
|
||||
connection.close()
|
||||
|
||||
def _initialize(self) -> None:
|
||||
with self.transaction() as connection:
|
||||
connection.execute(
|
||||
"CREATE TABLE IF NOT EXISTS metadata (key TEXT PRIMARY KEY, value TEXT NOT NULL)"
|
||||
)
|
||||
row = connection.execute(
|
||||
"SELECT value FROM metadata WHERE key='schema_version'"
|
||||
).fetchone()
|
||||
version = int(row["value"]) if row is not None else None
|
||||
if version not in (None, 1, SCHEMA_VERSION):
|
||||
raise StateConflict(
|
||||
"SCHEMA_VERSION_UNSUPPORTED",
|
||||
"state schema is not supported",
|
||||
{"found": version, "expected": SCHEMA_VERSION},
|
||||
)
|
||||
connection.executescript(
|
||||
"""
|
||||
CREATE TABLE IF NOT EXISTS tasks (
|
||||
task_id TEXT PRIMARY KEY,
|
||||
plan_digest TEXT NOT NULL,
|
||||
plan_json TEXT NOT NULL,
|
||||
state TEXT NOT NULL,
|
||||
revision INTEGER NOT NULL DEFAULT 0,
|
||||
created_at TEXT NOT NULL,
|
||||
updated_at TEXT NOT NULL
|
||||
);
|
||||
CREATE TABLE IF NOT EXISTS steps (
|
||||
task_id TEXT NOT NULL,
|
||||
step_id TEXT NOT NULL,
|
||||
state TEXT NOT NULL,
|
||||
attempt INTEGER NOT NULL DEFAULT 0,
|
||||
max_attempts INTEGER NOT NULL DEFAULT 1,
|
||||
worker_id TEXT,
|
||||
session_id TEXT,
|
||||
lease_expires_at TEXT,
|
||||
result_digest TEXT,
|
||||
last_error TEXT,
|
||||
updated_at TEXT NOT NULL,
|
||||
PRIMARY KEY(task_id, step_id),
|
||||
FOREIGN KEY(task_id) REFERENCES tasks(task_id) ON DELETE CASCADE
|
||||
);
|
||||
CREATE TABLE IF NOT EXISTS events (
|
||||
sequence INTEGER PRIMARY KEY AUTOINCREMENT,
|
||||
task_id TEXT NOT NULL,
|
||||
event_type TEXT NOT NULL,
|
||||
payload_json TEXT NOT NULL,
|
||||
previous_digest TEXT,
|
||||
digest TEXT NOT NULL UNIQUE,
|
||||
created_at TEXT NOT NULL
|
||||
);
|
||||
CREATE TABLE IF NOT EXISTS consumed_nonces (
|
||||
scope TEXT NOT NULL,
|
||||
nonce TEXT NOT NULL,
|
||||
consumed_at TEXT NOT NULL,
|
||||
PRIMARY KEY(scope, nonce)
|
||||
);
|
||||
CREATE TABLE IF NOT EXISTS credentials (
|
||||
credential_id TEXT PRIMARY KEY,
|
||||
task_id TEXT NOT NULL,
|
||||
reference TEXT NOT NULL UNIQUE,
|
||||
state TEXT NOT NULL,
|
||||
metadata_json TEXT NOT NULL,
|
||||
issued_at TEXT NOT NULL,
|
||||
expires_at TEXT NOT NULL,
|
||||
revoked_at TEXT
|
||||
);
|
||||
CREATE TABLE IF NOT EXISTS idempotency (
|
||||
namespace TEXT NOT NULL,
|
||||
operation_id TEXT NOT NULL,
|
||||
result_json TEXT NOT NULL,
|
||||
created_at TEXT NOT NULL,
|
||||
PRIMARY KEY(namespace, operation_id)
|
||||
);
|
||||
"""
|
||||
)
|
||||
if version == 1:
|
||||
existing = {
|
||||
item["name"] for item in connection.execute("PRAGMA table_info(steps)")
|
||||
}
|
||||
additions = {
|
||||
"max_attempts": "INTEGER NOT NULL DEFAULT 1",
|
||||
"lease_expires_at": "TEXT",
|
||||
"result_digest": "TEXT",
|
||||
}
|
||||
for column, declaration in additions.items():
|
||||
if column not in existing:
|
||||
connection.execute(f"ALTER TABLE steps ADD COLUMN {column} {declaration}")
|
||||
connection.execute(
|
||||
"INSERT INTO metadata(key, value) VALUES('schema_version', ?) "
|
||||
"ON CONFLICT(key) DO UPDATE SET value=excluded.value",
|
||||
(str(SCHEMA_VERSION),),
|
||||
)
|
||||
|
||||
@staticmethod
|
||||
def _now() -> str:
|
||||
return datetime.now(timezone.utc).isoformat()
|
||||
|
||||
def create_task(
|
||||
self,
|
||||
task_id: str,
|
||||
plan_digest: str,
|
||||
plan: Mapping[str, Any],
|
||||
step_ids: tuple[str, ...],
|
||||
step_limits: Mapping[str, int] | None = None,
|
||||
) -> None:
|
||||
now = self._now()
|
||||
limits = step_limits or {}
|
||||
with self.transaction() as connection:
|
||||
connection.execute(
|
||||
"INSERT INTO tasks(task_id, plan_digest, plan_json, state, created_at, updated_at) "
|
||||
"VALUES(?, ?, ?, ?, ?, ?)",
|
||||
(task_id, plan_digest, canonical_json(plan), TaskState.PLANNED.value, now, now),
|
||||
)
|
||||
connection.executemany(
|
||||
"INSERT INTO steps(task_id, step_id, state, max_attempts, updated_at) "
|
||||
"VALUES(?, ?, ?, ?, ?)",
|
||||
[
|
||||
(task_id, step_id, StepState.PENDING.value, int(limits.get(step_id, 1)), now)
|
||||
for step_id in step_ids
|
||||
],
|
||||
)
|
||||
|
||||
def get_task_state(self, task_id: str) -> tuple[TaskState, int]:
|
||||
with self._connect() as connection:
|
||||
row = connection.execute(
|
||||
"SELECT state, revision FROM tasks WHERE task_id=?", (task_id,)
|
||||
).fetchone()
|
||||
if row is None:
|
||||
raise KeyError(task_id)
|
||||
return TaskState(row["state"]), int(row["revision"])
|
||||
|
||||
def compare_and_set_task_state(
|
||||
self, task_id: str, expected_revision: int, new_state: TaskState
|
||||
) -> int:
|
||||
with self.transaction() as connection:
|
||||
cursor = connection.execute(
|
||||
"UPDATE tasks SET state=?, revision=revision+1, updated_at=? "
|
||||
"WHERE task_id=? AND revision=?",
|
||||
(new_state.value, self._now(), task_id, expected_revision),
|
||||
)
|
||||
if cursor.rowcount != 1:
|
||||
raise StateConflict(
|
||||
"TASK_REVISION_CONFLICT",
|
||||
"task state changed concurrently",
|
||||
{"task_id": task_id, "expected_revision": expected_revision},
|
||||
)
|
||||
row = connection.execute(
|
||||
"SELECT revision FROM tasks WHERE task_id=?", (task_id,)
|
||||
).fetchone()
|
||||
return int(row["revision"])
|
||||
|
||||
def transition_step(
|
||||
self,
|
||||
task_id: str,
|
||||
step_id: str,
|
||||
expected: Sequence[StepState],
|
||||
state: StepState,
|
||||
*,
|
||||
worker_id: str | None = None,
|
||||
session_id: str | None = None,
|
||||
lease_expires_at: datetime | None = None,
|
||||
result_digest: str | None = None,
|
||||
last_error: str | None = None,
|
||||
increment_attempt: bool = False,
|
||||
clear_assignment: bool = False,
|
||||
) -> StoredStep:
|
||||
with self.transaction() as connection:
|
||||
row = connection.execute(
|
||||
"SELECT * FROM steps WHERE task_id=? AND step_id=?", (task_id, step_id)
|
||||
).fetchone()
|
||||
if row is None:
|
||||
raise KeyError(f"{task_id}:{step_id}")
|
||||
if StepState(row["state"]) not in set(expected):
|
||||
raise StateConflict(
|
||||
"STEP_STATE_CONFLICT",
|
||||
"step state changed or transition is invalid",
|
||||
{"task_id": task_id, "step_id": step_id, "state": row["state"]},
|
||||
)
|
||||
if increment_attempt and int(row["attempt"]) >= int(row["max_attempts"]):
|
||||
raise StateConflict(
|
||||
"STEP_ATTEMPTS_EXHAUSTED",
|
||||
"step has no remaining attempts",
|
||||
{"task_id": task_id, "step_id": step_id},
|
||||
)
|
||||
next_worker = None if clear_assignment else (worker_id or row["worker_id"])
|
||||
next_session = None if clear_assignment else (session_id or row["session_id"])
|
||||
connection.execute(
|
||||
"UPDATE steps SET state=?, attempt=attempt+?, worker_id=?, session_id=?, "
|
||||
"lease_expires_at=?, result_digest=COALESCE(?, result_digest), last_error=?, updated_at=? "
|
||||
"WHERE task_id=? AND step_id=?",
|
||||
(
|
||||
state.value,
|
||||
1 if increment_attempt else 0,
|
||||
next_worker,
|
||||
next_session,
|
||||
lease_expires_at.isoformat() if lease_expires_at else None,
|
||||
result_digest,
|
||||
last_error,
|
||||
self._now(),
|
||||
task_id,
|
||||
step_id,
|
||||
),
|
||||
)
|
||||
updated = connection.execute(
|
||||
"SELECT * FROM steps WHERE task_id=? AND step_id=?", (task_id, step_id)
|
||||
).fetchone()
|
||||
return self._step_from_row(updated)
|
||||
|
||||
def set_step_state(
|
||||
self,
|
||||
task_id: str,
|
||||
step_id: str,
|
||||
state: StepState,
|
||||
**kwargs: Any,
|
||||
) -> StoredStep:
|
||||
current = self.list_steps(task_id)[step_id]
|
||||
return self.transition_step(task_id, step_id, (current.state,), state, **kwargs)
|
||||
|
||||
def list_steps(self, task_id: str) -> dict[str, StoredStep]:
|
||||
with self._connect() as connection:
|
||||
rows = connection.execute(
|
||||
"SELECT * FROM steps WHERE task_id=? ORDER BY step_id", (task_id,)
|
||||
).fetchall()
|
||||
return {row["step_id"]: self._step_from_row(row) for row in rows}
|
||||
|
||||
@staticmethod
|
||||
def _step_from_row(row: sqlite3.Row) -> StoredStep:
|
||||
return StoredStep(
|
||||
task_id=row["task_id"],
|
||||
step_id=row["step_id"],
|
||||
state=StepState(row["state"]),
|
||||
attempt=int(row["attempt"]),
|
||||
max_attempts=int(row["max_attempts"]),
|
||||
worker_id=row["worker_id"],
|
||||
session_id=row["session_id"],
|
||||
lease_expires_at=(
|
||||
datetime.fromisoformat(row["lease_expires_at"])
|
||||
if row["lease_expires_at"]
|
||||
else None
|
||||
),
|
||||
result_digest=row["result_digest"],
|
||||
updated_at=datetime.fromisoformat(row["updated_at"]),
|
||||
last_error=row["last_error"],
|
||||
)
|
||||
|
||||
def consume_nonce(self, scope: str, nonce: str) -> None:
|
||||
try:
|
||||
with self.transaction() as connection:
|
||||
connection.execute(
|
||||
"INSERT INTO consumed_nonces(scope, nonce, consumed_at) VALUES(?, ?, ?)",
|
||||
(scope, nonce, self._now()),
|
||||
)
|
||||
except sqlite3.IntegrityError as error:
|
||||
raise StateConflict(
|
||||
"NONCE_REPLAY", "nonce was already consumed", {"scope": scope, "nonce": nonce}
|
||||
) from error
|
||||
|
||||
def append_event(
|
||||
self,
|
||||
task_id: str,
|
||||
event_type: str,
|
||||
payload: Mapping[str, Any],
|
||||
previous_digest: str | None,
|
||||
event_digest: str,
|
||||
created_at: datetime,
|
||||
) -> int:
|
||||
with self.transaction() as connection:
|
||||
cursor = connection.execute(
|
||||
"INSERT INTO events(task_id, event_type, payload_json, previous_digest, digest, created_at) "
|
||||
"VALUES(?, ?, ?, ?, ?, ?)",
|
||||
(
|
||||
task_id,
|
||||
event_type,
|
||||
canonical_json(payload),
|
||||
previous_digest,
|
||||
event_digest,
|
||||
created_at.astimezone(timezone.utc).isoformat(),
|
||||
),
|
||||
)
|
||||
return int(cursor.lastrowid)
|
||||
|
||||
def list_events(self, task_id: str) -> list[Mapping[str, Any]]:
|
||||
with self._connect() as connection:
|
||||
rows = connection.execute(
|
||||
"SELECT * FROM events WHERE task_id=? ORDER BY sequence", (task_id,)
|
||||
).fetchall()
|
||||
return [dict(row) for row in rows]
|
||||
|
||||
def put_idempotent_result(
|
||||
self, namespace: str, operation_id: str, result: Mapping[str, Any]
|
||||
) -> Mapping[str, Any]:
|
||||
encoded = canonical_json(result)
|
||||
with self.transaction() as connection:
|
||||
existing = connection.execute(
|
||||
"SELECT result_json FROM idempotency WHERE namespace=? AND operation_id=?",
|
||||
(namespace, operation_id),
|
||||
).fetchone()
|
||||
if existing is not None:
|
||||
return json.loads(existing["result_json"])
|
||||
connection.execute(
|
||||
"INSERT INTO idempotency(namespace, operation_id, result_json, created_at) "
|
||||
"VALUES(?, ?, ?, ?)",
|
||||
(namespace, operation_id, encoded, self._now()),
|
||||
)
|
||||
return dict(result)
|
||||
@@ -1,44 +0,0 @@
|
||||
"""Read-only annotated and lightweight tag consistency checks."""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
from dataclasses import dataclass
|
||||
|
||||
from .errors import ReleaseBlocked
|
||||
from .models import is_git_oid
|
||||
|
||||
|
||||
@dataclass(frozen=True, slots=True)
|
||||
class TagReference:
|
||||
ref: str
|
||||
object_type: str
|
||||
tag_oid: str
|
||||
peeled_target_oid: str
|
||||
|
||||
|
||||
class TagVerifier:
|
||||
def verify(
|
||||
self,
|
||||
tag: TagReference,
|
||||
*,
|
||||
expected_tag_oid: str,
|
||||
expected_target_oid: str,
|
||||
) -> None:
|
||||
if not tag.ref.startswith("refs/tags/") or tag.ref.endswith("^{}"):
|
||||
raise ReleaseBlocked("TAG_REF_INVALID", "canonical tag ref is required")
|
||||
if tag.object_type not in ("commit", "tag"):
|
||||
raise ReleaseBlocked("TAG_OBJECT_TYPE_INVALID", "unsupported tag object type")
|
||||
values = (tag.tag_oid, tag.peeled_target_oid, expected_tag_oid, expected_target_oid)
|
||||
if any(not is_git_oid(value) for value in values):
|
||||
raise ReleaseBlocked("TAG_OID_INVALID", "tag OIDs must be complete lowercase hex")
|
||||
if tag.tag_oid != expected_tag_oid:
|
||||
raise ReleaseBlocked("TAG_OBJECT_MISMATCH", "tag object does not match expectation")
|
||||
if tag.peeled_target_oid != expected_target_oid:
|
||||
raise ReleaseBlocked(
|
||||
"TAG_PEELED_TARGET_MISMATCH", "peeled target does not match expected target"
|
||||
)
|
||||
if tag.object_type == "commit" and tag.tag_oid != tag.peeled_target_oid:
|
||||
raise ReleaseBlocked(
|
||||
"LIGHTWEIGHT_TAG_INCONSISTENT",
|
||||
"lightweight tag object and target must be identical",
|
||||
)
|
||||
-69
@@ -1,69 +0,0 @@
|
||||
"""Dormant Candidate worker supervisor.
|
||||
|
||||
Provider clients are injected by the external management plane. This process
|
||||
never converts a missing projection into a simulated native identity.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import argparse
|
||||
import json
|
||||
import os
|
||||
from pathlib import Path
|
||||
import signal
|
||||
import threading
|
||||
|
||||
|
||||
def write_status(directory: Path) -> None:
|
||||
directory.mkdir(parents=True, exist_ok=True, mode=0o750)
|
||||
if directory.is_symlink():
|
||||
raise RuntimeError("worker state directory symlink rejected")
|
||||
payload = {
|
||||
"status": "dormant",
|
||||
"task_plane_execution_enabled": os.environ.get(
|
||||
"AIOS_TASK_PLANE_EXECUTION_ENABLED", "false"
|
||||
).lower()
|
||||
== "true",
|
||||
"gitops_writes_enabled": os.environ.get("AIOS_GITOPS_WRITES_ENABLED", "false").lower()
|
||||
== "true",
|
||||
"production_side_effects": False,
|
||||
"secrets_included": False,
|
||||
}
|
||||
temporary = directory / f"worker-status.{os.getpid()}.new"
|
||||
target = directory / "worker-status.json"
|
||||
if temporary.is_symlink() or target.is_symlink():
|
||||
raise RuntimeError("worker status symlink rejected")
|
||||
descriptor = os.open(
|
||||
temporary,
|
||||
os.O_WRONLY | os.O_CREAT | os.O_EXCL | getattr(os, "O_NOFOLLOW", 0),
|
||||
0o640,
|
||||
)
|
||||
try:
|
||||
os.write(descriptor, (json.dumps(payload, sort_keys=True) + "\n").encode("utf-8"))
|
||||
os.fsync(descriptor)
|
||||
finally:
|
||||
os.close(descriptor)
|
||||
os.replace(temporary, target)
|
||||
|
||||
|
||||
def build_parser() -> argparse.ArgumentParser:
|
||||
parser = argparse.ArgumentParser()
|
||||
parser.add_argument("--state-directory", required=True, type=Path)
|
||||
return parser
|
||||
|
||||
|
||||
def main(argv: list[str] | None = None) -> int:
|
||||
args = build_parser().parse_args(argv)
|
||||
if os.environ.get("AIOS_PRODUCTION_DEPLOYMENT_ENABLED", "false").lower() == "true":
|
||||
raise RuntimeError("Candidate worker refuses production deployment mode")
|
||||
write_status(args.state_directory)
|
||||
stopping = threading.Event()
|
||||
signal.signal(signal.SIGTERM, lambda *_: stopping.set())
|
||||
signal.signal(signal.SIGINT, lambda *_: stopping.set())
|
||||
while not stopping.wait(5):
|
||||
write_status(args.state_directory)
|
||||
return 0
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
raise SystemExit(main())
|
||||
-201
@@ -1,201 +0,0 @@
|
||||
"""Durable fail-closed workflow state machine."""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
from dataclasses import dataclass
|
||||
from datetime import datetime, timedelta, timezone
|
||||
|
||||
from .errors import StateConflict
|
||||
from .models import StepState, TaskPlan, TaskState, is_sha256
|
||||
from .store import StateStore
|
||||
|
||||
|
||||
@dataclass(frozen=True, slots=True)
|
||||
class WorkflowDecision:
|
||||
task_id: str
|
||||
ready_steps: tuple[str, ...]
|
||||
blocked: bool
|
||||
reason: str | None = None
|
||||
|
||||
|
||||
class WorkflowEngine:
|
||||
def __init__(self, store: StateStore) -> None:
|
||||
self.store = store
|
||||
|
||||
def _task_state(self, task_id: str, state: TaskState) -> None:
|
||||
current, revision = self.store.get_task_state(task_id)
|
||||
if current != state:
|
||||
self.store.compare_and_set_task_state(task_id, revision, state)
|
||||
|
||||
def plan(self, task: TaskPlan) -> None:
|
||||
self.store.create_task(
|
||||
task.task_id,
|
||||
task.digest(),
|
||||
{
|
||||
"task_id": task.task_id,
|
||||
"intent": task.intent,
|
||||
"branch": task.binding.branch,
|
||||
"base_oid": task.binding.base_oid,
|
||||
},
|
||||
tuple(step.step_id for step in task.steps),
|
||||
{step.step_id: step.max_attempts for step in task.steps},
|
||||
)
|
||||
|
||||
def next_steps(self, task: TaskPlan) -> WorkflowDecision:
|
||||
states = self.store.list_steps(task.task_id)
|
||||
by_id = {step.step_id: step for step in task.steps}
|
||||
if any(item.state == StepState.FAILED for item in states.values()):
|
||||
self._task_state(task.task_id, TaskState.FAILED)
|
||||
return WorkflowDecision(task.task_id, (), True, "terminal_step_failure")
|
||||
ready: list[str] = []
|
||||
for step_id, stored in states.items():
|
||||
if stored.state not in (StepState.PENDING, StepState.READY):
|
||||
continue
|
||||
dependencies = by_id[step_id].depends_on
|
||||
dependency_states = tuple(states[item].state for item in dependencies)
|
||||
if any(item in (StepState.FAILED, StepState.BLOCKED) for item in dependency_states):
|
||||
if stored.state != StepState.BLOCKED:
|
||||
self.store.transition_step(
|
||||
task.task_id,
|
||||
step_id,
|
||||
(stored.state,),
|
||||
StepState.BLOCKED,
|
||||
last_error="dependency_failed",
|
||||
)
|
||||
continue
|
||||
if all(item == StepState.COMPLETED for item in dependency_states):
|
||||
if stored.state == StepState.PENDING:
|
||||
self.store.transition_step(
|
||||
task.task_id, step_id, (StepState.PENDING,), StepState.READY
|
||||
)
|
||||
ready.append(step_id)
|
||||
if states and all(item.state == StepState.COMPLETED for item in states.values()):
|
||||
self._task_state(task.task_id, TaskState.COMPLETED)
|
||||
elif ready:
|
||||
self._task_state(task.task_id, TaskState.READY)
|
||||
return WorkflowDecision(task.task_id, tuple(sorted(ready)), False)
|
||||
|
||||
def claim(self, task_id: str, step_id: str, worker_id: str, session_id: str) -> None:
|
||||
if not worker_id or not session_id:
|
||||
raise StateConflict("STEP_CLAIM_BINDING_REQUIRED", "worker and session are required")
|
||||
self.store.transition_step(
|
||||
task_id,
|
||||
step_id,
|
||||
(StepState.READY,),
|
||||
StepState.CLAIMED,
|
||||
worker_id=worker_id,
|
||||
session_id=session_id,
|
||||
increment_attempt=True,
|
||||
)
|
||||
|
||||
def start(
|
||||
self,
|
||||
task_id: str,
|
||||
step_id: str,
|
||||
worker_id: str,
|
||||
session_id: str,
|
||||
*,
|
||||
lease_seconds: int = 60,
|
||||
now: datetime | None = None,
|
||||
) -> None:
|
||||
current = self.store.list_steps(task_id)[step_id]
|
||||
if current.worker_id != worker_id or current.session_id != session_id:
|
||||
raise StateConflict("STEP_CLAIM_OWNER_MISMATCH", "claim owner does not match")
|
||||
now = now or datetime.now(timezone.utc)
|
||||
self.store.transition_step(
|
||||
task_id,
|
||||
step_id,
|
||||
(StepState.CLAIMED,),
|
||||
StepState.RUNNING,
|
||||
worker_id=worker_id,
|
||||
session_id=session_id,
|
||||
lease_expires_at=now + timedelta(seconds=lease_seconds),
|
||||
)
|
||||
self._task_state(task_id, TaskState.RUNNING)
|
||||
|
||||
def heartbeat(
|
||||
self,
|
||||
task_id: str,
|
||||
step_id: str,
|
||||
worker_id: str,
|
||||
session_id: str,
|
||||
*,
|
||||
lease_seconds: int = 60,
|
||||
now: datetime | None = None,
|
||||
) -> None:
|
||||
current = self.store.list_steps(task_id)[step_id]
|
||||
if current.worker_id != worker_id or current.session_id != session_id:
|
||||
raise StateConflict("STEP_CLAIM_OWNER_MISMATCH", "heartbeat owner does not match")
|
||||
now = now or datetime.now(timezone.utc)
|
||||
self.store.transition_step(
|
||||
task_id,
|
||||
step_id,
|
||||
(StepState.RUNNING,),
|
||||
StepState.RUNNING,
|
||||
lease_expires_at=now + timedelta(seconds=lease_seconds),
|
||||
)
|
||||
|
||||
def complete(self, task_id: str, step_id: str, *, result_digest: str) -> None:
|
||||
if not is_sha256(result_digest):
|
||||
raise StateConflict("RESULT_DIGEST_INVALID", "result digest must be SHA-256")
|
||||
current = self.store.list_steps(task_id)[step_id]
|
||||
if current.state == StepState.COMPLETED and current.result_digest == result_digest:
|
||||
return
|
||||
self.store.transition_step(
|
||||
task_id,
|
||||
step_id,
|
||||
(StepState.RUNNING,),
|
||||
StepState.COMPLETED,
|
||||
result_digest=result_digest,
|
||||
)
|
||||
|
||||
def fail(
|
||||
self,
|
||||
task: TaskPlan,
|
||||
step_id: str,
|
||||
reason: str,
|
||||
*,
|
||||
retryable: bool,
|
||||
) -> StepState:
|
||||
current = self.store.list_steps(task.task_id)[step_id]
|
||||
next_state = (
|
||||
StepState.PENDING
|
||||
if retryable and current.attempt < current.max_attempts
|
||||
else StepState.FAILED
|
||||
)
|
||||
self.store.transition_step(
|
||||
task.task_id,
|
||||
step_id,
|
||||
(StepState.CLAIMED, StepState.RUNNING),
|
||||
next_state,
|
||||
last_error=reason,
|
||||
clear_assignment=next_state == StepState.PENDING,
|
||||
)
|
||||
self._task_state(
|
||||
task.task_id, TaskState.BLOCKED if next_state == StepState.PENDING else TaskState.FAILED
|
||||
)
|
||||
return next_state
|
||||
|
||||
def recover_expired(
|
||||
self, task: TaskPlan, *, now: datetime | None = None
|
||||
) -> tuple[str, ...]:
|
||||
now = now or datetime.now(timezone.utc)
|
||||
recovered: list[str] = []
|
||||
for step_id, current in self.store.list_steps(task.task_id).items():
|
||||
if (
|
||||
current.state == StepState.RUNNING
|
||||
and current.lease_expires_at is not None
|
||||
and current.lease_expires_at <= now
|
||||
):
|
||||
self.fail(task, step_id, "lease_expired", retryable=True)
|
||||
recovered.append(step_id)
|
||||
return tuple(recovered)
|
||||
|
||||
def recoverable(self, task_id: str, step_id: str) -> None:
|
||||
self.store.transition_step(
|
||||
task_id,
|
||||
step_id,
|
||||
(StepState.BLOCKED,),
|
||||
StepState.PENDING,
|
||||
clear_assignment=True,
|
||||
)
|
||||
@@ -1,25 +0,0 @@
|
||||
[build-system]
|
||||
requires = ["setuptools>=69"]
|
||||
build-backend = "setuptools.build_meta"
|
||||
|
||||
[project]
|
||||
name = "aios-autonomous-release-candidate"
|
||||
version = "0.1.0"
|
||||
description = "Candidate-only governed autonomous release control plane"
|
||||
readme = "README.md"
|
||||
requires-python = ">=3.11"
|
||||
license = { text = "Proprietary" }
|
||||
authors = [{ name = "AIOS" }]
|
||||
dependencies = []
|
||||
|
||||
[project.scripts]
|
||||
aios-autonomous-release = "aios_autonomous_release_candidate.cli:main"
|
||||
aios-autonomous-release-service = "aios_autonomous_release_candidate.service:main"
|
||||
|
||||
[tool.setuptools.packages.find]
|
||||
where = ["."]
|
||||
include = ["aios_autonomous_release_candidate*"]
|
||||
|
||||
[tool.pytest.ini_options]
|
||||
addopts = "-ra --strict-config --strict-markers"
|
||||
testpaths = ["../../tests/autonomous_release"]
|
||||
@@ -1,48 +0,0 @@
|
||||
from datetime import datetime, timezone, timedelta
|
||||
|
||||
from aios_autonomous_release_candidate.models import (
|
||||
ResourceBinding,
|
||||
RiskClass,
|
||||
TaskPlan,
|
||||
WorkflowStep,
|
||||
)
|
||||
from aios_autonomous_release_candidate.policy import ReleasePolicy
|
||||
from aios_autonomous_release_candidate.evidence import EvidenceChain
|
||||
|
||||
|
||||
OID = "a" * 40
|
||||
|
||||
|
||||
def build_plan():
|
||||
return TaskPlan(
|
||||
task_id="test-task",
|
||||
intent="candidate validation",
|
||||
binding=ResourceBinding(
|
||||
repository="aios/aios",
|
||||
branch="patch/test",
|
||||
base_oid=OID,
|
||||
allowed_paths=("services/test/",),
|
||||
),
|
||||
risk=RiskClass.LOW,
|
||||
steps=(
|
||||
WorkflowStep(
|
||||
step_id="validate",
|
||||
worker_role="tester",
|
||||
required_capabilities=("test.execute",),
|
||||
allowed_paths=("services/test/",),
|
||||
),
|
||||
),
|
||||
evidence_requirements=("tests",),
|
||||
)
|
||||
|
||||
|
||||
def test_plan_policy_accepts_candidate_plan():
|
||||
ReleasePolicy().validate_task(build_plan())
|
||||
|
||||
|
||||
def test_evidence_chain_detects_valid_closure():
|
||||
chain = EvidenceChain()
|
||||
chain.append("START", "test-task", {"ok": True, "secrets_included": False})
|
||||
chain.append("DONE", "test-task", {"ok": True, "secrets_included": False})
|
||||
assert chain.verify()
|
||||
assert len(chain.closure_digest()) == 64
|
||||
@@ -1,41 +0,0 @@
|
||||
from pathlib import Path
|
||||
|
||||
import pytest
|
||||
|
||||
from aios_autonomous_release_candidate.artifact import ArtifactBuilder, ArtifactFile, BuiltArtifact
|
||||
from aios_autonomous_release_candidate.errors import EvidenceIncomplete, ReleaseBlocked
|
||||
|
||||
|
||||
def test_artifact_is_deterministic_and_reverified() -> None:
|
||||
builder = ArtifactBuilder()
|
||||
files = (
|
||||
ArtifactFile("bin/run", b"#!/bin/sh\nexit 0\n", 0o755),
|
||||
ArtifactFile("config/candidate.json", b'{"production":false}\n'),
|
||||
)
|
||||
first = builder.build("a" * 40, "b" * 40, files)
|
||||
second = builder.build("a" * 40, "b" * 40, tuple(reversed(files)))
|
||||
assert first.content == second.content
|
||||
assert first.manifest.manifest_sha256 == second.manifest.manifest_sha256
|
||||
assert first.manifest.secrets_included is False
|
||||
builder.verify(first)
|
||||
with pytest.raises(EvidenceIncomplete, match="ARTIFACT_DIGEST_MISMATCH"):
|
||||
builder.verify(BuiltArtifact(first.content + b"tampered", first.manifest))
|
||||
|
||||
|
||||
def test_source_tree_rejects_symlink_and_hardlink(tmp_path: Path) -> None:
|
||||
root = tmp_path / "source"
|
||||
root.mkdir()
|
||||
target = root / "file.txt"
|
||||
target.write_text("safe", encoding="utf-8")
|
||||
(root / "link.txt").symlink_to(target)
|
||||
with pytest.raises(ReleaseBlocked, match="ARTIFACT_SOURCE_LINK_REJECTED"):
|
||||
ArtifactBuilder().build_from_directory("a" * 40, "b" * 40, root)
|
||||
|
||||
|
||||
def test_artifact_rejects_secret_markers() -> None:
|
||||
with pytest.raises(ReleaseBlocked, match="ARTIFACT_SECRET_MARKER"):
|
||||
ArtifactBuilder().build(
|
||||
"a" * 40,
|
||||
"b" * 40,
|
||||
(ArtifactFile("unsafe.env", b"password" + b"=" + b"x" * 16),),
|
||||
)
|
||||
@@ -1,66 +0,0 @@
|
||||
import json
|
||||
from pathlib import Path
|
||||
|
||||
from aios_autonomous_release_candidate.cli import main
|
||||
|
||||
|
||||
def test_cli_artifact_build_and_verify(tmp_path: Path, capsys) -> None:
|
||||
source = tmp_path / "source"
|
||||
source.mkdir()
|
||||
(source / "payload.txt").write_text("candidate payload\n", encoding="utf-8")
|
||||
output = tmp_path / "output"
|
||||
assert main(
|
||||
[
|
||||
"artifact",
|
||||
"build",
|
||||
"--source",
|
||||
str(source),
|
||||
"--source-oid",
|
||||
"a" * 40,
|
||||
"--tree-oid",
|
||||
"b" * 40,
|
||||
"--output-directory",
|
||||
str(output),
|
||||
]
|
||||
) == 0
|
||||
built = json.loads(capsys.readouterr().out)
|
||||
assert built["secrets_included"] is False
|
||||
assert main(
|
||||
[
|
||||
"artifact",
|
||||
"verify",
|
||||
"--artifact",
|
||||
built["artifact"],
|
||||
"--manifest",
|
||||
built["manifest"],
|
||||
]
|
||||
) == 0
|
||||
assert json.loads(capsys.readouterr().out)["verified"] is True
|
||||
|
||||
|
||||
def test_cli_release_verify_stops_at_owner(tmp_path: Path, capsys) -> None:
|
||||
payload = {
|
||||
"task_id": "cli-release-task",
|
||||
"repository": "aios/aios",
|
||||
"branch": "integration/cli-release",
|
||||
"version": "SHADOW-0.1.0",
|
||||
"target_oid": "a" * 40,
|
||||
"tree_oid": "b" * 40,
|
||||
"artifact_sha256": "c" * 64,
|
||||
"manifest_sha256": "d" * 64,
|
||||
"package_closure_sha256": "e" * 64,
|
||||
"evidence_closure_oid": "f" * 40,
|
||||
"approval_plan_id": "external-owner-release",
|
||||
"rollback_approval_plan_id": "external-owner-rollback",
|
||||
"rollback_artifact_sha256": "1" * 64,
|
||||
"expected_tag_oid": "2" * 40,
|
||||
"expected_target_oid": "a" * 40,
|
||||
"production_config_sha256": "3" * 64,
|
||||
}
|
||||
path = tmp_path / "release-plan.json"
|
||||
path.write_text(json.dumps(payload), encoding="utf-8")
|
||||
assert main(["release", "verify", "--payload", str(path)]) == 0
|
||||
result = json.loads(capsys.readouterr().out)
|
||||
assert result["release_state"] == "WAITING_OWNER"
|
||||
assert result["production_release"] == "BLOCKED_EXTERNAL_OWNER_SIGNATURE"
|
||||
assert result["production_side_effects"] is False
|
||||
@@ -1,48 +0,0 @@
|
||||
from datetime import datetime, timezone, timedelta
|
||||
|
||||
from aios_autonomous_release_candidate.models import (
|
||||
ResourceBinding,
|
||||
RiskClass,
|
||||
TaskPlan,
|
||||
WorkflowStep,
|
||||
)
|
||||
from aios_autonomous_release_candidate.policy import ReleasePolicy
|
||||
from aios_autonomous_release_candidate.evidence import EvidenceChain
|
||||
|
||||
|
||||
OID = "a" * 40
|
||||
|
||||
|
||||
def build_plan():
|
||||
return TaskPlan(
|
||||
task_id="test-task",
|
||||
intent="candidate validation",
|
||||
binding=ResourceBinding(
|
||||
repository="aios/aios",
|
||||
branch="patch/test",
|
||||
base_oid=OID,
|
||||
allowed_paths=("services/test/",),
|
||||
),
|
||||
risk=RiskClass.LOW,
|
||||
steps=(
|
||||
WorkflowStep(
|
||||
step_id="validate",
|
||||
worker_role="tester",
|
||||
required_capabilities=("test.execute",),
|
||||
allowed_paths=("services/test/",),
|
||||
),
|
||||
),
|
||||
evidence_requirements=("tests",),
|
||||
)
|
||||
|
||||
|
||||
def test_plan_policy_accepts_candidate_plan():
|
||||
ReleasePolicy().validate_task(build_plan())
|
||||
|
||||
|
||||
def test_evidence_chain_detects_valid_closure():
|
||||
chain = EvidenceChain()
|
||||
chain.append("START", "test-task", {"ok": True, "secrets_included": False})
|
||||
chain.append("DONE", "test-task", {"ok": True, "secrets_included": False})
|
||||
assert chain.verify()
|
||||
assert len(chain.closure_digest()) == 64
|
||||
@@ -1,129 +0,0 @@
|
||||
from datetime import datetime, timedelta, timezone
|
||||
from pathlib import Path
|
||||
|
||||
import pytest
|
||||
|
||||
from aios_autonomous_release_candidate.credential import CredentialBroker
|
||||
from aios_autonomous_release_candidate.errors import CredentialUnavailable, EvidenceIncomplete
|
||||
from aios_autonomous_release_candidate.evidence import EvidenceChain
|
||||
from aios_autonomous_release_candidate.models import CredentialRequest, ResourceBinding
|
||||
from aios_autonomous_release_candidate.store import StateStore
|
||||
|
||||
|
||||
NOW = datetime(2026, 7, 26, tzinfo=timezone.utc)
|
||||
|
||||
|
||||
class Provider:
|
||||
def __init__(self, reference: str = "systemd-credential:openclaw-gateway-candidate") -> None:
|
||||
self.reference = reference
|
||||
self.active: set[str] = set()
|
||||
self.revoked: list[str] = []
|
||||
self.count = 0
|
||||
|
||||
def issue(self, request, expires_at):
|
||||
self.count += 1
|
||||
credential_id = f"credential-{self.count}"
|
||||
self.active.add(credential_id)
|
||||
return credential_id, self.reference
|
||||
|
||||
def revoke(self, credential_id, reference):
|
||||
self.active.discard(credential_id)
|
||||
self.revoked.append(credential_id)
|
||||
|
||||
def is_usable(self, credential_id, reference):
|
||||
return credential_id in self.active
|
||||
|
||||
|
||||
def request(request_id: str = "request-1") -> CredentialRequest:
|
||||
return CredentialRequest(
|
||||
request_id=request_id,
|
||||
task_id="task-credential",
|
||||
session_id="session-1",
|
||||
worker_id="worker-1",
|
||||
audience="openclaw-candidate",
|
||||
consumer_service="aios-autonomous-release-worker-candidate.service",
|
||||
binding=ResourceBinding("aios/aios", "patch/credential-test", "a" * 40, ("services/test",)),
|
||||
operations=("native_session.spawn",),
|
||||
ttl_seconds=300,
|
||||
max_uses=1,
|
||||
provider="openclaw",
|
||||
runtime_user="aiman",
|
||||
approval_plan_id="owner-stage-b-native-sessions-20260726",
|
||||
not_before=NOW,
|
||||
expires_at=NOW + timedelta(minutes=5),
|
||||
nonce="nonce-credential-1",
|
||||
)
|
||||
|
||||
|
||||
def test_credential_is_scope_bound_revocable_and_idempotent(tmp_path: Path) -> None:
|
||||
provider = Provider()
|
||||
broker = CredentialBroker(StateStore(tmp_path / "state.sqlite3"), provider)
|
||||
projection = broker.issue(request(), NOW)
|
||||
broker.project(projection)
|
||||
broker.authorize(
|
||||
projection,
|
||||
task_id="task-credential",
|
||||
session_id="session-1",
|
||||
worker_id="worker-1",
|
||||
audience="openclaw-candidate",
|
||||
consumer_service="aios-autonomous-release-worker-candidate.service",
|
||||
operation="native_session.spawn",
|
||||
path="services/test/file.py",
|
||||
now=NOW,
|
||||
)
|
||||
with pytest.raises(CredentialUnavailable, match="CREDENTIAL_SCOPE_MISMATCH"):
|
||||
broker.authorize(
|
||||
projection,
|
||||
task_id="other-task",
|
||||
session_id="session-1",
|
||||
worker_id="worker-1",
|
||||
audience="openclaw-candidate",
|
||||
consumer_service="aios-autonomous-release-worker-candidate.service",
|
||||
operation="native_session.spawn",
|
||||
path="services/test/file.py",
|
||||
now=NOW,
|
||||
)
|
||||
first = broker.revoke(projection.credential_id, projection.reference, NOW)
|
||||
second = broker.revoke(projection.credential_id, projection.reference, NOW)
|
||||
assert first == second
|
||||
broker.verify_revoked(projection.credential_id, projection.reference)
|
||||
|
||||
|
||||
def test_persistence_failure_compensates_upstream_issuance(tmp_path: Path) -> None:
|
||||
provider = Provider()
|
||||
broker = CredentialBroker(StateStore(tmp_path / "state.sqlite3"), provider)
|
||||
broker.issue(request(), NOW)
|
||||
with pytest.raises(CredentialUnavailable, match="CREDENTIAL_PERSISTENCE_FAILED"):
|
||||
broker.issue(request("request-2"), NOW)
|
||||
assert "credential-2" in provider.revoked
|
||||
|
||||
|
||||
def test_plaintext_or_untrusted_projection_is_rejected(tmp_path: Path) -> None:
|
||||
provider = Provider("/run/credentials/candidate/raw-value")
|
||||
broker = CredentialBroker(StateStore(tmp_path / "state.sqlite3"), provider)
|
||||
with pytest.raises(CredentialUnavailable, match="CREDENTIAL_REFERENCE_REJECTED"):
|
||||
broker.issue(request(), NOW)
|
||||
assert provider.revoked == ["credential-1"]
|
||||
|
||||
|
||||
def test_evidence_chain_survives_restart_and_detects_tampering(tmp_path: Path) -> None:
|
||||
store = StateStore(tmp_path / "state.sqlite3")
|
||||
chain = EvidenceChain(store, "task-evidence")
|
||||
chain.append("TASK_STARTED", "task-evidence", {"secrets_included": False})
|
||||
chain.append(
|
||||
"TESTS_PASSED",
|
||||
"task-evidence",
|
||||
{"passed": 42, "skipped": 0, "secrets_included": False},
|
||||
)
|
||||
reopened = EvidenceChain(store, "task-evidence")
|
||||
assert reopened.verify()
|
||||
assert len(reopened.close(("TASK_STARTED", "TESTS_PASSED"))) == 64
|
||||
with pytest.raises(EvidenceIncomplete, match="EVIDENCE_REQUIREMENT_MISSING"):
|
||||
reopened.close(("NATIVE_SESSION_VERIFIED",))
|
||||
|
||||
with store.transaction() as connection:
|
||||
connection.execute(
|
||||
"UPDATE events SET payload_json=? WHERE task_id=? AND sequence=1",
|
||||
('{"secrets_included":true}', "task-evidence"),
|
||||
)
|
||||
assert EvidenceChain(store, "task-evidence").verify() is False
|
||||
@@ -1,125 +0,0 @@
|
||||
from datetime import datetime, timedelta, timezone
|
||||
|
||||
import pytest
|
||||
|
||||
from aios_autonomous_release_candidate.approval import (
|
||||
ApprovalVerifier,
|
||||
StaticRevocationSource,
|
||||
UnavailableSignatureVerifier,
|
||||
)
|
||||
from aios_autonomous_release_candidate.errors import ApprovalRequired
|
||||
from aios_autonomous_release_candidate.gitea_canary import (
|
||||
EphemeralKeyProjection,
|
||||
GiteaDeployKeyCanary,
|
||||
)
|
||||
from aios_autonomous_release_candidate.models import (
|
||||
ApprovalEnvelope,
|
||||
ResourceBinding,
|
||||
RiskClass,
|
||||
TaskPlan,
|
||||
WorkflowStep,
|
||||
)
|
||||
from aios_autonomous_release_candidate.store import StateStore
|
||||
|
||||
|
||||
NOW = datetime(2026, 7, 26, tzinfo=timezone.utc)
|
||||
OID = "a" * 40
|
||||
|
||||
|
||||
def task_plan() -> TaskPlan:
|
||||
return TaskPlan(
|
||||
"external-gate-task",
|
||||
"external gate verification",
|
||||
ResourceBinding("aios/aios", "patch/external-gate", OID, ("services/test",)),
|
||||
RiskClass.HIGH,
|
||||
(WorkflowStep("canary", "tester", ("native_session.spawn",)),),
|
||||
("external-gates",),
|
||||
)
|
||||
|
||||
|
||||
def test_unknown_owner_verifier_fails_with_stable_blocker(tmp_path) -> None:
|
||||
plan = task_plan()
|
||||
envelope = ApprovalEnvelope(
|
||||
approval_plan_id="owner-external-gate",
|
||||
task_id=plan.task_id,
|
||||
task_plan_sha256=plan.digest(),
|
||||
binding=plan.binding,
|
||||
capabilities=("native_session.spawn",),
|
||||
risk=RiskClass.HIGH,
|
||||
not_before=NOW - timedelta(minutes=1),
|
||||
expires_at=NOW + timedelta(minutes=5),
|
||||
nonce="nonce-owner-external",
|
||||
signing_key_id="owner-kms-1",
|
||||
signature="opaque-signature",
|
||||
)
|
||||
verifier = ApprovalVerifier(
|
||||
StateStore(tmp_path / "state.sqlite3"),
|
||||
UnavailableSignatureVerifier(),
|
||||
StaticRevocationSource(),
|
||||
)
|
||||
with pytest.raises(
|
||||
ApprovalRequired, match="BLOCKED_OWNER_APPROVAL_VERIFIER_UNAVAILABLE"
|
||||
):
|
||||
verifier.verify(plan, envelope, now=NOW)
|
||||
|
||||
|
||||
class KeyProjection:
|
||||
def __init__(self) -> None:
|
||||
self.present = False
|
||||
|
||||
def create(self, task_id, branch):
|
||||
self.present = True
|
||||
return EphemeralKeyProjection(
|
||||
public_key="ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAICandidateCanaryOnly",
|
||||
private_key_reference="systemd-credential:gitea-deploy-key-canary",
|
||||
)
|
||||
|
||||
def delete(self, reference):
|
||||
self.present = False
|
||||
|
||||
def is_present(self, reference):
|
||||
return self.present
|
||||
|
||||
|
||||
class Gitea:
|
||||
simulation = True
|
||||
|
||||
def __init__(self) -> None:
|
||||
self.keys = {}
|
||||
|
||||
def list_deploy_keys(self, repository, credential_reference):
|
||||
return list(self.keys.values())
|
||||
|
||||
def create_deploy_key(self, repository, title, public_key, credential_reference):
|
||||
item = {"id": 1, "title": title, "key": public_key, "read_only": False}
|
||||
self.keys[1] = item
|
||||
return item
|
||||
|
||||
def delete_deploy_key(self, repository, key_id, credential_reference):
|
||||
self.keys.pop(key_id, None)
|
||||
|
||||
|
||||
class SSHProbe:
|
||||
def __init__(self, gitea, projection) -> None:
|
||||
self.gitea = gitea
|
||||
self.projection = projection
|
||||
|
||||
def authenticate(self, repository, branch, private_key_reference):
|
||||
return bool(self.gitea.keys) and self.projection.present
|
||||
|
||||
|
||||
def test_gitea_canary_always_revokes_key_and_projection() -> None:
|
||||
projection = KeyProjection()
|
||||
gitea = Gitea()
|
||||
result = GiteaDeployKeyCanary(gitea, projection, SSHProbe(gitea, projection)).run(
|
||||
task_id="external-gate-task",
|
||||
branch="patch/external-gate",
|
||||
credential_reference="systemd-credential:gitea-admin-api-candidate",
|
||||
)
|
||||
assert result.key_created is True
|
||||
assert result.key_deleted is True
|
||||
assert result.post_revoke_auth_rejected is True
|
||||
assert result.credential_projection_deleted is True
|
||||
assert result.gitea_admin_api_lifecycle_canary is False # simulation is not real evidence
|
||||
assert gitea.keys == {}
|
||||
assert projection.present is False
|
||||
@@ -1,156 +0,0 @@
|
||||
from contextlib import contextmanager
|
||||
import hashlib
|
||||
import json
|
||||
from pathlib import Path
|
||||
from threading import Thread
|
||||
import urllib.error
|
||||
import urllib.request
|
||||
|
||||
from aios_autonomous_release_candidate.service import CandidateApplication, CandidateHTTPServer
|
||||
|
||||
|
||||
@contextmanager
|
||||
def running_server(tmp_path: Path):
|
||||
application = CandidateApplication(tmp_path / "state.sqlite3")
|
||||
server = CandidateHTTPServer(("127.0.0.1", 0), application)
|
||||
thread = Thread(target=server.serve_forever, daemon=True)
|
||||
thread.start()
|
||||
try:
|
||||
yield application, f"http://127.0.0.1:{server.server_port}"
|
||||
finally:
|
||||
server.shutdown()
|
||||
server.server_close()
|
||||
thread.join(timeout=5)
|
||||
|
||||
|
||||
def get_json(url: str):
|
||||
with urllib.request.urlopen(url, timeout=5) as response:
|
||||
return response.status, json.load(response)
|
||||
|
||||
|
||||
def post_json(url: str, payload: dict):
|
||||
request = urllib.request.Request(
|
||||
url,
|
||||
data=json.dumps(payload).encode("utf-8"),
|
||||
method="POST",
|
||||
headers={"Content-Type": "application/json"},
|
||||
)
|
||||
with urllib.request.urlopen(request, timeout=5) as response:
|
||||
return response.status, json.load(response)
|
||||
|
||||
|
||||
def test_health_and_readiness_are_loopback_safe(tmp_path: Path) -> None:
|
||||
with running_server(tmp_path) as (_, base):
|
||||
status, health = get_json(f"{base}/health")
|
||||
assert status == 200
|
||||
assert health["production_side_effects"] is False
|
||||
status, ready = get_json(f"{base}/ready")
|
||||
assert status == 200
|
||||
assert ready == {"status": "ready", "secrets_included": False}
|
||||
|
||||
|
||||
def test_json_content_type_is_required(tmp_path: Path) -> None:
|
||||
with running_server(tmp_path) as (_, base):
|
||||
request = urllib.request.Request(f"{base}/v1/tasks", data=b"{}", method="POST")
|
||||
try:
|
||||
urllib.request.urlopen(request, timeout=5)
|
||||
except urllib.error.HTTPError as error:
|
||||
assert error.code == 415
|
||||
assert json.load(error)["error"] == "content_type_required"
|
||||
|
||||
|
||||
def test_internal_exception_text_is_not_disclosed(tmp_path: Path) -> None:
|
||||
with running_server(tmp_path) as (application, base):
|
||||
def fail(_payload):
|
||||
raise RuntimeError("sensitive internal diagnostic")
|
||||
|
||||
application.api.create_task = fail
|
||||
request = urllib.request.Request(
|
||||
f"{base}/v1/tasks",
|
||||
data=b"{}",
|
||||
method="POST",
|
||||
headers={"Content-Type": "application/json"},
|
||||
)
|
||||
try:
|
||||
urllib.request.urlopen(request, timeout=5)
|
||||
except urllib.error.HTTPError as error:
|
||||
assert error.code == 500
|
||||
body = error.read().decode("utf-8")
|
||||
assert "candidate_request_failed" in body
|
||||
assert "sensitive internal diagnostic" not in body
|
||||
|
||||
|
||||
def test_task_lifecycle_evidence_and_release_gate_endpoints(tmp_path: Path) -> None:
|
||||
task_id = "api-lifecycle-task"
|
||||
task = {
|
||||
"task_id": task_id,
|
||||
"intent": "exercise candidate API",
|
||||
"binding": {
|
||||
"repository": "aios/aios",
|
||||
"branch": "patch/api-lifecycle",
|
||||
"base_oid": "a" * 40,
|
||||
"allowed_paths": ["services/test"],
|
||||
},
|
||||
"risk": "medium",
|
||||
"steps": [
|
||||
{
|
||||
"step_id": "test-step",
|
||||
"worker_role": "tester",
|
||||
"required_capabilities": ["test.execute"],
|
||||
}
|
||||
],
|
||||
"evidence_requirements": ["STEP_RESULT"],
|
||||
"production_side_effects_allowed": False,
|
||||
}
|
||||
with running_server(tmp_path) as (_, base):
|
||||
status, created = post_json(f"{base}/v1/tasks", task)
|
||||
assert status == 201
|
||||
assert created["production_side_effects"] is False
|
||||
status, steps = get_json(f"{base}/v1/tasks/{task_id}/steps")
|
||||
assert status == 200
|
||||
assert steps["steps"]["test-step"]["state"] == "READY"
|
||||
binding = {
|
||||
"step_id": "test-step",
|
||||
"worker_id": "worker-1",
|
||||
"session_id": "session-1",
|
||||
}
|
||||
_, claimed = post_json(f"{base}/v1/tasks/{task_id}/claim", binding)
|
||||
assert claimed["state"] == "RUNNING"
|
||||
_, heartbeat = post_json(f"{base}/v1/tasks/{task_id}/heartbeat", binding)
|
||||
assert heartbeat["state"] == "RUNNING"
|
||||
_, result = post_json(
|
||||
f"{base}/v1/tasks/{task_id}/result",
|
||||
{"step_id": "test-step", "result_digest": hashlib.sha256(b"ok").hexdigest()},
|
||||
)
|
||||
assert result["state"] == "COMPLETED"
|
||||
_, evidence = get_json(f"{base}/v1/tasks/{task_id}/evidence")
|
||||
assert evidence["verified"] is True
|
||||
assert any(item["event_type"] == "STEP_RESULT" for item in evidence["events"])
|
||||
_, closure = post_json(f"{base}/v1/tasks/{task_id}/evidence/close", {})
|
||||
assert len(closure["evidence_closure"]) == 64
|
||||
|
||||
release_plan = {
|
||||
"task_id": task_id,
|
||||
"repository": "aios/aios",
|
||||
"branch": "integration/api-lifecycle",
|
||||
"version": "SHADOW-0.1.0",
|
||||
"target_oid": "b" * 40,
|
||||
"tree_oid": "c" * 40,
|
||||
"artifact_sha256": "d" * 64,
|
||||
"manifest_sha256": "e" * 64,
|
||||
"package_closure_sha256": "f" * 64,
|
||||
"evidence_closure_oid": "1" * 40,
|
||||
"approval_plan_id": "external-owner-release",
|
||||
"rollback_approval_plan_id": "external-owner-rollback",
|
||||
"rollback_artifact_sha256": "2" * 64,
|
||||
"expected_tag_oid": "3" * 40,
|
||||
"expected_target_oid": "b" * 40,
|
||||
"production_config_sha256": "4" * 64,
|
||||
}
|
||||
_, release = post_json(f"{base}/v1/release/plan", release_plan)
|
||||
assert release["release_state"] == "BUILT"
|
||||
_, verified = post_json(
|
||||
f"{base}/v1/release/verify", {"artifact_ok": True, "evidence_ok": True}
|
||||
)
|
||||
assert verified["release_state"] == "WAITING_OWNER"
|
||||
assert verified["production_release"] == "BLOCKED_EXTERNAL_OWNER_SIGNATURE"
|
||||
@@ -1,94 +0,0 @@
|
||||
from typing import Any, Mapping
|
||||
|
||||
import pytest
|
||||
|
||||
from aios_autonomous_release_candidate.errors import StateConflict
|
||||
from aios_autonomous_release_candidate.native_adapters import (
|
||||
CodexNativeAdapter,
|
||||
OpenClawNativeAdapter,
|
||||
)
|
||||
|
||||
|
||||
class Provider:
|
||||
simulation = True
|
||||
|
||||
def __init__(self, name: str) -> None:
|
||||
self.name = name
|
||||
self.state = "ACTIVE"
|
||||
self.parent = "parent-1"
|
||||
|
||||
def spawn(self, request: Mapping[str, Any], credential_reference: str):
|
||||
return {
|
||||
"provider_session_id": f"{self.name}-native-1",
|
||||
"task_id": request["task_id"],
|
||||
"parent_session_id": request["parent_session_id"],
|
||||
"candidate_only": True,
|
||||
"production_session_access": False,
|
||||
}
|
||||
|
||||
def status(self, provider_session_id: str, credential_reference: str):
|
||||
return {"provider_session_id": provider_session_id, "state": self.state}
|
||||
|
||||
def list_tree(self, parent_session_id: str, credential_reference: str):
|
||||
return [{"provider_session_id": f"{self.name}-native-1", "parent_session_id": parent_session_id}]
|
||||
|
||||
def send_text(self, provider_session_id, payload, credential_reference):
|
||||
return {
|
||||
"content_type": "text/plain",
|
||||
"encoding": "utf-8",
|
||||
"image_only": False,
|
||||
"task_id": payload["task_id"],
|
||||
"message_id": "message-1",
|
||||
"receipt": "receipt-1",
|
||||
"recipient_binding": payload["recipient_binding"],
|
||||
"secrets_included": False,
|
||||
}
|
||||
|
||||
def interrupt(self, provider_session_id: str, credential_reference: str):
|
||||
self.state = "INTERRUPTED"
|
||||
|
||||
def close(self, provider_session_id: str, credential_reference: str):
|
||||
self.state = "CLOSED"
|
||||
|
||||
|
||||
@pytest.mark.parametrize(
|
||||
("adapter_type", "provider_name", "reference", "flag"),
|
||||
(
|
||||
(
|
||||
OpenClawNativeAdapter,
|
||||
"openclaw",
|
||||
"systemd-credential:openclaw-gateway-candidate",
|
||||
"openclaw_native_child_session_verified",
|
||||
),
|
||||
(
|
||||
CodexNativeAdapter,
|
||||
"codex",
|
||||
"systemd-credential:codex-app-server-candidate",
|
||||
"codex_child_session_verified",
|
||||
),
|
||||
),
|
||||
)
|
||||
def test_native_adapter_preserves_identity_and_text_contract(
|
||||
adapter_type, provider_name, reference, flag
|
||||
) -> None:
|
||||
adapter = adapter_type(Provider(provider_name), reference)
|
||||
session = adapter.spawn("task-native", "parent-1", {"recipient_id": "weixin-owner"})
|
||||
assert session.broker_session_id != session.provider_session_id
|
||||
verification = adapter.verify(session)
|
||||
assert verification.broker_session_verified is True
|
||||
assert getattr(verification, flag) is False # simulated providers are never real canary evidence
|
||||
result = adapter.send_text(session, "hello")
|
||||
assert result.content_type == "text/plain"
|
||||
assert result.secrets_included is False
|
||||
adapter.interrupt(session)
|
||||
assert adapter.status(session) == "INTERRUPTED"
|
||||
adapter.close(session)
|
||||
assert adapter.status(session) == "CLOSED"
|
||||
|
||||
|
||||
def test_recipient_binding_must_be_single_and_trusted() -> None:
|
||||
adapter = OpenClawNativeAdapter(
|
||||
Provider("openclaw"), "systemd-credential:openclaw-gateway-candidate"
|
||||
)
|
||||
with pytest.raises(StateConflict, match="RECIPIENT_BINDING_REQUIRED"):
|
||||
adapter.spawn("task-native", "parent-1", {"recipients": ["one", "two"]})
|
||||
@@ -1,95 +0,0 @@
|
||||
from dataclasses import replace
|
||||
from datetime import datetime, timezone
|
||||
|
||||
import pytest
|
||||
|
||||
from aios_autonomous_release_candidate.approval import ApprovalVerificationResult
|
||||
from aios_autonomous_release_candidate.errors import ReleaseBlocked
|
||||
from aios_autonomous_release_candidate.models import ReleasePlan
|
||||
from aios_autonomous_release_candidate.release import ReleaseController, ReleaseState
|
||||
from aios_autonomous_release_candidate.release_gate import ReleaseEvidence, ReleaseGate
|
||||
from aios_autonomous_release_candidate.tag import TagReference, TagVerifier
|
||||
|
||||
|
||||
OID = "a" * 40
|
||||
TAG_OID = "b" * 40
|
||||
DIGEST = "c" * 64
|
||||
|
||||
|
||||
def plan() -> ReleasePlan:
|
||||
return ReleasePlan(
|
||||
task_id="release-task",
|
||||
repository="aios/aios",
|
||||
branch="integration/autonomous-release",
|
||||
version="V2R1C4",
|
||||
target_oid=OID,
|
||||
tree_oid="d" * 40,
|
||||
artifact_sha256=DIGEST,
|
||||
manifest_sha256="e" * 64,
|
||||
package_closure_sha256="3" * 64,
|
||||
evidence_closure_oid="f" * 40,
|
||||
approval_plan_id="owner-release-v2r1c4",
|
||||
rollback_approval_plan_id="owner-rollback-v2r1c4",
|
||||
rollback_artifact_sha256="1" * 64,
|
||||
expected_tag_oid=TAG_OID,
|
||||
expected_target_oid=OID,
|
||||
production_config_sha256="2" * 64,
|
||||
)
|
||||
|
||||
|
||||
def approval(plan_id: str) -> ApprovalVerificationResult:
|
||||
return ApprovalVerificationResult(
|
||||
approval_plan_id=plan_id,
|
||||
task_id="release-task",
|
||||
signing_key_id="owner-kms-1",
|
||||
verified_at=datetime(2026, 7, 26, tzinfo=timezone.utc),
|
||||
)
|
||||
|
||||
|
||||
def test_deploy_and_rollback_require_distinct_verified_approvals() -> None:
|
||||
controller = ReleaseController()
|
||||
controller.attach_plan(plan())
|
||||
controller.mark_built()
|
||||
controller.verify(artifact_ok=True, evidence_ok=True)
|
||||
controller.request_owner_approval()
|
||||
with pytest.raises(ReleaseBlocked, match="OWNER_APPROVAL_PLAN_MISMATCH"):
|
||||
controller.approve(approval("wrong-plan"))
|
||||
controller.approve(approval("owner-release-v2r1c4"))
|
||||
controller.start_deployment()
|
||||
controller.mark_deployed()
|
||||
controller.request_rollback("candidate acceptance regression")
|
||||
with pytest.raises(ReleaseBlocked, match="ROLLBACK_APPROVAL_PLAN_MISMATCH"):
|
||||
controller.approve_rollback(approval("owner-release-v2r1c4"))
|
||||
controller.approve_rollback(approval("owner-rollback-v2r1c4"))
|
||||
controller.start_rollback()
|
||||
assert controller.mark_rolled_back().state == ReleaseState.ROLLED_BACK
|
||||
|
||||
|
||||
def test_annotated_tag_uses_object_and_peeled_oids_separately() -> None:
|
||||
tag = TagReference("refs/tags/V2R1C4", "tag", TAG_OID, OID)
|
||||
TagVerifier().verify(tag, expected_tag_oid=TAG_OID, expected_target_oid=OID)
|
||||
with pytest.raises(ReleaseBlocked, match="TAG_PEELED_TARGET_MISMATCH"):
|
||||
TagVerifier().verify(tag, expected_tag_oid=TAG_OID, expected_target_oid="3" * 40)
|
||||
|
||||
|
||||
def test_release_gate_requires_four_source_tag_and_artifact_closure() -> None:
|
||||
evidence = ReleaseEvidence(
|
||||
expected_version="V2R1C4",
|
||||
registry_version="V2R1C4",
|
||||
baseline_version="V2R1C4",
|
||||
local_tag_oid=TAG_OID,
|
||||
remote_tag_oid=TAG_OID,
|
||||
gitea_tag_oid=TAG_OID,
|
||||
expected_tag_oid=TAG_OID,
|
||||
local_peeled_target_oid=OID,
|
||||
remote_peeled_target_oid=OID,
|
||||
gitea_peeled_target_oid=OID,
|
||||
expected_target_oid=OID,
|
||||
artifact_sha256=DIGEST,
|
||||
manifest_sha256="e" * 64,
|
||||
evidence_sha256="4" * 64,
|
||||
rollback_artifact_sha256="1" * 64,
|
||||
)
|
||||
ReleaseGate().verify(evidence)
|
||||
with pytest.raises(ReleaseBlocked, match="TAG_GITEA_MISMATCH"):
|
||||
ReleaseGate().verify(replace(evidence, gitea_tag_oid="5" * 40))
|
||||
@@ -1,116 +0,0 @@
|
||||
from datetime import datetime, timedelta, timezone
|
||||
from pathlib import Path
|
||||
|
||||
import pytest
|
||||
|
||||
from aios_autonomous_release_candidate.errors import CredentialUnavailable
|
||||
from aios_autonomous_release_candidate.evidence import EvidenceChain
|
||||
from aios_autonomous_release_candidate.execution_manager import ExecutionManager
|
||||
from aios_autonomous_release_candidate.models import CredentialRequest, ResourceBinding
|
||||
from aios_autonomous_release_candidate.native_adapters import OpenClawNativeAdapter
|
||||
from aios_autonomous_release_candidate.secret_manager import SecretManagerV2
|
||||
from aios_autonomous_release_candidate.store import StateStore
|
||||
from test_native_adapter_contracts import Provider
|
||||
|
||||
|
||||
NOW = datetime(2026, 7, 26, tzinfo=timezone.utc)
|
||||
|
||||
|
||||
class Transport:
|
||||
def __init__(self) -> None:
|
||||
self.calls = []
|
||||
|
||||
def exchange(self, operation, payload):
|
||||
self.calls.append((operation, payload))
|
||||
base = {
|
||||
"task_id": payload["task_id"],
|
||||
"credential_id": payload.get("credential_id", "credential-openclaw-1"),
|
||||
"plaintext_secret_returned": False,
|
||||
}
|
||||
if operation == "issue":
|
||||
return {
|
||||
**base,
|
||||
"credential_reference": "systemd-credential:openclaw-gateway-candidate",
|
||||
"state": "ISSUED",
|
||||
"expires_at": payload["expires_at"],
|
||||
}
|
||||
if operation == "audit":
|
||||
return {**base, "events": [{"operation": "issue", "secrets_included": False}]}
|
||||
if operation in {"project", "status"}:
|
||||
return {**base, "state": "PROJECTED"}
|
||||
if operation == "verify_revocation":
|
||||
return {**base, "state": "REVOKED", "post_revocation_auth": "REJECTED"}
|
||||
return {**base, "state": "REVOKED"}
|
||||
|
||||
|
||||
def credential_request() -> CredentialRequest:
|
||||
return CredentialRequest(
|
||||
request_id="request-1",
|
||||
task_id="task-execution",
|
||||
session_id="session-1",
|
||||
worker_id="worker-1",
|
||||
audience="openclaw-candidate",
|
||||
consumer_service="aios-autonomous-release-worker-candidate.service",
|
||||
binding=ResourceBinding("aios/aios", "patch/execution", "a" * 40, ("services/test",)),
|
||||
operations=("native_session.spawn",),
|
||||
provider="openclaw",
|
||||
runtime_user="aiman",
|
||||
approval_plan_id="owner-stage-b-native-sessions-20260726",
|
||||
not_before=NOW,
|
||||
expires_at=NOW + timedelta(minutes=5),
|
||||
nonce="nonce-execution-1",
|
||||
ttl_seconds=300,
|
||||
max_uses=1,
|
||||
)
|
||||
|
||||
|
||||
def test_secret_manager_uses_reference_only_protocol() -> None:
|
||||
transport = Transport()
|
||||
manager = SecretManagerV2(transport)
|
||||
receipt = manager.issue(credential_request(), NOW)
|
||||
assert receipt.reference == "systemd-credential:openclaw-gateway-candidate"
|
||||
assert receipt.plaintext_secret_returned is False
|
||||
manager.project(receipt)
|
||||
manager.status(receipt)
|
||||
manager.revoke(receipt)
|
||||
manager.verify_revocation(receipt)
|
||||
events = manager.audit(receipt)
|
||||
assert events[0]["secrets_included"] is False
|
||||
assert [operation for operation, _ in transport.calls] == [
|
||||
"issue",
|
||||
"project",
|
||||
"status",
|
||||
"revoke",
|
||||
"verify_revocation",
|
||||
"audit",
|
||||
]
|
||||
|
||||
|
||||
def test_secret_manager_rejects_plaintext_fields() -> None:
|
||||
transport = Transport()
|
||||
|
||||
def unsafe(operation, payload):
|
||||
return {"task_id": payload["task_id"], "credential_id": "credential-1", "api_key": "redacted"}
|
||||
|
||||
transport.exchange = unsafe
|
||||
with pytest.raises(CredentialUnavailable, match="SECRET_MANAGER_PLAINTEXT_REJECTED"):
|
||||
SecretManagerV2(transport).issue(credential_request(), NOW)
|
||||
|
||||
|
||||
def test_execution_manager_records_simulation_without_native_claim(tmp_path: Path) -> None:
|
||||
evidence = EvidenceChain(StateStore(tmp_path / "state.sqlite3"), "task-execution")
|
||||
adapter = OpenClawNativeAdapter(
|
||||
Provider("openclaw"), "systemd-credential:openclaw-gateway-candidate"
|
||||
)
|
||||
result = ExecutionManager(evidence).run_native_canary(
|
||||
adapter,
|
||||
task_id="task-execution",
|
||||
parent_session_id="parent-1",
|
||||
recipient_binding={"recipient_id": "weixin-owner"},
|
||||
text="candidate canary",
|
||||
)
|
||||
assert result.broker_session_verified is True
|
||||
assert result.openclaw_native_child_session_verified is False
|
||||
assert result.simulation is True
|
||||
assert result.session_closed is True
|
||||
assert evidence.verify()
|
||||
@@ -1,89 +0,0 @@
|
||||
from concurrent.futures import ThreadPoolExecutor
|
||||
from pathlib import Path
|
||||
import stat
|
||||
|
||||
import pytest
|
||||
|
||||
from aios_autonomous_release_candidate.errors import StateConflict
|
||||
from aios_autonomous_release_candidate.models import (
|
||||
ResourceBinding,
|
||||
RiskClass,
|
||||
StepState,
|
||||
TaskPlan,
|
||||
WorkflowStep,
|
||||
)
|
||||
from aios_autonomous_release_candidate.store import StateStore
|
||||
from aios_autonomous_release_candidate.workflow import WorkflowEngine
|
||||
|
||||
|
||||
OID = "a" * 40
|
||||
|
||||
|
||||
def plan() -> TaskPlan:
|
||||
return TaskPlan(
|
||||
task_id="workflow-test",
|
||||
intent="exercise durable workflow",
|
||||
binding=ResourceBinding("aios/aios", "patch/workflow-test", OID, ("services/test",)),
|
||||
risk=RiskClass.LOW,
|
||||
steps=(
|
||||
WorkflowStep("build", "builder", ("file.write",), max_attempts=2, timeout_seconds=30),
|
||||
WorkflowStep("test", "tester", ("test.execute",), depends_on=("build",), max_attempts=2),
|
||||
),
|
||||
evidence_requirements=("tests",),
|
||||
)
|
||||
|
||||
|
||||
def test_store_is_private_and_rejects_schema_drift(tmp_path: Path) -> None:
|
||||
state = tmp_path / "private" / "state.sqlite3"
|
||||
StateStore(state)
|
||||
assert stat.S_IMODE(state.stat().st_mode) == 0o600
|
||||
assert stat.S_IMODE(state.parent.stat().st_mode) & 0o027 == 0
|
||||
|
||||
with StateStore(state).transaction() as connection:
|
||||
connection.execute("UPDATE metadata SET value='999' WHERE key='schema_version'")
|
||||
with pytest.raises(StateConflict, match="SCHEMA_VERSION_UNSUPPORTED"):
|
||||
StateStore(state)
|
||||
|
||||
|
||||
def test_dependency_retry_and_terminal_failure_are_durable(tmp_path: Path) -> None:
|
||||
store = StateStore(tmp_path / "state.sqlite3")
|
||||
engine = WorkflowEngine(store)
|
||||
task = plan()
|
||||
engine.plan(task)
|
||||
|
||||
assert engine.next_steps(task).ready_steps == ("build",)
|
||||
assert store.list_steps(task.task_id)["build"].state == StepState.READY
|
||||
engine.claim(task.task_id, "build", "writer", "session-1")
|
||||
engine.start(task.task_id, "build", "writer", "session-1")
|
||||
engine.complete(task.task_id, "build", result_digest="b" * 64)
|
||||
|
||||
assert engine.next_steps(task).ready_steps == ("test",)
|
||||
engine.claim(task.task_id, "test", "tester", "session-2")
|
||||
engine.start(task.task_id, "test", "tester", "session-2")
|
||||
assert engine.fail(task, "test", "transient", retryable=True) == StepState.PENDING
|
||||
assert engine.next_steps(task).ready_steps == ("test",)
|
||||
engine.claim(task.task_id, "test", "tester", "session-3")
|
||||
engine.start(task.task_id, "test", "tester", "session-3")
|
||||
assert engine.fail(task, "test", "still broken", retryable=True) == StepState.FAILED
|
||||
decision = engine.next_steps(task)
|
||||
assert decision.blocked is True
|
||||
assert decision.reason == "terminal_step_failure"
|
||||
|
||||
|
||||
def test_claim_is_atomic_under_contention(tmp_path: Path) -> None:
|
||||
store = StateStore(tmp_path / "state.sqlite3")
|
||||
engine = WorkflowEngine(store)
|
||||
task = plan()
|
||||
engine.plan(task)
|
||||
engine.next_steps(task)
|
||||
|
||||
def claim(worker: str) -> str:
|
||||
try:
|
||||
engine.claim(task.task_id, "build", worker, f"session-{worker}")
|
||||
return "claimed"
|
||||
except StateConflict:
|
||||
return "rejected"
|
||||
|
||||
with ThreadPoolExecutor(max_workers=2) as pool:
|
||||
results = list(pool.map(claim, ("one", "two")))
|
||||
assert sorted(results) == ["claimed", "rejected"]
|
||||
Some files were not shown because too many files have changed in this diff Show More
Reference in New Issue
Block a user