unity-devkit 0.1.14__py3-none-any.whl → 0.1.16__py3-none-any.whl

unity_devkit/build_unity.py

@@ -1,113 +1,41 @@
-from __future__ import annotations
-
-import json
-import os
-import shutil
-from pathlib import Path
 from typing import Annotated
 
 import typer
-from bashrun.bash import bash_output
-from pydantic_settings import BaseSettings
-
-from ci_devkit.cache import restore, save
-from ci_devkit.ci_step import ci_step
-from .license_restore import restore_license
-from ci_devkit.setup import configure_git, install_dotnet
-from ci_devkit.setup_oras import install_oras
-from .unity import prepare_unity_project, resolve_unity_build, run_unity_batchmode
-
-
-class Settings(BaseSettings):
-    github_workspace: str
 
+from .player_build import build_player, parse_environment_fields
 
 app = typer.Typer(add_completion=False, pretty_exceptions_show_locals=False)
 
 
 @app.command()
-def main(
-    project: Annotated[str, typer.Option(help="Project name")],
-    project_path: Annotated[Path, typer.Option(help="Path to Unity project")],
-    platform: Annotated[str, typer.Option(help="Target platform")],
-    cache_key: Annotated[str, typer.Option(help="Cache key prefix")],
-    registry: Annotated[str, typer.Option(help="OCI registry path")],
-    run_number: Annotated[int, typer.Option(help="CI run number")] = 0,
-    branch: Annotated[str, typer.Option(help="Git branch name")] = "dev",
-    build_env: Annotated[
-        str, typer.Option(help="Newline-separated KEY=VALUE pairs injected into the Unity build process environment")
+def build_unity(
+    project: Annotated[str, typer.Option(help="Unity project name (catalog key in unity-devkit.json)")],
+    build: Annotated[str, typer.Option(help="Build target from the project's builds list (e.g. AndroidMobile)")],
+    version: Annotated[
+        str,
+        typer.Option(help="Version string to stamp into ProjectSettings.asset; empty builds unversioned"),
+    ] = "",
+    run_number: Annotated[int, typer.Option(help="bundleVersionCode to stamp; local builds default to 0")] = 0,
+    development: Annotated[bool, typer.Option(help="Development build column")] = False,
+    environment_preset: Annotated[
+        str,
+        typer.Option(
+            help="Environment preset name (the env class's Presets key); unset leaves the workspace untouched"
+        ),
     ] = "",
+    environment_field: Annotated[
+        list[str] | None,
+        typer.Option("--environment-field", help="Environment field override as path=value (repeatable)"),
+    ] = None,
 ) -> None:
-    settings = Settings.model_validate({})
-
-    for line in build_env.splitlines():
-        entry = line.strip()
-        if not entry:
-            continue
-        key, separator, value = entry.partition("=")
-        if not separator:
-            raise SystemExit(f"Invalid --build-env entry (expected KEY=VALUE): {entry!r}")
-        os.environ[key.strip()] = value.strip()
-
-    with ci_step("Setup"):
-        configure_git(settings.github_workspace)
-        install_dotnet("8.0")
-        install_oras()
-        restore_license()
-
-    branch_slug = branch.replace("/", "-")
-    tag = f"{cache_key}-{platform}-{branch_slug}"
-    fallback_branch = "dev"
-    fallback_tags = [f"{cache_key}-{platform}-{fallback_branch}"] if branch_slug != fallback_branch else None
-
-    with ci_step("Restore library cache"):
-        restore(registry, "unity-library", tag, Path("."), fallback_tags=fallback_tags)
-
-    with ci_step("Prepare build"):
-        project_config, build_flag, execute_method = resolve_unity_build(project, platform)
-        unity_project_path = project_config.path
-        if unity_project_path.resolve() != project_path.resolve():
-            raise SystemExit(
-                f"--project-path {project_path} does not match catalog entry '{project}' at {unity_project_path}"
-            )
-
-    with ci_step("Prepare project"):
-        prepare_unity_project(unity_project_path)
-
-    with ci_step(f"Build {project} [{platform}]"):
-        tag_prefix = project_config.tag_prefix
-        if tag_prefix:
-            version = latest_tag_version(f"{tag_prefix}-v") or "0.0.0"
-            full_version = f"{version}-dev+{run_number}" if branch != "main" else f"{version}+{run_number}"
-            version_file = unity_project_path / ".build-version.json"
-            version_file.write_text(json.dumps({"version": full_version, "runNumber": run_number}))
-            print(f"Wrote version {full_version} (bundleVersionCode={run_number}) to {version_file}")
-
-        run_unity_batchmode(unity_project_path, f"{build_flag} -executeMethod {execute_method}", nographics=False)
-
-    with ci_step("Save library cache"):
-        # PackageCache (~1.6 GiB) is redundant with the shared UPM cache at ~/.cache/Unity/upm/
-        package_cache = project_path / "Library" / "PackageCache"
-        if package_cache.exists():
-            shutil.rmtree(package_cache)
-
-        save(registry, "unity-library", tag, Path("."), [f"{project_path}/Library/"])
-
-    with ci_step("Collect build artifacts"):
-        build_directory = project_path / "Build"
-        if build_directory.is_dir():
-            artifact_directory = Path("/tmp/unity-builds")
-            artifact_directory.mkdir(parents=True, exist_ok=True)
-            if platform == "linux64":
-                shutil.copytree(build_directory, artifact_directory, dirs_exist_ok=True)
-            else:
-                for file in build_directory.rglob("*"):
-                    if file.suffix in {".apk", ".exe"}:
-                        shutil.copy2(file, artifact_directory / file.name)
-
-
-def latest_tag_version(prefix: str) -> str | None:
-    output = bash_output(f'git tag --list "{prefix}*" --sort=-v:refname').strip()
-    if not output:
-        return None
-    return output.splitlines()[0][len(prefix) :]
+    fields = parse_environment_fields(environment_field or [])
+    for artifact in build_player(
+        project,
+        build,
+        version=version,
+        run_number=run_number,
+        development=development,
+        environment_preset=environment_preset,
+        environment_fields=fields,
+    ):
+        print(f"Built: {artifact}")

unity_devkit/ci_build_unity.py

@@ -0,0 +1,98 @@
+from __future__ import annotations
+
+import shutil
+from pathlib import Path
+from typing import Annotated
+
+import typer
+from pydantic_settings import BaseSettings
+
+from ci_devkit.cache import restore, save
+from ci_devkit.ci_step import ci_step
+from .license_restore import restore_license
+from ci_devkit.setup import configure_git, install_dotnet
+from ci_devkit.setup_oras import install_oras
+from .player_build import build_player, parse_environment_fields, resolve_unity_project
+
+
+class Settings(BaseSettings):
+    github_workspace: str
+
+
+app = typer.Typer(add_completion=False, pretty_exceptions_show_locals=False)
+
+
+@app.command()
+def ci_build_unity(
+    project: Annotated[str, typer.Option(help="Project name")],
+    project_path: Annotated[Path, typer.Option(help="Path to Unity project")],
+    platform: Annotated[str, typer.Option(help="Target platform")],
+    cache_key: Annotated[str, typer.Option(help="Cache key prefix")],
+    registry: Annotated[str, typer.Option(help="OCI registry path")],
+    run_number: Annotated[int, typer.Option(help="CI run number")] = 0,
+    branch: Annotated[str, typer.Option(help="Git branch name")] = "dev",
+    environment_preset: Annotated[
+        str, typer.Option(help="Environment preset name; empty leaves the workspace untouched")
+    ] = "",
+    development: Annotated[bool, typer.Option("--development", help="Development build column")] = False,
+    environment_fields: Annotated[
+        str, typer.Option(help="Newline-separated path=value environment field overrides")
+    ] = "",
+    version: Annotated[
+        str, typer.Option(help="Version string to stamp into ProjectSettings.asset; empty builds unversioned")
+    ] = "",
+) -> None:
+    settings = Settings.model_validate({})
+    fields = parse_environment_fields(environment_fields.splitlines())
+
+    with ci_step("Setup"):
+        configure_git(settings.github_workspace)
+        install_dotnet("8.0")
+        install_oras()
+        restore_license()
+
+    branch_slug = branch.replace("/", "-")
+    tag = f"{cache_key}-{platform}-{branch_slug}"
+    fallback_branch = "dev"
+    fallback_tags = [f"{cache_key}-{platform}-{fallback_branch}"] if branch_slug != fallback_branch else None
+
+    with ci_step("Restore library cache"):
+        restore(registry, "unity-library", tag, Path("."), fallback_tags=fallback_tags)
+
+    with ci_step("Prepare build"):
+        unity_project_path = resolve_unity_project(project).path
+        if unity_project_path.resolve() != project_path.resolve():
+            raise SystemExit(
+                f"--project-path {project_path} does not match catalog entry '{project}' at {unity_project_path}"
+            )
+
+    with ci_step(f"Build {project} [{platform}]"):
+        build_player(
+            project,
+            platform,
+            version=version,
+            run_number=run_number,
+            development=development,
+            environment_preset=environment_preset,
+            environment_fields=fields,
+        )
+
+    with ci_step("Save library cache"):
+        # PackageCache (~1.6 GiB) is redundant with the shared UPM cache at ~/.cache/Unity/upm/
+        package_cache = project_path / "Library" / "PackageCache"
+        if package_cache.exists():
+            shutil.rmtree(package_cache)
+
+        save(registry, "unity-library", tag, Path("."), [f"{project_path}/Library/"])
+
+    with ci_step("Collect build artifacts"):
+        build_directory = project_path / "Build"
+        if build_directory.is_dir():
+            artifact_directory = Path("/tmp/unity-builds")
+            artifact_directory.mkdir(parents=True, exist_ok=True)
+            if platform == "Linux":
+                shutil.copytree(build_directory, artifact_directory, dirs_exist_ok=True)
+            else:
+                for file in build_directory.rglob("*"):
+                    if file.suffix in {".apk", ".exe"}:
+                        shutil.copy2(file, artifact_directory / file.name)

unity_devkit/compile_check_unity.py

@@ -0,0 +1,33 @@
+from typing import Annotated
+
+import typer
+
+from .player_build import prepare_unity_project, resolve_unity_project, run_unity_batchmode
+
+app = typer.Typer(add_completion=False, pretty_exceptions_show_locals=False)
+
+COMPILE_ERROR_SIGNATURES = ("error CS",)
+
+
+@app.command()
+def compile_check_unity(
+    project: Annotated[str, typer.Option(help="Unity project name (catalog key in unity-devkit.json)")],
+    execute_method: Annotated[
+        str | None,
+        typer.Option(help="Static method to run after load (Class.Method) — one editor session per invocation"),
+    ] = None,
+    build_target: Annotated[
+        str | None,
+        typer.Option(help="Startup build target (e.g. Android) for sessions that must open on a non-default platform"),
+    ] = None,
+) -> None:
+    project_path = resolve_unity_project(project).path
+    extra_flags = ""
+    if build_target:
+        extra_flags += f" -buildTarget {build_target}"
+    if execute_method:
+        extra_flags += f" -executeMethod {execute_method}"
+    print(f"Compile-checking {project}...")
+    prepare_unity_project(project_path)
+    run_unity_batchmode(project_path, extra_flags, extra_failure_signatures=COMPILE_ERROR_SIGNATURES)
+    print("  Compiles clean")

unity_devkit/dispatch_workflow_generator.py

@@ -0,0 +1,266 @@
+import json
+from pathlib import Path
+from typing import Annotated
+
+import typer
+from pydantic import BaseModel, ConfigDict
+
+from .compile_check_unity import COMPILE_ERROR_SIGNATURES
+from .projects import load_catalog
+from .player_build import prepare_unity_project, run_unity_batchmode
+
+app = typer.Typer(add_completion=False, pretty_exceptions_show_locals=False)
+
+DUMP_EXECUTE_METHOD = "Outernet.PlayerBuild.DumpEnvironment"
+DISPATCH_INPUT_CAP = 25
+NUMERIC_FIELD_TYPES = {
+    "Byte",
+    "SByte",
+    "Int16",
+    "UInt16",
+    "Int32",
+    "UInt32",
+    "Int64",
+    "UInt64",
+    "Single",
+    "Double",
+    "Decimal",
+}
+
+
+class EnvironmentEnum(BaseModel):
+    model_config = ConfigDict(extra="forbid")
+
+    name: str
+    values: list[str]
+    flags: bool
+
+
+class EnvironmentFieldDump(BaseModel):
+    model_config = ConfigDict(extra="forbid")
+
+    path: str
+    field_type: str
+
+
+class EnvironmentDump(BaseModel):
+    model_config = ConfigDict(extra="forbid")
+
+    class_name: str
+    mode_field: str
+    target_path: str
+    presets: dict[str, str]
+    enums: list[EnvironmentEnum]
+    fields: list[EnvironmentFieldDump]
+
+
+@app.command()
+def unity_dispatch(
+    project: Annotated[str, typer.Option(help="Unity project name (catalog key in unity-devkit.json)")],
+    output: Annotated[Path, typer.Option(help="Workflow file to write (or check with --check)")],
+    build_workflow: Annotated[
+        str,
+        typer.Option(
+            help="The build job's uses: value — the consumer's pinned build-unity.yml reference "
+            "(owner/repo/.github/workflows/build-unity.yml@sha, or ./.github/workflows/build-unity.yml inside unity-devkit)"
+        ),
+    ],
+    environment_config_class: Annotated[
+        str | None,
+        typer.Option(help="Env class file path override (defaults to build-config.json's environment_config)"),
+    ] = None,
+    check: Annotated[
+        bool, typer.Option("--check", help="Compare against the existing file instead of writing; fail on drift")
+    ] = False,
+) -> None:
+    projects = load_catalog()
+    if project not in projects:
+        raise SystemExit(f"Unknown project '{project}'. Valid: {', '.join(projects)}")
+
+    project_path = projects[project].path
+    env = {"ENVIRONMENT_CONFIG_CLASS": environment_config_class} if environment_config_class else None
+    print(f"Dumping environment of {project}...")
+    prepare_unity_project(project_path)
+    log_path = run_unity_batchmode(
+        project_path,
+        f"-executeMethod {DUMP_EXECUTE_METHOD}",
+        extra_failure_signatures=COMPILE_ERROR_SIGNATURES,
+        env=env,
+    )
+    dump = extract_environment_dump(log_path)
+    workflow = render_dispatch_workflow(dump, project=project, output=output.as_posix(), build_workflow=build_workflow)
+
+    if check:
+        if not output.is_file():
+            raise SystemExit(f"Dispatch workflow drift: {output} does not exist — generate it")
+        committed = output.read_text(encoding="utf-8")
+        if committed != workflow:
+            raise SystemExit(
+                f"Dispatch workflow drift: {output} differs from the environment class — regenerate with "
+                f"'{regen_command(project, output.as_posix(), build_workflow)}'"
+            )
+        print(f"  {output} matches the environment class")
+        return
+
+    output.parent.mkdir(parents=True, exist_ok=True)
+    output.write_text(workflow, encoding="utf-8")
+    print(f"  wrote {output}")
+
+
+def extract_environment_dump(log_path: Path) -> EnvironmentDump:
+    for line in log_path.read_text(encoding="utf-8", errors="replace").splitlines():
+        candidate = line.strip()
+        if not candidate.startswith("{"):
+            continue
+        try:
+            payload = json.loads(candidate)
+        except json.JSONDecodeError:
+            continue
+        if isinstance(payload, dict) and "class_name" in payload:
+            return EnvironmentDump.model_validate(payload)
+
+    raise SystemExit(f"No environment dump JSON found in the editor log at {log_path}")
+
+
+def render_dispatch_workflow(dump: EnvironmentDump, *, project: str, output: str, build_workflow: str) -> str:
+    enums_by_name = {environment_enum.name: environment_enum for environment_enum in dump.enums}
+    input_blocks: list[tuple[str, str, list[str], str | None]] = [
+        (
+            "environment-preset",
+            "Environment preset (Presets key) — empty leaves the workspace untouched",
+            ["type: choice", "options:", *indent_lines([*(f'- "{preset}"' for preset in ("", *dump.presets))], 2)],
+            'default: ""',
+        ),
+        ("development", "Development build column", ["type: boolean"], "default: false"),
+    ]
+    for field in dump.fields:
+        if field.path == dump.mode_field:
+            continue
+        input_blocks.append(field_input_block(field, enums_by_name))
+
+    input_count = len(input_blocks)
+    if input_count > DISPATCH_INPUT_CAP:
+        raise SystemExit(
+            f"Dispatch panel would carry {input_count} inputs — GitHub's workflow_dispatch cap is {DISPATCH_INPUT_CAP}. "
+            "Shrink the env class or move configuration out of it."
+        )
+
+    transport_lines = [field_transport_line(field) for field in dump.fields if field.path != dump.mode_field]
+    header = (
+        f"# Generated by '{regen_command(project, output, build_workflow)}' from the environment class "
+        f"{dump.class_name} —"
+    )
+
+    lines = [
+        header,
+        "# edit the class, then regenerate this workflow.",
+        "name: Unity Dispatch Build",
+        "",
+        "on:",
+        "  workflow_dispatch:",
+        "    inputs:",
+        *indent_lines([line for block in input_blocks for line in build_input_block(block)], 6),
+        "",
+        "jobs:",
+        "  build:",
+        f"    uses: {build_workflow}",
+        "    with:",
+        "      environment-preset: ${{ inputs['environment-preset'] }}",
+        "      development: ${{ inputs.development }}",
+    ]
+    if transport_lines:
+        lines.append("      environment-fields: |-")
+        lines.extend(indent_lines(transport_lines, 8))
+    else:
+        lines.append("      environment-fields: ''")
+    lines.append("    secrets: inherit")
+    return "\n".join(lines) + "\n"
+
+
+def regen_command(project: str, output: str, build_workflow: str) -> str:
+    return f"uv run unity-dispatch --project {project} --output {output} --build-workflow {build_workflow}"
+
+
+def field_input_block(
+    field: EnvironmentFieldDump, enums_by_name: dict[str, EnvironmentEnum]
+) -> tuple[str, str, list[str], str | None]:
+    input_id = field.path.replace(".", "-")
+    if field.field_type == "Boolean":
+        return (
+            input_id,
+            f"environment field {field.path} (bool) — checked overrides the preset value",
+            ["type: boolean"],
+            "default: false",
+        )
+
+    if field.field_type in enums_by_name:
+        environment_enum = enums_by_name[field.field_type]
+        if environment_enum.flags:
+            return (
+                input_id,
+                (
+                    f"environment field {field.path} (flags: {', '.join(environment_enum.values)}) — "
+                    "comma-separated names, empty keeps the preset value"
+                ),
+                ["type: string"],
+                'default: ""',
+            )
+        return (
+            input_id,
+            f"environment field {field.path} ({environment_enum.name}) — empty keeps the preset value",
+            [
+                "type: choice",
+                "options:",
+                *indent_lines([*(f'- "{value}"' for value in ("", *environment_enum.values))], 2),
+            ],
+            'default: ""',
+        )
+
+    if field.field_type == "String":
+        return (
+            input_id,
+            f"environment field {field.path} (string) — empty keeps the preset value",
+            ["type: string"],
+            'default: ""',
+        )
+
+    if field.field_type in NUMERIC_FIELD_TYPES:
+        return (
+            input_id,
+            f"environment field {field.path} ({field.field_type}) — empty keeps the preset value",
+            ["type: number"],
+            None,
+        )
+
+    raise SystemExit(
+        f"Environment field '{field.path}' has type '{field.field_type}' — no dispatch input type maps to it "
+        "(arrays and object references self-exclude from the dump; this is contract drift)"
+    )
+
+
+def field_transport_line(field: EnvironmentFieldDump) -> str:
+    input_id = field.path.replace(".", "-")
+    guard = "" if field.field_type == "Boolean" else " != ''"
+    return (
+        "${{ inputs['"
+        + input_id
+        + "']"
+        + guard
+        + " && format('"
+        + field.path
+        + "={0}', inputs['"
+        + input_id
+        + "']) || '' }}"
+    )
+
+
+def build_input_block(input_block: tuple[str, str, list[str], str | None]) -> list[str]:
+    input_id, description, type_lines, default_line = input_block
+    lines = [f"{input_id}:", f'  description: "{description}"', *[f"  {line}" for line in type_lines]]
+    if default_line is not None:
+        lines.append(f"  {default_line}")
+    return lines
+
+
+def indent_lines(lines: list[str], spaces: int) -> list[str]:
+    return [f"{' ' * spaces}{line}" if line else line for line in lines]

unity_devkit/install.py

@@ -6,13 +6,13 @@ from pathlib import Path
 from typing import Annotated, Any
 
 import typer
-from bashrun.bash import bash, bash_check, bash_handoff, bash_output
+from bashrun.bash import bash, bash_handoff, bash_output
 
-from .compile_unity import build_unity_project
 from .projects import load_catalog
+from .player_build import build_player
 
-INSTALLABLE_TARGETS = {"android-mobile", "magicleap", "linux64"}
-ADB_TARGETS = {"android-mobile", "magicleap"}
+INSTALLABLE_TARGETS = {"AndroidMobile", "MagicLeap2", "Linux"}
+ADB_TARGETS = {"AndroidMobile", "MagicLeap2"}
 CACHE_ROOT = Path.home() / ".unity-devkit" / "builds"
 
 app = typer.Typer(add_completion=False, pretty_exceptions_show_locals=False)
@@ -23,7 +23,7 @@ def main(
     project: Annotated[str, typer.Option("--project", "-p", help="Unity project name")],
     target: Annotated[
         str | None,
-        typer.Option("--target", "-t", help="Device target (android-mobile, magicleap, linux64)"),
+        typer.Option("--target", "-t", help="Device target (AndroidMobile, MagicLeap2, Linux)"),
     ] = None,
     branch: Annotated[
         str | None,
@@ -31,23 +31,13 @@ def main(
     ] = None,
     run: Annotated[int | None, typer.Option("--run", "-r", help="Specific GitHub Actions run ID")] = None,
     serial: Annotated[str | None, typer.Option("--serial", "-s", help="adb device serial")] = None,
-    no_grant_permissions: Annotated[
-        bool,
-        typer.Option(
-            "--no-grant-permissions",
-            help=(
-                "Skip the post-install `adb shell pm grant` calls listed under `grant_permissions` "
-                "for the project's entry in unity-devkit.json. Permissions are granted by default."
-            ),
-        ),
-    ] = False,
     build_locally: Annotated[
         bool,
         typer.Option(
             "--build",
             "-B",
             help=(
-                "Compile the project locally via `compile-unity` and install the produced APK / "
+                "Build the project locally via `build-unity` and install the produced APK / "
                 "linux executable. Skips the GitHub Actions artifact lookup; --branch / --run are ignored."
             ),
         ),
@@ -81,9 +71,9 @@ def main(
     if build_locally:
         if branch or run:
             print("Warning: --branch / --run are ignored when --build is set")
-        produced = build_unity_project(project_name, target_name)
+        produced = build_player(project_name, target_name)
         apks = [path for path in produced if path.suffix == ".apk"]
-        executables = [path for path in produced if path.suffix == ".exe"]
+        executables = [path for path in produced if path.suffix in {".exe", ".x86_64"}]
     else:
         artifact_name = f"{project_name}-{target_name}"
 
@@ -127,7 +117,7 @@ def main(
         apks = sorted(cache_path.rglob("*.apk"))
 
         executables = []
-        if target_name == "linux64":
+        if target_name == "Linux":
             executable = next(
                 (
                     item
@@ -137,7 +127,7 @@ def main(
                 None,
             )
             if executable is None:
-                print("No linux64 executable found in artifact (expected a file with a matching _Data/ directory)")
+                print("No Linux executable found in artifact (expected a file with a matching _Data/ directory)")
                 raise SystemExit(1)
             executables = [executable]
 
@@ -148,19 +138,7 @@ def main(
 
         print(f"Installing: {apks[0].name}")
         adb_prefix = f"adb -s {serial}" if serial else "adb"
-        package = project_config.package
-        if package:
-            bash_check(f"{adb_prefix} uninstall {package}")
         bash(f"{adb_prefix} install {apks[0]}")
-        permissions = project_config.grant_permissions
-        if permissions and not no_grant_permissions:
-            if not package:
-                raise typer.BadParameter(
-                    f"{project_name} has grant_permissions but no 'package' field in its unity-devkit.json entry"
-                )
-            for permission in permissions:
-                print(f"Granting {permission} to {package}")
-                bash(f"{adb_prefix} shell pm grant {package} {permission}")
         print("Done.")
     else:
         if not executables:

unity_devkit/lock_unity.py

@@ -3,7 +3,7 @@ from typing import Annotated
 import typer
 
 from .projects import load_catalog
-from .unity import prepare_unity_project, run_unity_batchmode
+from .player_build import prepare_unity_project, run_unity_batchmode
 
 app = typer.Typer(add_completion=False, pretty_exceptions_show_locals=False)