gowalk-cicd 1.0.155 → 1.0.157

package/CLAUDE.md

@@ -205,6 +205,12 @@ node /path/to/gowalk-cicd/bin/cli.mjs
   `cache_scope.cjs` and `artifact_env.cjs` copies match the Android distribution byte for byte,
   enforced by `test/artifact-wiring.test.mjs`; update both when changing that common guard.
   Update existing consumer workflow artifact steps as well as action directories on adoption.
+- Backend layout selection belongs in `backend-action/layout.cjs`, reused by the installer and both
+  workflow entrypoints. Support the four standard Compose names without source renames. Multiple
+  matches require explicit existing `backend-dir`/`compose-file` configuration before writes or SSH.
+  Keep the chosen basename through transfer and remote `COMPOSE_FILE`; stale host files must not win
+  Docker's implicit filename precedence. Root source directories remain unsupported. Cover isolated
+  consumer installs, action validation/transfer and remote command selection in focused tests.
 - Backend runtime credentials use the single encrypted `BACKEND_RUNTIME_ENV`
   secret. The action writes it to host-side `.runtime.env` with mode 0600 and
   supplies it to Compose after the generated `.env`; never print its content.

package/README.md

@@ -166,10 +166,34 @@ mobile-only repo is unaffected (the backend path is not installed).
 
 Both supported layouts keep application source under `backend/` or `server/`:
 
-- the compose file can live beside that source as `backend/docker-compose.yml`; or
-- it can live at the repository root as `docker-compose.yml` and build `./backend`
+- the Compose file can live beside that source as `backend/compose.yaml`; or
+- it can live at the repository root as `compose.yaml` and build `./backend`
   (equivalently for `server/`).
 
+The standard names `compose.yaml`, `compose.yml`, `docker-compose.yaml` and
+`docker-compose.yml` are supported without renaming source. Installation, both workflows and the
+backend action use the same selector. Multiple matching files or source directories refuse with
+`backend_layout_ambiguous` before installer writes or SSH. Select the intended existing paths using
+`backend.backend-dir` and `backend.compose-file` in `.gowalk-cicd.yml`; custom source subdirectories
+are supported through that configuration. Source at the repository root (`backend-dir: .`) remains
+unsupported. The host receives and explicitly uses the selected filename, even if an older alternate
+file exists there. Other root-level files are not implicitly copied.
+
+Before preparing the complete app candidate, run the released installer with `--dry-run`, then run
+it without that option. Verify `.github/workflows/deploy-backend.yml` exists and run the ready local
+selector from the app checkout:
+
+```sh
+node .github/actions/backend-app/layout.cjs
+# For an explicitly selected layout, pass the same nonsecret configuration values:
+BACKEND_DIR_INPUT=service COMPOSE_FILE_INPUT=service/compose.yml \
+  BACKEND_LAYOUT_REQUIRED=true node .github/actions/backend-app/layout.cjs
+```
+
+These commands only inspect file locations and return a JSON layout receipt; they do not read Compose
+contents, contact a provider or deploy. Preserve app-owned configuration and generated workflow changes
+in the same validated candidate. A layout receipt proves selection, not production readiness.
+
 The backend workflow runs on a GitHub-hosted runner and, on a push touching
 `backend/**`, deploys to the gowalk host (`138.197.36.107`, publicly reachable):
 it rsyncs the backend dir to `/opt/gowalk-backends/<app>/`, runs
@@ -182,7 +206,7 @@ certificate is installed for the requested domain on redeploy, repairing older H
 
 Requirements on the consumer repo:
 
-- A supported **`docker-compose.yml`** that publishes the API on a **loopback host
+- A supported **Compose file** that publishes the API on a **loopback host
   port** (`127.0.0.1:<port>:<container-port>`) so nginx can proxy it. Include a
   Postgres service (or use a per-app database) and a `/health` endpoint.
 - A **`Dockerfile`** the compose file builds; pin the base image, run non-root,

package/action/.daemux-version

@@ -1 +1 @@
-1.0.155
+1.0.157

package/android-action/.daemux-version

@@ -1 +1 @@
-1.0.155
+1.0.157

package/backend-action/.daemux-version

@@ -1 +1 @@
-1.0.155
+1.0.157

package/backend-action/action.yml

@@ -49,8 +49,8 @@ inputs:
     default: "backend"
   compose-file:
     description: >
-      Compose file path. Empty defaults to <backend-dir>/docker-compose.yml;
-      docker-compose.yml supports a root compose file that builds ./backend or ./server.
+      Compose file path: compose.yaml, compose.yml, docker-compose.yaml or docker-compose.yml
+      at the root or inside backend-dir. Empty selects the one unambiguous supported file.
     required: false
     default: ""
   health-path:
@@ -104,8 +104,9 @@ runs:
       id: layout
       shell: bash
       env:
-        BACKEND_DIR: ${{ inputs.backend-dir }}
+        BACKEND_DIR_INPUT: ${{ inputs.backend-dir }}
         COMPOSE_FILE_INPUT: ${{ inputs.compose-file }}
+        BACKEND_LAYOUT_REQUIRED: "true"
         BACKEND_PUBLIC_HEALTH_URL: ${{ inputs.public-health-url }}
         BACKEND_PUBLIC_BASE_URL: ${{ inputs.public-base-url }}
         BACKEND_EXPECTED_BUILD_SHA: ${{ inputs.expected-build-sha }}
@@ -116,26 +117,10 @@ runs:
         source "${{ github.action_path }}/deploy_evidence.sh"
         BACKEND_DEPLOY_PHASE=validate_inputs
         python3 "${{ github.action_path }}/edge_inputs.py" check
-        COMPOSE_FILE="${COMPOSE_FILE_INPUT:-$BACKEND_DIR/docker-compose.yml}"
-        test -d "$BACKEND_DIR" \
-          || { echo "::error::no backend directory $BACKEND_DIR"; exit 1; }
-        test -f "$COMPOSE_FILE" \
-          || { echo "::error::no compose file $COMPOSE_FILE"; exit 1; }
-        case "$BACKEND_DIR" in
-          /*|../*|*/../*|*/..|.) echo "::error::backend-dir must be a safe relative path"; exit 1;;
-        esac
-        case "$COMPOSE_FILE" in
-          /*|../*|*/../*|*/..) echo "::error::compose-file must be a safe relative path"; exit 1;;
-        esac
-        if [ "$COMPOSE_FILE" != "$BACKEND_DIR/docker-compose.yml" ] \
-          && [ "$COMPOSE_FILE" != "docker-compose.yml" ]; then
-          echo "::error::compose-file must be docker-compose.yml or $BACKEND_DIR/docker-compose.yml"
-          exit 1
-        fi
         case "${{ inputs.app-name }}" in
           *[!a-z0-9-]*|"") echo "::error::app-name must be [a-z0-9-]"; exit 1;;
         esac
-        echo "compose-file=$COMPOSE_FILE" >> "$GITHUB_OUTPUT"
+        node "${{ github.action_path }}/layout.cjs"
 
     - name: Configure SSH
       shell: bash
@@ -155,7 +140,7 @@ runs:
       if: inputs.operation == 'deploy'
       shell: bash
       env:
-        BACKEND_DIR: ${{ inputs.backend-dir }}
+        BACKEND_DIR: ${{ steps.layout.outputs.path }}
         COMPOSE_FILE: ${{ steps.layout.outputs.compose-file }}
       run: |
         set -euo pipefail
@@ -166,7 +151,7 @@ runs:
         $SSH "${{ inputs.ssh-user }}@${{ inputs.host }}" "mkdir -p '$DEST'"
         # --delete keeps the mirror true; exclude .env so server-side secrets
         # (generated DB password, etc.) survive across deploys.
-        if [ "$COMPOSE_FILE" = "$BACKEND_DIR/docker-compose.yml" ]; then
+        if [ "${COMPOSE_FILE%/*}" = "$BACKEND_DIR" ]; then
           rsync -az --delete --exclude '.env' --exclude '.git' \
             --exclude '.backend-edge.json' --exclude '.backend-ingress.conf' --exclude '.backend-public.env' \
             -e "$SSH" "$BACKEND_DIR/" \
@@ -178,7 +163,7 @@ runs:
             -e "$SSH" "$BACKEND_DIR/" \
             "${{ inputs.ssh-user }}@${{ inputs.host }}:$DEST/$BACKEND_DIR/"
           rsync -az -e "$SSH" "$COMPOSE_FILE" \
-            "${{ inputs.ssh-user }}@${{ inputs.host }}:$DEST/docker-compose.yml"
+            "${{ inputs.ssh-user }}@${{ inputs.host }}:$DEST/${COMPOSE_FILE##*/}"
         fi
         # Ship remote helpers after the application mirror. They are package
         # owned and kept out of the consumer's source tree.
@@ -206,6 +191,7 @@ runs:
       shell: bash
       env:
         RUNTIME_ENV: ${{ inputs.runtime-env }}
+        COMPOSE_FILE: ${{ steps.layout.outputs.compose-file }}
         BACKEND_PUBLIC_HEALTH_URL: ${{ inputs.public-health-url }}
         BACKEND_PUBLIC_BASE_URL: ${{ inputs.public-base-url }}
         BACKEND_EXPECTED_BUILD_SHA: ${{ inputs.expected-build-sha }}
@@ -230,7 +216,7 @@ runs:
         $SSH "${{ inputs.ssh-user }}@${{ inputs.host }}" \
           "bash '$DEST/remote_deploy.sh' \
              '${{ inputs.app-name }}' '${{ inputs.api-domain }}' \
-             '${{ inputs.health-path }}' '${{ inputs.cert-email }}'"
+             '${{ inputs.health-path }}' '${{ inputs.cert-email }}' '${COMPOSE_FILE##*/}'"
 
     - name: Read fixed backend identity diagnostics
       id: identity_diagnostics

package/backend-action/layout.cjs

@@ -0,0 +1,72 @@
+// One local-only layout decision for installation, workflow selection and action validation.
+const { appendFileSync, existsSync, lstatSync } = require('node:fs');
+const { join, resolve } = require('node:path');
+
+const NAMES = ['compose.yaml', 'compose.yml', 'docker-compose.yaml', 'docker-compose.yml'];
+
+function refusal(code) {
+  const error = new Error(code);
+  error.result = { schema: 'gowalk-cicd/backend-layout.v1', code,
+    next: 'Set backend.backend-dir and backend.compose-file in .gowalk-cicd.yml, then rerun the installer.' };
+  throw error;
+}
+
+function safePath(value) {
+  if (typeof value !== 'string' || !/^[A-Za-z0-9_.-]+(?:\/[A-Za-z0-9_.-]+)*$/.test(value)
+      || value.split('/').some(part => part === '.' || part === '..')) refusal('backend_layout_path_invalid');
+  return value;
+}
+
+function present(root, path, directory = false) {
+  let current = root;
+  const parts = path.split('/');
+  for (const [index, part] of parts.entries()) {
+    current = join(current, part);
+    if (!existsSync(current)) return false;
+    const stat = lstatSync(current);
+    if (stat.isSymbolicLink()) refusal('backend_layout_symlink_refused');
+    if (index < parts.length - 1 && !stat.isDirectory()) return false;
+  }
+  const stat = lstatSync(current);
+  return directory ? stat.isDirectory() : stat.isFile();
+}
+
+function selectLayout(root, { backendDir = '', composeFile = '', required = false } = {}) {
+  root = resolve(root);
+  if (backendDir) safePath(backendDir);
+  if (composeFile) safePath(composeFile);
+  const directories = backendDir ? [backendDir] : ['backend', 'server'];
+  const layouts = [];
+  for (const directory of directories) {
+    if (!present(root, directory, true)) continue;
+    const files = NAMES.map(name => `${directory}/${name}`);
+    if (present(root, `${directory}/Dockerfile`)) files.push(...NAMES);
+    for (const file of files) {
+      if ((!composeFile || composeFile === file) && present(root, file)) {
+        layouts.push({ backendDir: directory, composeFile: file });
+      }
+    }
+  }
+  if (layouts.length > 1) refusal('backend_layout_ambiguous');
+  if (!layouts.length && (required || backendDir || composeFile)) refusal('backend_layout_missing');
+  return layouts[0] || null;
+}
+
+function main() {
+  try {
+    const layout = selectLayout(process.cwd(), { backendDir: process.env.BACKEND_DIR_INPUT || '',
+      composeFile: process.env.COMPOSE_FILE_INPUT || '', required: process.env.BACKEND_LAYOUT_REQUIRED === 'true' });
+    if (process.env.GITHUB_OUTPUT) {
+      const source = layout?.backendDir || '', compose = layout?.composeFile || '';
+      appendFileSync(process.env.GITHUB_OUTPUT, `path=${source}\ncompose=${compose}\ncompose-file=${compose}\n`);
+    }
+    console.log(JSON.stringify({ schema: 'gowalk-cicd/backend-layout.v1', layout }));
+  } catch (error) {
+    console.error(JSON.stringify(error.result || { schema: 'gowalk-cicd/backend-layout.v1',
+      code: 'backend_layout_unavailable' }));
+    process.exitCode = 1;
+  }
+}
+
+module.exports = { NAMES, selectLayout };
+if (require.main === module) main();

package/backend-action/network_prepare.py

@@ -122,7 +122,8 @@ def prepare(config, app, *, reader=collect, owner_reader=ownership_inventory, co
                 inventory = reader(command, require_pools=False)
                 if inventory.get('pool_failure'):
                     raise NetworkFailure(inventory['pool_failure'])
-                if not re.fullmatch(r'v?2\.\d+\.\d+', inventory['compose_version']):
+                # Compose 2 and 5 reuse a project network that carries no config-hash label (docs/BACKEND_NETWORKS.md).
+                if not re.fullmatch(r'v?(?:2|5)\.\d+\.\d+', inventory['compose_version']):
                     raise NetworkFailure('compose_version_unsupported')
                 rows.append(create_one(plan, inventory, reader, command))
                 inventory = reader(command, require_pools=False)

package/backend-action/network_test_fixture.py

@@ -28,9 +28,10 @@ class Host:
         self.calls = []
         self.pool_failure = ''
         self.lose_reply = False
+        self.compose_version = '2.39.4'
 
     def inventory(self, command, require_pools=True):
-        return {'docker_version': '28.0.4', 'compose_version': '2.39.4', 'observed_at': '2026-09-15T00:00:00Z',
+        return {'docker_version': '28.0.4', 'compose_version': self.compose_version, 'observed_at': '2026-09-15T00:00:00Z',
                 'python_version': '3.8.20', 'pool_source': 'fixture', 'pool_failure': self.pool_failure,
                 'pools': [{'base': '172.28.0.0/22', 'size': 16}], 'networks': copy.deepcopy(self.networks),
                 'host_excluded': [], 'host_records': [],

package/backend-action/remote_deploy.sh

@@ -12,6 +12,12 @@ DIR="/opt/gowalk-backends/$APP"
 source "$(dirname "${BASH_SOURCE[0]}")/deploy_evidence.sh"
 BACKEND_DEPLOY_PHASE=remote_setup
 cd "$DIR"
+export COMPOSE_FILE="${5:-docker-compose.yml}"
+case "$COMPOSE_FILE" in
+  compose.yaml|compose.yml|docker-compose.yaml|docker-compose.yml) ;;
+  *) echo "::error::unsupported backend compose filename"; exit 1;;
+esac
+test -f "$COMPOSE_FILE" || { echo "::error::selected backend compose file is missing"; exit 1; }
 source "$DIR/select_certbot_account.sh"
 source "$DIR/ensure_certificate.sh"
 

package/backend-action/test_network_prepare.py

@@ -85,6 +85,27 @@ class PreparationTests(unittest.TestCase):
         self.assertEqual(set(values), {'172.28.1.0/24', '172.28.2.0/24'})
         self.assertEqual(len(host.calls), 2)
 
+    def test_reviewed_compose_majors_allocate_and_others_refuse_before_create(self):
+        for version in ('2.39.4', 'v2.40.3', '5.0.0', '5.3.1', 'v5.5.1'):
+            host = Host()
+            host.compose_version = version
+            result = prepare(config('first'), 'first', **host.arguments())
+            self.assertTrue(result['ok'])
+            self.assertEqual(result['compose_version'], version)
+            self.assertEqual(host.networks[-1]['Labels']['com.docker.compose.version'], version)
+            self.assertNotIn('com.docker.compose.config-hash', host.networks[-1]['Labels'])
+            self.assertEqual(len(host.calls), 1)
+        for version in ('1.29.2', '3.0.0', '4.1.0', '6.0.0', '5.3', '25.0.0'):
+            host = Host()
+            host.compose_version = version
+            with self.assertRaisesRegex(NetworkFailure, 'compose_version_unsupported'):
+                prepare(config('first'), 'first', **host.arguments())
+            self.assertEqual(host.calls, [])
+            host.networks.append(network('existing', '172.29.0.0/16'))
+            preserved = prepare(config('existing'), 'existing', **host.arguments())
+            self.assertEqual(preserved['networks'][0]['state'], 'preserved')
+            self.assertEqual(host.calls, [])
+
     def test_full_effective_pool_and_unknown_provenance_refuse_expansion(self):
         for unknown in (False, True):
             host = Host()

package/docs/BACKEND_NETWORKS.md

@@ -28,10 +28,21 @@ fingerprint. A later change to its network contract refuses before Compose rathe
 ignoring authored IPAM or replacing a network that may carry active workloads. An app requiring a
 different network must implement that deliberate migration in its own deployment.
 
-The helper intentionally does not manufacture `com.docker.compose.config-hash`. Compose 2 accepts a
-network with the correct project/network labels and no hash. A wrong hash can trigger replacement.
-Its own fingerprint protects replay, including configuration changes. Other Compose major versions
-require compatibility review before new-network preparation is admitted.
+The helper intentionally does not manufacture `com.docker.compose.config-hash`. Compose 2 and Compose 5
+accept a network with the correct project/network labels and no hash. A wrong hash can trigger
+replacement. Its own fingerprint protects replay, including configuration changes. New-network
+preparation admits Compose 2.x and 5.x; any other major version refuses with
+`compose_version_unsupported` until it has been reviewed. Existing selected networks are preserved
+under every Compose version because preservation never allocates.
+
+Compose 5 review (2026-09-17, docker/compose tags v5.0.0, v5.3.1 and v5.5.1 against v2.40.3):
+`resolveOrCreateNetwork` in `pkg/compose/create.go` at v5.0.0 and v5.3.1 returns the inspected
+network when its `com.docker.compose.network` label matches and its config-hash label is empty or
+equal (`hash == "" || hash == expected`), the same branch as v2.40.3; the remaining differences are
+Docker client types, IPAM parsing and event emission. v5.5.1 moved reuse into `reconcileNetworks`
+in `pkg/compose/reconcile.go`, whose observed state is scoped by the project label and which leaves a
+network with no recorded hash untouched (`observed.ConfigHash == ""`). docker/compose carries no v3 or
+v4 tags, and Compose 1 (`docker-compose`) stays unreviewed.
 
 ## Address-space proof
 

package/docs/CONFIGURATION.md

@@ -35,6 +35,26 @@ until the app explicitly replaces their references in this file. Keep passwords,
 signing material, tokens and private keys in GitHub Secrets. Reference their names;
 never put their values in this configuration.
 
+Backend discovery accepts `compose.yaml`, `compose.yml`, `docker-compose.yaml` and
+`docker-compose.yml` inside `backend/` or `server/`, or at the repository root with a Dockerfile in
+exactly one of those source directories. Multiple matches require an explicit selection; no file is
+renamed and no arbitrary precedence chooses the deployment. Existing named settings disambiguate it:
+
+```yaml
+backend:
+  backend-dir: service
+  compose-file: service/compose.yml
+```
+
+Use an existing source subdirectory and either its standard Compose file or a root standard Compose
+file. Root Compose layouts also require that source directory's Dockerfile. `backend-dir: .`, parent
+paths and symlinks are refused. Both generated backend entrypoints receive the selected settings.
+For a custom source directory, retain its app-owned backend workflow path filter alongside the standard
+`backend/**` and `server/**` defaults; layout selection does not change custom deployment triggers.
+Run `npx --yes gowalk-cicd@<version> --dry-run`, then the same installer without `--dry-run`; a
+`backend_layout_ambiguous` or `backend_layout_missing` receipt identifies selection repair before any
+files are written. Keep runtime and workflow customizations in this configuration when rerunning it.
+
 Backend edge settings are optional and preserve legacy deployments when absent. When enabled,
 the infrastructure `api-domain` must be a fresh alias distinct from the retained legacy hostname.
 Provision its Cloudflare route/token first. Public health proves the exact `build_sha`; the app's

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gowalk-cicd",
-  "version": "1.0.155",
+  "version": "1.0.157",
   "description": "Zero-config GitHub Actions delivery for iOS TestFlight and Android Google Play.",
   "type": "module",
   "bin": {

package/src/backend-layout.mjs

@@ -0,0 +1,11 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import layout from '../backend-action/layout.cjs';
+import { readYaml } from './config/yaml.mjs';
+
+export function backendLayout(root) {
+  const file = '.gowalk-cicd.yml', path = join(root, file);
+  const settings = existsSync(path) ? readYaml(readFileSync(path, 'utf8'), file).value.backend || {} : {};
+  const local = key => typeof settings[key] === 'string' && !settings[key].includes('${{') ? settings[key] : '';
+  return layout.selectLayout(root, { backendDir: local('backend-dir'), composeFile: local('compose-file') });
+}

package/src/config/settings.mjs

@@ -36,6 +36,16 @@ export function applySettings(config, file, workflow) {
     const value = at(config, name);
     if (value !== undefined) assign(workflow, { path, value });
   }
+  const job = file === 'deploy.yml' ? 'backend-preview' : file === 'deploy-backend.yml' ? 'deploy' : null;
+  if (job) {
+    for (const [key, output, variable] of [['backend-dir', 'path', 'BACKEND_DIR_INPUT'],
+      ['compose-file', 'compose', 'COMPOSE_FILE_INPUT']]) {
+      const value = config.backend?.[key];
+      if (value !== undefined && value !== `\${{ steps.dir.outputs.${output} }}`) {
+        assign(workflow, { path: ['jobs', job, 'steps', 'items', 'id:dir', 'env', variable], value });
+      }
+    }
+  }
   return workflow;
 }
 

package/src/install.mjs

@@ -21,6 +21,7 @@ import { fileURLToPath } from 'node:url';
 import { dirname } from 'node:path';
 import { planWorkflows, writeWorkflows } from './config/workflows.mjs';
 import { recoverWorkflows } from './config/transaction.mjs';
+import { backendLayout } from './backend-layout.mjs';
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
@@ -40,26 +41,6 @@ const VERSION_MARKER_REL = join('.github', 'actions', 'swift-app', '.daemux-vers
 const ANDROID_VERSION_MARKER_REL = join('.github', 'actions', 'android-app', '.daemux-version');
 const BACKEND_VERSION_MARKER_REL = join('.github', 'actions', 'backend-app', '.daemux-version');
 
-// A repo has a backend when backend/ or server/ either carries the compose file
-// or is referenced by a root compose file. The latter is Flutter's common
-// full-stack layout: docker-compose.yml stays at the repo root so it can build
-// ./backend while the deploy action still syncs only backend-owned files.
-function backendLayout(repoRoot) {
-  for (const d of ['backend', 'server']) {
-    if (existsSync(join(repoRoot, d, 'docker-compose.yml'))) {
-      return { backendDir: d, composeFile: join(d, 'docker-compose.yml') };
-    }
-  }
-  if (existsSync(join(repoRoot, 'docker-compose.yml'))) {
-    for (const d of ['backend', 'server']) {
-      if (existsSync(join(repoRoot, d, 'Dockerfile'))) {
-        return { backendDir: d, composeFile: 'docker-compose.yml' };
-      }
-    }
-  }
-  return null;
-}
-
 // Lines we treat as ignoring credentials. If any appears in the consumer's
 // .gitignore, CI will not see one or both platform keys. We warn instead of
 // auto-editing, because

package/templates/deploy-backend.yml

@@ -10,6 +10,9 @@ on:
       - "backend/**"
       - "server/**"
       - "docker-compose.yml"
+      - "docker-compose.yaml"
+      - "compose.yml"
+      - "compose.yaml"
       - ".github/workflows/deploy-backend.yml"
       - ".github/actions/backend-app/**"
       - "!.github/actions/backend-app/.daemux-version"
@@ -47,23 +50,9 @@ jobs:
       # Pick the source dir and either its nested compose file or a root one.
       - id: dir
         if: inputs.operation == '' || inputs.operation == 'deploy'
-        run: |
-          if [ -f backend/docker-compose.yml ]; then
-            echo "path=backend" >> "$GITHUB_OUTPUT"
-            echo "compose=backend/docker-compose.yml" >> "$GITHUB_OUTPUT"
-          elif [ -f server/docker-compose.yml ]; then
-            echo "path=server" >> "$GITHUB_OUTPUT"
-            echo "compose=server/docker-compose.yml" >> "$GITHUB_OUTPUT"
-          elif [ -f docker-compose.yml ] && [ -f backend/Dockerfile ]; then
-            echo "path=backend" >> "$GITHUB_OUTPUT"
-            echo "compose=docker-compose.yml" >> "$GITHUB_OUTPUT"
-          elif [ -f docker-compose.yml ] && [ -f server/Dockerfile ]; then
-            echo "path=server" >> "$GITHUB_OUTPUT"
-            echo "compose=docker-compose.yml" >> "$GITHUB_OUTPUT"
-          else
-            echo "::error::no supported backend compose layout"
-            exit 1
-          fi
+        env:
+          BACKEND_LAYOUT_REQUIRED: "true"
+        run: node .github/actions/backend-app/layout.cjs
 
       - name: Deploy backend
         uses: ./.github/actions/backend-app

package/templates/deploy.yml

@@ -687,18 +687,8 @@ jobs:
       - id: dir
         shell: bash
         run: |
-          if [ -f backend/docker-compose.yml ]; then
-            echo "path=backend" >> "$GITHUB_OUTPUT"
-            echo "compose=backend/docker-compose.yml" >> "$GITHUB_OUTPUT"
-          elif [ -f server/docker-compose.yml ]; then
-            echo "path=server" >> "$GITHUB_OUTPUT"
-            echo "compose=server/docker-compose.yml" >> "$GITHUB_OUTPUT"
-          elif [ -f docker-compose.yml ] && [ -f backend/Dockerfile ]; then
-            echo "path=backend" >> "$GITHUB_OUTPUT"
-            echo "compose=docker-compose.yml" >> "$GITHUB_OUTPUT"
-          elif [ -f docker-compose.yml ] && [ -f server/Dockerfile ]; then
-            echo "path=server" >> "$GITHUB_OUTPUT"
-            echo "compose=docker-compose.yml" >> "$GITHUB_OUTPUT"
+          if [ -f .github/actions/backend-app/layout.cjs ]; then
+            node .github/actions/backend-app/layout.cjs
           else
             echo "path=" >> "$GITHUB_OUTPUT"
             echo "compose=" >> "$GITHUB_OUTPUT"