sdk-release-kit 0.2.0__py3-none-any.whl

sdk_release_kit/_data/web/index.html

@@ -0,0 +1,142 @@
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1">
+  <meta name="srk-token" content="{{SRK_TOKEN}}">
+  <title>SDK Release Kit</title>
+  <link rel="stylesheet" href="/static/styles.css">
+</head>
+<body>
+  <header class="top">
+    <div class="brand">SDK Release Kit <span id="version" class="muted"></span></div>
+    <nav id="tabs">
+      <button data-tab="repos" class="active">Repositories</button>
+      <button data-tab="outputs">Outputs</button>
+      <button data-tab="keys">Keys</button>
+      <button data-tab="custom">Custom data</button>
+      <button data-tab="run">Run</button>
+    </nav>
+  </header>
+
+  <main>
+    <div id="toast" class="toast" hidden></div>
+
+    <section id="tab-repos" class="tab">
+      <h1>Repositories</h1>
+      <p class="muted">Point each recipe at its checkout on this machine. Paths are stored in
+        <code id="repos-file"></code>, never in git.</p>
+      <table class="grid" id="repos-table">
+        <thead><tr><th>On</th><th>Recipe</th><th>Checkout path</th><th>Check</th></tr></thead>
+        <tbody></tbody>
+      </table>
+      <h2>Tooling</h2>
+      <div class="form" id="tooling-form">
+        <label>JAVA_HOME <input name="java_home" placeholder="/Applications/Android Studio.app/Contents/jbr/Contents/Home"></label>
+        <label>Android SDK <input name="android_sdk" placeholder="~/Library/Android/sdk"></label>
+        <label>Flutter bin <input name="flutter_bin" placeholder="~/path/to/flutter/bin"></label>
+        <label>Xcode DEVELOPER_DIR <input name="developer_dir" placeholder="/Applications/Xcode.app/Contents/Developer"></label>
+        <label>Extra PATH entries <input name="extra_path" placeholder="comma-separated"></label>
+      </div>
+      <div class="actions"><button class="primary" id="save-repos">Save</button></div>
+    </section>
+
+    <section id="tab-outputs" class="tab" hidden>
+      <h1>Outputs</h1>
+      <div class="form">
+        <label>Staging directory <input data-k="staging" placeholder="~/sdk-release-kit/staging"></label>
+      </div>
+      <h2><label class="inline"><input type="checkbox" data-k="onedrive.enabled"> Shared folder (OneDrive or any synced folder)</label></h2>
+      <div class="form">
+        <label>Root <input data-k="onedrive.root" placeholder="~/Library/CloudStorage/OneDrive-Org/SDK Builds"></label>
+        <label>Android demos subfolder <input data-k="onedrive.demos_android"></label>
+        <label>iOS demos subfolder <input data-k="onedrive.demos_ios"></label>
+        <label>Packages subfolder <input data-k="onedrive.packages"></label>
+        <label class="inline"><input type="checkbox" data-k="onedrive.copy_untargeted"> Also copy demos without a target id</label>
+      </div>
+      <h2><label class="inline"><input type="checkbox" data-k="play.enabled"> Google Play</label></h2>
+      <div class="form">
+        <label>Track <input data-k="play.track"></label>
+        <label>Release status
+          <select data-k="play.release_status"><option>completed</option><option>draft</option></select></label>
+        <label>Method
+          <select data-k="play.method"><option>auto</option><option>api</option><option>fastlane</option></select></label>
+        <p class="muted">The service account JSON is set on the Keys page.</p>
+      </div>
+      <h2><label class="inline"><input type="checkbox" data-k="testflight.enabled"> TestFlight</label></h2>
+      <div class="form">
+        <label>Method
+          <select data-k="testflight.method"><option>altool</option><option>fastlane</option></select></label>
+        <p class="muted">The App Store Connect API key is set on the Keys page.</p>
+      </div>
+      <div class="actions"><button class="primary" id="save-outputs">Save</button></div>
+    </section>
+
+    <section id="tab-keys" class="tab" hidden>
+      <h1>Keys</h1>
+      <p class="muted">Key files are referenced by path or uploaded into the private settings
+        directory. Passwords go to the OS keychain or an environment variable; their values are
+        never shown here.</p>
+      <div id="keys-status" class="chips"></div>
+
+      <h2>Android signing</h2>
+      <div class="form">
+        <label>Keystore path <span class="row"><input data-key="android.keystore_path">
+          <input type="file" data-upload="android.keystore_path"></span></label>
+        <label>Key alias <input data-key="android.key_alias"></label>
+        <div class="secret" data-secret="android.store_password"></div>
+        <div class="secret" data-secret="android.key_password"></div>
+        <label class="inline"><input type="checkbox" data-key="android.inject_signing"> Inject signing into Gradle builds</label>
+      </div>
+
+      <h2>Google Play</h2>
+      <div class="form">
+        <label>Service account JSON <span class="row"><input data-key="play.json_key_path">
+          <input type="file" data-upload="play.json_key_path" accept=".json"></span></label>
+      </div>
+
+      <h2>App Store Connect (TestFlight)</h2>
+      <div class="form">
+        <label>.p8 key file <span class="row"><input data-key="testflight.key_path">
+          <input type="file" data-upload="testflight.key_path" accept=".p8"></span></label>
+        <div class="secret" data-secret="testflight.key_id"></div>
+        <div class="secret" data-secret="testflight.issuer_id"></div>
+      </div>
+      <div class="actions"><button class="primary" id="save-keys">Save</button></div>
+    </section>
+
+    <section id="tab-custom" class="tab" hidden>
+      <h1>Custom data</h1>
+      <p class="muted">Free-form YAML. Recipes read values as <code>${custom.some.key}</code>.
+        Comments and unknown keys are kept exactly as written.</p>
+      <textarea id="custom-text" spellcheck="false" rows="22"></textarea>
+      <div class="actions"><button class="primary" id="save-custom">Save</button></div>
+    </section>
+
+    <section id="tab-run" class="tab" hidden>
+      <h1>Run</h1>
+      <div class="run-grid">
+        <fieldset><legend>SDKs</legend><div id="run-sdks"></div></fieldset>
+        <fieldset><legend>Artifacts</legend>
+          <label class="inline"><input type="radio" name="artifacts" value="both" checked> Both</label>
+          <label class="inline"><input type="radio" name="artifacts" value="demos"> Demos</label>
+          <label class="inline"><input type="radio" name="artifacts" value="packages"> Packages</label>
+        </fieldset>
+        <fieldset><legend>Destinations</legend>
+          <label class="inline"><input type="checkbox" name="dest" value="onedrive"> Shared folder</label>
+          <label class="inline"><input type="checkbox" name="dest" value="play"> Google Play</label>
+          <label class="inline"><input type="checkbox" name="dest" value="testflight"> TestFlight</label>
+          <label class="inline"><input type="checkbox" id="skip-upload"> Build only (skip upload)</label>
+        </fieldset>
+      </div>
+      <div class="actions">
+        <button id="dry-run">Dry run</button>
+        <button class="primary" id="start-run">Start</button>
+        <span id="run-state" class="muted"></span>
+      </div>
+      <pre id="run-log" class="log"></pre>
+    </section>
+  </main>
+  <script src="/static/app.js"></script>
+</body>
+</html>

sdk_release_kit/_data/web/styles.css

@@ -0,0 +1,93 @@
+:root {
+  --bg: #f7f8fa;
+  --surface: #ffffff;
+  --text: #1b1f24;
+  --muted: #5f6b7a;
+  --border: #d9dee5;
+  --accent: #2563eb;
+  --accent-text: #ffffff;
+  --ok: #157f3b;
+  --ok-bg: #e5f5ea;
+  --bad: #b42318;
+  --bad-bg: #fdecea;
+  --log-bg: #0f141a;
+  --log-text: #d6dde6;
+}
+@media (prefers-color-scheme: dark) {
+  :root {
+    --bg: #0f141a;
+    --surface: #161c24;
+    --text: #e6ebf1;
+    --muted: #93a0b0;
+    --border: #2a3340;
+    --accent: #4c8dff;
+    --ok: #5fd08a;
+    --ok-bg: #12301f;
+    --bad: #ff8a80;
+    --bad-bg: #3a1a18;
+    --log-bg: #0a0e13;
+  }
+}
+* { box-sizing: border-box; }
+body {
+  margin: 0; background: var(--bg); color: var(--text);
+  font: 15px/1.5 -apple-system, BlinkMacSystemFont, "Segoe UI", Inter, Roboto, sans-serif;
+}
+code { font-family: ui-monospace, SFMono-Regular, Menlo, monospace; font-size: 0.9em; }
+.top {
+  position: sticky; top: 0; z-index: 2; background: var(--surface);
+  border-bottom: 1px solid var(--border); padding: 10px 16px;
+  display: flex; flex-wrap: wrap; gap: 8px 24px; align-items: center;
+}
+.brand { font-weight: 650; }
+nav { display: flex; flex-wrap: wrap; gap: 4px; }
+nav button { background: none; border: 0; padding: 6px 10px; border-radius: 6px; color: var(--muted); cursor: pointer; font: inherit; }
+nav button.active { background: var(--bg); color: var(--text); font-weight: 600; }
+main { max-width: 980px; margin: 0 auto; padding: 16px; }
+h1 { font-size: 1.35rem; margin: 8px 0 4px; }
+h2 { font-size: 1.05rem; margin: 24px 0 8px; }
+.muted { color: var(--muted); }
+.form { display: grid; gap: 10px; background: var(--surface); border: 1px solid var(--border); border-radius: 10px; padding: 14px; }
+.form label { display: grid; gap: 4px; font-size: 0.9rem; color: var(--muted); }
+label.inline { display: inline-flex; gap: 6px; align-items: center; color: var(--text); margin-right: 14px; }
+input:not([type=checkbox]):not([type=radio]):not([type=file]), select, textarea {
+  width: 100%; padding: 7px 9px; border: 1px solid var(--border); border-radius: 6px;
+  background: var(--bg); color: var(--text); font: inherit;
+}
+textarea { font-family: ui-monospace, SFMono-Regular, Menlo, monospace; font-size: 13px; }
+.row { display: flex; gap: 8px; align-items: center; flex-wrap: wrap; }
+.row input:first-child { flex: 1 1 260px; }
+.grid { width: 100%; border-collapse: collapse; background: var(--surface); border: 1px solid var(--border); border-radius: 10px; overflow: hidden; }
+.grid th, .grid td { text-align: left; padding: 8px 10px; border-bottom: 1px solid var(--border); vertical-align: middle; }
+.grid th { font-size: 0.8rem; text-transform: uppercase; letter-spacing: .04em; color: var(--muted); }
+.grid td.check { font-size: 0.85rem; white-space: nowrap; }
+.actions { margin: 16px 0; display: flex; gap: 10px; align-items: center; flex-wrap: wrap; }
+button { font: inherit; padding: 7px 14px; border-radius: 7px; border: 1px solid var(--border); background: var(--surface); color: var(--text); cursor: pointer; }
+button.primary { background: var(--accent); border-color: var(--accent); color: var(--accent-text); }
+button:disabled { opacity: .5; cursor: default; }
+.chips { display: flex; flex-wrap: wrap; gap: 6px; margin: 10px 0; }
+.chip { font-size: 0.8rem; padding: 3px 9px; border-radius: 999px; }
+.chip.ok, .ok { color: var(--ok); }
+.chip.ok { background: var(--ok-bg); }
+.chip.bad, .bad { color: var(--bad); }
+.chip.bad { background: var(--bad-bg); }
+.secret { display: grid; gap: 6px; border-top: 1px dashed var(--border); padding-top: 10px; }
+.secret .row select { width: auto; flex: 0 0 auto; }
+.run-grid { display: grid; gap: 12px; grid-template-columns: repeat(auto-fit, minmax(240px, 1fr)); }
+fieldset { background: var(--surface); border: 1px solid var(--border); border-radius: 10px; padding: 10px 14px; }
+fieldset label.inline { display: flex; margin: 4px 0; }
+legend { font-weight: 600; padding: 0 4px; }
+.log { background: var(--log-bg); color: var(--log-text); padding: 12px; border-radius: 10px; min-height: 160px; max-height: 60vh; overflow: auto; font-size: 12.5px; white-space: pre-wrap; word-break: break-word; }
+.toast { position: fixed; right: 16px; bottom: 16px; max-width: min(90vw, 420px); padding: 10px 14px; border-radius: 8px; background: var(--surface); border: 1px solid var(--border); box-shadow: 0 6px 20px rgba(0,0,0,.15); z-index: 5; white-space: pre-wrap; }
+.toast.err { border-color: var(--bad); color: var(--bad); }
+main, section, .form, fieldset { min-width: 0; }
+p code { overflow-wrap: anywhere; }
+@media (max-width: 640px) {
+  nav { width: 100%; flex-wrap: nowrap; overflow-x: auto; }
+  nav button { flex: 0 0 auto; }
+  .grid, .grid tbody { display: block; width: 100%; }
+  .grid thead { display: none; }
+  .grid tr { display: grid; grid-template-columns: auto 1fr; gap: 4px 8px; padding: 8px 0; border-bottom: 1px solid var(--border); }
+  .grid td { border: 0; padding: 2px 10px; }
+  .grid td.path, .grid td.check { grid-column: 1 / -1; }
+}

sdk_release_kit/builders/__init__.py

@@ -0,0 +1,24 @@
+"""Builders. Importing this package registers every step handler."""
+
+from . import android, flutter, generic, ios, reactnative  # noqa: F401  (registration)
+from .base import (
+    HANDLERS,
+    Artifact,
+    BuildContext,
+    StepError,
+    describe_step,
+    execute_step,
+    skip_reason,
+    step_label,
+)
+
+__all__ = [
+    "HANDLERS",
+    "Artifact",
+    "BuildContext",
+    "StepError",
+    "describe_step",
+    "execute_step",
+    "skip_reason",
+    "step_label",
+]

sdk_release_kit/builders/android.py

@@ -0,0 +1,86 @@
+"""Android: Gradle steps, JAVA_HOME / Android SDK environment, and release signing."""
+
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+from ..models import GradleStep
+from ..paths import expand
+from ..store.keys import resolve_secret
+from .base import BuildContext, Command, StepPlan, handler
+
+_INJECT = "ORG_GRADLE_PROJECT_android.injected.signing."
+
+
+def signing_env(ctx: BuildContext) -> dict[str, str]:
+    """Signing properties for the Android Gradle plugin, passed through the environment.
+
+    Using ``ORG_GRADLE_PROJECT_*`` keeps passwords off the command line (and out of ``ps``).
+    Returns an empty dict when signing is not configured, so Gradle uses the project's own
+    signing setup.
+    """
+    k = ctx.settings.keys.android
+    if not k.inject_signing:
+        return {}
+    keystore = expand(k.keystore_path)
+    if keystore is None or not k.key_alias:
+        return {}
+    if not keystore.is_file():
+        ctx.log.info("WARNING: keystore path is set but the file is missing; not injecting signing")
+        return {}
+    store_pw = resolve_secret(k.store_password)
+    key_pw = resolve_secret(k.key_password) or store_pw
+    if not store_pw:
+        ctx.log.info("WARNING: keystore password not available; not injecting signing")
+        return {}
+    ctx.log.add_secret(store_pw)
+    ctx.log.add_secret(key_pw)
+    return {
+        _INJECT + "store.file": str(keystore),
+        _INJECT + "store.password": store_pw,
+        _INJECT + "key.alias": k.key_alias,
+        _INJECT + "key.password": key_pw or store_pw,
+    }
+
+
+def tooling_env(ctx_env: dict[str, str], tooling) -> dict[str, str]:
+    """Environment adjustments from Repositories > Tooling. Applied to every step."""
+    env = dict(ctx_env)
+    path_parts: list[str] = []
+    java_home = expand(tooling.java_home)
+    if java_home:
+        env["JAVA_HOME"] = str(java_home)
+        path_parts.append(str(java_home / "bin"))
+    sdk = expand(tooling.android_sdk)
+    if sdk:
+        env["ANDROID_HOME"] = str(sdk)
+        env["ANDROID_SDK_ROOT"] = str(sdk)
+        path_parts.append(str(sdk / "platform-tools"))
+    flutter = expand(tooling.flutter_bin)
+    if flutter:
+        # Accept the executable, its bin/ folder, or the SDK root.
+        if flutter.is_file():
+            flutter = flutter.parent
+        elif (flutter / "bin" / "flutter").exists():
+            flutter = flutter / "bin"
+        path_parts.append(str(flutter))
+    dev_dir = expand(tooling.developer_dir)
+    if dev_dir:
+        env["DEVELOPER_DIR"] = str(dev_dir)
+    for extra in tooling.extra_path:
+        p = expand(extra)
+        if p:
+            path_parts.append(str(p))
+    if path_parts:
+        env["PATH"] = os.pathsep.join([*path_parts, env.get("PATH", "")])
+    return env
+
+
+@handler("gradle")
+def gradle_step(ctx: BuildContext, step: GradleStep, cwd: Path) -> StepPlan:
+    wrapper = "gradlew.bat" if os.name == "nt" else "gradlew"
+    exe = f".{os.sep}{wrapper}" if (cwd / wrapper).exists() else "gradle"
+    env = signing_env(ctx) if step.sign else {}
+    notes = ["(release signing injected from Keys)"] if env else []
+    return StepPlan(commands=[Command([exe, *step.tasks, *step.args], cwd, env)], notes=notes)

sdk_release_kit/builders/base.py

@@ -0,0 +1,217 @@
+"""Step execution framework shared by every platform builder.
+
+A recipe stage (``demos`` or ``packages``) is a list of steps. Each step type has a handler
+that turns the step into a ``StepPlan``: commands to run plus how to find what they produced.
+Dry runs print the plan; real runs execute it and copy collected artifacts into staging.
+
+To add a step type: write a handler in a builder module, decorate it with ``@handler("name")``,
+add the matching model to ``models.Step``, and import the module in ``builders/__init__.py``.
+"""
+
+from __future__ import annotations
+
+import os
+import shlex
+import shutil
+import subprocess
+import sys
+from collections.abc import Callable
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any
+
+from ..models import Recipe
+from ..paths import safe_join
+from ..runlog import RunLog
+from ..store import Settings
+
+
+class StepError(RuntimeError):
+    pass
+
+
+@dataclass
+class Artifact:
+    path: Path
+    kind: str
+    recipe: str
+    stage: str  # "demos" or "packages"
+    version: str
+    target: str | None = None
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "path": str(self.path),
+            "kind": self.kind,
+            "recipe": self.recipe,
+            "stage": self.stage,
+            "version": self.version,
+            "target": self.target,
+        }
+
+
+@dataclass
+class Command:
+    argv: list[str]
+    cwd: Path
+    env: dict[str, str] = field(default_factory=dict)
+
+    def display(self) -> str:
+        return f"(cd {shlex.quote(str(self.cwd))} && {shlex.join(self.argv)})"
+
+
+@dataclass
+class Produced:
+    path: Path
+    kind: str
+    target: str | None = None
+
+
+@dataclass
+class StepPlan:
+    commands: list[Command] = field(default_factory=list)
+    roots: dict[str, Path] = field(default_factory=dict)
+    prepare: Callable[[], None] | None = None
+    finish: Callable[[], list[Produced]] | None = None
+    notes: list[str] = field(default_factory=list)
+
+
+@dataclass
+class BuildContext:
+    recipe_id: str
+    recipe: Recipe
+    repo: Path
+    out_dir: Path  # staging/runs/<ts>/<recipe-id>
+    work_dir: Path  # staging/work/<recipe-id>, reused across runs (derived data, archives)
+    version: str
+    env: dict[str, str]
+    settings: Settings
+    log: RunLog
+    active_destinations: set[str]
+
+
+Handler = Callable[[BuildContext, Any, Path], StepPlan]
+HANDLERS: dict[str, Handler] = {}
+
+
+def handler(step_type: str) -> Callable[[Handler], Handler]:
+    def register(fn: Handler) -> Handler:
+        HANDLERS[step_type] = fn
+        return fn
+
+    return register
+
+
+def step_label(step: Any) -> str:
+    return step.name or f"{step.type} in {step.workdir}"
+
+
+def skip_reason(ctx: BuildContext, step: Any) -> str | None:
+    if step.when and not (set(step.when) & ctx.active_destinations):
+        return f"only runs for {', '.join(step.when)}"
+    if step.host == "macos" and sys.platform != "darwin":
+        return "needs macOS"
+    return None
+
+
+def plan_step(ctx: BuildContext, step: Any) -> tuple[Path, StepPlan]:
+    try:
+        cwd = safe_join(ctx.repo, step.workdir)
+    except ValueError as exc:
+        raise StepError(str(exc)) from exc
+    fn = HANDLERS.get(step.type)
+    if fn is None:
+        raise StepError(f"no handler for step type '{step.type}'")
+    plan = fn(ctx, step, cwd)
+    for cmd in plan.commands:
+        cmd.env = {**step.env, **cmd.env}
+    return cwd, plan
+
+
+def run_command(ctx: BuildContext, cmd: Command) -> None:
+    env = {**ctx.env, **cmd.env}
+    argv0 = cmd.argv[0]
+    if os.sep in argv0:
+        exe = str((cmd.cwd / argv0).resolve()) if not os.path.isabs(argv0) else argv0
+    else:
+        exe = shutil.which(argv0, path=env.get("PATH"))
+        if exe is None:
+            raise StepError(f"'{argv0}' not found on PATH (set it in Repositories > Tooling)")
+    ctx.log.info(f"$ {cmd.display()}")
+    proc = subprocess.Popen(
+        [exe, *cmd.argv[1:]],
+        cwd=cmd.cwd,
+        env=env,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.STDOUT,
+        text=True,
+        bufsize=1,
+        errors="replace",
+    )
+    assert proc.stdout is not None
+    for out_line in proc.stdout:
+        ctx.log.line(f"    {out_line.rstrip()}")
+    code = proc.wait()
+    if code != 0:
+        raise StepError(f"command failed with exit code {code}: {shlex.join(cmd.argv)}")
+
+
+def _copy_into(src: Path, dest_dir: Path) -> Path:
+    dest_dir.mkdir(parents=True, exist_ok=True)
+    dest = dest_dir / src.name
+    if dest.exists():
+        shutil.rmtree(dest) if dest.is_dir() and not dest.is_symlink() else dest.unlink()
+    if src.is_dir():
+        shutil.copytree(src, dest, symlinks=True)
+    else:
+        shutil.copy2(src, dest)
+    return dest
+
+
+def execute_step(ctx: BuildContext, step: Any, stage: str) -> list[Artifact]:
+    cwd, plan = plan_step(ctx, step)
+    if not cwd.is_dir():
+        raise StepError(f"workdir '{step.workdir}' does not exist in {ctx.repo}")
+    if plan.prepare:
+        plan.prepare()
+    for cmd in plan.commands:
+        run_command(ctx, cmd)
+    produced: list[Produced] = list(plan.finish() if plan.finish else [])
+
+    roots = {"workdir": cwd, "repo": ctx.repo, **plan.roots}
+    for spec in step.collect:
+        root = roots.get(spec.root)
+        if root is None:
+            raise StepError(f"collect root '{spec.root}' is not available for {step.type} steps")
+        matches = sorted(p for p in root.glob(spec.glob) if p.exists())
+        if not matches and spec.required:
+            raise StepError(f"no files matched '{spec.glob}' under {root}")
+        produced += [Produced(m, spec.kind, spec.target) for m in matches]
+
+    artifacts = []
+    stage_dir = ctx.out_dir / stage
+    for item in produced:
+        dest = _copy_into(item.path, stage_dir)
+        ctx.log.info(
+            f"collected {item.kind}: {dest.name}" + (f" -> {item.target}" if item.target else "")
+        )
+        artifacts.append(Artifact(dest, item.kind, ctx.recipe_id, stage, ctx.version, item.target))
+    return artifacts
+
+
+def describe_step(ctx: BuildContext, step: Any) -> list[str]:
+    """Lines for a dry run: the commands that would run and what would be collected."""
+    reason = skip_reason(ctx, step)
+    if reason:
+        return [f"skip {step_label(step)} ({reason})"]
+    cwd, plan = plan_step(ctx, step)
+    lines = [cmd.display() for cmd in plan.commands]
+    lines += plan.notes
+    for spec in step.collect:
+        lines.append(
+            f"collect {spec.kind} '{spec.glob}' from {spec.root}"
+            + (f" -> {spec.target}" if spec.target else "")
+        )
+    if not cwd.is_dir():
+        lines.append(f"WARNING: workdir '{step.workdir}' does not exist yet")
+    return lines

sdk_release_kit/builders/flutter.py

@@ -0,0 +1,16 @@
+"""Flutter: ``flutter <args>`` from the recipe, with Android signing injected for Gradle."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from ..models import FlutterStep
+from .android import signing_env
+from .base import BuildContext, Command, StepPlan, handler
+
+
+@handler("flutter")
+def flutter_step(ctx: BuildContext, step: FlutterStep, cwd: Path) -> StepPlan:
+    builds_android = any(a in ("apk", "appbundle") for a in step.args)
+    env = signing_env(ctx) if step.sign and builds_android else {}
+    return StepPlan(commands=[Command(["flutter", *step.args], cwd, env)])

sdk_release_kit/builders/generic.py

@@ -0,0 +1,56 @@
+"""Platform-neutral steps: ``run`` (any command) and ``source-zip``."""
+
+from __future__ import annotations
+
+import fnmatch
+import shlex
+import zipfile
+from pathlib import Path
+
+from ..models import RunStep, SourceZipStep
+from .base import BuildContext, Command, Produced, StepPlan, handler
+
+
+@handler("run")
+def run_step(ctx: BuildContext, step: RunStep, cwd: Path) -> StepPlan:
+    argv = shlex.split(step.cmd) if isinstance(step.cmd, str) else list(step.cmd)
+    return StepPlan(commands=[Command(argv, cwd)])
+
+
+def _excluded(rel: Path, patterns: list[str]) -> bool:
+    return any(fnmatch.fnmatch(part, pat) for part in rel.parts for pat in patterns)
+
+
+@handler("source-zip")
+def source_zip(ctx: BuildContext, step: SourceZipStep, cwd: Path) -> StepPlan:
+    out = ctx.work_dir / "source-zip" / f"{ctx.recipe_id}-{ctx.version}.zip"
+    prefix = f"{ctx.recipe_id}-{ctx.version}/"
+    use_git = step.method == "git-archive" and (ctx.repo / ".git").exists()
+
+    def prepare() -> None:
+        out.parent.mkdir(parents=True, exist_ok=True)
+        out.unlink(missing_ok=True)
+
+    if use_git:
+        cmd = Command(
+            ["git", "archive", "--format=zip", f"--prefix={prefix}", "-o", str(out), "HEAD", "."],
+            cwd,
+        )
+        return StepPlan(
+            commands=[cmd],
+            prepare=prepare,
+            finish=lambda: [Produced(out, "zip")],
+            notes=["(committed files only; uncommitted changes are not included)"],
+        )
+
+    def build_zip() -> list[Produced]:
+        prepare()
+        with zipfile.ZipFile(out, "w", zipfile.ZIP_DEFLATED) as zf:
+            for path in sorted(cwd.rglob("*")):
+                rel = path.relative_to(cwd)
+                if path.is_file() and not _excluded(rel, step.exclude):
+                    zf.write(path, prefix + rel.as_posix())
+        ctx.log.info(f"zipped sources into {out.name}")
+        return [Produced(out, "zip")]
+
+    return StepPlan(finish=build_zip, notes=[f"zip files under {cwd} excluding {step.exclude}"])