@mriekki/project-forge 4.12.0 → 4.13.1

package/assets/generated/deployment/src/project_forge_deployment/sqlite_adapter.py

@@ -14,6 +14,7 @@ from .app_runtime import APP_ROOT
 from .box_platform import platform_status
 from .errors import DeploymentKitError
 from .profiles import load_profile
+from .recovery_scope import normalize_recovery_scope, public_recovery_scope, recovery_evidence, recovery_readiness
 from .sqlite_adapter_remote import REMOTE_SCRIPT
 from .ssh import ssh_args, verify_access
 
@@ -111,6 +112,7 @@ def normalize_sqlite_request(
     maintenance_environment: dict[str, str] | Iterable[tuple[str, str]],
     run_as: str | None = None, database_file: str | None = None,
     source_database: str | None = None, first_install: bool = False,
+    recovery_scope: dict[str, Any] | None = None,
 ) -> dict[str, Any]:
     request = {
         "ownerRepo": _owner_repo(owner_repo),
@@ -122,6 +124,7 @@ def normalize_sqlite_request(
         "runAs": _run_as(run_as) if run_as is not None else None,
         "databaseFile": _database_file(database_file) if database_file is not None else None,
         "sourceDatabase": _source_database(source_database) if source_database is not None else None,
+        "recoveryScope": normalize_recovery_scope(recovery_scope),
     }
     if request["sourceDatabase"] is not None:
         if request["runAs"] is None or request["databaseFile"] is None:
@@ -140,6 +143,7 @@ def _b64(value: str) -> str:
 def build_remote_script(spec: dict[str, Any] | None = None) -> str:
     spec = spec or {}
     env = spec.get("maintenanceEnvironment", {})
+    recovery_payload = json.dumps(spec.get("recoveryEvidence", {}), sort_keys=True, separators=(",", ":"))
     replacements = {
         "__APP_ROOT__": APP_ROOT,
         "__SQLITE_SCHEMA_VERSION__": str(SQLITE_SCHEMA_VERSION),
@@ -154,6 +158,7 @@ def build_remote_script(spec: dict[str, Any] | None = None) -> str:
         "__RESERVATION_SHA__": spec.get("reservationSha256", ""),
         "__ENV_KEYS__": " ".join(f"'{_b64(k)}'" for k in env),
         "__ENV_VALUES__": " ".join(f"'{_b64(v)}'" for v in env.values()),
+        "__RECOVERY_EVIDENCE_B64__": _b64(recovery_payload),
     }
     script = REMOTE_SCRIPT
     for placeholder, value in replacements.items():
@@ -291,6 +296,12 @@ def plan_sqlite_operation(
         spec.update(runAs=existing["runAs"], databaseFile=existing["databaseFile"], reservationSha256=existing["reservationSha256"])
         if action in {"backup", "migrate", "rollback-check"} and not existing["databasePresent"]:
             raise DeploymentKitError(f"SQLite {action} requires an existing database.")
+    creates_verified_backup = bool(action == "backup" or (action == "migrate" and not request["firstInstall"]))
+    recovery_scope = request["recoveryScope"]
+    spec["recoveryEvidence"] = recovery_evidence(
+        recovery_scope,
+        database_backup_verified=creates_verified_backup,
+    )
     return {
         "targetName": name, "action": action, "ownerRepo": request["ownerRepo"],
         "environment": request["environment"], "productionClassified": production_classified,
@@ -299,7 +310,10 @@ def plan_sqlite_operation(
         "sourceDatabase": request["sourceDatabase"] if action == "import" else None,
         "firstInstall": bool(request["firstInstall"] if action == "migrate" else False),
         "stopsManagedRuntime": bool(action == "migrate" and existing and existing["managedRuntimeRunning"]),
-        "createsVerifiedBackup": bool(action == "backup" or (action == "migrate" and not request["firstInstall"])),
+        "createsVerifiedBackup": creates_verified_backup,
+        "verifiedBackupScope": "database" if creates_verified_backup else None,
+        "recoveryScope": public_recovery_scope(recovery_scope),
+        "applicationRecoveryReadyAfterOperation": False,
         "inventorySnapshot": _snapshot(inventory), "expectedReservationSha256": expected_sha, "spec": spec,
     }
 
@@ -319,11 +333,18 @@ def authorization_phrase(plan: dict[str, Any]) -> str:
 
 
 def apply_sqlite_operation(plan: dict[str, Any]) -> dict[str, Any]:
-    required = {"targetName", "action", "ownerRepo", "environment", "productionClassified", "appSlug", "image", "databaseFile", "runAs", "sourceDatabase", "firstInstall", "stopsManagedRuntime", "createsVerifiedBackup", "inventorySnapshot", "expectedReservationSha256", "spec"}
+    required = {
+        "targetName", "action", "ownerRepo", "environment", "productionClassified", "appSlug", "image",
+        "databaseFile", "runAs", "sourceDatabase", "firstInstall", "stopsManagedRuntime", "createsVerifiedBackup",
+        "verifiedBackupScope", "recoveryScope", "applicationRecoveryReadyAfterOperation", "inventorySnapshot",
+        "expectedReservationSha256", "spec",
+    }
     if not isinstance(plan, dict) or set(plan) != required or not isinstance(plan["productionClassified"], bool):
         raise DeploymentKitError("Malformed SQLite operation plan.")
     if plan["environment"] == "production" and not plan["productionClassified"]:
         raise DeploymentKitError("Literal production environment must remain Production-classified.")
+    if plan["applicationRecoveryReadyAfterOperation"] is not False:
+        raise DeploymentKitError("SQLite operations cannot claim application recovery readiness.")
     _require_ready_platform(plan["targetName"])
     current = sqlite_inventory(plan["targetName"])
     if _snapshot(current) != plan["inventorySnapshot"]:
@@ -334,6 +355,10 @@ def apply_sqlite_operation(plan: dict[str, Any]) -> dict[str, Any]:
     result["mutated"] = True
     result["operation"] = plan["action"]; result["operationOutput"] = output.strip()
     result["productionClassified"] = plan["productionClassified"]
+    result["recoveryReadiness"] = recovery_readiness(
+        plan["spec"]["recoveryScope"],
+        database_backup_verified=plan["createsVerifiedBackup"],
+    )
     return result
 
 

package/assets/generated/deployment/src/project_forge_deployment/sqlite_adapter_remote.py

@@ -19,6 +19,7 @@ FIRST_INSTALL="__FIRST_INSTALL__"
 RESERVATION_SHA="__RESERVATION_SHA__"
 ENV_KEYS=(__ENV_KEYS__)
 ENV_VALUES=(__ENV_VALUES__)
+RECOVERY_EVIDENCE_B64="__RECOVERY_EVIDENCE_B64__"
 
 b64d() { printf '%s' "$1" | base64 --decode; }
 meta_value() {
@@ -121,6 +122,7 @@ decode_spec() {
     RUN_AS="$(b64d "$RUN_AS_B64")"
     DATABASE_FILE="$(b64d "$DB_FILE_B64")"
     SOURCE_DATABASE="$(b64d "$SOURCE_DB_B64")"
+    RECOVERY_EVIDENCE_JSON="$(b64d "$RECOVERY_EVIDENCE_B64")"
     valid_repo "$OWNER" || { echo "Invalid SQLite owner repository." >&2; exit 45; }
     valid_slug "$ENVIRONMENT" || { echo "Invalid SQLite environment." >&2; exit 45; }
     valid_slug "$APP_SLUG" || { echo "Invalid SQLite app slug." >&2; exit 45; }
@@ -129,6 +131,7 @@ decode_spec() {
     valid_db_file "$DATABASE_FILE" || { echo "Invalid SQLite database file name." >&2; exit 45; }
     [[ "$RESERVATION_SHA" =~ ^[0-9a-f]{64}$ ]] || { echo "Invalid SQLite reservation fingerprint." >&2; exit 45; }
     [[ "${#ENV_KEYS[@]}" -eq "${#ENV_VALUES[@]}" && "${#ENV_KEYS[@]}" -gt 0 ]] || { echo "Invalid SQLite maintenance environment payload." >&2; exit 45; }
+    [[ "$RECOVERY_EVIDENCE_JSON" == \{*\} ]] || { echo "Invalid SQLite recovery evidence payload." >&2; exit 45; }
     local index key
     for index in "${!ENV_KEYS[@]}"; do
         key="$(b64d "${ENV_KEYS[$index]}")"
@@ -210,8 +213,8 @@ run_migrate() {
 record_evidence() {
     local root="$1" action="$2" outcome="$3" artifact="${4:-}" timestamp
     timestamp="$(date -u +'%Y-%m-%dT%H:%M:%SZ')"
-    printf '{"timestamp":"%s","action":"%s","ownerRepo":"%s","environment":"%s","appSlug":"%s","image":"%s","databaseFile":"%s","reservationSha256":"%s","artifact":"%s","outcome":"%s"}\n' \
-        "$timestamp" "$action" "$OWNER" "$ENVIRONMENT" "$APP_SLUG" "$IMAGE" "$DATABASE_FILE" "$RESERVATION_SHA" "$artifact" "$outcome" >> "$root/sqlite-evidence.jsonl"
+    printf '{"timestamp":"%s","action":"%s","ownerRepo":"%s","environment":"%s","appSlug":"%s","image":"%s","databaseFile":"%s","reservationSha256":"%s","artifact":"%s","outcome":"%s","recovery":%s}\n' \
+        "$timestamp" "$action" "$OWNER" "$ENVIRONMENT" "$APP_SLUG" "$IMAGE" "$DATABASE_FILE" "$RESERVATION_SHA" "$artifact" "$outcome" "$RECOVERY_EVIDENCE_JSON" >> "$root/sqlite-evidence.jsonl"
     chmod 0600 "$root/sqlite-evidence.jsonl"
 }
 
@@ -287,7 +290,7 @@ operate() {
             backup_name="backup-$stamp-$DATABASE_FILE"
             run_backup "$DATA" "$BACKUPS" "$backup_name"
             record_evidence "$ROOT" backup backed-up "$backup_name"
-            printf 'SQLite verified backup created: %s\n' "$BACKUPS/$backup_name"
+            printf 'SQLite verified database backup created: %s\n' "$BACKUPS/$backup_name"
             ;;
         migrate)
             if [[ "$FIRST_INSTALL" == true ]]; then
@@ -311,12 +314,12 @@ operate() {
                 if [[ "$MANAGED_RUNNING" == true ]]; then docker stop "$MANAGED_CONTAINER" >/dev/null; fi
                 if ! run_migrate "$DATA"; then
                     record_evidence "$ROOT" migrate failed "$backup_name"
-                    echo "SQLite migration failed; verified pre-migration backup is retained and managed runtime remains stopped." >&2
+                    echo "SQLite migration failed; verified pre-migration database backup is retained and managed runtime remains stopped." >&2
                     exit 50
                 fi
                 run_check "$DATA"
                 record_evidence "$ROOT" migrate migrated "$backup_name"
-                printf 'SQLite migration completed; verified pre-migration backup: %s\n' "$BACKUPS/$backup_name"
+                printf 'SQLite migration completed; verified pre-migration database backup: %s\n' "$BACKUPS/$backup_name"
             fi
             ;;
         rollback-check)
@@ -337,4 +340,4 @@ case "$ACTION" in
     import|backup|migrate|rollback-check) operate ;;
     *) echo "Unsupported SQLite adapter action: $ACTION" >&2; exit 2 ;;
 esac
-'''
+'''

package/assets/generated/deployment/src/project_forge_deployment/sqlite_cli.py

@@ -1,6 +1,7 @@
 """CLI for the SQLite persistence adapter."""
 from __future__ import annotations
 import argparse, json, sys
+from pathlib import Path
 from typing import Any
 from .errors import DeploymentKitError
 from .sqlite_adapter import authorization_phrase, apply_sqlite_operation, normalize_sqlite_request, plan_sqlite_operation, sqlite_inventory
@@ -28,6 +29,18 @@ def _parse_env(items: list[str]) -> list[tuple[str,str]]:
     return out
 
 
+def _load_recovery_manifest(path: str | None) -> dict[str, Any] | None:
+    if path is None:
+        return None
+    try:
+        value = json.loads(Path(path).read_text(encoding='utf-8'))
+    except (OSError, UnicodeError, json.JSONDecodeError) as error:
+        raise DeploymentKitError(f"Could not read recovery manifest as UTF-8 JSON: {error}") from error
+    if not isinstance(value, dict):
+        raise DeploymentKitError("Recovery manifest root must be a JSON object.")
+    return value
+
+
 def _confirm(args: argparse.Namespace, phrase: str, action: str) -> None:
     if args.yes: return
     if input(f"Type {phrase} to {action}: ").strip() != phrase:
@@ -50,6 +63,10 @@ def _common(parser: argparse.ArgumentParser) -> None:
     parser.add_argument('--yes', action='store_true')
 
 
+def _recovery_manifest_arg(parser: argparse.ArgumentParser) -> None:
+    parser.add_argument('--recovery-manifest', help='Optional strict non-secret JSON declaration of recovery dependencies and authentication policy')
+
+
 def _import_args(parser: argparse.ArgumentParser) -> None:
     parser.add_argument('--run-as', required=True)
     parser.add_argument('--database-file', required=True)
@@ -62,8 +79,8 @@ def build_parser() -> argparse.ArgumentParser:
     inv=sub.add_parser('inventory',help='Read SQLite persistence reservations without writes'); inv.add_argument('name'); inv.add_argument('--json',action='store_true')
     imp=sub.add_parser('import',help='Import an existing SQLite DB via the exact image online-backup contract'); _common(imp); _import_args(imp)
     recover=sub.add_parser('recover-import',help='Recover a verified failed import without overwriting or recopying the database'); _common(recover); _import_args(recover)
-    backup=sub.add_parser('backup',help='Create a verified SQLite backup with the exact image'); _common(backup)
-    migrate=sub.add_parser('migrate',help='Create required backup and run exact-image SQLite migration'); _common(migrate)
+    backup=sub.add_parser('backup',help='Create a verified SQLite database backup with the exact image'); _common(backup); _recovery_manifest_arg(backup)
+    migrate=sub.add_parser('migrate',help='Create required database backup and run exact-image SQLite migration'); _common(migrate); _recovery_manifest_arg(migrate)
     migrate.add_argument('--first-install',action='store_true'); migrate.add_argument('--run-as'); migrate.add_argument('--database-file')
     check=sub.add_parser('rollback-check',help='Verify that an exact rollback image accepts the current SQLite state'); _common(check)
     return parser
@@ -73,10 +90,13 @@ def main(argv: list[str]|None=None) -> int:
     args=build_parser().parse_args(argv)
     try:
         if args.command=='inventory': _print(sqlite_inventory(args.name),as_json=args.json); return 0
+        if args.command=='migrate' and getattr(args,'first_install',False) and getattr(args,'recovery_manifest',None):
+            raise DeploymentKitError("--recovery-manifest is supported only for existing-database SQLite migration, not --first-install.")
         production_classified = args.production or args.environment == 'production'
         request=normalize_sqlite_request(owner_repo=args.owner_repo,environment=args.environment,app_slug=args.app_slug,image=args.image,
             maintenance_environment=_parse_env(args.maintenance_env),run_as=getattr(args,'run_as',None),database_file=getattr(args,'database_file',None),
-            source_database=getattr(args,'source_database',None),first_install=getattr(args,'first_install',False))
+            source_database=getattr(args,'source_database',None),first_install=getattr(args,'first_install',False),
+            recovery_scope=_load_recovery_manifest(getattr(args,'recovery_manifest',None)))
         if args.command=='recover-import':
             plan=plan_sqlite_import_recovery(args.name,request,production=production_classified)
             _print({k:v for k,v in plan.items() if k!='request'},as_json=False)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mriekki/project-forge",
-  "version": "4.12.0",
+  "version": "4.13.1",
   "description": "Public consumer distribution and updater for Project Forge engineering assets.",
   "type": "module",
   "bin": {