@mriekki/project-forge 4.4.0 → 4.4.1

package/README.md

@@ -126,6 +126,15 @@ npx @mriekki/project-forge@latest check
 
 Managed updates verify baselines and refuse unsafe drift or conflicts before modifying Project Forge-managed files.
 
+## Maintainer system reference
+
+For cross-repository architecture, ownership, lifecycle, provenance, deployment, support-evidence, and governance questions, start with:
+
+- [`docs/system/PROJECT_FORGE_SYSTEM_REQUIREMENTS.md`](docs/system/PROJECT_FORGE_SYSTEM_REQUIREMENTS.md) — normative cross-repository invariants;
+- [`docs/system/PROJECT_FORGE_SYSTEM_DESIGN.md`](docs/system/PROJECT_FORGE_SYSTEM_DESIGN.md) — explanatory system map and pointers to detailed owning-repository contracts.
+
+The system reference deliberately does not duplicate current component SHAs, package/catalog versions, support status, or implementation-level CLI/schema detail. Resolve mutable facts from the owning repositories and machine-readable Platform/Bootstrap/consumer provenance.
+
 ## Maintainer release process
 
 Project Forge maintainers use a gated release workflow that resolves accepted component commits, verifies the assembled package, creates the package pull request, verifies CI, and stops at the explicit publication gate.

package/assets/components.json

@@ -1,7 +1,7 @@
 {
   "schemaVersion": 1,
   "package": "@mriekki/project-forge",
-  "version": "4.4.0",
+  "version": "4.4.1",
   "defaultProfile": "greenfield-project",
   "profiles": {
     "greenfield-project": {
@@ -23,7 +23,7 @@
     },
     "deployment": {
       "repository": "mriekki/project-forge-deployment-kit",
-      "commit": "eb157c8ae2c638ae1cd08bf27446d430835adc80",
+      "commit": "880a911bc87e38c74ca4b336c9563a6f026ac3b4",
       "distribution": "greenfield-project",
       "descriptor": "assets/deployment/distribution.json",
       "sourceRoot": "assets/generated/deployment",

package/assets/generated/ASSEMBLY.json

@@ -1,7 +1,7 @@
 {
   "schemaVersion": 1,
   "package": "@mriekki/project-forge",
-  "version": "4.4.0",
+  "version": "4.4.1",
   "components": {
     "core": {
       "repository": "mriekki/project-forge-core",
@@ -328,7 +328,7 @@
     },
     "deployment": {
       "repository": "mriekki/project-forge-deployment-kit",
-      "commit": "eb157c8ae2c638ae1cd08bf27446d430835adc80",
+      "commit": "880a911bc87e38c74ca4b336c9563a6f026ac3b4",
       "distribution": "greenfield-project",
       "files": [
         {
@@ -519,7 +519,7 @@
         {
           "source": "src/project_forge_deployment/sqlite_adapter.py",
           "destination": "tools/project-forge-deployment/project_forge_deployment/sqlite_adapter.py",
-          "sha256": "b6f5fd33b776a1fb02d6b6a00fbab0b95827946e5fee51aafef9446fa084f42b"
+          "sha256": "011615339f739316fb1350a7d4f1385a841744cf09c66da61c10e46f444c059f"
         },
         {
           "source": "src/project_forge_deployment/sqlite_adapter_remote.py",
@@ -529,12 +529,12 @@
         {
           "source": "src/project_forge_deployment/sqlite_cli.py",
           "destination": "tools/project-forge-deployment/project_forge_deployment/sqlite_cli.py",
-          "sha256": "e56fe51fe92110704f709f9b4a3e89f667aa4f827dbf562262b3f89ab7637dfb"
+          "sha256": "abee3a7fbef21f1a02b1511f5d050f90d9ef51afcd6714046c25b786568fb833"
         },
         {
           "source": "src/project_forge_deployment/sqlite_import_recovery.py",
           "destination": "tools/project-forge-deployment/project_forge_deployment/sqlite_import_recovery.py",
-          "sha256": "417096927ae2f36d19df90e26ed88a1f8659a83538155d3538f660a887077f4e"
+          "sha256": "b047494e403963120d8667e189f20ed6310526870b56adb1f433a9b0154c7636"
         },
         {
           "source": "src/project_forge_deployment/ssh.py",

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

@@ -252,9 +252,18 @@ def _reservation_from_request(request: dict[str, Any]) -> dict[str, Any]:
     }
 
 
-def plan_sqlite_operation(name: str, action: str, request: dict[str, Any]) -> dict[str, Any]:
+def plan_sqlite_operation(
+    name: str,
+    action: str,
+    request: dict[str, Any],
+    *,
+    production: bool = False,
+) -> dict[str, Any]:
     if action not in {"import", "backup", "migrate", "rollback-check"}:
         raise DeploymentKitError("Unsupported SQLite plan action.")
+    if not isinstance(production, bool):
+        raise DeploymentKitError("SQLite Production classification must be a boolean.")
+    production_classified = production or request["environment"] == "production"
     _require_ready_platform(name)
     inventory = sqlite_inventory(name)
     existing = _find(inventory, request["appSlug"], request["environment"])
@@ -284,7 +293,8 @@ def plan_sqlite_operation(name: str, action: str, request: dict[str, Any]) -> di
             raise DeploymentKitError(f"SQLite {action} requires an existing database.")
     return {
         "targetName": name, "action": action, "ownerRepo": request["ownerRepo"],
-        "environment": request["environment"], "appSlug": request["appSlug"], "image": request["image"],
+        "environment": request["environment"], "productionClassified": production_classified,
+        "appSlug": request["appSlug"], "image": request["image"],
         "databaseFile": spec["databaseFile"], "runAs": spec["runAs"],
         "sourceDatabase": request["sourceDatabase"] if action == "import" else None,
         "firstInstall": bool(request["firstInstall"] if action == "migrate" else False),
@@ -295,7 +305,9 @@ def plan_sqlite_operation(name: str, action: str, request: dict[str, Any]) -> di
 
 
 def authorization_phrase(plan: dict[str, Any]) -> str:
-    production = plan["environment"] == "production"
+    production = plan.get("productionClassified")
+    if not isinstance(production, bool):
+        raise DeploymentKitError("Malformed SQLite operation plan Production classification.")
     mapping = {
         "import": (SQLITE_IMPORT_WRITE_PHRASE, PRODUCTION_SQLITE_IMPORT_WRITE_PHRASE),
         "backup": (SQLITE_BACKUP_WRITE_PHRASE, PRODUCTION_SQLITE_BACKUP_WRITE_PHRASE),
@@ -307,9 +319,11 @@ def authorization_phrase(plan: dict[str, Any]) -> str:
 
 
 def apply_sqlite_operation(plan: dict[str, Any]) -> dict[str, Any]:
-    required = {"targetName", "action", "ownerRepo", "environment", "appSlug", "image", "databaseFile", "runAs", "sourceDatabase", "firstInstall", "stopsManagedRuntime", "createsVerifiedBackup", "inventorySnapshot", "expectedReservationSha256", "spec"}
-    if not isinstance(plan, dict) or set(plan) != required:
+    required = {"targetName", "action", "ownerRepo", "environment", "productionClassified", "appSlug", "image", "databaseFile", "runAs", "sourceDatabase", "firstInstall", "stopsManagedRuntime", "createsVerifiedBackup", "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.")
     _require_ready_platform(plan["targetName"])
     current = sqlite_inventory(plan["targetName"])
     if _snapshot(current) != plan["inventorySnapshot"]:
@@ -319,6 +333,7 @@ def apply_sqlite_operation(plan: dict[str, Any]) -> dict[str, Any]:
     result = sqlite_inventory(plan["targetName"])
     result["mutated"] = True
     result["operation"] = plan["action"]; result["operationOutput"] = output.strip()
+    result["productionClassified"] = plan["productionClassified"]
     return result
 
 
@@ -332,4 +347,4 @@ def assert_app_spec_matches_persistence(name: str, app_spec: dict[str, Any]) ->
     if existing["runAs"] != app_spec["runAs"]:
         raise DeploymentKitError("Application runAs does not match the prepared SQLite persistence reservation.")
     if app_spec.get("persistence", {}).get("mode") != "directory":
-        raise DeploymentKitError("Prepared SQLite persistence requires directory application persistence.")
+        raise DeploymentKitError("Prepared SQLite persistence requires directory application persistence.")

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

@@ -38,6 +38,11 @@ def _common(parser: argparse.ArgumentParser) -> None:
     parser.add_argument('name')
     parser.add_argument('--owner-repo', required=True)
     parser.add_argument('--environment', required=True)
+    parser.add_argument(
+        '--production',
+        action='store_true',
+        help="Classify this named environment as Production even when its name is not literally 'production'",
+    )
     parser.add_argument('--app-slug', required=True)
     parser.add_argument('--image', required=True)
     parser.add_argument('--maintenance-env', action='append', default=[], help='Non-secret image maintenance environment value in NAME=value form; repeat as needed')
@@ -68,19 +73,20 @@ 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
+        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))
         if args.command=='recover-import':
-            plan=plan_sqlite_import_recovery(args.name,request)
+            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)
             phrase=recovery_authorization_phrase(plan)
             _confirm(args,phrase,f"recover SQLite import for {plan['appSlug']} ({plan['environment']}) on target {args.name}")
             _print(apply_sqlite_import_recovery(plan),as_json=args.json); return 0
-        plan=plan_sqlite_operation(args.name,args.command,request)
+        plan=plan_sqlite_operation(args.name,args.command,request,production=production_classified)
         _print({k:v for k,v in plan.items() if k!='spec'},as_json=False)
         phrase=authorization_phrase(plan)
         _confirm(args,phrase,f"run SQLite {args.command} for {plan['appSlug']} ({plan['environment']}) on target {args.name}")
         _print(apply_sqlite_operation(plan),as_json=args.json); return 0
     except DeploymentKitError as error:
-        print(f"ERROR: {error}",file=sys.stderr); return 2
+        print(f"ERROR: {error}",file=sys.stderr); return 2

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

@@ -356,13 +356,22 @@ def _snapshot(inspection: dict[str, Any]) -> str:
     return hashlib.sha256(json.dumps(value, sort_keys=True, separators=(",", ":")).encode("utf-8")).hexdigest()
 
 
-def plan_sqlite_import_recovery(name: str, request: dict[str, Any]) -> dict[str, Any]:
+def plan_sqlite_import_recovery(
+    name: str,
+    request: dict[str, Any],
+    *,
+    production: bool = False,
+) -> dict[str, Any]:
+    if not isinstance(production, bool):
+        raise DeploymentKitError("SQLite Production classification must be a boolean.")
+    production_classified = production or request["environment"] == "production"
     inspection = inspect_sqlite_import_recovery(name, request)
     return {
         "targetName": name,
         "action": "recover-import",
         "ownerRepo": request["ownerRepo"],
         "environment": request["environment"],
+        "productionClassified": production_classified,
         "appSlug": request["appSlug"],
         "image": request["image"],
         "runAs": request["runAs"],
@@ -381,22 +390,32 @@ def plan_sqlite_import_recovery(name: str, request: dict[str, Any]) -> dict[str,
 
 
 def authorization_phrase(plan: dict[str, Any]) -> str:
+    production = plan.get("productionClassified")
+    if not isinstance(production, bool):
+        raise DeploymentKitError("Malformed SQLite import recovery Production classification.")
     return (
         PRODUCTION_SQLITE_IMPORT_RECOVERY_WRITE_PHRASE
-        if plan["environment"] == "production"
+        if production
         else SQLITE_IMPORT_RECOVERY_WRITE_PHRASE
     )
 
 
 def apply_sqlite_import_recovery(plan: dict[str, Any]) -> dict[str, Any]:
     required = {
-        "targetName", "action", "ownerRepo", "environment", "appSlug", "image", "runAs",
+        "targetName", "action", "ownerRepo", "environment", "productionClassified", "appSlug", "image", "runAs",
         "databaseFile", "sourceDatabase", "databaseSha256", "sourceSha256", "databaseBytes",
         "stateSnapshot", "overwritesDatabase", "deletesPersistentData", "createsReservation",
         "reverifiesDatabase", "request",
     }
-    if not isinstance(plan, dict) or set(plan) != required or plan["action"] != "recover-import":
+    if (
+        not isinstance(plan, dict)
+        or set(plan) != required
+        or plan["action"] != "recover-import"
+        or not isinstance(plan["productionClassified"], bool)
+    ):
         raise DeploymentKitError("Malformed SQLite import recovery plan.")
+    if plan["environment"] == "production" and not plan["productionClassified"]:
+        raise DeploymentKitError("Literal production environment must remain Production-classified.")
     current = inspect_sqlite_import_recovery(plan["targetName"], plan["request"])
     if _snapshot(current) != plan["stateSnapshot"]:
         raise DeploymentKitError(
@@ -434,4 +453,5 @@ def apply_sqlite_import_recovery(plan: dict[str, Any]) -> dict[str, Any]:
     inventory["mutated"] = True
     inventory["operation"] = "recover-import"
     inventory["operationOutput"] = output.strip()
+    inventory["productionClassified"] = plan["productionClassified"]
     return inventory

package/package.json

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