Upload 7 files

app.py

@@ -392,6 +392,22 @@ def detect_type(src: Path) -> str:
             has_fw = False
         if has_web_entry or has_fw or has_pkg:
             return "hybrid-capacitor"
+    # Flat baked manifest: AndroidManifest.xml at project root next to web
+    # files (same level as index.html / capacitor config). Same baked-perms
+    # intent as the partial-shell path above, minus the scaffolding. Gated on
+    # a web entry so stray files alone never hijack routing; native uploads
+    # keep their manifests under android/... and never match here.
+    if (src / "AndroidManifest.xml").is_file():
+        try:
+            has_flat_web = (
+                (src / "index.html").exists()
+                or (src / "www" / "index.html").exists()
+                or any(p.suffix == ".html" for p in src.rglob("*.html"))
+            )
+        except Exception:
+            has_flat_web = False
+        if has_flat_web:
+            return "hybrid-capacitor"
     if (src / "config.xml").exists() and (src / "package.json").exists():
         return "hybrid-cordova"
     if list(src.rglob("app/build.gradle")) or list(src.rglob("app/build.gradle.kts")):
@@ -1641,6 +1657,59 @@ async def run_build(job_id: str, build_id: str, task: str, signing: dict, app_co
                     log(f"WARNING: capacitor dev server.url={server_url} — remove it for production builds, else the app loads your machine instead of the bundled web")
             except Exception as e:
                 log(f"capacitor config note: {e} — using webDir={web_dir_name}")
+            # --- webDir "." normalization (Capacitor CLI rejects it by design:
+            # checkWebDir invalidFolders = ['', '.', '..', '../', './'] — copying
+            # the project root would swallow android/ itself. Materialize www/
+            # in the disposable work copy (the upload is never touched) and point
+            # the work-copy config at it. Meaning-preserving: identical files,
+            # CLI-accepted directory. Baked-manifest handling below is unchanged.
+            try:
+                if web_dir_name.strip() in (".", "./", ""):
+                    www = work_base / "www"
+                    www.mkdir(parents=True, exist_ok=True)
+                    skip = {"android", "android.partial_bak", "node_modules",
+                            "package.json", "package-lock.json",
+                            "capacitor.config.json", "capacitor.config.ts",
+                            "capacitor.config.js", "AndroidManifest.xml"}
+                    copied = 0
+                    for child in work_base.iterdir():
+                        if child.name in skip or child.name.startswith("."):
+                            continue
+                        dest = www / child.name
+                        if dest.exists():
+                            continue
+                        try:
+                            if child.is_dir() and not child.is_symlink():
+                                shutil.copytree(child, dest, symlinks=False, ignore_dangling_symlinks=True)
+                            elif child.is_file():
+                                shutil.copy2(child, dest)
+                            else:
+                                continue
+                            copied += 1
+                        except Exception as ce:
+                            log(f"webDir normalize skip {child.name}: {ce}")
+                    if cfg_json.exists():
+                        try:
+                            data = json.loads(cfg_json.read_text(encoding="utf-8", errors="ignore"))
+                            data["webDir"] = "www"
+                            cfg_json.write_text(json.dumps(data, indent=2), encoding="utf-8")
+                        except Exception as je:
+                            log(f"webDir config rewrite note: {je}")
+                    else:
+                        for cn in ("capacitor.config.ts", "capacitor.config.js"):
+                            cp = work_base / cn
+                            if cp.is_file():
+                                try:
+                                    ctxt = cp.read_text(encoding="utf-8", errors="ignore")
+                                    ntxt = re.sub(r"(webDir\s*:\s*)['\"][^'\"]*['\"]", r'\1"www"', ctxt, count=1)
+                                    if ntxt != ctxt:
+                                        cp.write_text(ntxt, encoding="utf-8")
+                                except Exception as te:
+                                    log(f"webDir config rewrite note: {te}")
+                    web_dir_name = "www"
+                    log(f"webDir '.' is rejected by Capacitor CLI — normalized root web assets into www/ ({copied} entries) in work copy, upload untouched")
+            except Exception as e:
+                log(f"webDir normalize note: {e}")
             # --- env preflight (versions only) + JDK gate (Cap7+ cannot compile on JDK17) ---
             try:
                 res = await _run_cmd(["node", "-v"], timeout=15)
@@ -1782,13 +1851,22 @@ async def run_build(job_id: str, build_id: str, task: str, signing: dict, app_co
             # used as-is (extra files under android/ preserved).
             try:
                 andra = work_base / "android"
-                baked_man = andra / "app" / "src" / "main" / "AndroidManifest.xml"
+                # Baked manifest sources, in order: partial-shell manifest, then
+                # a flat AndroidManifest.xml at project root next to the web
+                # files (same baked-perms intent, minus scaffolding). First hit
+                # wins; the restore below is source-agnostic.
                 baked_bytes = None
-                if baked_man.is_file():
-                    try:
-                        baked_bytes = baked_man.read_bytes()
-                    except Exception:
-                        baked_bytes = None
+                baked_src = ""
+                for cand in (andra / "app" / "src" / "main" / "AndroidManifest.xml",
+                             work_base / "AndroidManifest.xml"):
+                    if cand.is_file():
+                        try:
+                            baked_bytes = cand.read_bytes()
+                            baked_src = str(cand.relative_to(work_base))
+                            break
+                        except Exception:
+                            baked_bytes = None
+                            baked_src = ""
                 shell_complete = (
                     (andra / "app" / "build.gradle").is_file()
                     or (andra / "app" / "build.gradle.kts").is_file()
@@ -1809,7 +1887,10 @@ async def run_build(job_id: str, build_id: str, task: str, signing: dict, app_co
                     log("cap: local binary missing — using npx @capacitor/cli")
                 if not andra.exists() or not shell_complete:
                     if baked_bytes is not None:
-                        log("Partial baked android/ detected (manifest without Gradle shell) — cap add builds the shell first, baked manifest replaces the generated one afterwards")
+                        if baked_src == "AndroidManifest.xml":
+                            log("Root-level AndroidManifest.xml found alongside web files — cap add builds the shell first, your manifest replaces the generated one afterwards")
+                        else:
+                            log("Partial baked android/ detected (manifest without Gradle shell) — cap add builds the shell first, baked manifest replaces the generated one afterwards")
                     else:
                         log("android/ missing or incomplete — running cap add android")
                     # Move the partial shell aside (never rmtree): on `cap add`
@@ -1826,7 +1907,16 @@ async def run_build(job_id: str, build_id: str, task: str, signing: dict, app_co
                     res = await _run_cmd(cap_add, cwd=work_base, timeout=180)
                     if res.returncode != 0:
                         try:
-                            if partial_bak.exists() and not andra.exists():
+                            if partial_bak.exists():
+                                # Failed `cap add` can leave a half-created android/
+                                # behind (skeleton is made before the copy step that
+                                # failed). That output is disposable; the moved-aside
+                                # original is the only thing worth keeping. The rmtree
+                                # is safe exactly because partial_bak exists — it proves
+                                # the original was moved aside, so current android/
+                                # can only be cap's failed output, never user files.
+                                if andra.exists():
+                                    shutil.rmtree(andra, ignore_errors=True)
                                 partial_bak.rename(andra)
                                 log("Restored partial android/ after cap add failure")
                         except Exception: