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,307 +0,0 @@
|
||||
"""Strict service-level exact-path policy for isolated Git writers."""
|
||||
from __future__ import annotations
|
||||
|
||||
import configparser
|
||||
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*[:=])"
|
||||
)
|
||||
|
||||
|
||||
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)
|
||||
encoded = content.encode("utf-8")
|
||||
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 "\x00" in content or _SECRET_RE.search(content):
|
||||
raise PathPolicyError("isolated_writer_systemd_profile_rejected")
|
||||
lowered = content.lower()
|
||||
forbidden = (
|
||||
"bash -c",
|
||||
"sh -c",
|
||||
"eval ",
|
||||
"/bin/bash",
|
||||
"/bin/sh",
|
||||
"/data/aios-gitops/worktrees/",
|
||||
)
|
||||
if any(value in lowered for value in forbidden):
|
||||
raise PathPolicyError("isolated_writer_systemd_profile_rejected")
|
||||
parser = configparser.ConfigParser(interpolation=None, strict=False)
|
||||
parser.optionxform = str
|
||||
try:
|
||||
parser.read_string(content)
|
||||
except configparser.Error:
|
||||
raise PathPolicyError("isolated_writer_systemd_profile_rejected") from None
|
||||
if "Service" not in parser:
|
||||
raise PathPolicyError("isolated_writer_systemd_profile_rejected")
|
||||
service = parser["Service"]
|
||||
if service.get("ExecStart") != "/usr/bin/python3 -m task_plane.workers.codex_review_test":
|
||||
raise PathPolicyError("isolated_writer_systemd_profile_rejected")
|
||||
required = {
|
||||
"NoNewPrivileges": "true",
|
||||
"ProtectSystem": "strict",
|
||||
"PrivateTmp": "true",
|
||||
"AIOS_TASK_PLANE_EXECUTION_ENABLED": "false",
|
||||
}
|
||||
environments: dict[str, str] = {}
|
||||
for line in content.splitlines():
|
||||
if line.startswith("Environment="):
|
||||
value = line.removeprefix("Environment=").strip().strip('"')
|
||||
if "=" in value:
|
||||
key, inner = value.split("=", 1)
|
||||
environments[key] = inner
|
||||
if environments.get("AIOS_TASK_PLANE_EXECUTION_ENABLED") != "false":
|
||||
raise PathPolicyError("isolated_writer_systemd_profile_rejected")
|
||||
for key in ("NoNewPrivileges", "ProtectSystem", "PrivateTmp"):
|
||||
if service.get(key, "").lower() != required[key]:
|
||||
raise PathPolicyError("isolated_writer_systemd_profile_rejected")
|
||||
if service.get("User", "").strip().lower() == "root":
|
||||
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,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,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,48 +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` requires the fixed Python module
|
||||
`task_plane.workers.codex_review_test`, Shadow execution, `NoNewPrivileges`,
|
||||
`ProtectSystem=strict` and `PrivateTmp`. It rejects shell execution, root
|
||||
user declarations, worktree paths, authorization material and plaintext
|
||||
credential markers.
|
||||
|
||||
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,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,172 +0,0 @@
|
||||
import contextlib
|
||||
import importlib.util
|
||||
import io
|
||||
import json
|
||||
import sys
|
||||
import tempfile
|
||||
import threading
|
||||
import unittest
|
||||
import urllib.error
|
||||
import urllib.request
|
||||
from http.server import ThreadingHTTPServer
|
||||
from pathlib import Path
|
||||
|
||||
ROOT = Path(__file__).resolve().parents[0]
|
||||
|
||||
|
||||
def _load_client(root: Path):
|
||||
path = root / "scripts" / "task-plane" / "create_shadow_tasks.py"
|
||||
spec = importlib.util.spec_from_file_location("shadow_client", path)
|
||||
module = importlib.util.module_from_spec(spec)
|
||||
assert spec and spec.loader
|
||||
spec.loader.exec_module(module)
|
||||
return module
|
||||
|
||||
|
||||
class ShadowClientRBACPublicInterfaceTests(unittest.TestCase):
|
||||
@classmethod
|
||||
def setUpClass(cls):
|
||||
cls.repo_root = Path.cwd()
|
||||
sys.path.insert(0, str(cls.repo_root / "active-runtime"))
|
||||
from app.task_plane.api import TaskPlaneRequestHandler, TaskPlaneService
|
||||
from app.task_plane.policy import IdentityVerifier, PolicyEngine
|
||||
from app.task_plane.store import TaskPlaneStore
|
||||
|
||||
cls.RequestHandler = TaskPlaneRequestHandler
|
||||
cls.TaskPlaneService = TaskPlaneService
|
||||
cls.IdentityVerifier = IdentityVerifier
|
||||
cls.PolicyEngine = PolicyEngine
|
||||
cls.TaskPlaneStore = TaskPlaneStore
|
||||
cls.client = _load_client(cls.repo_root)
|
||||
|
||||
def _server(self, capabilities):
|
||||
store = self.TaskPlaneStore(":memory:")
|
||||
policy = self.PolicyEngine(
|
||||
identity_verifier=self.IdentityVerifier({"shadow-client"}),
|
||||
execution_enabled=False,
|
||||
identity_capabilities={"shadow-client": set(capabilities)},
|
||||
)
|
||||
service = self.TaskPlaneService(store, policy=policy)
|
||||
|
||||
class Handler(self.RequestHandler):
|
||||
pass
|
||||
|
||||
Handler.service = service
|
||||
Handler.authenticator = lambda value: "shadow-client" if value == "test-token" else None
|
||||
server = ThreadingHTTPServer(("127.0.0.1", 0), Handler)
|
||||
thread = threading.Thread(target=server.serve_forever, daemon=True)
|
||||
thread.start()
|
||||
self.addCleanup(server.shutdown)
|
||||
self.addCleanup(server.server_close)
|
||||
self.addCleanup(thread.join, 2)
|
||||
return f"http://127.0.0.1:{server.server_port}", store
|
||||
|
||||
@staticmethod
|
||||
def _request(base, path, token=None, body=None):
|
||||
headers = {"Content-Type": "application/json"}
|
||||
if token is not None:
|
||||
headers["Authorization"] = f"Bearer {token}"
|
||||
req = urllib.request.Request(
|
||||
base + path,
|
||||
data=None if body is None else json.dumps(body).encode(),
|
||||
headers=headers,
|
||||
method="POST" if body is not None else "GET",
|
||||
)
|
||||
return urllib.request.urlopen(req, timeout=3)
|
||||
|
||||
def test_missing_credential_returns_401(self):
|
||||
base, _ = self._server({"task.creator", "task.read", "task.audit"})
|
||||
with self.assertRaises(urllib.error.HTTPError) as raised:
|
||||
self._request(base, "/tasks")
|
||||
self.assertEqual(raised.exception.code, 401)
|
||||
|
||||
def test_missing_task_creator_returns_403(self):
|
||||
base, _ = self._server({"task.read", "task.audit"})
|
||||
with self.assertRaises(self.client.ShadowClientError) as raised:
|
||||
self.client.run_shadow_client(
|
||||
base_url=base,
|
||||
token="test-token",
|
||||
task_id="SHADOW-RBAC-NO-CREATE",
|
||||
idempotency_key="shadow-rbac-no-create-v1",
|
||||
)
|
||||
self.assertEqual(raised.exception.status, 403)
|
||||
|
||||
def test_minimum_client_is_idempotent_and_cannot_claim(self):
|
||||
base, store = self._server({"task.creator", "task.read", "task.audit"})
|
||||
first = self.client.run_shadow_client(
|
||||
base_url=base,
|
||||
token="test-token",
|
||||
task_id="SHADOW-RBAC-IDEMPOTENT",
|
||||
idempotency_key="shadow-rbac-idempotent-v1",
|
||||
)
|
||||
second = self.client.run_shadow_client(
|
||||
base_url=base,
|
||||
token="test-token",
|
||||
task_id="SHADOW-RBAC-IDEMPOTENT",
|
||||
idempotency_key="shadow-rbac-idempotent-v1",
|
||||
)
|
||||
self.assertEqual(first["task_id"], second["task_id"])
|
||||
self.assertEqual(first["status"], "CREATED")
|
||||
self.assertEqual(first["event_count"], 1)
|
||||
self.assertEqual(first["evidence_count"], 0)
|
||||
self.assertEqual(store.list_workers(), [])
|
||||
claim_base, _ = self._server({"task.claim"})
|
||||
with self.assertRaises(urllib.error.HTTPError) as raised:
|
||||
self._request(
|
||||
claim_base,
|
||||
"/tasks/SHADOW-RBAC-IDEMPOTENT/claim",
|
||||
"test-token",
|
||||
{"worker_id": "shadow-worker", "lease_seconds": 30},
|
||||
)
|
||||
self.assertEqual(raised.exception.code, 423)
|
||||
|
||||
def test_forged_request_body_identity_is_rejected(self):
|
||||
base, _ = self._server({"task.creator", "task.read", "task.audit"})
|
||||
with self.assertRaises(urllib.error.HTTPError) as raised:
|
||||
self._request(
|
||||
base,
|
||||
"/tasks",
|
||||
"test-token",
|
||||
{
|
||||
"task_id": "SHADOW-RBAC-FORGED",
|
||||
"actor_identity": "administrator",
|
||||
},
|
||||
)
|
||||
self.assertEqual(raised.exception.code, 400)
|
||||
|
||||
def test_default_deny_get_rbac_and_redacted_report(self):
|
||||
base, _ = self._server({"task.creator", "task.read", "task.audit"})
|
||||
with tempfile.TemporaryDirectory() as directory:
|
||||
root = Path(directory)
|
||||
token_file = root / "token"
|
||||
report = root / "report.json"
|
||||
token_file.write_text("test-token", encoding="utf-8")
|
||||
stdout = io.StringIO()
|
||||
with contextlib.redirect_stdout(stdout):
|
||||
self.client.main(
|
||||
[
|
||||
"--base-url", base,
|
||||
"--token-file", str(token_file),
|
||||
"--task-id", "SHADOW-RBAC-REPORT",
|
||||
"--idempotency-key", "shadow-rbac-report-v1",
|
||||
"--report", str(report),
|
||||
]
|
||||
)
|
||||
output = stdout.getvalue()
|
||||
self.assertNotIn("test-token", output)
|
||||
self.assertNotIn("Authorization", output)
|
||||
self.assertNotIn("test-token", report.read_text(encoding="utf-8"))
|
||||
self.assertNotIn("Authorization", report.read_text(encoding="utf-8"))
|
||||
self.assertIn("report_sha256=", output)
|
||||
|
||||
denied_base, _ = self._server({"task.creator"})
|
||||
with self.assertRaises(urllib.error.HTTPError) as raised:
|
||||
self._request(denied_base, "/tasks", "test-token")
|
||||
self.assertEqual(raised.exception.code, 403)
|
||||
|
||||
def test_plaintext_token_argument_is_rejected_without_echo(self):
|
||||
stderr = io.StringIO()
|
||||
with contextlib.redirect_stderr(stderr):
|
||||
with self.assertRaises(SystemExit):
|
||||
self.client.main(["--token", "sentinel-token"])
|
||||
self.assertNotIn("sentinel-token", stderr.getvalue())
|
||||
@@ -1,215 +0,0 @@
|
||||
import os
|
||||
import sys
|
||||
import unittest
|
||||
|
||||
ROOT = os.getcwd()
|
||||
if os.path.join(ROOT, "active-runtime") not in sys.path:
|
||||
sys.path.append(os.path.join(ROOT, "active-runtime"))
|
||||
|
||||
from app.task_plane.api import TaskPlaneService
|
||||
from app.task_plane.policy import (
|
||||
ALL_ACTION_CAPABILITIES,
|
||||
IdentityVerifier,
|
||||
PolicyEngine,
|
||||
ReadonlyWorkerProfile,
|
||||
)
|
||||
|
||||
|
||||
def _policy(**kwargs):
|
||||
return PolicyEngine(
|
||||
identity_capabilities={"*": set(ALL_ACTION_CAPABILITIES)}, **kwargs
|
||||
)
|
||||
from app.task_plane.store import TaskPlaneStore
|
||||
|
||||
|
||||
class TaskPlaneAPIBehaviorTests(unittest.TestCase):
|
||||
def setUp(self):
|
||||
self.store = TaskPlaneStore(":memory:")
|
||||
self.service = TaskPlaneService(self.store, policy=_policy(execution_enabled=False))
|
||||
|
||||
def test_task_crud_and_events_chain(self):
|
||||
task = self.service.create_task(
|
||||
{
|
||||
"task_type": "code.change",
|
||||
"intent": "verify core",
|
||||
"required_capabilities": ["code.read", "test.python"],
|
||||
}
|
||||
)
|
||||
self.assertIn("task_id", task)
|
||||
read = self.service.get_task(task["task_id"])
|
||||
self.assertEqual("CREATED", read["status"])
|
||||
events = self.service.get_events(task["task_id"])
|
||||
self.assertEqual(len(events), 1)
|
||||
|
||||
def test_execution_disabled_blocks_claim(self):
|
||||
task = self.service.create_task({"task_type": "code.change"})
|
||||
self.store.register_worker(
|
||||
{
|
||||
"worker_id": "codex-dev-01",
|
||||
"worker_type": "codex",
|
||||
"identity": "spiffe://aios/agent/codex/dev-01",
|
||||
"capabilities": ["code.read", "test.python"],
|
||||
"trust_zone": "isolated-development",
|
||||
"max_concurrency": 1,
|
||||
"heartbeat_interval_seconds": 15,
|
||||
"supported_protocols": ["aios-task-v1"],
|
||||
}
|
||||
)
|
||||
with self.assertRaises(Exception):
|
||||
self.service.claim(task["task_id"], {"worker_id": "codex-dev-01", "lease_seconds": 20})
|
||||
|
||||
def test_workers_and_events_outbox(self):
|
||||
policy = _policy(execution_enabled=True)
|
||||
service = TaskPlaneService(TaskPlaneStore(":memory:"), policy=policy)
|
||||
service.register_worker(
|
||||
{
|
||||
"worker_id": "codex-dev-01",
|
||||
"worker_type": "codex",
|
||||
"identity": "spiffe://aios/agent/codex/dev-01",
|
||||
"capabilities": ["code.read", "test.python", "code.write.patch"],
|
||||
"trust_zone": "isolated-development",
|
||||
"max_concurrency": 2,
|
||||
"heartbeat_interval_seconds": 15,
|
||||
"supported_protocols": ["aios-task-v1"],
|
||||
}
|
||||
)
|
||||
task = service.create_task({"required_capabilities": ["code.read"], "task_type": "code.change"})
|
||||
task_record = service.store.get_task(task["task_id"])
|
||||
identity = "spiffe://aios/agent/codex/dev-01"
|
||||
claim = service.claim(task["task_id"], {"worker_id": "codex-dev-01", "lease_seconds": 15, "actor_identity": identity})
|
||||
service.heartbeat(task["task_id"], {"claim_id": claim["claim_id"], "lease_seconds": 20, "actor_identity": identity})
|
||||
service.progress(task["task_id"], {"claim_id": claim["claim_id"], "progress": 40, "stage": "tests", "message": "running", "actor_identity": identity})
|
||||
service.complete(task["task_id"], {"claim_id": claim["claim_id"], "status": "COMPLETED", "outputs": [], "evidence": [], "actor_identity": identity})
|
||||
events = service.get_events(task["task_id"])
|
||||
self.assertGreater(len(events), 1)
|
||||
self.assertTrue(service.store.verify_event_chain(task["task_id"]))
|
||||
self.assertEqual(service.get_children(task["task_id"]), [])
|
||||
|
||||
|
||||
class ReadonlyCodexWorkerPolicyTests(unittest.TestCase):
|
||||
identity = "spiffe://aios/agent/codex/review-test-01"
|
||||
worker_id = "codex-review-test-01"
|
||||
capabilities = frozenset(
|
||||
{
|
||||
"code.read",
|
||||
"git.diff.read",
|
||||
"code.review",
|
||||
"review.security",
|
||||
"review.api-contract",
|
||||
"test.python",
|
||||
"test.shell.allowlisted",
|
||||
"task.progress",
|
||||
"task.result",
|
||||
"task.evidence.submit",
|
||||
}
|
||||
)
|
||||
|
||||
def setUp(self):
|
||||
profile = ReadonlyWorkerProfile(self.worker_id, self.identity, self.capabilities)
|
||||
policy = PolicyEngine(
|
||||
identity_verifier=IdentityVerifier({"anon", self.identity}),
|
||||
execution_enabled=False,
|
||||
readonly_worker_execution_enabled=True,
|
||||
readonly_worker_profiles=[profile],
|
||||
identity_capabilities={
|
||||
"anon": {"task.creator"},
|
||||
self.identity: {"worker.self_register", "task.claim"},
|
||||
},
|
||||
)
|
||||
self.service = TaskPlaneService(TaskPlaneStore(":memory:"), policy=policy)
|
||||
self.registration = {
|
||||
"worker_id": self.worker_id,
|
||||
"worker_type": "codex",
|
||||
"identity": self.identity,
|
||||
"capabilities": sorted(self.capabilities),
|
||||
"trust_zone": "isolated-review",
|
||||
"max_concurrency": 1,
|
||||
"heartbeat_interval_seconds": 15,
|
||||
"supported_protocols": ["aios-task-v1", "a2a"],
|
||||
"actor_identity": self.identity,
|
||||
}
|
||||
self.service.register_worker(self.registration)
|
||||
|
||||
def _task(self, *, task_type="code.review", capabilities=None, risk="low"):
|
||||
return self.service.create_task(
|
||||
{
|
||||
"task_type": task_type,
|
||||
"required_capabilities": capabilities or ["code.read", "code.review"],
|
||||
"risk": risk,
|
||||
"metadata": {"production_side_effects": False},
|
||||
}
|
||||
)
|
||||
|
||||
def test_readonly_profile_can_claim_only_safe_task(self):
|
||||
task = self._task()
|
||||
claim = self.service.claim(
|
||||
task["task_id"],
|
||||
{"worker_id": self.worker_id, "lease_seconds": 120, "actor_identity": self.identity},
|
||||
)
|
||||
self.assertTrue(claim["claim_id"])
|
||||
|
||||
def test_readonly_profile_rejects_wrong_worker_or_write_task(self):
|
||||
task = self._task()
|
||||
with self.assertRaises(Exception):
|
||||
self.service.claim(
|
||||
task["task_id"],
|
||||
{"worker_id": "other-worker", "lease_seconds": 120, "actor_identity": self.identity},
|
||||
)
|
||||
write_task = self._task(task_type="code.change", capabilities=["code.write"])
|
||||
with self.assertRaises(Exception):
|
||||
self.service.claim(
|
||||
write_task["task_id"],
|
||||
{"worker_id": self.worker_id, "lease_seconds": 120, "actor_identity": self.identity},
|
||||
)
|
||||
|
||||
def test_readonly_registration_cannot_escalate_capabilities(self):
|
||||
payload = dict(self.registration)
|
||||
payload["capabilities"] = [*payload["capabilities"], "git.commit"]
|
||||
with self.assertRaises(Exception):
|
||||
self.service.register_worker(payload)
|
||||
|
||||
|
||||
class DelegationGuardTests(unittest.TestCase):
|
||||
def setUp(self):
|
||||
self.store = TaskPlaneStore(":memory:")
|
||||
self.policy = _policy(execution_enabled=True)
|
||||
self.service = TaskPlaneService(self.store, policy=self.policy)
|
||||
self.parent = self.service.create_task(
|
||||
{
|
||||
"task_type": "code.change",
|
||||
"required_capabilities": ["code.read"],
|
||||
"budgets": {"attempts": 3, "tokens": 100, "time_seconds": 1000},
|
||||
"max_delegation_depth": 2,
|
||||
}
|
||||
)
|
||||
|
||||
def test_delegation_budget_and_depth(self):
|
||||
child = self.service.delegate(
|
||||
self.parent["task_id"],
|
||||
{
|
||||
"task_type": "code.change",
|
||||
"required_capabilities": ["code.read"],
|
||||
"budgets": {"attempts": 1},
|
||||
"actor_identity": "owner",
|
||||
},
|
||||
)
|
||||
self.assertEqual(child["plan"]["parent_task_id"], self.parent["task_id"])
|
||||
grandchild = self.service.delegate(
|
||||
child["task_id"],
|
||||
{
|
||||
"task_type": "code.change",
|
||||
"required_capabilities": ["code.read"],
|
||||
"budgets": {"attempts": 1},
|
||||
"actor_identity": "owner",
|
||||
},
|
||||
)
|
||||
with self.assertRaises(Exception):
|
||||
self.service.delegate(
|
||||
grandchild["task_id"],
|
||||
{
|
||||
"task_type": "code.change",
|
||||
"required_capabilities": ["code.read"],
|
||||
"budgets": {"attempts": 1},
|
||||
"actor_identity": "owner",
|
||||
},
|
||||
)
|
||||
@@ -1,381 +0,0 @@
|
||||
import json
|
||||
import http.client
|
||||
import os
|
||||
import tempfile
|
||||
import threading
|
||||
import time
|
||||
import unittest
|
||||
from http.server import ThreadingHTTPServer
|
||||
from unittest import mock
|
||||
|
||||
from app.task_plane.adapters.codex import CodexAdapter
|
||||
from app.task_plane.adapters.hermes import HermesAdapter
|
||||
from app.task_plane.adapters.openclaw import OpenClawAdapter
|
||||
from app.task_plane.api import TaskPlaneRequestHandler, TaskPlaneService
|
||||
from app.task_plane.errors import ConflictError, LockedError, ValidationError
|
||||
from app.task_plane.events import DurableOutboxDispatcher, WeChatGatewayAdapter
|
||||
from app.task_plane.models import ProbeEvidence, ProbeOutcome, TaskPlan
|
||||
from app.task_plane.policy import ALL_ACTION_CAPABILITIES, PolicyEngine
|
||||
from app.task_plane.store import TaskPlaneStore
|
||||
|
||||
|
||||
IDENTITY = "spiffe://aios/agent/codex/dev-01"
|
||||
|
||||
|
||||
def _policy(**kwargs):
|
||||
return PolicyEngine(
|
||||
identity_capabilities={"*": set(ALL_ACTION_CAPABILITIES)}, **kwargs
|
||||
)
|
||||
|
||||
|
||||
def register_worker(service):
|
||||
return service.register_worker(
|
||||
{
|
||||
"worker_id": "codex-dev-01",
|
||||
"worker_type": "codex",
|
||||
"identity": IDENTITY,
|
||||
"capabilities": ["code.read", "code.write.patch", "test.python"],
|
||||
"trust_zone": "isolated-development",
|
||||
"max_concurrency": 2,
|
||||
"heartbeat_interval_seconds": 15,
|
||||
"supported_protocols": ["aios-task-v1"],
|
||||
}
|
||||
)
|
||||
|
||||
|
||||
class DurableStoreTests(unittest.TestCase):
|
||||
def test_idempotency_replay_and_payload_conflict(self):
|
||||
service = TaskPlaneService(TaskPlaneStore(":memory:"))
|
||||
first = service.create_task(
|
||||
{"task_id": "task-idempotent", "intent": "same"}, "idem-1"
|
||||
)
|
||||
replay = service.create_task(
|
||||
{"task_id": "task-idempotent", "intent": "same"}, "idem-1"
|
||||
)
|
||||
self.assertEqual(first["task_id"], replay["task_id"])
|
||||
with self.assertRaises(ConflictError):
|
||||
service.create_task(
|
||||
{"task_id": "task-other", "intent": "different"}, "idem-1"
|
||||
)
|
||||
|
||||
def test_cas_rejects_stale_revision(self):
|
||||
store = TaskPlaneStore(":memory:")
|
||||
task = store.create_task(TaskPlan.from_dict({"task_id": "task-cas"}))
|
||||
store.update_task_status(task.task_id, task.revision, "QUEUED")
|
||||
with self.assertRaises(ConflictError):
|
||||
store.update_task_status(task.task_id, task.revision, "CANCELLED")
|
||||
|
||||
def test_crash_recovery_preserves_task_events_and_outbox(self):
|
||||
with tempfile.TemporaryDirectory() as directory:
|
||||
path = os.path.join(directory, "task-plane.sqlite3")
|
||||
first = TaskPlaneService(TaskPlaneStore(path))
|
||||
task = first.create_task({"task_id": "task-restart"})
|
||||
first.store.close()
|
||||
second = TaskPlaneService(TaskPlaneStore(path))
|
||||
self.assertEqual("CREATED", second.get_task(task["task_id"])["status"])
|
||||
self.assertTrue(second.store.verify_event_chain(task["task_id"]))
|
||||
self.assertEqual(1, len(second.store.list_outbox()))
|
||||
second.store.close()
|
||||
|
||||
def test_event_and_evidence_tamper_are_detected(self):
|
||||
store = TaskPlaneStore(":memory:")
|
||||
service = TaskPlaneService(store)
|
||||
task = service.create_task({"task_id": "task-tamper"})
|
||||
evidence_id = store.add_evidence(
|
||||
task["task_id"], "test-report", {"passed": True}, IDENTITY
|
||||
)
|
||||
store.conn.execute(
|
||||
"UPDATE events SET event_data=? WHERE task_id=?",
|
||||
(json.dumps({"changed": True}), task["task_id"]),
|
||||
)
|
||||
store.conn.execute(
|
||||
"UPDATE evidence SET payload=? WHERE evidence_id=?",
|
||||
(json.dumps({"passed": False}), evidence_id),
|
||||
)
|
||||
self.assertFalse(store.verify_event_chain(task["task_id"]))
|
||||
self.assertFalse(store.verify_evidence_integrity(task["task_id"]))
|
||||
|
||||
def test_secrets_are_redacted_at_rest_and_in_outbox(self):
|
||||
store = TaskPlaneStore(":memory:")
|
||||
service = TaskPlaneService(store)
|
||||
secret = "never-store-this-value"
|
||||
task = service.create_task(
|
||||
{
|
||||
"task_id": "task-redaction",
|
||||
"metadata": {"access_token": secret, "token_count": 12},
|
||||
}
|
||||
)
|
||||
raw_task = store.conn.execute(
|
||||
"SELECT task_json FROM tasks WHERE task_id=?", (task["task_id"],)
|
||||
).fetchone()[0]
|
||||
raw_outbox = store.conn.execute(
|
||||
"SELECT payload FROM outbox WHERE task_id=?", (task["task_id"],)
|
||||
).fetchone()[0]
|
||||
self.assertNotIn(secret, raw_task + raw_outbox)
|
||||
self.assertIn("[REDACTED]", raw_task)
|
||||
self.assertIn("token_count", raw_task)
|
||||
|
||||
|
||||
class ClaimLeaseTests(unittest.TestCase):
|
||||
def setUp(self):
|
||||
self.store = TaskPlaneStore(":memory:")
|
||||
self.service = TaskPlaneService(
|
||||
self.store, policy=_policy(execution_enabled=True)
|
||||
)
|
||||
register_worker(self.service)
|
||||
|
||||
def test_only_one_worker_can_claim_concurrently(self):
|
||||
task = self.service.create_task({"task_id": "task-race"})
|
||||
revision = self.store.get_task(task["task_id"]).revision
|
||||
outcomes = []
|
||||
barrier = threading.Barrier(2)
|
||||
|
||||
def attempt():
|
||||
barrier.wait()
|
||||
try:
|
||||
self.store.claim_task(
|
||||
task["task_id"],
|
||||
"codex-dev-01",
|
||||
IDENTITY,
|
||||
30,
|
||||
revision,
|
||||
self.store.get_task(task["task_id"]).task_plan.operation_digest(),
|
||||
)
|
||||
outcomes.append("claimed")
|
||||
except ConflictError:
|
||||
outcomes.append("conflict")
|
||||
|
||||
threads = [threading.Thread(target=attempt) for _ in range(2)]
|
||||
for thread in threads:
|
||||
thread.start()
|
||||
for thread in threads:
|
||||
thread.join()
|
||||
self.assertCountEqual(["claimed", "conflict"], outcomes)
|
||||
|
||||
def test_expired_lease_requires_probe_before_reassignment(self):
|
||||
task = self.service.create_task({"task_id": "task-expiry"})
|
||||
claim = self.service.claim(
|
||||
task["task_id"],
|
||||
{
|
||||
"worker_id": "codex-dev-01",
|
||||
"actor_identity": IDENTITY,
|
||||
"lease_seconds": 1,
|
||||
},
|
||||
)
|
||||
future = time.time() + 5
|
||||
with mock.patch("app.task_plane.store._now", return_value=future):
|
||||
self.store.probe_attestation_verifier = lambda probe: (
|
||||
probe.attestation_ref == "trusted://probe/recovery"
|
||||
)
|
||||
probe = ProbeEvidence.create(
|
||||
task_id=task["task_id"],
|
||||
claim_id=claim["claim_id"],
|
||||
worker_id="codex-dev-01",
|
||||
worker_identity=IDENTITY,
|
||||
operation_digest=claim["operation_digest"],
|
||||
outcome=ProbeOutcome.NOT_APPLIED,
|
||||
observed_at=future,
|
||||
expires_at=future + 60,
|
||||
probe_executor_identity="spiffe://aios/admin/recovery",
|
||||
attestation_ref="trusted://probe/recovery",
|
||||
)
|
||||
recovered = self.store.recover_claim_with_probe_and_event(
|
||||
task["task_id"],
|
||||
claim["claim_id"],
|
||||
probe,
|
||||
)
|
||||
self.assertEqual("FAILED_RECOVERABLE", recovered.status)
|
||||
retry = self.service.claim(
|
||||
task["task_id"],
|
||||
{
|
||||
"worker_id": "codex-dev-01",
|
||||
"actor_identity": IDENTITY,
|
||||
"lease_seconds": 30,
|
||||
},
|
||||
)
|
||||
self.assertEqual(2, retry["attempt"])
|
||||
|
||||
def test_wrong_claim_identity_and_duplicate_result_are_rejected(self):
|
||||
task = self.service.create_task({"task_id": "task-result"})
|
||||
claim = self.service.claim(
|
||||
task["task_id"],
|
||||
{"worker_id": "codex-dev-01", "actor_identity": IDENTITY},
|
||||
)
|
||||
with self.assertRaises(Exception):
|
||||
self.service.complete(
|
||||
task["task_id"],
|
||||
{
|
||||
"claim_id": claim["claim_id"],
|
||||
"actor_identity": "spiffe://aios/agent/codex/other",
|
||||
},
|
||||
)
|
||||
self.service.progress(
|
||||
task["task_id"],
|
||||
{
|
||||
"claim_id": claim["claim_id"],
|
||||
"actor_identity": IDENTITY,
|
||||
"progress": 10,
|
||||
"stage": "running",
|
||||
},
|
||||
)
|
||||
self.service.complete(
|
||||
task["task_id"],
|
||||
{"claim_id": claim["claim_id"], "actor_identity": IDENTITY},
|
||||
)
|
||||
with self.assertRaises(ConflictError):
|
||||
self.service.complete(
|
||||
task["task_id"],
|
||||
{"claim_id": claim["claim_id"], "actor_identity": IDENTITY},
|
||||
)
|
||||
|
||||
def test_tampered_result_digest_and_unverifiable_signature_fail_closed(self):
|
||||
for suffix, extra in (
|
||||
("digest", {"result_digest": "0" * 64}),
|
||||
("signature", {"signature": "tampered"}),
|
||||
):
|
||||
task = self.service.create_task({"task_id": f"task-{suffix}"})
|
||||
claim = self.service.claim(
|
||||
task["task_id"],
|
||||
{"worker_id": "codex-dev-01", "actor_identity": IDENTITY},
|
||||
)
|
||||
self.service.progress(
|
||||
task["task_id"],
|
||||
{
|
||||
"claim_id": claim["claim_id"],
|
||||
"actor_identity": IDENTITY,
|
||||
"progress": 10,
|
||||
"stage": "running",
|
||||
},
|
||||
)
|
||||
with self.assertRaises(Exception):
|
||||
self.service.complete(
|
||||
task["task_id"],
|
||||
{
|
||||
"claim_id": claim["claim_id"],
|
||||
"actor_identity": IDENTITY,
|
||||
**extra,
|
||||
},
|
||||
)
|
||||
self.assertEqual(
|
||||
"ACTIVE", self.store.get_claim(claim["claim_id"]).status
|
||||
)
|
||||
|
||||
|
||||
class DelegationAndNotificationTests(unittest.TestCase):
|
||||
def setUp(self):
|
||||
self.service = TaskPlaneService(
|
||||
TaskPlaneStore(":memory:"),
|
||||
policy=_policy(execution_enabled=True, max_risk="high"),
|
||||
)
|
||||
self.parent = self.service.create_task(
|
||||
{
|
||||
"task_id": "task-parent",
|
||||
"task_type": "code.review",
|
||||
"required_capabilities": ["code.read"],
|
||||
"risk": "medium",
|
||||
"approval_policy": "patch-only",
|
||||
"max_delegation_depth": 1,
|
||||
"budgets": {"attempts": 1, "tokens": 10},
|
||||
}
|
||||
)
|
||||
|
||||
def test_capability_risk_budget_and_cycle_escalation_are_rejected(self):
|
||||
base = {
|
||||
"actor_identity": "owner",
|
||||
"task_type": "code.review",
|
||||
"budgets": {"attempts": 1},
|
||||
}
|
||||
for payload in (
|
||||
{**base, "required_capabilities": ["git.force_push"]},
|
||||
{**base, "required_capabilities": ["code.read"], "risk": "high"},
|
||||
{**base, "required_capabilities": ["code.read"], "budgets": {"tokens": 11}},
|
||||
{
|
||||
**base,
|
||||
"task_id": "task-parent",
|
||||
"required_capabilities": ["code.read"],
|
||||
},
|
||||
):
|
||||
with self.assertRaises(Exception):
|
||||
self.service.delegate(self.parent["task_id"], payload)
|
||||
|
||||
def test_missing_gateway_receipt_remains_not_delivered(self):
|
||||
message = self.service.store.list_outbox()[0]
|
||||
dispatcher = DurableOutboxDispatcher(self.service.store)
|
||||
updated = dispatcher.dispatch(
|
||||
message["message_id"], WeChatGatewayAdapter(lambda envelope: None)
|
||||
)
|
||||
self.assertEqual("NOT_DELIVERED", updated["delivery_status"])
|
||||
delivered = self.service.store.record_outbox_delivery(
|
||||
message["message_id"], receipt="gateway-receipt-1"
|
||||
)
|
||||
replay = self.service.store.record_outbox_delivery(
|
||||
message["message_id"], receipt="gateway-receipt-1"
|
||||
)
|
||||
self.assertEqual("DELIVERED", delivered["delivery_status"])
|
||||
self.assertEqual(delivered["receipt"], replay["receipt"])
|
||||
|
||||
def test_worker_offline_detection_is_fail_closed(self):
|
||||
register_worker(self.service)
|
||||
worker = self.service.store.get_worker("codex-dev-01")
|
||||
after_deadline = (
|
||||
worker.last_heartbeat + worker.heartbeat_interval_seconds * 3 + 1
|
||||
)
|
||||
self.assertFalse(
|
||||
self.service.workers.is_online("codex-dev-01", now=after_deadline)
|
||||
)
|
||||
|
||||
def test_path_and_parameter_injection_are_rejected(self):
|
||||
for value in ("../task", "task/child", "%2e%2e", "task\ninjected", ""):
|
||||
with self.assertRaises(ValidationError):
|
||||
self.service.store.get_task(value)
|
||||
|
||||
def test_shadow_adapters_only_return_descriptions(self):
|
||||
task = TaskPlan.from_dict({"task_id": "task-shadow"})
|
||||
claim = type("Claim", (), {"claim_id": "claim-shadow", "status": "ACTIVE"})()
|
||||
for adapter in (OpenClawAdapter(), CodexAdapter(), HermesAdapter()):
|
||||
result = adapter.execute(task, claim)
|
||||
self.assertEqual("SHADOW_VERIFIED", result["status"])
|
||||
self.assertFalse(result["production_side_effects"])
|
||||
self.assertNotIn("command", result)
|
||||
|
||||
def test_http_rejects_encoded_path_and_non_object_json(self):
|
||||
TaskPlaneRequestHandler.service = self.service
|
||||
TaskPlaneRequestHandler.authenticator = None
|
||||
server = ThreadingHTTPServer(("127.0.0.1", 0), TaskPlaneRequestHandler)
|
||||
thread = threading.Thread(target=server.serve_forever, daemon=True)
|
||||
thread.start()
|
||||
try:
|
||||
connection = http.client.HTTPConnection(
|
||||
"127.0.0.1", server.server_address[1], timeout=3
|
||||
)
|
||||
connection.request("GET", "/tasks/%2e%2e")
|
||||
response = connection.getresponse()
|
||||
payload = response.read().decode()
|
||||
self.assertEqual(400, response.status)
|
||||
self.assertNotIn("Traceback", payload)
|
||||
connection.request(
|
||||
"POST",
|
||||
"/tasks",
|
||||
body="[]",
|
||||
headers={"Content-Type": "application/json"},
|
||||
)
|
||||
response = connection.getresponse()
|
||||
response.read()
|
||||
self.assertEqual(400, response.status)
|
||||
connection.request(
|
||||
"POST",
|
||||
"/tasks",
|
||||
body=json.dumps({"task_id": "task-http-unauthorized"}),
|
||||
headers={"Content-Type": "application/json"},
|
||||
)
|
||||
response = connection.getresponse()
|
||||
response.read()
|
||||
self.assertEqual(401, response.status)
|
||||
finally:
|
||||
server.shutdown()
|
||||
server.server_close()
|
||||
thread.join(timeout=3)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
@@ -1,892 +0,0 @@
|
||||
import dataclasses
|
||||
import http.client
|
||||
import json
|
||||
import multiprocessing
|
||||
import os
|
||||
import tempfile
|
||||
import threading
|
||||
import time
|
||||
import unittest
|
||||
from http.server import ThreadingHTTPServer
|
||||
|
||||
from app.task_plane.api import TaskPlaneRequestHandler, TaskPlaneService
|
||||
from app.task_plane.errors import (
|
||||
ConflictError,
|
||||
ForbiddenError,
|
||||
LockedError,
|
||||
ValidationError,
|
||||
)
|
||||
from app.task_plane.models import (
|
||||
EvidenceEnvelope,
|
||||
ProbeEvidence,
|
||||
ProbeOutcome,
|
||||
TaskPlan,
|
||||
)
|
||||
from app.task_plane.policy import ALL_ACTION_CAPABILITIES, PolicyEngine
|
||||
from app.task_plane.scheduler import TaskScheduler
|
||||
from app.task_plane.store import TaskPlaneStore
|
||||
|
||||
|
||||
WORKER_ID = "codex-secure-01"
|
||||
WORKER_IDENTITY = "spiffe://aios/agent/codex/secure-01"
|
||||
ADMIN_IDENTITY = "spiffe://aios/admin/task-plane"
|
||||
|
||||
|
||||
def _worker_payload(**overrides):
|
||||
payload = {
|
||||
"worker_id": WORKER_ID,
|
||||
"worker_type": "codex",
|
||||
"identity": WORKER_IDENTITY,
|
||||
"owner_identity": WORKER_IDENTITY,
|
||||
"capabilities": ["code.read", "test.python"],
|
||||
"trust_zone": "isolated-development",
|
||||
"max_concurrency": 1,
|
||||
"heartbeat_interval_seconds": 15,
|
||||
"supported_protocols": ["aios-task-v1"],
|
||||
"registration_policy": "self",
|
||||
"actor_identity": WORKER_IDENTITY,
|
||||
}
|
||||
payload.update(overrides)
|
||||
return payload
|
||||
|
||||
|
||||
def _service(store=None, **policy_kwargs):
|
||||
grants = {
|
||||
ADMIN_IDENTITY: {
|
||||
"task.creator",
|
||||
"task.read",
|
||||
"task.audit",
|
||||
"task.cancel",
|
||||
"task.delegate",
|
||||
"task.claim",
|
||||
"worker.admin",
|
||||
"worker.self_register",
|
||||
},
|
||||
WORKER_IDENTITY: {
|
||||
"task.read",
|
||||
"task.claim",
|
||||
"worker.self_register",
|
||||
},
|
||||
}
|
||||
return TaskPlaneService(
|
||||
store or TaskPlaneStore(":memory:"),
|
||||
policy=PolicyEngine(
|
||||
execution_enabled=True,
|
||||
identity_capabilities=grants,
|
||||
admin_identities={ADMIN_IDENTITY},
|
||||
**policy_kwargs,
|
||||
),
|
||||
)
|
||||
|
||||
|
||||
def _claim_for_service(service, *, task_id="task-secure", plan=None):
|
||||
plan = plan or {
|
||||
"task_id": task_id,
|
||||
"issuer": {"type": "agent", "id": ADMIN_IDENTITY},
|
||||
"required_capabilities": ["code.read"],
|
||||
"risk": "low",
|
||||
}
|
||||
service.register_worker(
|
||||
_worker_payload(
|
||||
capabilities=sorted(
|
||||
{"code.read", "test.python", *plan.get("required_capabilities", [])}
|
||||
)
|
||||
)
|
||||
)
|
||||
task = service.create_task(plan)
|
||||
claim = service.claim(
|
||||
task["task_id"],
|
||||
{"worker_id": WORKER_ID, "actor_identity": WORKER_IDENTITY},
|
||||
)
|
||||
return task, claim
|
||||
|
||||
|
||||
def _process_claim(db_path, task_id, expected_revision, digest, queue):
|
||||
store = TaskPlaneStore(db_path)
|
||||
try:
|
||||
store.claim_task(
|
||||
task_id,
|
||||
WORKER_ID,
|
||||
WORKER_IDENTITY,
|
||||
30,
|
||||
expected_revision,
|
||||
digest,
|
||||
)
|
||||
queue.put("claimed")
|
||||
except Exception as exc:
|
||||
queue.put(type(exc).__name__)
|
||||
finally:
|
||||
store.close()
|
||||
|
||||
|
||||
class EvidenceEnvelopeContractTests(unittest.TestCase):
|
||||
def setUp(self):
|
||||
self.base = EvidenceEnvelope.create(
|
||||
task_id="task-evidence",
|
||||
claim_id="claim-evidence",
|
||||
kind="test-report",
|
||||
worker_identity=WORKER_IDENTITY,
|
||||
payload={"passed": True},
|
||||
previous_evidence_hash="",
|
||||
attestation_ref="trusted://shadow/test-report",
|
||||
)
|
||||
|
||||
def test_digest_binds_complete_envelope_and_order(self):
|
||||
self.assertTrue(
|
||||
self.base.verify(
|
||||
expected_task_id="task-evidence",
|
||||
expected_claim_id="claim-evidence",
|
||||
expected_previous_hash="",
|
||||
)
|
||||
)
|
||||
mutations = {
|
||||
"kind": "secret-scan",
|
||||
"worker_identity": "spiffe://attacker",
|
||||
"task_id": "task-other",
|
||||
"claim_id": "claim-other",
|
||||
"created_at": self.base.created_at + 1,
|
||||
"payload": {"passed": False},
|
||||
"previous_evidence_hash": "f" * 64,
|
||||
}
|
||||
for field, value in mutations.items():
|
||||
with self.subTest(field=field):
|
||||
self.assertFalse(
|
||||
dataclasses.replace(self.base, **{field: value}).verify(
|
||||
expected_task_id="task-evidence",
|
||||
expected_claim_id="claim-evidence",
|
||||
expected_previous_hash="",
|
||||
)
|
||||
)
|
||||
|
||||
def test_store_rejects_cross_task_required_evidence_and_chain_tamper(self):
|
||||
store = TaskPlaneStore(":memory:")
|
||||
store.create_task_with_event(
|
||||
TaskPlan.from_dict({"task_id": "task-evidence"})
|
||||
)
|
||||
store.add_evidence_envelope(self.base)
|
||||
self.assertTrue(store.verify_evidence_integrity("task-evidence"))
|
||||
store.conn.execute(
|
||||
"UPDATE evidence SET envelope_json=json_set(envelope_json,'$.task_id','task-other')"
|
||||
)
|
||||
self.assertFalse(store.verify_evidence_integrity("task-evidence"))
|
||||
|
||||
|
||||
class AtomicMutationContractTests(unittest.TestCase):
|
||||
def _fault(self, point):
|
||||
def inject(observed):
|
||||
if observed == point:
|
||||
raise RuntimeError("injected fault")
|
||||
|
||||
return inject
|
||||
|
||||
def test_create_cancel_and_delegate_roll_back_at_event_boundaries(self):
|
||||
store = TaskPlaneStore(":memory:")
|
||||
store.fault_injector = self._fault("create.after_task_before_event")
|
||||
with self.assertRaises(RuntimeError):
|
||||
store.create_task_with_event(TaskPlan.from_dict({"task_id": "task-create"}))
|
||||
self.assertEqual([], store.list_tasks())
|
||||
|
||||
store.fault_injector = None
|
||||
parent = store.create_task_with_event(
|
||||
TaskPlan.from_dict(
|
||||
{
|
||||
"task_id": "task-parent-atomic",
|
||||
"required_capabilities": ["code.read"],
|
||||
"budgets": {"attempts": 2},
|
||||
}
|
||||
)
|
||||
)
|
||||
store.fault_injector = self._fault("cancel.after_state_before_event")
|
||||
with self.assertRaises(RuntimeError):
|
||||
store.cancel_task_with_event(parent.task_id, parent.revision, "stop")
|
||||
self.assertEqual("CREATED", store.get_task(parent.task_id).status)
|
||||
|
||||
store.fault_injector = self._fault("delegate.after_budget_before_child")
|
||||
with self.assertRaises(RuntimeError):
|
||||
store.delegate_task_with_budget_and_events(
|
||||
parent.task_id,
|
||||
TaskPlan.from_dict(
|
||||
{
|
||||
"task_id": "task-child-atomic",
|
||||
"required_capabilities": ["code.read"],
|
||||
"budgets": {"attempts": 1},
|
||||
}
|
||||
),
|
||||
caller=ADMIN_IDENTITY,
|
||||
)
|
||||
self.assertEqual(2, store.get_task_budget(parent.task_id).attempts)
|
||||
self.assertEqual([], store.list_children(parent.task_id))
|
||||
|
||||
def test_complete_fail_and_recover_roll_back_wholly(self):
|
||||
service = _service()
|
||||
task, claim = _claim_for_service(service, task_id="task-complete-atomic")
|
||||
service.progress(
|
||||
task["task_id"],
|
||||
{
|
||||
"claim_id": claim["claim_id"],
|
||||
"actor_identity": WORKER_IDENTITY,
|
||||
"progress": 10,
|
||||
"stage": "running",
|
||||
},
|
||||
)
|
||||
service.store.fault_injector = self._fault(
|
||||
"complete.after_evidence_before_state"
|
||||
)
|
||||
envelope = EvidenceEnvelope.create(
|
||||
task_id=task["task_id"],
|
||||
claim_id=claim["claim_id"],
|
||||
kind="test-report",
|
||||
worker_identity=WORKER_IDENTITY,
|
||||
payload={"passed": True},
|
||||
previous_evidence_hash="",
|
||||
attestation_ref="trusted://shadow/test",
|
||||
)
|
||||
with self.assertRaises(RuntimeError):
|
||||
service.store.complete_claim_with_evidence_and_event(
|
||||
task["task_id"],
|
||||
claim["claim_id"],
|
||||
"COMPLETED",
|
||||
{"status": "COMPLETED"},
|
||||
[envelope],
|
||||
)
|
||||
self.assertEqual([], service.store.list_evidence(task["task_id"]))
|
||||
self.assertEqual("RUNNING", service.store.get_task(task["task_id"]).status)
|
||||
|
||||
def test_fail_rolls_back_claim_state_and_event(self):
|
||||
service = _service()
|
||||
task, claim = _claim_for_service(service, task_id="task-fail-atomic")
|
||||
service.store.fault_injector = self._fault("fail.after_state_before_commit")
|
||||
with self.assertRaises(RuntimeError):
|
||||
service.store.fail_claim_with_event(
|
||||
task["task_id"], claim["claim_id"], "FAILED_FINAL", "injected"
|
||||
)
|
||||
self.assertEqual("ACTIVE", service.store.get_claim(claim["claim_id"]).status)
|
||||
self.assertEqual("CLAIMED", service.store.get_task(task["task_id"]).status)
|
||||
self.assertNotIn(
|
||||
"TASK_FAILED",
|
||||
{
|
||||
event["type"]
|
||||
for event in service.store.list_events(task["task_id"])
|
||||
},
|
||||
)
|
||||
|
||||
def test_recovery_rolls_back_probe_state_and_event(self):
|
||||
service = _service(
|
||||
probe_attestation_verifier=lambda probe: probe.attestation_ref
|
||||
== "trusted://probe/atomic"
|
||||
)
|
||||
task, claim = _claim_for_service(service, task_id="task-recover-atomic")
|
||||
service.store.conn.execute(
|
||||
"UPDATE claims SET lease_until=? WHERE claim_id=?",
|
||||
(time.time() - 10, claim["claim_id"]),
|
||||
)
|
||||
probe = ProbeEvidence.create(
|
||||
task_id=task["task_id"],
|
||||
claim_id=claim["claim_id"],
|
||||
worker_id=WORKER_ID,
|
||||
worker_identity=WORKER_IDENTITY,
|
||||
operation_digest=claim["operation_digest"],
|
||||
outcome=ProbeOutcome.NOT_APPLIED,
|
||||
observed_at=time.time(),
|
||||
expires_at=time.time() + 60,
|
||||
probe_executor_identity=ADMIN_IDENTITY,
|
||||
attestation_ref="trusted://probe/atomic",
|
||||
)
|
||||
service.store.fault_injector = self._fault(
|
||||
"recover.after_probe_before_state"
|
||||
)
|
||||
with self.assertRaises(RuntimeError):
|
||||
service.store.recover_claim_with_probe_and_event(
|
||||
task["task_id"], claim["claim_id"], probe
|
||||
)
|
||||
self.assertEqual(
|
||||
0,
|
||||
service.store.conn.execute(
|
||||
"SELECT COUNT(*) FROM probe_evidence WHERE probe_id=?",
|
||||
(probe.probe_id,),
|
||||
).fetchone()[0],
|
||||
)
|
||||
self.assertEqual("ACTIVE", service.store.get_claim(claim["claim_id"]).status)
|
||||
self.assertEqual("CLAIMED", service.store.get_task(task["task_id"]).status)
|
||||
|
||||
|
||||
class WorkerOwnershipContractTests(unittest.TestCase):
|
||||
def test_identity_takeover_escalation_and_disabled_reregistration_rejected(self):
|
||||
service = _service()
|
||||
registered = service.register_worker(_worker_payload())
|
||||
revision = registered["registration_revision"]
|
||||
with self.assertRaises(ConflictError):
|
||||
service.register_worker(
|
||||
_worker_payload(
|
||||
identity="spiffe://aios/attacker",
|
||||
owner_identity="spiffe://aios/attacker",
|
||||
actor_identity="spiffe://aios/attacker",
|
||||
expected_revision=revision,
|
||||
)
|
||||
)
|
||||
with self.assertRaises(ForbiddenError):
|
||||
service.register_worker(
|
||||
_worker_payload(
|
||||
capabilities=["code.read", "deploy.production"],
|
||||
expected_revision=revision,
|
||||
)
|
||||
)
|
||||
disabled = service.disable_worker(
|
||||
WORKER_ID,
|
||||
{
|
||||
"actor_identity": ADMIN_IDENTITY,
|
||||
"expected_revision": revision,
|
||||
"reason": "security review",
|
||||
},
|
||||
)
|
||||
with self.assertRaises(LockedError):
|
||||
service.register_worker(
|
||||
_worker_payload(expected_revision=disabled["registration_revision"])
|
||||
)
|
||||
|
||||
def test_worker_cannot_heartbeat_other_identity_and_all_updates_use_cas(self):
|
||||
service = _service()
|
||||
worker = service.register_worker(_worker_payload())
|
||||
with self.assertRaises(ForbiddenError):
|
||||
service.worker_heartbeat(
|
||||
WORKER_ID,
|
||||
{
|
||||
"actor_identity": "spiffe://aios/attacker",
|
||||
"expected_revision": worker["registration_revision"],
|
||||
},
|
||||
)
|
||||
with self.assertRaises(ConflictError):
|
||||
service.worker_heartbeat(
|
||||
WORKER_ID,
|
||||
{
|
||||
"actor_identity": WORKER_IDENTITY,
|
||||
"expected_revision": worker["registration_revision"] + 1,
|
||||
},
|
||||
)
|
||||
|
||||
|
||||
class RecoveryProbeContractTests(unittest.TestCase):
|
||||
def _expired_claim(self, suffix):
|
||||
service = _service(
|
||||
probe_attestation_verifier=lambda probe: probe.attestation_ref
|
||||
== "trusted://probe/test"
|
||||
)
|
||||
task, claim = _claim_for_service(service, task_id=f"task-probe-{suffix}")
|
||||
service.store.conn.execute(
|
||||
"UPDATE claims SET lease_until=? WHERE claim_id=?",
|
||||
(time.time() - 10, claim["claim_id"]),
|
||||
)
|
||||
return service, task, claim
|
||||
|
||||
def _probe(self, task, claim, outcome, **overrides):
|
||||
data = {
|
||||
"task_id": task["task_id"],
|
||||
"claim_id": claim["claim_id"],
|
||||
"worker_id": WORKER_ID,
|
||||
"worker_identity": WORKER_IDENTITY,
|
||||
"operation_digest": claim["operation_digest"],
|
||||
"outcome": outcome,
|
||||
"observed_at": time.time(),
|
||||
"expires_at": time.time() + 60,
|
||||
"probe_executor_identity": ADMIN_IDENTITY,
|
||||
"attestation_ref": "trusted://probe/test",
|
||||
}
|
||||
data.update(overrides)
|
||||
return ProbeEvidence.create(**data)
|
||||
|
||||
def test_four_probe_outcomes_have_distinct_fail_closed_transitions(self):
|
||||
expected = {
|
||||
ProbeOutcome.NOT_APPLIED: "FAILED_RECOVERABLE",
|
||||
ProbeOutcome.APPLIED_VERIFIED: "COMPLETED",
|
||||
ProbeOutcome.INDETERMINATE: "FAILED_RECOVERABLE",
|
||||
ProbeOutcome.CONFLICT: "MANUAL_REVIEW_REQUIRED",
|
||||
}
|
||||
for outcome, status in expected.items():
|
||||
with self.subTest(outcome=outcome):
|
||||
service, task, claim = self._expired_claim(outcome.value.lower())
|
||||
recovered = service.store.recover_claim_with_probe_and_event(
|
||||
task["task_id"],
|
||||
claim["claim_id"],
|
||||
self._probe(task, claim, outcome),
|
||||
)
|
||||
self.assertEqual(status, recovered.status)
|
||||
if outcome == ProbeOutcome.INDETERMINATE:
|
||||
self.assertFalse(
|
||||
service.store.task_has_retryable_probe(task["task_id"])
|
||||
)
|
||||
|
||||
def test_forged_expired_or_mismatched_probe_is_rejected(self):
|
||||
service, task, claim = self._expired_claim("invalid")
|
||||
valid = self._probe(task, claim, ProbeOutcome.NOT_APPLIED)
|
||||
for probe in (
|
||||
dataclasses.replace(valid, evidence_digest="0" * 64),
|
||||
self._probe(
|
||||
task,
|
||||
claim,
|
||||
ProbeOutcome.NOT_APPLIED,
|
||||
expires_at=time.time() - 1,
|
||||
),
|
||||
self._probe(
|
||||
task,
|
||||
claim,
|
||||
ProbeOutcome.NOT_APPLIED,
|
||||
operation_digest="f" * 64,
|
||||
),
|
||||
):
|
||||
with self.assertRaises((ForbiddenError, ConflictError, LockedError)):
|
||||
service.store.recover_claim_with_probe_and_event(
|
||||
task["task_id"], claim["claim_id"], probe
|
||||
)
|
||||
|
||||
|
||||
class SchedulerAndClassificationTests(unittest.TestCase):
|
||||
def test_scheduler_skips_incompatible_and_dependency_blocked_tasks(self):
|
||||
service = _service()
|
||||
service.register_worker(_worker_payload())
|
||||
service.create_task(
|
||||
{
|
||||
"task_id": "task-incompatible",
|
||||
"issuer": {"type": "agent", "id": ADMIN_IDENTITY},
|
||||
"required_capabilities": ["gpu.train"],
|
||||
}
|
||||
)
|
||||
service.create_task(
|
||||
{
|
||||
"task_id": "task-dependency",
|
||||
"issuer": {"type": "agent", "id": ADMIN_IDENTITY},
|
||||
}
|
||||
)
|
||||
service.create_task(
|
||||
{
|
||||
"task_id": "task-blocked",
|
||||
"issuer": {"type": "agent", "id": ADMIN_IDENTITY},
|
||||
"required_capabilities": ["code.read"],
|
||||
"dependencies": ["task-dependency"],
|
||||
}
|
||||
)
|
||||
service.create_task(
|
||||
{
|
||||
"task_id": "task-eligible",
|
||||
"issuer": {"type": "agent", "id": ADMIN_IDENTITY},
|
||||
"required_capabilities": ["code.read"],
|
||||
"metadata": {"priority": 100},
|
||||
}
|
||||
)
|
||||
claim = TaskScheduler(service.store).schedule_for_worker(WORKER_ID)
|
||||
self.assertEqual("task-eligible", claim.task_id)
|
||||
self.assertEqual(WORKER_IDENTITY, claim.worker_identity)
|
||||
|
||||
def test_credential_secret_rejects_generic_worker_and_redacts_free_text(self):
|
||||
service = _service()
|
||||
service.register_worker(_worker_payload())
|
||||
task = service.create_task(
|
||||
{
|
||||
"task_id": "task-credential-secret",
|
||||
"issuer": {"type": "agent", "id": ADMIN_IDENTITY},
|
||||
"required_capabilities": ["secret.transform"],
|
||||
"data_classification": "credential-secret",
|
||||
"execution_zone": "secure-file-transformer",
|
||||
"network_policy": "denied",
|
||||
"logging_policy": "metadata-only",
|
||||
"output_policy": "hash-count-status-only",
|
||||
}
|
||||
)
|
||||
with self.assertRaises(ForbiddenError):
|
||||
service.claim(
|
||||
task["task_id"],
|
||||
{"worker_id": WORKER_ID, "actor_identity": WORKER_IDENTITY},
|
||||
)
|
||||
with self.assertRaises(ValueError):
|
||||
TaskPlan.from_dict(
|
||||
{
|
||||
"task_id": "task-secret-leak",
|
||||
"intent": "Authorization: Bearer super-secret-value",
|
||||
"data_classification": "credential-secret",
|
||||
}
|
||||
)
|
||||
|
||||
|
||||
class ReadRBACAndResultProofTests(unittest.TestCase):
|
||||
def test_get_evidence_requires_authentication(self):
|
||||
service = _service()
|
||||
service.create_task(
|
||||
{
|
||||
"task_id": "task-http-read",
|
||||
"issuer": {"type": "agent", "id": ADMIN_IDENTITY},
|
||||
}
|
||||
)
|
||||
TaskPlaneRequestHandler.service = service
|
||||
TaskPlaneRequestHandler.authenticator = lambda token: (
|
||||
ADMIN_IDENTITY if token == "valid" else None
|
||||
)
|
||||
server = ThreadingHTTPServer(("127.0.0.1", 0), TaskPlaneRequestHandler)
|
||||
thread = threading.Thread(target=server.serve_forever, daemon=True)
|
||||
thread.start()
|
||||
try:
|
||||
connection = http.client.HTTPConnection(
|
||||
"127.0.0.1", server.server_address[1], timeout=3
|
||||
)
|
||||
connection.request("GET", "/tasks/task-http-read/evidence")
|
||||
response = connection.getresponse()
|
||||
response.read()
|
||||
self.assertEqual(401, response.status)
|
||||
connection.request(
|
||||
"GET",
|
||||
"/tasks/task-http-read/evidence",
|
||||
headers={"Authorization": "Bearer valid"},
|
||||
)
|
||||
response = connection.getresponse()
|
||||
response.read()
|
||||
self.assertEqual(200, response.status)
|
||||
finally:
|
||||
server.shutdown()
|
||||
server.server_close()
|
||||
thread.join(timeout=3)
|
||||
|
||||
def test_sensitive_result_requires_worker_proof_but_low_shadow_is_marked(self):
|
||||
service = _service(result_signature_verifier=lambda result: False)
|
||||
task, claim = _claim_for_service(
|
||||
service,
|
||||
task_id="task-write-proof",
|
||||
plan={
|
||||
"task_id": "task-write-proof",
|
||||
"issuer": {"type": "agent", "id": ADMIN_IDENTITY},
|
||||
"required_capabilities": ["code.read", "code.write.patch"],
|
||||
"risk": "medium",
|
||||
},
|
||||
)
|
||||
service.progress(
|
||||
task["task_id"],
|
||||
{
|
||||
"claim_id": claim["claim_id"],
|
||||
"actor_identity": WORKER_IDENTITY,
|
||||
"progress": 100,
|
||||
"stage": "done",
|
||||
},
|
||||
)
|
||||
with self.assertRaises(ForbiddenError):
|
||||
service.complete(
|
||||
task["task_id"],
|
||||
{
|
||||
"claim_id": claim["claim_id"],
|
||||
"actor_identity": WORKER_IDENTITY,
|
||||
"signature": "invalid",
|
||||
},
|
||||
)
|
||||
|
||||
|
||||
class SQLiteAndEventIntegrityTests(unittest.TestCase):
|
||||
def test_event_hash_binds_metadata(self):
|
||||
store = TaskPlaneStore(":memory:")
|
||||
task = store.create_task_with_event(
|
||||
TaskPlan.from_dict({"task_id": "task-event-metadata"})
|
||||
)
|
||||
self.assertTrue(store.verify_event_chain(task.task_id))
|
||||
for column, value in (
|
||||
("event_id", "evt-forged"),
|
||||
("subject", "task/other"),
|
||||
("created_at", 1.0),
|
||||
):
|
||||
with self.subTest(column=column):
|
||||
original = dict(
|
||||
store.conn.execute(
|
||||
"SELECT * FROM events WHERE task_id=?", (task.task_id,)
|
||||
).fetchone()
|
||||
)
|
||||
store.conn.execute(
|
||||
f"UPDATE events SET {column}=? WHERE task_id=?",
|
||||
(value, task.task_id),
|
||||
)
|
||||
self.assertFalse(store.verify_event_chain(task.task_id))
|
||||
store.conn.execute(
|
||||
f"UPDATE events SET {column}=? WHERE task_id=?",
|
||||
(original[column], task.task_id),
|
||||
)
|
||||
|
||||
def test_sqlite_high_assurance_schema_integrity_checkpoint_and_backup(self):
|
||||
with tempfile.TemporaryDirectory() as directory:
|
||||
path = os.path.join(directory, "task-plane.sqlite3")
|
||||
store = TaskPlaneStore(path, high_assurance=True)
|
||||
self.assertGreaterEqual(store.schema_version(), 2)
|
||||
self.assertEqual(5000, store.conn.execute("PRAGMA busy_timeout").fetchone()[0])
|
||||
self.assertEqual(2, store.conn.execute("PRAGMA synchronous").fetchone()[0])
|
||||
self.assertEqual("ok", store.integrity_check())
|
||||
store.create_task_with_event(
|
||||
TaskPlan.from_dict({"task_id": "task-backup"})
|
||||
)
|
||||
backup = os.path.join(directory, "backup.sqlite3")
|
||||
store.checkpoint_and_backup(backup)
|
||||
self.assertTrue(os.path.exists(backup))
|
||||
store.close()
|
||||
|
||||
def test_multi_process_claim_race_has_single_winner(self):
|
||||
with tempfile.TemporaryDirectory() as directory:
|
||||
path = os.path.join(directory, "task-plane.sqlite3")
|
||||
store = TaskPlaneStore(path)
|
||||
service = _service(store)
|
||||
service.register_worker(_worker_payload(max_concurrency=2))
|
||||
task = service.create_task(
|
||||
{
|
||||
"task_id": "task-multiprocess",
|
||||
"issuer": {"type": "agent", "id": ADMIN_IDENTITY},
|
||||
"required_capabilities": ["code.read"],
|
||||
}
|
||||
)
|
||||
record = store.get_task(task["task_id"])
|
||||
queue = multiprocessing.Queue()
|
||||
processes = [
|
||||
multiprocessing.Process(
|
||||
target=_process_claim,
|
||||
args=(
|
||||
path,
|
||||
task["task_id"],
|
||||
record.revision,
|
||||
record.task_plan.operation_digest(),
|
||||
queue,
|
||||
),
|
||||
)
|
||||
for _ in range(2)
|
||||
]
|
||||
for process in processes:
|
||||
process.start()
|
||||
for process in processes:
|
||||
process.join(10)
|
||||
outcomes = [queue.get(timeout=3) for _ in processes]
|
||||
self.assertEqual(1, outcomes.count("claimed"))
|
||||
store.close()
|
||||
|
||||
|
||||
class ExplicitSecurityMatrixTests(unittest.TestCase):
|
||||
def test_evidence_kind_tamper_is_rejected(self):
|
||||
envelope = EvidenceEnvelope.create(
|
||||
task_id="task-kind",
|
||||
claim_id="claim-kind",
|
||||
kind="test-report",
|
||||
worker_identity=WORKER_IDENTITY,
|
||||
payload={"passed": True},
|
||||
previous_evidence_hash="",
|
||||
)
|
||||
self.assertFalse(
|
||||
dataclasses.replace(envelope, kind="forged").verify(
|
||||
expected_task_id="task-kind",
|
||||
expected_claim_id="claim-kind",
|
||||
expected_previous_hash="",
|
||||
)
|
||||
)
|
||||
|
||||
def test_worker_admin_restore_is_cas_and_journaled(self):
|
||||
service = _service()
|
||||
worker = service.register_worker(_worker_payload())
|
||||
disabled = service.disable_worker(
|
||||
WORKER_ID,
|
||||
{
|
||||
"actor_identity": ADMIN_IDENTITY,
|
||||
"expected_revision": worker["registration_revision"],
|
||||
"reason": "test",
|
||||
},
|
||||
)
|
||||
restored = service.restore_worker(
|
||||
WORKER_ID,
|
||||
{
|
||||
"actor_identity": ADMIN_IDENTITY,
|
||||
"expected_revision": disabled["registration_revision"],
|
||||
},
|
||||
)
|
||||
self.assertFalse(restored["disabled"])
|
||||
events = service.store.list_events("task-worker-registry")
|
||||
self.assertIn("WORKER_RESTORED", {event["type"] for event in events})
|
||||
|
||||
def test_disabled_worker_heartbeat_is_rejected(self):
|
||||
service = _service()
|
||||
worker = service.register_worker(_worker_payload())
|
||||
disabled = service.disable_worker(
|
||||
WORKER_ID,
|
||||
{
|
||||
"actor_identity": ADMIN_IDENTITY,
|
||||
"expected_revision": worker["registration_revision"],
|
||||
"reason": "test",
|
||||
},
|
||||
)
|
||||
with self.assertRaises(LockedError):
|
||||
service.worker_heartbeat(
|
||||
WORKER_ID,
|
||||
{
|
||||
"actor_identity": WORKER_IDENTITY,
|
||||
"expected_revision": disabled["registration_revision"],
|
||||
},
|
||||
)
|
||||
|
||||
def test_low_risk_unsigned_result_is_explicitly_untrusted(self):
|
||||
service = _service()
|
||||
task, claim = _claim_for_service(service, task_id="task-low-shadow")
|
||||
service.progress(
|
||||
task["task_id"],
|
||||
{
|
||||
"claim_id": claim["claim_id"],
|
||||
"actor_identity": WORKER_IDENTITY,
|
||||
"progress": 100,
|
||||
"stage": "done",
|
||||
},
|
||||
)
|
||||
result = service.complete(
|
||||
task["task_id"],
|
||||
{
|
||||
"claim_id": claim["claim_id"],
|
||||
"actor_identity": WORKER_IDENTITY,
|
||||
},
|
||||
)
|
||||
self.assertEqual("untrusted_shadow_result", result["trust_status"])
|
||||
|
||||
def test_boolean_recovery_contract_is_rejected(self):
|
||||
service = _service()
|
||||
task, claim = _claim_for_service(service, task_id="task-no-bool-probe")
|
||||
service.store.conn.execute(
|
||||
"UPDATE claims SET lease_until=? WHERE claim_id=?",
|
||||
(time.time() - 10, claim["claim_id"]),
|
||||
)
|
||||
with self.assertRaises(ValidationError):
|
||||
service.store.recover_expired_claim(
|
||||
task["task_id"], claim["claim_id"], True
|
||||
)
|
||||
|
||||
def test_scheduler_rejects_offline_worker(self):
|
||||
service = _service()
|
||||
service.register_worker(_worker_payload())
|
||||
service.create_task(
|
||||
{
|
||||
"task_id": "task-offline",
|
||||
"issuer": {"type": "agent", "id": ADMIN_IDENTITY},
|
||||
"required_capabilities": ["code.read"],
|
||||
}
|
||||
)
|
||||
service.store.conn.execute(
|
||||
"UPDATE workers SET last_heartbeat=? WHERE worker_id=?",
|
||||
(time.time() - 1000, WORKER_ID),
|
||||
)
|
||||
with self.assertRaises(LockedError):
|
||||
TaskScheduler(service.store).schedule_for_worker(WORKER_ID)
|
||||
|
||||
def test_schedule_decision_event_is_single_for_claim(self):
|
||||
service = _service()
|
||||
service.register_worker(_worker_payload())
|
||||
service.create_task(
|
||||
{
|
||||
"task_id": "task-schedule-event",
|
||||
"issuer": {"type": "agent", "id": ADMIN_IDENTITY},
|
||||
"required_capabilities": ["code.read"],
|
||||
}
|
||||
)
|
||||
TaskScheduler(service.store).schedule_for_worker(WORKER_ID)
|
||||
events = service.store.list_events("task-schedule-event")
|
||||
self.assertEqual(
|
||||
1, sum(event["type"] == "SCHEDULE_DECISION" for event in events)
|
||||
)
|
||||
|
||||
def _credential_service_and_claim(self):
|
||||
identity = "spiffe://aios/agent/secure-file-transformer/01"
|
||||
service = TaskPlaneService(
|
||||
TaskPlaneStore(":memory:"),
|
||||
policy=PolicyEngine(
|
||||
execution_enabled=True,
|
||||
identity_capabilities={"*": set(ALL_ACTION_CAPABILITIES)},
|
||||
),
|
||||
)
|
||||
service.register_worker(
|
||||
{
|
||||
"worker_id": "secure-transformer-01",
|
||||
"worker_type": "secure_file_transformer",
|
||||
"identity": identity,
|
||||
"capabilities": ["secret.transform", "secure_file_transformer"],
|
||||
"trust_zone": "secure",
|
||||
"max_concurrency": 1,
|
||||
"heartbeat_interval_seconds": 15,
|
||||
"supported_protocols": ["aios-task-v1"],
|
||||
}
|
||||
)
|
||||
task = service.create_task(
|
||||
{
|
||||
"task_id": "task-secure-output",
|
||||
"required_capabilities": ["secret.transform"],
|
||||
"data_classification": "credential-secret",
|
||||
"execution_zone": "secure-file-transformer",
|
||||
"network_policy": "denied",
|
||||
"logging_policy": "metadata-only",
|
||||
"output_policy": "hash-count-status-only",
|
||||
}
|
||||
)
|
||||
claim = service.claim(
|
||||
task["task_id"],
|
||||
{"worker_id": "secure-transformer-01", "actor_identity": identity},
|
||||
)
|
||||
return service, task, claim, identity
|
||||
|
||||
def test_credential_progress_free_text_is_rejected(self):
|
||||
service, task, claim, identity = self._credential_service_and_claim()
|
||||
with self.assertRaises(ValidationError):
|
||||
service.progress(
|
||||
task["task_id"],
|
||||
{
|
||||
"claim_id": claim["claim_id"],
|
||||
"actor_identity": identity,
|
||||
"progress": 10,
|
||||
"stage": "running",
|
||||
"message": "Authorization: Bearer forbidden",
|
||||
},
|
||||
)
|
||||
|
||||
def test_credential_result_content_is_rejected(self):
|
||||
service, task, claim, identity = self._credential_service_and_claim()
|
||||
service.progress(
|
||||
task["task_id"],
|
||||
{
|
||||
"claim_id": claim["claim_id"],
|
||||
"actor_identity": identity,
|
||||
"progress": 100,
|
||||
"stage": "done",
|
||||
},
|
||||
)
|
||||
with self.assertRaises(ValidationError):
|
||||
service.complete(
|
||||
task["task_id"],
|
||||
{
|
||||
"claim_id": claim["claim_id"],
|
||||
"actor_identity": identity,
|
||||
"outputs": [{"content": "forbidden"}],
|
||||
},
|
||||
)
|
||||
|
||||
def test_action_rbac_denies_read_without_task_read(self):
|
||||
store = TaskPlaneStore(":memory:")
|
||||
service = TaskPlaneService(
|
||||
store,
|
||||
policy=PolicyEngine(
|
||||
identity_capabilities={"spiffe://reader/none": set()}
|
||||
),
|
||||
)
|
||||
store.create_task_with_event(TaskPlan.from_dict({"task_id": "task-rbac"}))
|
||||
with self.assertRaises(ForbiddenError):
|
||||
service.get_task("task-rbac", "spiffe://reader/none")
|
||||
|
||||
def test_default_service_policy_denies_authenticated_read(self):
|
||||
service = TaskPlaneService(TaskPlaneStore(":memory:"))
|
||||
service.create_task({"task_id": "task-default-deny"})
|
||||
with self.assertRaises(ForbiddenError):
|
||||
service.get_task("task-default-deny", "spiffe://reader/unconfigured")
|
||||
|
||||
def test_fail_path_emits_one_task_failed_event(self):
|
||||
service = _service()
|
||||
task, claim = _claim_for_service(service, task_id="task-single-fail")
|
||||
service.fail(
|
||||
task["task_id"],
|
||||
{
|
||||
"claim_id": claim["claim_id"],
|
||||
"actor_identity": WORKER_IDENTITY,
|
||||
"reason": "expected test failure",
|
||||
},
|
||||
)
|
||||
events = service.store.list_events(task["task_id"])
|
||||
self.assertEqual(1, sum(event["type"] == "TASK_FAILED" for event in events))
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
@@ -1,259 +0,0 @@
|
||||
from __future__ import annotations
|
||||
|
||||
import json
|
||||
import os
|
||||
import tempfile
|
||||
import unittest
|
||||
from datetime import datetime, timedelta, timezone
|
||||
from pathlib import Path
|
||||
from unittest import mock
|
||||
|
||||
import aios_isolated_writer_policy as writer_policy
|
||||
import isolated_writer_path_policy as path_policy
|
||||
from isolated_writer_authz import AuthorizationError, _validate_grant
|
||||
|
||||
|
||||
TARGET = "deploy/systemd/aios-codex-review-test-worker.service"
|
||||
BRANCH = "patch/codex-review-test-worker-20260724"
|
||||
AUDIENCE = "aios-codex-review-worker-writer.service"
|
||||
|
||||
VALID_UNIT = """\
|
||||
[Unit]
|
||||
Description=AIOS Codex Review/Test Worker
|
||||
|
||||
[Service]
|
||||
User=aiman
|
||||
Environment=AIOS_CODEX_WORKER_MODE=shadow
|
||||
Environment=AIOS_TASK_PLANE_EXECUTION_ENABLED=false
|
||||
ExecStart=/usr/bin/python3 -m task_plane.workers.codex_review_test
|
||||
NoNewPrivileges=true
|
||||
ProtectSystem=strict
|
||||
PrivateTmp=true
|
||||
"""
|
||||
|
||||
|
||||
def document(*, paths=None, **updates):
|
||||
value = {
|
||||
"schema_version": 1,
|
||||
"policy_id": "codex-review-worker-path-policy-v1",
|
||||
"audience": AUDIENCE,
|
||||
"repository_identity": "aios/aios",
|
||||
"allowed_branch": BRANCH,
|
||||
"allowed_operations": {
|
||||
"commit_file.atomic": {
|
||||
"exact_paths": paths or [TARGET],
|
||||
"max_content_bytes": 32768,
|
||||
"content_profile": "systemd-codex-review-worker-v1",
|
||||
}
|
||||
},
|
||||
}
|
||||
value.update(updates)
|
||||
return value
|
||||
|
||||
|
||||
class ExactPathPolicyTests(unittest.TestCase):
|
||||
def setUp(self):
|
||||
self.saved = dict(os.environ)
|
||||
self.temp = tempfile.TemporaryDirectory()
|
||||
self.root = Path(self.temp.name)
|
||||
self.policy_dir = self.root / "policies"
|
||||
self.policy_dir.mkdir(mode=0o750)
|
||||
self.policy_file = self.policy_dir / "writer.json"
|
||||
self.workspace = self.root / "workspace"
|
||||
self.workspace.mkdir(mode=0o700)
|
||||
os.environ.update(
|
||||
{
|
||||
"AIOS_GITOPS_ISOLATED_WRITER_ENFORCEMENT": "required",
|
||||
"AIOS_GITOPS_SERVICE_AUDIENCE": AUDIENCE,
|
||||
"AIOS_GITOPS_REPOSITORY_IDENTITY": "aios/aios",
|
||||
"AIOS_GITOPS_ALLOWED_BRANCH": BRANCH,
|
||||
}
|
||||
)
|
||||
|
||||
def tearDown(self):
|
||||
path_policy.clear_path_policy_cache()
|
||||
os.environ.clear()
|
||||
os.environ.update(self.saved)
|
||||
self.temp.cleanup()
|
||||
|
||||
def write_policy(self, value=None):
|
||||
payload = document() if value is None else value
|
||||
raw = (
|
||||
json.dumps(payload, ensure_ascii=False, sort_keys=True, separators=(",", ":"))
|
||||
+ "\n"
|
||||
)
|
||||
self.policy_file.write_text(raw, encoding="utf-8")
|
||||
self.policy_file.chmod(0o640)
|
||||
return path_policy.load_path_policy(
|
||||
self.policy_file,
|
||||
expected_owner_uid=os.getuid(),
|
||||
expected_group_gid=os.getgid(),
|
||||
)
|
||||
|
||||
def configured(self, loaded):
|
||||
return mock.patch.object(
|
||||
path_policy,
|
||||
"configured_path_policy",
|
||||
return_value=loaded,
|
||||
)
|
||||
|
||||
def test_exact_systemd_path_and_exact_token_path_are_allowed(self):
|
||||
loaded = self.write_policy()
|
||||
with self.configured(loaded):
|
||||
self.assertEqual(TARGET, writer_policy.validate_path(TARGET, self.workspace))
|
||||
writer_policy.validate_content_for_path(TARGET, VALID_UNIT)
|
||||
|
||||
def test_token_path_cannot_expand_service_policy(self):
|
||||
loaded = self.write_policy(document(paths=["deploy/systemd/other.service"]))
|
||||
with self.configured(loaded), self.assertRaisesRegex(
|
||||
PermissionError, "isolated_writer_service_path_rejected"
|
||||
):
|
||||
writer_policy.validate_path(TARGET, self.workspace)
|
||||
|
||||
def test_service_policy_cannot_expand_token_path(self):
|
||||
now = datetime.now(timezone.utc)
|
||||
grant = {
|
||||
"schema_version": 2,
|
||||
"audience": AUDIENCE,
|
||||
"source_cidrs": ["127.0.0.1/32"],
|
||||
"created_at": (now - timedelta(seconds=5)).isoformat(),
|
||||
"not_before": (now - timedelta(seconds=2)).isoformat(),
|
||||
"expires_at": (now + timedelta(minutes=5)).isoformat(),
|
||||
"revoked": False,
|
||||
"allowed_operations": ["commit_file.atomic"],
|
||||
"allowed_branch": BRANCH,
|
||||
"allowed_paths": ["deploy/systemd/other.service"],
|
||||
"approved_base_oid": "a" * 40,
|
||||
}
|
||||
with mock.patch(
|
||||
"isolated_writer_authz._git_is_ancestor", return_value=True
|
||||
), self.assertRaisesRegex(AuthorizationError, "writer_token_path_rejected"):
|
||||
_validate_grant(
|
||||
grant,
|
||||
audience=AUDIENCE,
|
||||
source_ip="127.0.0.1",
|
||||
operation="commit_file.atomic",
|
||||
branch=BRANCH,
|
||||
path=TARGET,
|
||||
workspace=self.workspace,
|
||||
current_time=now,
|
||||
)
|
||||
|
||||
def test_other_service_file_is_rejected(self):
|
||||
loaded = self.write_policy()
|
||||
with self.configured(loaded), self.assertRaisesRegex(
|
||||
PermissionError, "isolated_writer_service_path_rejected"
|
||||
):
|
||||
writer_policy.validate_path(
|
||||
"deploy/systemd/other.service", self.workspace
|
||||
)
|
||||
|
||||
def test_path_traversal_is_rejected(self):
|
||||
for value in ("deploy/systemd/../x", "../deploy/systemd/x"):
|
||||
with self.subTest(value=value), self.assertRaises(PermissionError):
|
||||
writer_policy.validate_path(value, self.workspace)
|
||||
|
||||
def test_url_encoded_traversal_is_rejected(self):
|
||||
with self.assertRaises(PermissionError):
|
||||
writer_policy.validate_path(
|
||||
"deploy/systemd/%2e%2e/x", self.workspace
|
||||
)
|
||||
|
||||
def test_symlink_policy_file_is_rejected(self):
|
||||
self.write_policy()
|
||||
link = self.policy_dir / "link.json"
|
||||
link.symlink_to(self.policy_file)
|
||||
with self.assertRaisesRegex(
|
||||
path_policy.PathPolicyError, "isolated_writer_path_policy_symlink_rejected"
|
||||
):
|
||||
path_policy.load_path_policy(
|
||||
link,
|
||||
expected_owner_uid=os.getuid(),
|
||||
expected_group_gid=os.getgid(),
|
||||
)
|
||||
|
||||
def test_world_writable_policy_file_is_rejected(self):
|
||||
self.write_policy()
|
||||
self.policy_file.chmod(0o646)
|
||||
with self.assertRaisesRegex(
|
||||
path_policy.PathPolicyError,
|
||||
"isolated_writer_path_policy_permissions_rejected",
|
||||
):
|
||||
path_policy.load_path_policy(
|
||||
self.policy_file,
|
||||
expected_owner_uid=os.getuid(),
|
||||
expected_group_gid=os.getgid(),
|
||||
)
|
||||
|
||||
def test_unknown_policy_field_is_rejected(self):
|
||||
value = document()
|
||||
value["unexpected"] = True
|
||||
with self.assertRaisesRegex(
|
||||
path_policy.PathPolicyError,
|
||||
"isolated_writer_path_policy_fields_rejected",
|
||||
):
|
||||
self.write_policy(value)
|
||||
|
||||
def test_audience_mismatch_is_rejected(self):
|
||||
loaded = self.write_policy()
|
||||
os.environ["AIOS_GITOPS_PATH_POLICY_FILE"] = str(self.policy_file)
|
||||
os.environ["AIOS_GITOPS_SERVICE_AUDIENCE"] = "other.service"
|
||||
path_policy.clear_path_policy_cache()
|
||||
with mock.patch.object(
|
||||
path_policy, "load_path_policy", return_value=loaded
|
||||
), self.assertRaisesRegex(
|
||||
path_policy.PathPolicyError,
|
||||
"isolated_writer_path_policy_audience_rejected",
|
||||
):
|
||||
path_policy.configured_path_policy()
|
||||
|
||||
def test_branch_mismatch_is_rejected(self):
|
||||
loaded = self.write_policy()
|
||||
os.environ["AIOS_GITOPS_PATH_POLICY_FILE"] = str(self.policy_file)
|
||||
os.environ["AIOS_GITOPS_ALLOWED_BRANCH"] = "patch/other"
|
||||
path_policy.clear_path_policy_cache()
|
||||
with mock.patch.object(
|
||||
path_policy, "load_path_policy", return_value=loaded
|
||||
), self.assertRaisesRegex(
|
||||
path_policy.PathPolicyError,
|
||||
"isolated_writer_path_policy_branch_rejected",
|
||||
):
|
||||
path_policy.configured_path_policy()
|
||||
|
||||
def test_content_profile_rejects_shell_or_production_execution(self):
|
||||
loaded = self.write_policy()
|
||||
bad_values = (
|
||||
VALID_UNIT.replace(
|
||||
"/usr/bin/python3 -m task_plane.workers.codex_review_test",
|
||||
"/bin/bash -c evil",
|
||||
),
|
||||
VALID_UNIT.replace(
|
||||
"AIOS_TASK_PLANE_EXECUTION_ENABLED=false",
|
||||
"AIOS_TASK_PLANE_EXECUTION_ENABLED=true",
|
||||
),
|
||||
VALID_UNIT + "Environment=Authorization: Bearer placeholder\n",
|
||||
)
|
||||
with self.configured(loaded):
|
||||
for value in bad_values:
|
||||
with self.subTest(value=value), self.assertRaises(PermissionError):
|
||||
writer_policy.validate_content_for_path(TARGET, value)
|
||||
|
||||
def test_writer_request_cannot_modify_policy_file(self):
|
||||
with self.assertRaises(PermissionError):
|
||||
writer_policy.validate_path(
|
||||
"etc/aios-gitops/writer-path-policies/codex-review-worker.json",
|
||||
self.workspace,
|
||||
)
|
||||
|
||||
def test_coarse_file_and_commit_endpoints_remain_forbidden(self):
|
||||
for endpoint in ("/api/file", "/api/commit"):
|
||||
with self.subTest(endpoint=endpoint), self.assertRaisesRegex(
|
||||
PermissionError, "isolated_writer_operation_forbidden"
|
||||
):
|
||||
writer_policy.validate_endpoint(
|
||||
"POST", endpoint, self.workspace, self.root
|
||||
)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
@@ -1,174 +0,0 @@
|
||||
import os
|
||||
import sys
|
||||
import tempfile
|
||||
import subprocess
|
||||
import unittest
|
||||
from pathlib import Path
|
||||
|
||||
sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "active-runtime" / "app"))
|
||||
import aios_isolated_writer_policy as policy
|
||||
|
||||
|
||||
class IsolatedWriterPolicyTests(unittest.TestCase):
|
||||
def setUp(self):
|
||||
self.saved = dict(os.environ)
|
||||
os.environ["AIOS_GITOPS_ISOLATED_WRITER_ENFORCEMENT"] = "required"
|
||||
os.environ["AIOS_GITOPS_ALLOWED_BRANCH"] = "patch/aios-agent-task-control-plane-20260724"
|
||||
os.environ["AIOS_GITOPS_ALLOWED_BASE_OID"] = "a8e97868976b0dce17b7cb8487eadc1d9c687622"
|
||||
os.environ["AIOS_GITOPS_TOKEN_POLICY_VERSION_REQUIRED"] = "2"
|
||||
os.environ["AIOS_GITOPS_SERVICE_AUDIENCE"] = "test-isolated-writer.service"
|
||||
os.environ["AIOS_GITOPS_TOKEN_REGISTRY_V2"] = "/tmp/test-writer-token-registry.sqlite3"
|
||||
os.environ["AIOS_GITOPS_WRITER_OPERATION_LEDGER"] = "/tmp/test-writer-operations.sqlite3"
|
||||
|
||||
def tearDown(self):
|
||||
os.environ.clear()
|
||||
os.environ.update(self.saved)
|
||||
|
||||
def test_only_expected_branch_is_accepted(self):
|
||||
policy.validate_branch_request({
|
||||
"branch": os.environ["AIOS_GITOPS_ALLOWED_BRANCH"],
|
||||
"base": "main",
|
||||
})
|
||||
for branch in ("patch/other", "main", ""):
|
||||
with self.subTest(branch=branch), self.assertRaises(PermissionError):
|
||||
policy.validate_branch_request({"branch": branch, "base": "main"})
|
||||
|
||||
def test_write_paths_are_scoped_and_canonical(self):
|
||||
with tempfile.TemporaryDirectory() as root:
|
||||
workspace = Path(root)
|
||||
self.assertEqual(
|
||||
policy.validate_path("active-runtime/app/x.py", workspace),
|
||||
"active-runtime/app/x.py",
|
||||
)
|
||||
self.assertEqual(policy.validate_path("docs/x.md", workspace), "docs/x.md")
|
||||
self.assertEqual(
|
||||
policy.validate_path("scripts/task-plane/run.sh", workspace),
|
||||
"scripts/task-plane/run.sh",
|
||||
)
|
||||
self.assertEqual(
|
||||
policy.validate_path("reports/task-plane.json", workspace),
|
||||
"reports/task-plane.json",
|
||||
)
|
||||
rejected = (
|
||||
"",
|
||||
"../docs/x.md",
|
||||
"/docs/x.md",
|
||||
"docs/../x.md",
|
||||
"%2e%2e/docs/x.md",
|
||||
"%2Fdocs/x.md",
|
||||
r"C:\temp\x",
|
||||
r"\\server\share\x",
|
||||
"./docs/x.md",
|
||||
"docs//x.md",
|
||||
"docs/./x.md",
|
||||
"docs/x.md\x00tail",
|
||||
"baseline/current.json",
|
||||
)
|
||||
for value in rejected:
|
||||
with self.subTest(value=value), self.assertRaises(PermissionError):
|
||||
policy.validate_path(value, workspace)
|
||||
|
||||
@unittest.skipIf(os.name == "nt", "symlink creation requires Windows privilege")
|
||||
def test_external_symlink_is_rejected(self):
|
||||
with tempfile.TemporaryDirectory() as root, tempfile.TemporaryDirectory() as outside:
|
||||
workspace = Path(root)
|
||||
(workspace / "docs").symlink_to(Path(outside), target_is_directory=True)
|
||||
with self.assertRaises(PermissionError):
|
||||
policy.validate_path("docs/escape.md", workspace)
|
||||
|
||||
def test_force_and_forbidden_endpoints_are_rejected(self):
|
||||
with self.assertRaises(PermissionError):
|
||||
policy.validate_branch_request({
|
||||
"branch": os.environ["AIOS_GITOPS_ALLOWED_BRANCH"],
|
||||
"force": True,
|
||||
})
|
||||
for endpoint in (
|
||||
"/api/tag",
|
||||
"/api/rollback",
|
||||
"/api/model",
|
||||
"/api/model-priority",
|
||||
"/api/baseline",
|
||||
"/api/registry",
|
||||
"/api/deploy",
|
||||
):
|
||||
self.assertNotIn(endpoint, policy.WRITE_ENDPOINTS)
|
||||
|
||||
@unittest.skipIf(os.name == "nt", "authoritative writer runs on POSIX")
|
||||
def test_approved_base_is_ancestor_even_when_main_drifts(self):
|
||||
with tempfile.TemporaryDirectory() as root:
|
||||
workspace = Path(root) / "writer"
|
||||
workspace.mkdir()
|
||||
subprocess.run(["git", "init"], cwd=workspace, check=True, capture_output=True)
|
||||
subprocess.run(
|
||||
["git", "config", "user.email", "task-plane@example.invalid"],
|
||||
cwd=workspace,
|
||||
check=True,
|
||||
)
|
||||
subprocess.run(
|
||||
["git", "config", "user.name", "Task Plane Test"],
|
||||
cwd=workspace,
|
||||
check=True,
|
||||
)
|
||||
(workspace / "README.md").write_text("base\n", encoding="utf-8")
|
||||
subprocess.run(["git", "add", "README.md"], cwd=workspace, check=True)
|
||||
subprocess.run(["git", "commit", "-m", "base"], cwd=workspace, check=True, capture_output=True)
|
||||
base = subprocess.check_output(
|
||||
["git", "rev-parse", "HEAD"], cwd=workspace, text=True
|
||||
).strip()
|
||||
branch = os.environ["AIOS_GITOPS_ALLOWED_BRANCH"]
|
||||
subprocess.run(["git", "checkout", "-b", branch], cwd=workspace, check=True, capture_output=True)
|
||||
(workspace / "README.md").write_text("branch\n", encoding="utf-8")
|
||||
subprocess.run(["git", "commit", "-am", "branch"], cwd=workspace, check=True, capture_output=True)
|
||||
os.environ.update(
|
||||
{
|
||||
"AIOS_GITOPS_ALLOWED_BASE_OID": base,
|
||||
"AIOS_GITOPS_WRITES_ENABLED": "true",
|
||||
"AIOS_GITOPS_RUNTIME_ROLE": "isolated-writer",
|
||||
"AIOS_GITOPS_WORKSPACE_ROLE": "isolated-writer",
|
||||
"AIOS_GITOPS_REPOSITORY_IDENTITY": "aios/aios",
|
||||
"AIOS_GITOPS_AUTHORITATIVE_GIT_DIR": str(workspace / ".git"),
|
||||
"AIOS_GITOPS_APPROVED_WRITER_ROOT": str(Path(root)),
|
||||
}
|
||||
)
|
||||
for name in policy._DENY_FLAGS:
|
||||
os.environ[name] = "false"
|
||||
policy.require_service_invariants(workspace, workspace / ".git")
|
||||
|
||||
@unittest.skipIf(os.name == "nt", "POSIX audit mode and O_NOFOLLOW contract")
|
||||
def test_audit_path_is_contained_durable_and_redacted(self):
|
||||
with tempfile.TemporaryDirectory() as root:
|
||||
approved = Path(root) / "approved"
|
||||
approved.mkdir(mode=0o750)
|
||||
log = approved / "writer.jsonl"
|
||||
os.environ["AIOS_GITOPS_APPROVED_AUDIT_ROOT"] = str(approved)
|
||||
os.environ["AIOS_GITOPS_AUDIT_LOG"] = str(log)
|
||||
policy.append_audit_record(
|
||||
{
|
||||
"action": "commit",
|
||||
"Authorization": "Bearer must-not-appear",
|
||||
"payload": "token=must-not-appear",
|
||||
}
|
||||
)
|
||||
text = log.read_text(encoding="utf-8")
|
||||
self.assertNotIn("must-not-appear", text)
|
||||
self.assertEqual(0o600, log.stat().st_mode & 0o777)
|
||||
os.environ["AIOS_GITOPS_AUDIT_LOG"] = str(Path(root) / "escape.jsonl")
|
||||
with self.assertRaises(PermissionError):
|
||||
policy.approved_audit_log_path()
|
||||
|
||||
|
||||
class SecretScannerBoundaryTests(unittest.TestCase):
|
||||
def test_task_control_plane_branch_is_not_an_api_key(self):
|
||||
import aios_chatgpt_actions_api as api
|
||||
|
||||
payload = (
|
||||
'{"branch":"patch/aios-agent-task-control-plane-20260724",'
|
||||
'"created_by":"agent-task-plane-writer"}'
|
||||
)
|
||||
self.assertFalse(api.content_has_secret(payload))
|
||||
|
||||
def test_real_openai_style_key_is_still_rejected(self):
|
||||
import aios_chatgpt_actions_api as api
|
||||
|
||||
payload = '{"value":"sk-abcdefghijklmnopqrstuvwxyz123456"}'
|
||||
self.assertTrue(api.content_has_secret(payload))
|
||||
@@ -1,471 +0,0 @@
|
||||
import hashlib
|
||||
import json
|
||||
import os
|
||||
import sqlite3
|
||||
import subprocess
|
||||
import sys
|
||||
import tempfile
|
||||
import threading
|
||||
import time
|
||||
import unittest
|
||||
from dataclasses import dataclass
|
||||
from datetime import datetime, timedelta, timezone
|
||||
from pathlib import Path
|
||||
|
||||
sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "active-runtime" / "app"))
|
||||
|
||||
import aios_isolated_writer_policy as policy
|
||||
from isolated_writer_authz import AuthorizationError, authorize, operation_for
|
||||
from isolated_writer_commit_file import (
|
||||
AtomicCommitFile,
|
||||
CommitFileError,
|
||||
OperationLedger,
|
||||
SimulatedCrash,
|
||||
)
|
||||
from isolated_writer_token_registry import TokenRegistry, token_digest
|
||||
|
||||
|
||||
BRANCH = "patch/codex-review-test-worker-20260724"
|
||||
AUDIENCE = "aios-codex-review-worker-writer.service"
|
||||
TASK_ID = "AIOS-CODEX-WRITER-SMOKE-20260724"
|
||||
TARGET_PATH = "docs/reliability/codex-review-worker-writer-smoke.json"
|
||||
|
||||
|
||||
def run(cwd, *args):
|
||||
return subprocess.check_output(args, cwd=cwd, text=True).strip()
|
||||
|
||||
|
||||
@dataclass
|
||||
class DummyGrant:
|
||||
token_id: str = "test-token-id"
|
||||
task_id: str = TASK_ID
|
||||
operation: str = "commit_file.atomic"
|
||||
record: dict = None
|
||||
|
||||
def __post_init__(self):
|
||||
if self.record is None:
|
||||
self.record = {"audience": AUDIENCE, "_source_ip": "127.0.0.1"}
|
||||
|
||||
|
||||
class RepositoryCase(unittest.TestCase):
|
||||
def setUp(self):
|
||||
self.saved = dict(os.environ)
|
||||
self.temp = tempfile.TemporaryDirectory()
|
||||
self.root = Path(self.temp.name)
|
||||
self.authoritative = self.root / "authoritative.git"
|
||||
self.gitea = self.root / "gitea.git"
|
||||
self.seed = self.root / "seed"
|
||||
self.workspace = self.root / "writer"
|
||||
subprocess.run(["git", "init", "--bare", str(self.authoritative)], check=True, capture_output=True)
|
||||
subprocess.run(["git", "init", str(self.seed)], check=True, capture_output=True)
|
||||
subprocess.run(["git", "config", "user.email", "writer@example.invalid"], cwd=self.seed, check=True)
|
||||
subprocess.run(["git", "config", "user.name", "Writer Test"], cwd=self.seed, check=True)
|
||||
(self.seed / "README.md").write_text("base\n", encoding="utf-8")
|
||||
subprocess.run(["git", "add", "README.md"], cwd=self.seed, check=True)
|
||||
subprocess.run(["git", "commit", "-m", "base"], cwd=self.seed, check=True, capture_output=True)
|
||||
subprocess.run(["git", "branch", "-M", "main"], cwd=self.seed, check=True)
|
||||
subprocess.run(["git", "remote", "add", "origin", str(self.authoritative)], cwd=self.seed, check=True)
|
||||
subprocess.run(["git", "push", "origin", "main"], cwd=self.seed, check=True, capture_output=True)
|
||||
self.base = run(self.seed, "git", "rev-parse", "HEAD")
|
||||
subprocess.run(["git", "checkout", "-b", BRANCH], cwd=self.seed, check=True, capture_output=True)
|
||||
subprocess.run(["git", "push", "origin", BRANCH], cwd=self.seed, check=True, capture_output=True)
|
||||
subprocess.run(
|
||||
["git", "--git-dir", str(self.authoritative), "worktree", "add", str(self.workspace), BRANCH],
|
||||
check=True,
|
||||
capture_output=True,
|
||||
)
|
||||
subprocess.run(["git", "config", "user.email", "writer@example.invalid"], cwd=self.workspace, check=True)
|
||||
subprocess.run(["git", "config", "user.name", "Writer Test"], cwd=self.workspace, check=True)
|
||||
subprocess.run(["git", "clone", "--bare", str(self.authoritative), str(self.gitea)], check=True, capture_output=True)
|
||||
subprocess.run(["git", "remote", "add", "gitea-http", str(self.gitea)], cwd=self.workspace, check=True)
|
||||
self.registry = TokenRegistry(self.root / "registry.sqlite3")
|
||||
os.environ.update({
|
||||
"AIOS_GITOPS_ALLOWED_BRANCH": BRANCH,
|
||||
"AIOS_GITOPS_TOKEN_POLICY_VERSION_REQUIRED": "2",
|
||||
"AIOS_GITOPS_SERVICE_AUDIENCE": AUDIENCE,
|
||||
"AIOS_GITOPS_ISOLATED_WRITER_ENFORCEMENT": "required",
|
||||
})
|
||||
|
||||
def tearDown(self):
|
||||
os.environ.clear()
|
||||
os.environ.update(self.saved)
|
||||
self.temp.cleanup()
|
||||
|
||||
def grant(self, **updates):
|
||||
now = datetime.now(timezone.utc)
|
||||
grant = {
|
||||
"token_id": "smoke-" + hashlib.sha256(os.urandom(16)).hexdigest()[:12],
|
||||
"audience": AUDIENCE,
|
||||
"task_id": TASK_ID,
|
||||
"source_cidrs": ["127.0.0.1/32", "::1/128"],
|
||||
"allowed_branch": BRANCH,
|
||||
"approved_base_oid": self.base,
|
||||
"allowed_operations": [
|
||||
"runtime.status.read",
|
||||
"baseline.read",
|
||||
"patches.read",
|
||||
"commit_file.atomic",
|
||||
],
|
||||
"allowed_paths": [TARGET_PATH],
|
||||
"not_before": (now - timedelta(seconds=2)).isoformat(),
|
||||
"expires_at": (now + timedelta(minutes=20)).isoformat(),
|
||||
"max_uses": {
|
||||
"runtime.status.read": 2,
|
||||
"baseline.read": 2,
|
||||
"patches.read": 2,
|
||||
"commit_file.atomic": 4,
|
||||
},
|
||||
"issued_by": "owner-authorized-local-maintenance-executor",
|
||||
"created_at": (now - timedelta(seconds=3)).isoformat(),
|
||||
}
|
||||
grant.update(updates)
|
||||
return grant
|
||||
|
||||
def issue(self, **updates):
|
||||
return self.registry.issue(self.grant(**updates))
|
||||
|
||||
def auth(self, token, **updates):
|
||||
args = {
|
||||
"method": "GET",
|
||||
"path": "/api/runtime-status",
|
||||
"source_ip": "127.0.0.1",
|
||||
"workspace": self.workspace,
|
||||
}
|
||||
args.update(updates)
|
||||
return authorize(self.registry, token, **args)
|
||||
|
||||
def request(self, key="writer-smoke-0001", content='{"status":"READY"}\n'):
|
||||
return {
|
||||
"branch": BRANCH,
|
||||
"path": TARGET_PATH,
|
||||
"content": content,
|
||||
"message": "chore(task-plane): verify Codex writer endpoint",
|
||||
"expected_head_oid": run(self.workspace, "git", "rev-parse", "HEAD"),
|
||||
"idempotency_key": key,
|
||||
}
|
||||
|
||||
def writer(self, crash=None, remote="gitea-http", audit=None):
|
||||
return AtomicCommitFile(
|
||||
workspace=self.workspace,
|
||||
bare_repo=self.authoritative,
|
||||
ledger=OperationLedger(self.root / "operations.sqlite3"),
|
||||
remote=remote,
|
||||
audit=audit or (lambda record: None),
|
||||
crash_after_state=crash,
|
||||
)
|
||||
|
||||
|
||||
class TokenPolicyV2Tests(RepositoryCase):
|
||||
def test_v1_coarse_scope_token_is_rejected(self):
|
||||
token, record = self.issue()
|
||||
record["schema_version"] = 1
|
||||
with self.registry._connect() as db:
|
||||
db.execute(
|
||||
"UPDATE token_grants SET grant_json=? WHERE token_id=?",
|
||||
(json.dumps(record), record["token_id"]),
|
||||
)
|
||||
with self.assertRaisesRegex(AuthorizationError, "writer_token_policy_v2_required"):
|
||||
self.auth(token)
|
||||
|
||||
def test_audience_mismatch_is_rejected(self):
|
||||
token, _ = self.issue(audience="other.service")
|
||||
with self.assertRaisesRegex(AuthorizationError, "writer_token_audience_rejected"):
|
||||
self.auth(token)
|
||||
|
||||
def test_source_ip_mismatch_is_rejected(self):
|
||||
token, _ = self.issue(source_cidrs=["192.0.2.0/24"])
|
||||
with self.assertRaisesRegex(AuthorizationError, "writer_token_source_rejected"):
|
||||
self.auth(token)
|
||||
|
||||
def test_branch_mismatch_is_rejected(self):
|
||||
token, _ = self.issue(allowed_branch="patch/other")
|
||||
with self.assertRaisesRegex(AuthorizationError, "writer_token_branch_rejected"):
|
||||
self.auth(token)
|
||||
|
||||
def test_operation_mismatch_is_rejected(self):
|
||||
token, _ = self.issue(allowed_operations=["baseline.read"])
|
||||
with self.assertRaisesRegex(AuthorizationError, "writer_token_operation_rejected"):
|
||||
self.auth(token)
|
||||
|
||||
def test_path_mismatch_is_rejected(self):
|
||||
token, _ = self.issue()
|
||||
with self.assertRaisesRegex(AuthorizationError, "writer_token_path_rejected"):
|
||||
self.auth(
|
||||
token,
|
||||
method="POST",
|
||||
path="/api/commit-file",
|
||||
branch=BRANCH,
|
||||
target_path="docs/other.json",
|
||||
)
|
||||
|
||||
def test_expired_token_is_rejected(self):
|
||||
now = datetime.now(timezone.utc)
|
||||
token, _ = self.issue(
|
||||
created_at=(now - timedelta(minutes=10)).isoformat(),
|
||||
not_before=(now - timedelta(minutes=9)).isoformat(),
|
||||
expires_at=(now - timedelta(seconds=1)).isoformat(),
|
||||
)
|
||||
with self.assertRaisesRegex(AuthorizationError, "writer_token_expired"):
|
||||
self.auth(token)
|
||||
|
||||
def test_not_before_token_is_rejected(self):
|
||||
now = datetime.now(timezone.utc)
|
||||
token, _ = self.issue(
|
||||
created_at=now.isoformat(),
|
||||
not_before=(now + timedelta(minutes=1)).isoformat(),
|
||||
expires_at=(now + timedelta(minutes=5)).isoformat(),
|
||||
)
|
||||
with self.assertRaisesRegex(AuthorizationError, "writer_token_not_yet_valid"):
|
||||
self.auth(token)
|
||||
|
||||
def test_revoked_token_is_rejected(self):
|
||||
token, grant = self.issue()
|
||||
self.assertTrue(self.registry.revoke(grant["token_id"]))
|
||||
with self.assertRaisesRegex(AuthorizationError, "writer_token_revoked"):
|
||||
self.auth(token)
|
||||
|
||||
def test_operation_use_count_is_atomic_and_exhausted(self):
|
||||
token, _ = self.issue(max_uses={
|
||||
"runtime.status.read": 1,
|
||||
"baseline.read": 1,
|
||||
"patches.read": 1,
|
||||
"commit_file.atomic": 1,
|
||||
})
|
||||
self.auth(token)
|
||||
with self.assertRaisesRegex(AuthorizationError, "writer_token_operation_exhausted"):
|
||||
self.auth(token)
|
||||
|
||||
def test_concurrent_use_count_never_exceeds_limit(self):
|
||||
token, _ = self.issue(max_uses={
|
||||
"runtime.status.read": 2,
|
||||
"baseline.read": 1,
|
||||
"patches.read": 1,
|
||||
"commit_file.atomic": 1,
|
||||
})
|
||||
successes, failures = [], []
|
||||
|
||||
def invoke():
|
||||
try:
|
||||
successes.append(self.auth(token))
|
||||
except AuthorizationError as exc:
|
||||
failures.append(exc.code)
|
||||
|
||||
threads = [threading.Thread(target=invoke) for _ in range(6)]
|
||||
for thread in threads:
|
||||
thread.start()
|
||||
for thread in threads:
|
||||
thread.join()
|
||||
self.assertEqual(2, len(successes))
|
||||
self.assertEqual(4, failures.count("writer_token_operation_exhausted"))
|
||||
|
||||
def test_registry_does_not_store_plaintext_token(self):
|
||||
token, _ = self.issue()
|
||||
registry_bytes = b"".join(
|
||||
item.read_bytes()
|
||||
for item in self.registry.path.parent.glob(self.registry.path.name + "*")
|
||||
if item.is_file()
|
||||
)
|
||||
self.assertNotIn(token.encode(), registry_bytes)
|
||||
with self.registry._connect() as db:
|
||||
stored = db.execute("SELECT token_digest FROM token_grants").fetchone()[0]
|
||||
self.assertEqual(token_digest(token), stored)
|
||||
|
||||
def test_coarse_routes_have_no_operation_mapping(self):
|
||||
for path in ("/api/file", "/api/commit", "/api/tag", "/api/rollback", "/api/model"):
|
||||
with self.subTest(path=path), self.assertRaises(AuthorizationError) as captured:
|
||||
operation_for("POST", path)
|
||||
self.assertEqual(403, captured.exception.status)
|
||||
|
||||
def test_route_mapping_is_fixed_not_request_controlled(self):
|
||||
self.assertEqual("runtime.status.read", operation_for("GET", "/api/runtime-status"))
|
||||
self.assertEqual("baseline.read", operation_for("GET", "/api/baseline"))
|
||||
self.assertEqual("patches.read", operation_for("GET", "/api/patches"))
|
||||
self.assertEqual("commit_file.atomic", operation_for("POST", "/api/commit-file"))
|
||||
|
||||
def test_x_forwarded_for_cannot_replace_socket_peer(self):
|
||||
token, _ = self.issue(source_cidrs=["203.0.113.9/32"])
|
||||
with self.assertRaisesRegex(AuthorizationError, "writer_token_source_rejected"):
|
||||
self.auth(token, source_ip="127.0.0.1")
|
||||
|
||||
|
||||
class AtomicCommitFileTests(RepositoryCase):
|
||||
def test_commit_file_succeeds_and_verifies_bare_and_gitea(self):
|
||||
result = self.writer().execute(DummyGrant(), self.request())
|
||||
self.assertEqual("COMPLETED", result["state"])
|
||||
self.assertEqual(
|
||||
result["commit_oid"],
|
||||
run(self.root, "git", "--git-dir", str(self.gitea), "rev-parse", f"refs/heads/{BRANCH}"),
|
||||
)
|
||||
|
||||
def test_same_idempotency_key_returns_same_commit(self):
|
||||
request = self.request()
|
||||
first = self.writer().execute(DummyGrant(), request)
|
||||
count = run(self.workspace, "git", "rev-list", "--count", "HEAD")
|
||||
second = self.writer().execute(DummyGrant(), request)
|
||||
self.assertEqual(first["commit_oid"], second["commit_oid"])
|
||||
self.assertEqual(count, run(self.workspace, "git", "rev-list", "--count", "HEAD"))
|
||||
self.assertTrue(second["idempotent"])
|
||||
|
||||
def test_same_key_with_different_payload_returns_409(self):
|
||||
request = self.request()
|
||||
self.writer().execute(DummyGrant(), request)
|
||||
request["content"] = '{"status":"DIFFERENT"}\n'
|
||||
with self.assertRaises(CommitFileError) as captured:
|
||||
self.writer().execute(DummyGrant(), request)
|
||||
self.assertEqual(409, captured.exception.status)
|
||||
|
||||
def test_same_key_from_different_task_returns_409(self):
|
||||
request = self.request()
|
||||
self.writer().execute(DummyGrant(), request)
|
||||
other = DummyGrant(token_id="other-token", task_id="OTHER-TASK")
|
||||
with self.assertRaisesRegex(CommitFileError, "writer_idempotency_owner_conflict"):
|
||||
self.writer().execute(other, request)
|
||||
|
||||
def test_file_written_crash_is_recoverable(self):
|
||||
request = self.request()
|
||||
with self.assertRaises(SimulatedCrash):
|
||||
self.writer(crash="FILE_WRITTEN").execute(DummyGrant(), request)
|
||||
result = self.writer().execute(DummyGrant(), request)
|
||||
self.assertEqual("COMPLETED", result["state"])
|
||||
|
||||
def test_committed_crash_is_recoverable_without_second_commit(self):
|
||||
request = self.request()
|
||||
with self.assertRaises(SimulatedCrash):
|
||||
self.writer(crash="COMMITTED").execute(DummyGrant(), request)
|
||||
committed = run(self.workspace, "git", "rev-parse", "HEAD")
|
||||
result = self.writer().execute(DummyGrant(), request)
|
||||
self.assertEqual(committed, result["commit_oid"])
|
||||
|
||||
def test_pushed_crash_only_reverifies(self):
|
||||
request = self.request()
|
||||
with self.assertRaises(SimulatedCrash):
|
||||
self.writer(crash="PUSHED").execute(DummyGrant(), request)
|
||||
result = self.writer().execute(DummyGrant(), request)
|
||||
self.assertEqual("COMPLETED", result["state"])
|
||||
|
||||
def test_push_failure_is_failed_recoverable(self):
|
||||
request = self.request()
|
||||
with self.assertRaisesRegex(CommitFileError, "writer_gitea_push_failed"):
|
||||
self.writer(remote="missing-remote").execute(DummyGrant(), request)
|
||||
row = OperationLedger(self.root / "operations.sqlite3").get(request["idempotency_key"])
|
||||
self.assertEqual("FAILED_RECOVERABLE", row["state"])
|
||||
|
||||
def test_branch_head_conflict_requires_manual_review(self):
|
||||
request = self.request()
|
||||
ledger = OperationLedger(self.root / "operations.sqlite3")
|
||||
ledger.get_or_create(DummyGrant(), request, __import__("isolated_writer_commit_file").canonical_digest(request))
|
||||
(self.workspace / "README.md").write_text("drift\n", encoding="utf-8")
|
||||
subprocess.run(["git", "commit", "-am", "drift"], cwd=self.workspace, check=True, capture_output=True)
|
||||
with self.assertRaisesRegex(CommitFileError, "writer_branch_head_conflict"):
|
||||
self.writer().execute(DummyGrant(), request)
|
||||
self.assertEqual("MANUAL_REVIEW_REQUIRED", ledger.get(request["idempotency_key"])["state"])
|
||||
|
||||
def test_extra_staged_file_is_rejected(self):
|
||||
(self.workspace / "README.md").write_text("staged\n", encoding="utf-8")
|
||||
subprocess.run(["git", "add", "README.md"], cwd=self.workspace, check=True)
|
||||
with self.assertRaisesRegex(CommitFileError, "writer_extra_staged_files_rejected"):
|
||||
self.writer().execute(DummyGrant(), self.request())
|
||||
|
||||
def test_path_traversal_and_protected_roots_are_rejected(self):
|
||||
for path in (
|
||||
"../docs/x", "%2e%2e/docs/x", "/etc/x", r"C:\temp\x",
|
||||
r"\\server\share\x", "baseline/current.json", "runtime/x",
|
||||
):
|
||||
request = self.request(key="writer-path-" + hashlib.sha256(path.encode()).hexdigest()[:12])
|
||||
request["path"] = path
|
||||
with self.subTest(path=path), self.assertRaises((PermissionError, CommitFileError)):
|
||||
self.writer().execute(DummyGrant(), request)
|
||||
|
||||
def test_audit_contains_ids_but_not_content_or_authorization(self):
|
||||
records = []
|
||||
request = self.request(content='{"value":"non-secret-body-marker"}\n')
|
||||
self.writer(audit=records.append).execute(DummyGrant(), request)
|
||||
encoded = json.dumps(records)
|
||||
self.assertIn("test-token-id", encoded)
|
||||
self.assertNotIn("non-secret-body-marker", encoded)
|
||||
self.assertNotIn("Authorization", encoded)
|
||||
|
||||
def test_concurrent_same_idempotency_creates_one_commit(self):
|
||||
request = self.request()
|
||||
results, errors = [], []
|
||||
|
||||
def invoke():
|
||||
try:
|
||||
results.append(self.writer().execute(DummyGrant(), request))
|
||||
except Exception as exc:
|
||||
errors.append(exc)
|
||||
|
||||
threads = [threading.Thread(target=invoke) for _ in range(4)]
|
||||
for thread in threads:
|
||||
thread.start()
|
||||
for thread in threads:
|
||||
thread.join()
|
||||
self.assertFalse(errors)
|
||||
self.assertEqual(1, len({item["commit_oid"] for item in results}))
|
||||
|
||||
def test_different_operations_are_serialized_by_branch_lock(self):
|
||||
active = 0
|
||||
maximum = 0
|
||||
guard = threading.Lock()
|
||||
|
||||
class Probe(AtomicCommitFile):
|
||||
def _execute_locked(inner, grant, data, digest):
|
||||
nonlocal active, maximum
|
||||
with guard:
|
||||
active += 1
|
||||
maximum = max(maximum, active)
|
||||
time.sleep(0.05)
|
||||
with guard:
|
||||
active -= 1
|
||||
return {"state": "PROBED"}
|
||||
|
||||
probe = Probe(
|
||||
workspace=self.workspace,
|
||||
bare_repo=self.authoritative,
|
||||
ledger=OperationLedger(self.root / "probe.sqlite3"),
|
||||
remote="gitea-http",
|
||||
audit=lambda record: None,
|
||||
)
|
||||
requests = [self.request(key=f"writer-lock-{index:04d}") for index in range(3)]
|
||||
threads = [threading.Thread(target=probe.execute, args=(DummyGrant(), item)) for item in requests]
|
||||
for thread in threads:
|
||||
thread.start()
|
||||
for thread in threads:
|
||||
thread.join()
|
||||
self.assertEqual(1, maximum)
|
||||
|
||||
def test_invalid_expected_head_and_idempotency_are_rejected(self):
|
||||
request = self.request()
|
||||
request["expected_head_oid"] = "short"
|
||||
with self.assertRaisesRegex(CommitFileError, "writer_expected_head_rejected"):
|
||||
self.writer().execute(DummyGrant(), request)
|
||||
request = self.request()
|
||||
request["idempotency_key"] = "../bad"
|
||||
with self.assertRaisesRegex(CommitFileError, "writer_idempotency_key_rejected"):
|
||||
self.writer().execute(DummyGrant(), request)
|
||||
|
||||
def test_invalid_message_and_nul_content_are_rejected(self):
|
||||
request = self.request()
|
||||
request["message"] = "bad\nmessage"
|
||||
with self.assertRaisesRegex(CommitFileError, "writer_message_rejected"):
|
||||
self.writer().execute(DummyGrant(), request)
|
||||
request = self.request()
|
||||
request["content"] = "bad\x00content"
|
||||
with self.assertRaisesRegex(CommitFileError, "writer_content_rejected"):
|
||||
self.writer().execute(DummyGrant(), request)
|
||||
|
||||
def test_force_flags_are_403_and_unknown_fields_are_rejected(self):
|
||||
for field in ("force", "force_push"):
|
||||
request = self.request(key=f"writer-force-{field}")
|
||||
request[field] = True
|
||||
with self.subTest(field=field), self.assertRaises(CommitFileError) as captured:
|
||||
self.writer().execute(DummyGrant(), request)
|
||||
self.assertEqual(403, captured.exception.status)
|
||||
request = self.request(key="writer-extra-field")
|
||||
request["operation"] = "commit_file.atomic"
|
||||
with self.assertRaisesRegex(CommitFileError, "writer_request_fields_rejected"):
|
||||
self.writer().execute(DummyGrant(), request)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
@@ -1,728 +0,0 @@
|
||||
from __future__ import annotations
|
||||
|
||||
import dataclasses
|
||||
import json
|
||||
import sys
|
||||
import threading
|
||||
import urllib.request
|
||||
from datetime import datetime, timedelta, timezone
|
||||
from http.server import ThreadingHTTPServer
|
||||
from pathlib import Path
|
||||
|
||||
import pytest
|
||||
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"))
|
||||
sys.path.insert(0, str(ROOT / "scripts"))
|
||||
|
||||
from silent_release_hardening import ( # noqa: E402
|
||||
CapabilityAuthorizationError,
|
||||
CapabilityController,
|
||||
CapabilityLedger,
|
||||
ClaimProbeResult,
|
||||
ApprovalKeyRing,
|
||||
ApprovalRevocationStore,
|
||||
BuilderAttestationVerifier,
|
||||
DeploymentPlan,
|
||||
FinalizationPlan,
|
||||
ProbeEvidence,
|
||||
ReleasePlan,
|
||||
SignedApprovalVerifier,
|
||||
SignedReleasePlanApproval,
|
||||
SilentReleaseActionService,
|
||||
TagPlan,
|
||||
TagPublicationProbeEvidence,
|
||||
TrustedCandidateBundle,
|
||||
TrustedReleasePolicy,
|
||||
classify_tag_publication,
|
||||
)
|
||||
from silent_release_controller import ReleaseCandidate, ReleaseState # noqa: E402
|
||||
from silent_release_execution import ( # noqa: E402
|
||||
LocalTestApprovalSigner,
|
||||
LocalTestBuilderSigner,
|
||||
PersistentSilentReleaseController,
|
||||
ShadowActionHandler,
|
||||
SignedTrustedBuilderAdapter,
|
||||
UnavailableProductionApprovalBackend,
|
||||
)
|
||||
from build_silent_release_artifact import ( # noqa: E402
|
||||
redact_output,
|
||||
secret_scan,
|
||||
)
|
||||
|
||||
|
||||
COMMIT = "1" * 40
|
||||
TAG_OID = "2" * 40
|
||||
|
||||
|
||||
def approval() -> SignedReleasePlanApproval:
|
||||
return SignedReleasePlanApproval(
|
||||
release_plan_id="release-plan-readiness-001",
|
||||
candidate_id="rc-readiness-001",
|
||||
source_commit=COMMIT,
|
||||
tree_oid="3" * 40,
|
||||
artifact_sha256="4" * 64,
|
||||
manifest_sha256="5" * 64,
|
||||
deployment_plan_sha256="6" * 64,
|
||||
policy_sha256="7" * 64,
|
||||
approval_plan_id="owner-plan-readiness-001",
|
||||
evidence_closure_oid="8" * 40,
|
||||
owner_approval_record_oid="9" * 40,
|
||||
capabilities=(
|
||||
"runtime_switch",
|
||||
"tag_publish",
|
||||
"baseline_registry_finalize",
|
||||
),
|
||||
expires_at="2099-01-01T00:00:00Z",
|
||||
nonce="nonce-readiness-000000001",
|
||||
key_id="owner-key-readiness-1",
|
||||
signature="test-signature",
|
||||
)
|
||||
|
||||
|
||||
def tag_plan() -> TagPlan:
|
||||
return TagPlan(
|
||||
version="shadow-readiness-001",
|
||||
tag_type="annotated",
|
||||
expected_tag_oid=TAG_OID,
|
||||
expected_target_oid=COMMIT,
|
||||
evidence_closure_oid="8" * 40,
|
||||
approval_plan_id="owner-plan-readiness-001",
|
||||
repository_identity="aios/aios",
|
||||
gitea_owner="aios",
|
||||
gitea_repository="aios",
|
||||
current_remote_tag_oid=None,
|
||||
remote_absent_evidence_sha256="a" * 64,
|
||||
verification_contract="git+api+listing/v1",
|
||||
)
|
||||
|
||||
|
||||
def make_failed_claim(
|
||||
ledger: CapabilityLedger,
|
||||
*,
|
||||
operation: str,
|
||||
) -> dict:
|
||||
claimed = ledger.claim(
|
||||
approval(),
|
||||
"runtime_switch",
|
||||
operation=operation,
|
||||
executor_id="worker-initial",
|
||||
lease_seconds=10,
|
||||
now=100,
|
||||
)
|
||||
ledger.fail_recoverable(
|
||||
approval(),
|
||||
"runtime_switch",
|
||||
operation=operation,
|
||||
claim_id=claimed["claim_id"],
|
||||
reason="adapter_error",
|
||||
)
|
||||
return claimed
|
||||
|
||||
|
||||
def test_failed_recoverable_not_applied_retries_once(tmp_path):
|
||||
ledger = CapabilityLedger(
|
||||
tmp_path / "ledger", maximum_probe_age_seconds=30
|
||||
)
|
||||
make_failed_claim(ledger, operation="runtime-retry")
|
||||
calls: list[str] = []
|
||||
controller = CapabilityController(
|
||||
capability="runtime_switch",
|
||||
ledger=ledger,
|
||||
adapter=lambda: calls.append("adapter") or {"verified": True},
|
||||
recovery_probe=lambda: ClaimProbeResult.NOT_APPLIED,
|
||||
executor_id="worker-recovery",
|
||||
)
|
||||
|
||||
assert controller.execute(
|
||||
approval(), operation="runtime-retry"
|
||||
)["status"] == "EXECUTED"
|
||||
assert controller.execute(
|
||||
approval(), operation="runtime-retry"
|
||||
)["status"] == "IDEMPOTENT"
|
||||
assert calls == ["adapter"]
|
||||
|
||||
|
||||
def test_failed_recoverable_applied_verified_skips_adapter(tmp_path):
|
||||
ledger = CapabilityLedger(tmp_path / "ledger")
|
||||
make_failed_claim(ledger, operation="runtime-applied")
|
||||
calls: list[str] = []
|
||||
controller = CapabilityController(
|
||||
capability="runtime_switch",
|
||||
ledger=ledger,
|
||||
adapter=lambda: calls.append("adapter") or {"verified": True},
|
||||
recovery_probe=lambda: ClaimProbeResult.APPLIED_VERIFIED,
|
||||
executor_id="worker-recovery",
|
||||
)
|
||||
|
||||
assert controller.execute(
|
||||
approval(), operation="runtime-applied"
|
||||
)["status"] == "IDEMPOTENT"
|
||||
assert calls == []
|
||||
|
||||
|
||||
@pytest.mark.parametrize(
|
||||
("probe", "expected"),
|
||||
(
|
||||
(
|
||||
ClaimProbeResult.INDETERMINATE,
|
||||
"RECONCILIATION_REQUIRED",
|
||||
),
|
||||
(
|
||||
ClaimProbeResult.CONFLICT,
|
||||
"MANUAL_OWNER_REVIEW_REQUIRED",
|
||||
),
|
||||
),
|
||||
)
|
||||
def test_failed_recoverable_unknown_or_conflict_stops_writes(
|
||||
tmp_path, probe, expected
|
||||
):
|
||||
ledger = CapabilityLedger(tmp_path / "ledger")
|
||||
make_failed_claim(ledger, operation=f"runtime-{probe.value.lower()}")
|
||||
calls: list[str] = []
|
||||
controller = CapabilityController(
|
||||
capability="runtime_switch",
|
||||
ledger=ledger,
|
||||
adapter=lambda: calls.append("adapter") or {"verified": True},
|
||||
recovery_probe=lambda: probe,
|
||||
executor_id="worker-recovery",
|
||||
)
|
||||
|
||||
assert controller.execute(
|
||||
approval(), operation=f"runtime-{probe.value.lower()}"
|
||||
)["status"] == expected
|
||||
assert calls == []
|
||||
|
||||
|
||||
def test_probe_must_bind_operation_and_be_fresh(tmp_path):
|
||||
ledger = CapabilityLedger(
|
||||
tmp_path / "ledger", maximum_probe_age_seconds=10
|
||||
)
|
||||
make_failed_claim(ledger, operation="runtime-freshness")
|
||||
record = ledger.read(
|
||||
approval(), "runtime_switch", operation="runtime-freshness"
|
||||
)
|
||||
assert record is not None
|
||||
|
||||
with pytest.raises(
|
||||
CapabilityAuthorizationError, match="operation digest"
|
||||
):
|
||||
ledger.claim(
|
||||
approval(),
|
||||
"runtime_switch",
|
||||
operation="runtime-freshness",
|
||||
executor_id="worker-recovery",
|
||||
lease_seconds=10,
|
||||
now=120,
|
||||
side_effect_probe=lambda: ProbeEvidence(
|
||||
result=ClaimProbeResult.NOT_APPLIED,
|
||||
operation_digest="0" * 64,
|
||||
observed_at=120,
|
||||
),
|
||||
)
|
||||
|
||||
with pytest.raises(CapabilityAuthorizationError, match="freshness"):
|
||||
ledger.claim(
|
||||
approval(),
|
||||
"runtime_switch",
|
||||
operation="runtime-freshness",
|
||||
executor_id="worker-recovery",
|
||||
lease_seconds=10,
|
||||
now=120,
|
||||
side_effect_probe=lambda: ProbeEvidence(
|
||||
result=ClaimProbeResult.NOT_APPLIED,
|
||||
operation_digest=record["operation_digest"],
|
||||
observed_at=100,
|
||||
),
|
||||
)
|
||||
|
||||
|
||||
def test_probe_journal_is_hash_chained_and_tamper_fails_closed(tmp_path):
|
||||
ledger = CapabilityLedger(tmp_path / "ledger")
|
||||
make_failed_claim(ledger, operation="runtime-journal")
|
||||
ledger.claim(
|
||||
approval(),
|
||||
"runtime_switch",
|
||||
operation="runtime-journal",
|
||||
executor_id="worker-recovery",
|
||||
lease_seconds=10,
|
||||
now=101,
|
||||
side_effect_probe=lambda: ClaimProbeResult.INDETERMINATE,
|
||||
)
|
||||
operation_path = ledger._operation_path(
|
||||
approval(), "runtime_switch", "runtime-journal"
|
||||
)
|
||||
records = ledger.verify_probe_journal(operation_path)
|
||||
assert records[0]["payload"]["result"] == "INDETERMINATE"
|
||||
journal = ledger._probe_journal_path(operation_path)
|
||||
payload = json.loads(journal.read_text(encoding="utf-8"))
|
||||
payload["payload"]["result"] = "NOT_APPLIED"
|
||||
journal.write_text(json.dumps(payload) + "\n", encoding="utf-8")
|
||||
with pytest.raises(Exception, match="hash chain"):
|
||||
ledger.verify_probe_journal(operation_path)
|
||||
|
||||
|
||||
def tag_evidence(**overrides) -> TagPublicationProbeEvidence:
|
||||
values = {
|
||||
"repository_identity": "aios/aios",
|
||||
"remote_reachable": True,
|
||||
"gitea_api_reachable": True,
|
||||
"gitea_listing_reachable": True,
|
||||
"remote_tag_oid": TAG_OID,
|
||||
"annotated_tag_object_oid": TAG_OID,
|
||||
"remote_peeled_target_oid": COMMIT,
|
||||
"gitea_api_tag_oid": TAG_OID,
|
||||
"gitea_api_peeled_target_oid": COMMIT,
|
||||
"gitea_listing_visible": True,
|
||||
"gitea_listing_tag_oid": TAG_OID,
|
||||
"gitea_listing_peeled_target_oid": COMMIT,
|
||||
"observed_at": 100,
|
||||
}
|
||||
values.update(overrides)
|
||||
return TagPublicationProbeEvidence(**values)
|
||||
|
||||
|
||||
def test_tag_probe_exact_absence_is_not_applied():
|
||||
evidence = tag_evidence(
|
||||
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,
|
||||
)
|
||||
assert (
|
||||
classify_tag_publication(evidence, tag_plan())
|
||||
== ClaimProbeResult.NOT_APPLIED
|
||||
)
|
||||
|
||||
|
||||
def test_tag_probe_exact_publication_is_applied_verified():
|
||||
assert (
|
||||
classify_tag_publication(tag_evidence(), tag_plan())
|
||||
== ClaimProbeResult.APPLIED_VERIFIED
|
||||
)
|
||||
|
||||
|
||||
def test_tag_probe_unavailable_or_divergent_is_indeterminate():
|
||||
assert (
|
||||
classify_tag_publication(
|
||||
tag_evidence(gitea_api_reachable=False), tag_plan()
|
||||
)
|
||||
== ClaimProbeResult.INDETERMINATE
|
||||
)
|
||||
assert (
|
||||
classify_tag_publication(
|
||||
tag_evidence(gitea_listing_tag_oid=None), tag_plan()
|
||||
)
|
||||
== ClaimProbeResult.INDETERMINATE
|
||||
)
|
||||
|
||||
|
||||
def test_tag_probe_same_name_different_oid_is_conflict():
|
||||
assert (
|
||||
classify_tag_publication(
|
||||
tag_evidence(remote_tag_oid="f" * 40), tag_plan()
|
||||
)
|
||||
== ClaimProbeResult.CONFLICT
|
||||
)
|
||||
assert (
|
||||
classify_tag_publication(
|
||||
tag_evidence(remote_peeled_target_oid="e" * 40), tag_plan()
|
||||
)
|
||||
== ClaimProbeResult.CONFLICT
|
||||
)
|
||||
|
||||
|
||||
def readiness_release_plan(source_commit: str = COMMIT) -> ReleasePlan:
|
||||
policy_sha = "7" * 64
|
||||
return ReleasePlan(
|
||||
deployment=DeploymentPlan(
|
||||
service="aios-silent-release-controller",
|
||||
release_path="/usr/libexec/aios-silent-release-shadow/release-1",
|
||||
release_root="/usr/libexec/aios-silent-release-shadow",
|
||||
cutover_link="/usr/libexec/aios-silent-release-shadow/current",
|
||||
dropin_path=(
|
||||
"/usr/libexec/aios-silent-release-shadow/release-1/"
|
||||
"deploy/systemd/aios-silent-release-controller.service"
|
||||
),
|
||||
dropin_sha256="a" * 64,
|
||||
systemd_unit_sha256="a" * 64,
|
||||
rollback_path=(
|
||||
"/usr/libexec/aios-silent-release-shadow/rollback-1"
|
||||
),
|
||||
rollback_sha256="b" * 64,
|
||||
source_commit=source_commit,
|
||||
tree_oid="3" * 40,
|
||||
artifact_sha256="4" * 64,
|
||||
manifest_sha256="5" * 64,
|
||||
package_closure_sha256="c" * 64,
|
||||
authoritative_git_dir="/data/aios-gitops/repo.git",
|
||||
repository_identity="aios/aios",
|
||||
writer_expected=False,
|
||||
baseline_before_sha256="d" * 64,
|
||||
registry_before_sha256="e" * 64,
|
||||
production_tag_refset_before_sha256="f" * 64,
|
||||
health_contract_version="shadow-health/v1",
|
||||
timeout_policy={"health_seconds": 10},
|
||||
retry_policy={"health_attempts": 1},
|
||||
policy_sha256=policy_sha,
|
||||
health_contract={"shadow_mode": True},
|
||||
),
|
||||
tag=TagPlan(
|
||||
version="shadow-readiness-001",
|
||||
tag_type="annotated",
|
||||
expected_tag_oid=TAG_OID,
|
||||
expected_target_oid=source_commit,
|
||||
evidence_closure_oid="8" * 40,
|
||||
approval_plan_id="owner-plan-readiness-001",
|
||||
repository_identity="aios/aios",
|
||||
gitea_owner="aios",
|
||||
gitea_repository="aios",
|
||||
current_remote_tag_oid=None,
|
||||
remote_absent_evidence_sha256="a" * 64,
|
||||
verification_contract="shadow-only/v1",
|
||||
),
|
||||
finalization=FinalizationPlan(
|
||||
version="shadow-readiness-001",
|
||||
expected_tag_oid=TAG_OID,
|
||||
expected_target_oid=source_commit,
|
||||
expected_previous_baseline_sha256="d" * 64,
|
||||
registry_expected_record={
|
||||
"shadow": True,
|
||||
"target_oid": source_commit,
|
||||
},
|
||||
baseline_expected_record={
|
||||
"shadow": True,
|
||||
"target_oid": source_commit,
|
||||
},
|
||||
final_consistency_contract="shadow-simulated/v1",
|
||||
),
|
||||
policy_sha256=policy_sha,
|
||||
)
|
||||
|
||||
|
||||
def readiness_candidate(source_commit: str = COMMIT) -> ReleaseCandidate:
|
||||
return ReleaseCandidate(
|
||||
candidate_id="rc-shadow-" + source_commit[:12],
|
||||
source_commit=source_commit,
|
||||
tree_oid="3" * 40,
|
||||
artifact_sha256="4" * 64,
|
||||
manifest_sha256="5" * 64,
|
||||
tests={"passed": True, "source": "trusted-builder"},
|
||||
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 trusted_service(tmp_path):
|
||||
builder_signer = LocalTestBuilderSigner.generate()
|
||||
builder_public = builder_signer.public_key.public_bytes(
|
||||
serialization.Encoding.Raw,
|
||||
serialization.PublicFormat.Raw,
|
||||
)
|
||||
|
||||
def collector(intent):
|
||||
source_commit = str(intent["source_commit"])
|
||||
return TrustedCandidateBundle(
|
||||
candidate=readiness_candidate(source_commit),
|
||||
release_plan=readiness_release_plan(source_commit),
|
||||
checks={
|
||||
"authoritative_git": True,
|
||||
"artifact": True,
|
||||
"canary": True,
|
||||
"gitea": True,
|
||||
"manifest": True,
|
||||
"package_closure": True,
|
||||
"rollback": True,
|
||||
"secret_scan": True,
|
||||
"tests": True,
|
||||
},
|
||||
)
|
||||
|
||||
owner_private = Ed25519PrivateKey.generate()
|
||||
owner_public = owner_private.public_key().public_bytes(
|
||||
serialization.Encoding.Raw,
|
||||
serialization.PublicFormat.Raw,
|
||||
)
|
||||
verifier = SignedApprovalVerifier(
|
||||
ApprovalKeyRing({"shadow-owner-test-key": owner_public}),
|
||||
ApprovalRevocationStore(tmp_path / "revocations"),
|
||||
allowed_trust_domains={"aios.shadow"},
|
||||
)
|
||||
policy = TrustedReleasePolicy(
|
||||
services=frozenset({"aios-silent-release-controller"}),
|
||||
release_roots=frozenset(
|
||||
{"/usr/libexec/aios-silent-release-shadow"}
|
||||
),
|
||||
cutover_links=frozenset(
|
||||
{"/usr/libexec/aios-silent-release-shadow/current"}
|
||||
),
|
||||
dropin_paths=frozenset(
|
||||
{
|
||||
"/usr/libexec/aios-silent-release-shadow/release-1/"
|
||||
"deploy/systemd/aios-silent-release-controller.service"
|
||||
}
|
||||
),
|
||||
authoritative_git_dirs=frozenset(
|
||||
{"/data/aios-gitops/repo.git"}
|
||||
),
|
||||
repository_identities=frozenset({"aios/aios"}),
|
||||
)
|
||||
service = SilentReleaseActionService(
|
||||
tmp_path / "state",
|
||||
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="aios/aios",
|
||||
policy_sha256="7" * 64,
|
||||
)
|
||||
return service, LocalTestApprovalSigner(
|
||||
"shadow-owner-test-key", owner_private
|
||||
)
|
||||
|
||||
|
||||
def signed_shadow_approval(
|
||||
service: SilentReleaseActionService,
|
||||
signer: LocalTestApprovalSigner,
|
||||
candidate_id: str,
|
||||
) -> SignedReleasePlanApproval:
|
||||
candidate = service.candidates.load(candidate_id)
|
||||
plan = service.release_plans.load(candidate_id)
|
||||
now = datetime.now(timezone.utc)
|
||||
value = SignedReleasePlanApproval(
|
||||
release_plan_id="release-plan-shadow-readiness-001",
|
||||
candidate_id=candidate_id,
|
||||
source_commit=candidate.source_commit,
|
||||
tree_oid=candidate.tree_oid,
|
||||
artifact_sha256=candidate.artifact_sha256,
|
||||
manifest_sha256=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="9" * 40,
|
||||
capabilities=(
|
||||
"runtime_switch",
|
||||
"tag_publish",
|
||||
"baseline_registry_finalize",
|
||||
),
|
||||
owner_identity="owner:shadow-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=5))
|
||||
.isoformat()
|
||||
.replace("+00:00", "Z"),
|
||||
nonce="nonce-shadow-readiness-000001",
|
||||
key_id="shadow-owner-test-key",
|
||||
signature="",
|
||||
)
|
||||
return signer.sign(value)
|
||||
|
||||
|
||||
def test_trusted_builder_attestation_and_caller_evidence_gate(tmp_path):
|
||||
service, _ = trusted_service(tmp_path)
|
||||
result = service.create_release_intent(
|
||||
{"event_id": "webhook-main-001", "source_commit": COMMIT}
|
||||
)
|
||||
acceptance = service.get_acceptance(result["candidate_id"])
|
||||
assert acceptance["attestation"]["builder_attestation_id"].startswith(
|
||||
"builder-attestation-"
|
||||
)
|
||||
assert acceptance["checks"]["tests"] is True
|
||||
with pytest.raises(
|
||||
CapabilityAuthorizationError, match="caller-supplied evidence"
|
||||
):
|
||||
service.create_release_intent(
|
||||
{
|
||||
"event_id": "webhook-main-002",
|
||||
"source_commit": COMMIT,
|
||||
"tests": {"passed": True},
|
||||
}
|
||||
)
|
||||
|
||||
|
||||
def test_builder_attestation_tamper_is_rejected(tmp_path):
|
||||
service, _ = trusted_service(tmp_path)
|
||||
bundle = service.candidate_builder.build(
|
||||
{"event_id": "webhook-main-001", "source_commit": COMMIT}
|
||||
)
|
||||
tampered = dataclasses.replace(
|
||||
bundle.attestation, artifact_sha256="0" * 64
|
||||
)
|
||||
with pytest.raises(
|
||||
CapabilityAuthorizationError, match="does not bind"
|
||||
):
|
||||
dataclasses.replace(bundle, attestation=tampered).validate(
|
||||
service.builder_attestation_verifier
|
||||
)
|
||||
|
||||
|
||||
def test_production_approval_backend_missing_disables_execution():
|
||||
backend = UnavailableProductionApprovalBackend()
|
||||
assert backend.available is False
|
||||
with pytest.raises(
|
||||
CapabilityAuthorizationError, match="not configured"
|
||||
):
|
||||
backend.verify()
|
||||
|
||||
|
||||
def test_controller_duplicate_webhook_notification_and_restart_are_idempotent(
|
||||
tmp_path,
|
||||
):
|
||||
service, _ = trusted_service(tmp_path)
|
||||
first_controller = PersistentSilentReleaseController(
|
||||
tmp_path / "state",
|
||||
service,
|
||||
main_probe=lambda: COMMIT,
|
||||
)
|
||||
first = first_controller.run_once()
|
||||
second = first_controller.run_once()
|
||||
restarted = PersistentSilentReleaseController(
|
||||
tmp_path / "state",
|
||||
service,
|
||||
main_probe=lambda: COMMIT,
|
||||
).run_once()
|
||||
assert first["intent"]["candidate_id"] == second["intent"]["candidate_id"]
|
||||
assert second["intent"]["idempotent"] is True
|
||||
assert first["notification"]["idempotent"] is False
|
||||
assert second["notification"]["idempotent"] is True
|
||||
assert restarted["notification"]["idempotent"] is True
|
||||
assert restarted["side_effects_executed"] is False
|
||||
|
||||
|
||||
def test_controller_startup_journal_failure_stops_before_main_event(tmp_path):
|
||||
service, _ = trusted_service(tmp_path)
|
||||
service.sagas.create(
|
||||
"rc-shadow-" + COMMIT[:12], "release-plan-shadow-readiness-001"
|
||||
)
|
||||
journal = next(service.sagas.root.glob("*.events.jsonl"))
|
||||
journal.write_text('{"tampered":true}\n', encoding="utf-8")
|
||||
probes: list[str] = []
|
||||
result = PersistentSilentReleaseController(
|
||||
tmp_path / "state",
|
||||
service,
|
||||
main_probe=lambda: probes.append("main") or COMMIT,
|
||||
).run_once()
|
||||
assert result["status"] == "FAIL_CLOSED"
|
||||
assert result["intent"] is None
|
||||
assert result["side_effects_executed"] is False
|
||||
assert probes == []
|
||||
|
||||
|
||||
def test_action_http_shadow_flow_has_zero_side_effects(tmp_path):
|
||||
service, signer = trusted_service(tmp_path)
|
||||
handler = type(
|
||||
"TestShadowHandler",
|
||||
(ShadowActionHandler,),
|
||||
{"service": service, "controller": None},
|
||||
)
|
||||
server = ThreadingHTTPServer(("127.0.0.1", 0), handler)
|
||||
thread = threading.Thread(target=server.serve_forever, daemon=True)
|
||||
thread.start()
|
||||
base = f"http://127.0.0.1:{server.server_port}"
|
||||
|
||||
def post(path, payload):
|
||||
request = urllib.request.Request(
|
||||
base + path,
|
||||
data=json.dumps(payload).encode(),
|
||||
headers={"Content-Type": "application/json"},
|
||||
)
|
||||
with urllib.request.urlopen(request, timeout=5) as response:
|
||||
return json.load(response)
|
||||
|
||||
try:
|
||||
intent = post(
|
||||
"/createReleaseIntent",
|
||||
{"event_id": "http-main-001", "source_commit": COMMIT},
|
||||
)
|
||||
candidate_id = intent["candidate_id"]
|
||||
approval = signed_shadow_approval(service, signer, candidate_id)
|
||||
accepted = post("/submitSignedApproval", approval.to_dict())
|
||||
deployed = post(
|
||||
"/startDeployment", {"candidate_id": candidate_id}
|
||||
)
|
||||
with urllib.request.urlopen(
|
||||
base + "/getReleasePlan?candidate_id=" + candidate_id,
|
||||
timeout=5,
|
||||
) as response:
|
||||
plan = json.load(response)
|
||||
finally:
|
||||
server.shutdown()
|
||||
server.server_close()
|
||||
thread.join(timeout=5)
|
||||
|
||||
assert accepted["status"] == "VERIFIED_AND_STORED"
|
||||
assert deployed == {
|
||||
"candidate_id": candidate_id,
|
||||
"execution_enabled": False,
|
||||
"shadow_mode": True,
|
||||
"side_effects": [],
|
||||
"side_effects_executed": False,
|
||||
"status": "SHADOW_COMPLETED",
|
||||
}
|
||||
assert plan["shadow_mode"] is True
|
||||
assert plan["side_effects_executed"] is False
|
||||
|
||||
|
||||
def test_secret_scan_redacts_placeholders_but_rejects_real_material(tmp_path):
|
||||
(tmp_path / "safe.txt").write_text(
|
||||
"Authorization: Bearer test-placeholder-token-000000",
|
||||
encoding="utf-8",
|
||||
)
|
||||
assert secret_scan(tmp_path) == {"findings": [], "passed": True}
|
||||
(tmp_path / "unsafe.txt").write_text(
|
||||
"-----BEGIN "
|
||||
+ "OPENSSH PRIVATE KEY-----\n"
|
||||
+ ("A" * 80)
|
||||
+ "\n-----END "
|
||||
+ "OPENSSH PRIVATE KEY-----",
|
||||
encoding="utf-8",
|
||||
)
|
||||
result = secret_scan(tmp_path)
|
||||
assert result["passed"] is False
|
||||
assert result["findings"] == ["unsafe.txt"]
|
||||
secret = "live-" + ("A" * 40)
|
||||
redacted = redact_output("Authorization: Bearer " + secret)
|
||||
assert secret not in redacted
|
||||
assert "<redacted>" in redacted
|
||||
(tmp_path / "unsafe.txt").write_text(
|
||||
"Authorization: " + "Bearer live-test-looking-secret-000001",
|
||||
encoding="utf-8",
|
||||
)
|
||||
result = secret_scan(tmp_path)
|
||||
assert result["passed"] is False
|
||||
assert result["findings"] == ["unsafe.txt"]
|
||||
|
||||
|
||||
def test_systemd_shadow_unit_has_both_gates_and_no_secret_environment():
|
||||
unit = (
|
||||
ROOT
|
||||
/ "deploy"
|
||||
/ "systemd"
|
||||
/ "aios-silent-release-controller.service"
|
||||
).read_text(encoding="utf-8")
|
||||
assert "AIOS_GITOPS_WRITES_ENABLED=false" in unit
|
||||
assert "AIOS_SILENT_RELEASE_EXECUTION_ENABLED=false" in unit
|
||||
assert "--host 127.0.0.1" in unit
|
||||
assert "PRIVATE_KEY=" not in unit
|
||||
assert "TOKEN=" not in unit
|
||||
assert "PASSWORD=" not in unit
|
||||
@@ -32,7 +32,6 @@ from silent_release_hardening import ( # noqa: E402
|
||||
CapabilityAuthorizationError,
|
||||
CapabilityController,
|
||||
CapabilityLedger,
|
||||
ClaimProbeResult,
|
||||
DeploymentPlan,
|
||||
PreSwitchValidator,
|
||||
HardenedTagController,
|
||||
@@ -368,7 +367,6 @@ def test_capability_failure_stays_reserved_and_retry_can_complete():
|
||||
capability="runtime_switch",
|
||||
ledger=ledger,
|
||||
adapter=lambda: {"verified": True},
|
||||
recovery_probe=lambda: ClaimProbeResult.NOT_APPLIED,
|
||||
).execute(verified, operation="runtime-switch-001")
|
||||
assert recovered["status"] == "EXECUTED"
|
||||
assert ledger.reserve(
|
||||
@@ -462,10 +460,6 @@ def test_finalize_controllers_require_governance_lineage(
|
||||
target_field: verified.source_commit,
|
||||
"evidence_closure_oid": verified.evidence_closure_oid,
|
||||
"approval_plan_id": verified.approval_plan_id,
|
||||
"tag_verified": True,
|
||||
"remote_peeled_target_oid": verified.source_commit,
|
||||
"gitea_api_peeled_target_oid": verified.source_commit,
|
||||
"gitea_listing_visible": True,
|
||||
}
|
||||
controller = controller_type(
|
||||
CapabilityLedger(Path(td) / "capabilities"),
|
||||
@@ -715,8 +709,7 @@ def test_shadow_mode_never_invokes_runtime_tag_or_finalize_adapters():
|
||||
)
|
||||
service.create_release_candidate(candidate().to_dict())
|
||||
result = service.start_deployment("rc-hardening-001")
|
||||
assert result["status"] == "SHADOW_COMPLETED"
|
||||
assert result["side_effects_executed"] is False
|
||||
assert result["status"] == "SHADOW_MODE"
|
||||
|
||||
|
||||
def test_action_service_candidate_and_saga_are_durable():
|
||||
@@ -735,10 +728,12 @@ def test_action_service_candidate_and_saga_are_durable():
|
||||
|
||||
def test_action_service_rejects_execution_without_signed_approval():
|
||||
with tempfile.TemporaryDirectory() as td:
|
||||
service = SilentReleaseActionService(
|
||||
Path(td), execution_enabled=True
|
||||
)
|
||||
service.create_release_candidate(candidate().to_dict())
|
||||
with pytest.raises(CapabilityAuthorizationError):
|
||||
SilentReleaseActionService(
|
||||
Path(td), execution_enabled=True
|
||||
)
|
||||
service.start_deployment("rc-hardening-001")
|
||||
|
||||
|
||||
def test_deployment_plan_rejects_release_root_escape():
|
||||
@@ -814,7 +809,6 @@ def test_action_service_verifies_and_stores_owner_approval(tmp_path):
|
||||
tmp_path / "control",
|
||||
approval_verifier=approval_verifier,
|
||||
policy_sha256=POLICY,
|
||||
allow_legacy_candidate_input=True,
|
||||
)
|
||||
service.create_release_candidate(
|
||||
{
|
||||
@@ -835,7 +829,6 @@ def test_action_service_owner_approval_submission_is_idempotent(tmp_path):
|
||||
tmp_path / "control",
|
||||
approval_verifier=approval_verifier,
|
||||
policy_sha256=POLICY,
|
||||
allow_legacy_candidate_input=True,
|
||||
)
|
||||
service.create_release_candidate(
|
||||
{
|
||||
@@ -852,9 +845,7 @@ def test_action_service_owner_approval_submission_is_idempotent(tmp_path):
|
||||
|
||||
def test_action_service_rejects_owner_approval_without_public_key(tmp_path):
|
||||
service = SilentReleaseActionService(
|
||||
tmp_path / "control",
|
||||
policy_sha256=POLICY,
|
||||
allow_legacy_candidate_input=True,
|
||||
tmp_path / "control", policy_sha256=POLICY
|
||||
)
|
||||
service.create_release_candidate(
|
||||
{
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
Reference in New Issue
Block a user