@mriekki/project-forge 0.0.0-stage → 2.0.0

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

@@ -0,0 +1,205 @@
+"""Non-destructive workstation SQLite lifecycle helpers."""
+
+from __future__ import annotations
+
+import json
+import re
+import sqlite3
+from pathlib import Path
+from typing import Any
+
+from .errors import DeploymentKitError
+from .profiles import config_root
+
+
+_SLUG_RE = re.compile(r"^[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?$")
+_REPO_RE = re.compile(r"^[A-Za-z0-9_.-]+/[A-Za-z0-9_.-]+$")
+_DB_FILE_RE = re.compile(r"^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$")
+_METADATA_FILE = "sqlite-local.json"
+
+
+def _slug(value: str, field: str) -> str:
+    if not isinstance(value, str) or _SLUG_RE.fullmatch(value) is None:
+        raise DeploymentKitError(f"{field} must use lowercase letters, digits, and internal hyphens.")
+    return value
+
+
+def _owner_repo(value: str) -> str:
+    if not isinstance(value, str) or _REPO_RE.fullmatch(value) is None:
+        raise DeploymentKitError("ownerRepo must use GitHub owner/repository form without URL syntax.")
+    return value
+
+
+def _database_file(value: str) -> str:
+    if not isinstance(value, str) or _DB_FILE_RE.fullmatch(value) is None or value in {".", ".."}:
+        raise DeploymentKitError("databaseFile must be a safe file name without path separators.")
+    return value
+
+
+def _state_root(app_slug: str, environment: str) -> Path:
+    return config_root() / "local-apps" / app_slug / environment
+
+
+def _data_dir(app_slug: str, environment: str) -> Path:
+    return _state_root(app_slug, environment) / "data"
+
+
+def _metadata_path(app_slug: str, environment: str) -> Path:
+    return _state_root(app_slug, environment) / _METADATA_FILE
+
+
+def _database_path(app_slug: str, environment: str, database_file: str) -> Path:
+    return _data_dir(app_slug, environment) / database_file
+
+
+def _load_metadata(app_slug: str, environment: str) -> dict[str, Any] | None:
+    path = _metadata_path(app_slug, environment)
+    if not path.is_file():
+        return None
+    try:
+        value = json.loads(path.read_text(encoding="utf-8"))
+    except (OSError, UnicodeError, json.JSONDecodeError) as error:
+        raise DeploymentKitError(f"Cannot read local SQLite metadata {path}: {error}") from error
+    if not isinstance(value, dict) or value.get("schemaVersion") != 1:
+        raise DeploymentKitError(f"Unsupported local SQLite metadata: {path}")
+    return value
+
+
+def _write_metadata(path: Path, value: dict[str, Any]) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    temporary = path.with_suffix(".tmp")
+    temporary.write_text(json.dumps(value, indent=2, sort_keys=True) + "\n", encoding="utf-8")
+    temporary.replace(path)
+
+
+def _quick_check(path: Path) -> str:
+    try:
+        with sqlite3.connect(path) as connection:
+            row = connection.execute("PRAGMA quick_check").fetchone()
+    except sqlite3.DatabaseError as error:
+        raise DeploymentKitError(f"Local SQLite database is not valid: {path}: {error}") from error
+    result = str(row[0]) if row else "missing-result"
+    if result.lower() != "ok":
+        raise DeploymentKitError(f"Local SQLite quick_check failed for {path}: {result}")
+    return result
+
+
+def local_sqlite_status(
+    *, owner_repo: str, environment: str, app_slug: str, database_file: str
+) -> dict[str, Any]:
+    owner_repo = _owner_repo(owner_repo)
+    environment = _slug(environment, "environment")
+    app_slug = _slug(app_slug, "appSlug")
+    database_file = _database_file(database_file)
+    metadata = _load_metadata(app_slug, environment)
+    path = _database_path(app_slug, environment, database_file)
+
+    if metadata is not None:
+        expected = {
+            "ownerRepo": owner_repo,
+            "environment": environment,
+            "appSlug": app_slug,
+            "databaseFile": database_file,
+        }
+        for key, value in expected.items():
+            if metadata.get(key) != value:
+                raise DeploymentKitError(
+                    f"Local SQLite metadata ownership mismatch for {app_slug}/{environment}: {key}."
+                )
+
+    if path.exists() and metadata is None:
+        return {
+            "schemaVersion": 1,
+            "ownerRepo": owner_repo,
+            "environment": environment,
+            "appSlug": app_slug,
+            "databaseFile": database_file,
+            "databasePath": str(path),
+            "state": "unmanaged-existing",
+            "managed": False,
+            "present": True,
+            "valid": False,
+            "mutated": False,
+        }
+
+    if not path.exists():
+        return {
+            "schemaVersion": 1,
+            "ownerRepo": owner_repo,
+            "environment": environment,
+            "appSlug": app_slug,
+            "databaseFile": database_file,
+            "databasePath": str(path),
+            "state": "missing",
+            "managed": metadata is not None,
+            "present": False,
+            "valid": False,
+            "mutated": False,
+        }
+
+    _quick_check(path)
+    return {
+        "schemaVersion": 1,
+        "ownerRepo": owner_repo,
+        "environment": environment,
+        "appSlug": app_slug,
+        "databaseFile": database_file,
+        "databasePath": str(path),
+        "state": "ready",
+        "managed": True,
+        "present": True,
+        "valid": True,
+        "bytes": path.stat().st_size,
+        "mutated": False,
+    }
+
+
+def ensure_local_sqlite(
+    *, owner_repo: str, environment: str, app_slug: str, database_file: str
+) -> dict[str, Any]:
+    owner_repo = _owner_repo(owner_repo)
+    environment = _slug(environment, "environment")
+    app_slug = _slug(app_slug, "appSlug")
+    database_file = _database_file(database_file)
+
+    status = local_sqlite_status(
+        owner_repo=owner_repo,
+        environment=environment,
+        app_slug=app_slug,
+        database_file=database_file,
+    )
+    if status["state"] == "unmanaged-existing":
+        raise DeploymentKitError(
+            "Refusing to adopt an existing unmanaged local SQLite database automatically. "
+            "Review its ownership/data before using or moving it."
+        )
+    if status["state"] == "ready":
+        return status
+
+    path = _database_path(app_slug, environment, database_file)
+    path.parent.mkdir(parents=True, exist_ok=True)
+    try:
+        with sqlite3.connect(path) as connection:
+            connection.execute("PRAGMA user_version")
+            connection.commit()
+    except sqlite3.DatabaseError as error:
+        raise DeploymentKitError(f"Unable to create local SQLite database {path}: {error}") from error
+
+    metadata = {
+        "schemaVersion": 1,
+        "ownerRepo": owner_repo,
+        "environment": environment,
+        "appSlug": app_slug,
+        "databaseFile": database_file,
+    }
+    _write_metadata(_metadata_path(app_slug, environment), metadata)
+    _quick_check(path)
+    result = local_sqlite_status(
+        owner_repo=owner_repo,
+        environment=environment,
+        app_slug=app_slug,
+        database_file=database_file,
+    )
+    result["mutated"] = True
+    result["created"] = True
+    return result

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

@@ -0,0 +1,181 @@
+"""Portable non-secret target-definition export/import."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Any
+
+from .errors import DeploymentKitError
+from .profiles import config_root, load_profile, save_profile, validate_target_name
+
+
+BUNDLE_SCHEMA_VERSION = 1
+BUNDLE_KIND = "project-forge-environment-bundle"
+
+
+def _portable_target(profile: dict[str, Any]) -> dict[str, Any]:
+    return {
+        "targetName": profile["targetName"],
+        "targetOs": profile["targetOs"],
+        "hostName": profile["hostName"],
+        "sshAlias": profile["sshAlias"],
+        "user": profile["user"],
+        "port": profile["port"],
+    }
+
+
+def list_target_names() -> list[str]:
+    directory = config_root() / "targets"
+    if not directory.exists():
+        return []
+    if directory.is_symlink() or not directory.is_dir():
+        raise DeploymentKitError(f"Target profile directory is not a real directory: {directory}")
+    names: list[str] = []
+    for path in sorted(directory.glob("*.json")):
+        if path.is_symlink() or not path.is_file():
+            raise DeploymentKitError(f"Target profile entry is not a real file: {path}")
+        names.append(validate_target_name(path.stem))
+    return names
+
+
+def export_bundle(names: list[str] | None = None) -> dict[str, Any]:
+    selected = list_target_names() if names is None else names
+    normalized = sorted(dict.fromkeys(validate_target_name(name) for name in selected))
+    return {
+        "schemaVersion": BUNDLE_SCHEMA_VERSION,
+        "kind": BUNDLE_KIND,
+        "targets": [_portable_target(load_profile(name)) for name in normalized],
+    }
+
+
+def write_bundle(bundle: dict[str, Any], path: Path) -> Path:
+    normalized = validate_bundle(bundle)
+    candidate = path.expanduser().resolve()
+    if candidate.exists():
+        raise DeploymentKitError(f"Refusing to overwrite existing bundle: {candidate}")
+    candidate.parent.mkdir(parents=True, exist_ok=True)
+    candidate.write_text(json.dumps(normalized, indent=2) + "\n", encoding="utf-8")
+    return candidate
+
+
+def validate_bundle(value: Any) -> dict[str, Any]:
+    if not isinstance(value, dict) or set(value) != {"schemaVersion", "kind", "targets"}:
+        raise DeploymentKitError("Portable environment bundle has an unexpected shape.")
+    if value["schemaVersion"] != BUNDLE_SCHEMA_VERSION or value["kind"] != BUNDLE_KIND:
+        raise DeploymentKitError("Unsupported portable environment bundle schema/kind.")
+    targets = value["targets"]
+    if not isinstance(targets, list):
+        raise DeploymentKitError("Portable environment bundle targets must be an array.")
+
+    expected = {"targetName", "targetOs", "hostName", "sshAlias", "user", "port"}
+    seen: set[str] = set()
+    normalized: list[dict[str, Any]] = []
+    for item in targets:
+        if not isinstance(item, dict) or set(item) != expected:
+            raise DeploymentKitError("Portable target definition has an unexpected shape.")
+        name = validate_target_name(item["targetName"])
+        if name in seen:
+            raise DeploymentKitError(f"Duplicate portable target definition: {name}")
+        seen.add(name)
+        machine = _machine_profile(item)
+        normalized_profile = _validate_machine_profile(machine)
+        normalized.append(_portable_target(normalized_profile))
+    return {"schemaVersion": BUNDLE_SCHEMA_VERSION, "kind": BUNDLE_KIND, "targets": normalized}
+
+
+def load_bundle(path: Path) -> dict[str, Any]:
+    candidate = path.expanduser().resolve()
+    if candidate.is_symlink() or not candidate.is_file():
+        raise DeploymentKitError(f"Portable environment bundle is missing or unsafe: {candidate}")
+    try:
+        value = json.loads(candidate.read_text(encoding="utf-8"))
+    except (OSError, UnicodeError, json.JSONDecodeError) as error:
+        raise DeploymentKitError(f"Cannot read portable environment bundle {candidate}: {error}") from error
+    return validate_bundle(value)
+
+
+def _machine_paths(name: str) -> tuple[str, str]:
+    base = Path.home().resolve() / ".ssh" / "project-forge" / validate_target_name(name)
+    return str(base / "id_ed25519"), str(base / "known_hosts")
+
+
+def _machine_profile(item: dict[str, Any]) -> dict[str, Any]:
+    identity, known_hosts = _machine_paths(item["targetName"])
+    return {
+        "schemaVersion": 1,
+        **item,
+        "identityFile": identity,
+        "knownHostsFile": known_hosts,
+        "addressOverride": None,
+    }
+
+
+def _validate_machine_profile(value: dict[str, Any]) -> dict[str, Any]:
+    from .profiles import validate_profile
+
+    return validate_profile(value, expected_target_name=value["targetName"])
+
+
+def plan_import(bundle: dict[str, Any]) -> dict[str, Any]:
+    normalized = validate_bundle(bundle)
+    items: list[dict[str, Any]] = []
+    for portable in normalized["targets"]:
+        desired = _validate_machine_profile(_machine_profile(portable))
+        path = config_root() / "targets" / f"{desired['targetName']}.json"
+        if path.exists():
+            current = load_profile(desired["targetName"])
+            current_portable = _portable_target(current)
+            if current_portable == portable:
+                state = "already-present"
+            else:
+                state = "conflict"
+        else:
+            state = "create"
+        items.append(
+            {
+                "targetName": desired["targetName"],
+                "state": state,
+                "portable": portable,
+                "identityFile": desired["identityFile"],
+                "knownHostsFile": desired["knownHostsFile"],
+            }
+        )
+    return {
+        "schemaVersion": BUNDLE_SCHEMA_VERSION,
+        "kind": BUNDLE_KIND,
+        "targets": items,
+        "hasConflicts": any(item["state"] == "conflict" for item in items),
+        "mutated": False,
+    }
+
+
+def apply_import(plan: dict[str, Any]) -> dict[str, Any]:
+    if plan.get("kind") != BUNDLE_KIND or not isinstance(plan.get("targets"), list):
+        raise DeploymentKitError("Portable environment import plan is malformed.")
+    if plan.get("hasConflicts"):
+        raise DeploymentKitError("Portable environment import has conflicts; existing target definitions are never overwritten.")
+
+    created: list[str] = []
+    existing: list[str] = []
+    for item in plan["targets"]:
+        state = item.get("state")
+        if state == "already-present":
+            existing.append(item["targetName"])
+            continue
+        if state != "create":
+            raise DeploymentKitError("Portable environment import plan contains an unsupported state.")
+        desired = _validate_machine_profile(_machine_profile(item["portable"]))
+        path = config_root() / "targets" / f"{desired['targetName']}.json"
+        if path.exists():
+            raise DeploymentKitError(
+                f"Target profile appeared after preview; re-run preview before importing: {desired['targetName']}"
+            )
+        save_profile(desired)
+        created.append(desired["targetName"])
+    return {
+        "created": created,
+        "alreadyPresent": existing,
+        "mutated": bool(created),
+        "next": "Imported definitions still need this workstation's SSH identity/trust before remote readiness.",
+    }

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

@@ -0,0 +1,70 @@
+"""One-time migration of an existing workstation into the personal Project Forge profile model."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from .errors import DeploymentKitError
+from .portable_profile import list_target_names
+from .profile_repository import ensure_profile_repository, publish_profile, sync_profile
+from .profiles import load_profile
+from .ssh import verify_access
+
+
+PERSONAL_PROFILE_MIGRATION_PHRASE = "[PERSONAL PROFILE MIGRATION]"
+
+
+def migrate_current_workstation() -> dict[str, Any]:
+    """Adopt existing portable target definitions without replacing machine identity/trust.
+
+    Remote verification is evidence only: an offline/unreachable target does not roll back
+    a successfully migrated personal profile/cache. Cleanup of legacy server credentials is
+    intentionally outside this operation and requires a proven new deployment path first.
+    """
+
+    local_targets = list_target_names()
+    ensured = ensure_profile_repository()
+    published = publish_profile()
+    synced = sync_profile(apply=True)
+    if synced.get("blocked"):
+        raise DeploymentKitError(str(synced["blocked"]))
+
+    checks: list[dict[str, Any]] = []
+    for name in local_targets:
+        try:
+            evidence = verify_access(load_profile(name))
+            checks.append(
+                {
+                    "targetName": name,
+                    "state": "ready",
+                    "strictVerification": evidence,
+                }
+            )
+        except DeploymentKitError as error:
+            checks.append(
+                {
+                    "targetName": name,
+                    "state": "not-verified",
+                    "detail": str(error),
+                }
+            )
+
+    return {
+        "profileRepository": ensured["repository"],
+        "localTargets": local_targets,
+        "profileEnsure": ensured,
+        "profilePublish": published,
+        "profileSync": synced,
+        "targetVerification": checks,
+        "machineKeysAndTrust": "preserved",
+        "legacyServerRegistryCredentials": "unchanged-until-new-deployment-path-is-proven",
+        "mutated": bool(
+            ensured.get("mutated")
+            or published.get("mutated")
+            or synced.get("mutated")
+        ),
+        "next": (
+            "Use the normal workstation-mediated Staging deployment path when ready; "
+            "remove legacy server-side registry credentials only after proving they are unused."
+        ),
+    }