@crvouga/dev-fleet 0.0.0-stage → 0.2.0

package/cliproxy/scripts/container-health

@@ -0,0 +1,6 @@
+#!/bin/bash
+set -eu
+exec 3<>/dev/tcp/127.0.0.1/8317
+printf 'GET /v1/models HTTP/1.1\r\nHost: localhost\r\nConnection: close\r\n\r\n' >&3
+read -r _ status _ <&3
+[[ $status == 401 ]]

package/cliproxy/scripts/docker

@@ -0,0 +1,24 @@
+#!/usr/bin/env python3
+import sys
+
+sys.dont_write_bytecode = True
+
+import os, pathlib
+
+sys.path.insert(0, str(pathlib.Path(__file__).resolve().parent))
+import cliproxy_host
+
+args = sys.argv[1:]
+if args and args[0] == "compose" and "--project-directory" not in args:
+    args = [
+        "compose",
+        "--project-directory",
+        str(cliproxy_host.default_root()),
+        *args[1:],
+    ]
+try:
+    argv, environment = cliproxy_host.docker_invocation(args, __file__)
+except cliproxy_host.DockerUnavailable as error:
+    print(str(error), file=sys.stderr)
+    sys.exit(cliproxy_host.DOCKER_UNAVAILABLE)
+os.execvpe(argv[0], argv, environment)

package/cliproxy/scripts/external-health.py

@@ -0,0 +1,79 @@
+#!/usr/bin/env python3
+"""Off-machine, read-only checks using short-lived GitHub OIDC Vault access."""
+
+import sys
+
+sys.dont_write_bytecode = True
+
+import json
+import os
+import pathlib
+import time
+import cloud_state
+import fleet_config
+
+
+def endpoint_health(endpoint, key, request=cloud_state.request):
+    def get(path, authenticated=False):
+        return request(
+            endpoint + path,
+            {"Authorization": "Bearer " + key} if authenticated else None,
+        )
+
+    if get("/v1/models")[0] != 401:
+        raise ValueError("Anonymous inference must be rejected")
+    status, body = get("/v1/models", True)
+    models = json.loads(body).get("data") if status == 200 else None
+    if not isinstance(models, list) or not models:
+        raise ValueError("Authenticated endpoint has no available models")
+    # Upstream counts missing/wrong management keys toward a per-IP ban.
+    # Scheduled health checks must never generate those failed login attempts.
+    if get("/management.html")[0] != 200:
+        raise ValueError("Dashboard unavailable")
+
+
+def cloud_health(restic):
+    snapshot = cloud_state.latest(restic)
+    cloud_state.fresh(snapshot["time"], 45 * 60)
+    path = snapshot["paths"][0].rstrip("/") + "/state/status/gc-success.json"
+    gc = json.loads(restic("dump", snapshot["id"], path))
+    cloud_state.fresh(gc["time"], 9 * 86400)
+    return snapshot["id"]
+
+
+def main():
+    token = os.environ.get("VAULT_TOKEN", "")
+    if not token:
+        raise ValueError("Existing short-lived Vault login required")
+    data = cloud_state.settings(token)
+    errors = []
+    for attempt in range(3):
+        try:
+            endpoint_health(fleet_config.endpoint(), data["CLIPROXY_FLEET_CLIENT_API_KEY"])
+            print("PASS: external HTTPS, client authentication, models and dashboard.")
+            break
+        except Exception:
+            if attempt == 2:
+                errors.append("Public endpoint authentication/availability failed.")
+            else:
+                time.sleep(10)
+    try:
+        cloud_health(cloud_state.client(data))
+        print(
+            "PASS: cloud checkpoint under 45 minutes old; successful GC under nine days old."
+        )
+    except Exception:
+        errors.append("Cloud checkpoint or GC freshness/readability failed.")
+    if errors:
+        for error in errors:
+            print("FAIL:", error)
+        raise ValueError(" ".join(errors))
+
+
+if __name__ == "__main__":
+    try:
+        main()
+    except Exception:
+        raise SystemExit(
+            "External CLI proxy verification failed; credentials and upstream responses suppressed. See the last completed check above."
+        ) from None

package/cliproxy/scripts/fleet_config.py

@@ -0,0 +1,43 @@
+"""This fleet's own configuration, as the proxy scripts need it.
+
+Nothing here is a default: the endpoint, the Vault address, its paths and the
+login all come from the fleet configuration every machine keeps at
+~/.config/dev-fleet/fleet.json (or DEVFLEET_CONFIG).
+"""
+import json
+import os
+import pathlib
+
+
+def path():
+    return pathlib.Path(os.environ.get('DEVFLEET_CONFIG')
+                        or pathlib.Path.home() / '.config/dev-fleet/fleet.json')
+
+
+def load():
+    try:
+        return json.loads(path().read_text())
+    except (OSError, ValueError):
+        raise ValueError('Fleet configuration unavailable: ' + str(path())) from None
+
+
+def endpoint():
+    """Public HTTPS origin of the proxy."""
+    return load()['services']['proxy']['endpoint']
+
+
+def vault():
+    """The proxy's backup, recovery and connector credentials live in Vault."""
+    config = load()
+    secrets = config['secrets']
+    if secrets.get('provider') != 'vault':
+        raise ValueError('The proxy service operations need the vault secrets provider')
+    locations = secrets['locations']
+    return {
+        'address': secrets['address'],
+        # KV v2 API paths: <mount>/data/<path>.
+        'shared': secrets['mount'] + '/data/' + locations['proxy-client-key']['path'],
+        'tunnel': secrets['mount'] + '/data/' + locations['proxy-tunnel-token']['path'],
+        'tunnel_field': locations['proxy-tunnel-token']['field'],
+        'user': config['worker']['vaultUser'],
+    }

package/cliproxy/scripts/fleet_sync.py

@@ -0,0 +1,274 @@
+#!/usr/bin/env python3
+"""Fleet singleton reconciliation: the manager hosts the proxy, workers are clients."""
+import sys
+sys.dont_write_bytecode = True
+
+import argparse
+import importlib.util
+import json
+import os
+import pathlib
+import re
+import subprocess
+import time
+
+SCRIPTS = pathlib.Path(__file__).resolve().parent
+sys.path.insert(0, str(SCRIPTS))
+import cliproxy_host
+import fleet_config
+
+DECOMMISSION = ('Workers never host singletons. Fence and decommission this local proxy with '
+                'cliproxy/docs/migration.md (disable timers, drain, stop, disable, '
+                'final backup); fleet-sync never stops it automatically.')
+
+
+def execute(args, timeout=120):
+    try:
+        result = subprocess.run(args, capture_output=True, text=True, timeout=timeout,
+                                env={**os.environ, 'PYTHONDONTWRITEBYTECODE': '1'})
+        return result.returncode == 0
+    except (OSError, subprocess.TimeoutExpired):
+        return False
+
+
+def audit(root):
+    spec = importlib.util.spec_from_file_location('fleet_audit', SCRIPTS / 'audit.py')
+    module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(module)
+    try:
+        # Provenance and unit links only: loaded/active state is reported per unit below.
+        manifest, errors = module.audit(root, run=lambda argv: True)
+        return not errors, manifest.get('revision')
+    except Exception:
+        return False, None
+
+
+def phase(code, status, summary, expected, observed, retryable=False):
+    return {'id': 'proxy:' + code.lower().replace('_', '-'), 'code': code,
+            'status': status, 'summary': summary, 'expected': expected,
+            'observed': observed, 'retryable': retryable,
+            'actionRequired': status in ('failed', 'action-required'),
+            'scope': 'node', 'remedy': {'owner': 'cliproxy-fleet', 'action': summary}}
+
+
+def unit_code(unit):
+    return 'PROXY_UNIT_' + re.sub('[^A-Z0-9]', '_', unit.upper())
+
+
+def equivalent_source(installed, revision):
+    """A monorepo-only update must not force a running gateway to restart."""
+    if not isinstance(installed, str) or not re.fullmatch('[a-f0-9]{40}', installed):
+        return False
+    try:
+        result = subprocess.run(['git', '-C', str(SCRIPTS.parents[1]), 'rev-parse',
+                                 installed + ':cliproxy', revision + ':cliproxy'],
+                                capture_output=True, text=True, timeout=15)
+        trees = result.stdout.splitlines()
+        return result.returncode == 0 and len(trees) == 2 and all(re.fullmatch('[a-f0-9]{40}', tree) for tree in trees) and trees[0] == trees[1]
+    except (OSError, subprocess.TimeoutExpired):
+        return False
+
+
+def inspect_worker(root, backend, run):
+    """Client role. A local host is reported, never stopped."""
+    live = [unit for unit in backend.units if any(backend.state(unit, run))]
+    if live:
+        return [phase('PROXY_DUPLICATE_OWNER', 'action-required', DECOMMISSION,
+                      'No proxy host on workers', 'Active or enabled local host: ' + ', '.join(live))]
+    if (root / 'INSTALLATION.json').exists():
+        return [phase('PROXY_DECOMMISSION_PENDING', 'action-required',
+                      'A fenced proxy installation (with private state) remains on this worker. After the manager '
+                      'cutover is verified, remove it as described in cliproxy/docs/migration.md.',
+                      'No proxy installation on workers', 'Stopped local installation present')]
+    return [phase('PROXY_CLIENT_ROLE', 'unchanged', 'Worker; the proxy runs on the manager.',
+                  'No proxy host on workers', 'No active host')]
+
+
+def inspect(root, node, owner, revision, run=execute, audit_fn=audit, compatible_fn=equivalent_source,
+            backend=None, identity=None):
+    backend = backend or cliproxy_host.backend()
+    if node != owner:
+        return inspect_worker(root, backend, run)
+    if backend.name != 'launchd':
+        return [phase('PROXY_PLATFORM_MISMATCH', 'action-required',
+                      'The manager hosts the proxy on macOS with launchd; run fleet-sync for the manager on the manager.',
+                      'macOS launchd owner backend', backend.name)]
+    if identity is not None and identity != owner:
+        return [phase('PROXY_IDENTITY_MISMATCH', 'action-required',
+                      'This host is not the declared manager; changing the manager requires reviewed identity assignment and fencing.',
+                      owner, identity)]
+    if not (root / 'state/runtime/config.yaml').is_file():
+        return [phase('PROXY_RECOVERY_REQUIRED', 'action-required',
+                      'Use the existing encrypted recovery flow after fencing the previous owner; never initialize a second provider identity.',
+                      'Recovered runtime state on the manager', 'Runtime cache missing')]
+    clean, installed = audit_fn(root)
+    if not clean:
+        return [phase('PROXY_SOURCE_DRIFT', 'action-required',
+                      'Inspect cliproxy audit, preserve runtime state, then reinstall a reviewed revision during maintenance.',
+                      'Clean tracked installation and units', 'Missing or modified deployment')]
+    if installed != revision and not compatible_fn(installed, revision):
+        return [phase('PROXY_UPDATE_PENDING', 'action-required',
+                      'Installing the reviewed revision failed. Inspect `bun run cliproxy install --revision REV` on the '
+                      'manager; runtime state is preserved.',
+                      revision, installed if isinstance(installed, str) and re.fullmatch('[0-9a-f]{40}', installed) else 'Unknown revision')]
+    checks = []
+    for unit in backend.units:
+        active, enabled = backend.state(unit, run)
+        checks.append(phase(unit_code(unit),
+                            'unchanged' if active and enabled else 'action-required',
+                            'Enable/start the declared unit; do not restart an already running gateway.',
+                            'Enabled and active ' + unit,
+                            'Enabled and active' if active and enabled else 'Stopped or disabled', True))
+    if not (root / 'state/public-endpoint-enabled').exists():
+        checks.append(phase('PROXY_ENDPOINT_DISABLED', 'action-required',
+                            'Enable the existing public connector using its existing Vault credential.',
+                            'Public connector enabled', 'Endpoint marker absent', True))
+    if not run(declared(root, apply=False)):
+        checks.append(phase('PROXY_CONFIG_PENDING', 'action-required',
+                            'The live proxy lacks fleet-declared settings (model aliases, account prefixes) and '
+                            'applying them failed. Inspect `ops declared --apply` on the manager; the previous config '
+                            'is kept as state/runtime/config.yaml.previous.',
+                            'Declared config settings and a model prefix per signed-in account', 'Live proxy differs', True))
+    return checks
+
+
+def claude_pin(repository=SCRIPTS.parents[1]):
+    """The Claude Code version every node runs (the shared toolchain pin)."""
+    try:
+        match = re.search(r'^claude = "(\d+\.\d+\.\d+)"$', (repository / 'mise.toml').read_text(), re.M)
+        return match.group(1) if match else None
+    except OSError:
+        return None
+
+
+def declared(root, apply):
+    """Checks (exit 0 when unchanged) or applies the template-owned settings.
+    Runs under the install's pinned interpreter: only it carries PyYAML. The
+    proxy must claim the Claude Code version the fleet actually runs."""
+    python = root / 'tools/bin/python3'
+    version = claude_pin()
+    return [str(python) if python.exists() else sys.executable, '-B', str(root / 'scripts/ops'),
+            'declared', *(['--claude-version', version] if version else []), *(['--apply'] if apply else [])]
+
+
+def endpoint_health(root):
+    try:
+        spec = importlib.util.spec_from_file_location('fleet_external_health', SCRIPTS / 'external-health.py')
+        module = importlib.util.module_from_spec(spec)
+        spec.loader.exec_module(module)
+        endpoint = fleet_config.endpoint()
+        key = (root / 'state/secrets/client-key').read_text().strip()
+        module.endpoint_health(endpoint, key)
+        return True
+    except Exception:
+        return False
+
+
+def endpoint_verified(root, endpoint_check, attempts=6, delay=10, sleep=time.sleep):
+    """The public route can take a few seconds to reconnect after a start or
+    update; a bounded retry keeps that from reading as a failure."""
+    for attempt in range(attempts):
+        if endpoint_check(root):
+            return True
+        if attempt + 1 < attempts:
+            sleep(delay)
+    return False
+
+
+def converge_units(root, checks, backend, run):
+    """Loads stopped agents and enables the connector; never restarts a running gateway."""
+    changed = False
+    for item in checks:
+        if item['status'] != 'action-required':
+            continue
+        if item['code'].startswith('PROXY_UNIT_'):
+            unit = item['expected'].removeprefix('Enabled and active ')
+            # Backup operations must not run before existing recovery confirmation.
+            if unit in backend.recovery_gated and not (root / 'state/secrets/recovery-confirmed').exists():
+                continue
+            for command in backend.enable(unit):
+                changed = run(command) or changed
+        elif item['code'] == 'PROXY_ENDPOINT_DISABLED':
+            changed = run([sys.executable, '-B', str(root / 'scripts/public-endpoint'), 'enable']) or changed
+    return changed
+
+
+def reconcile(root, node, owner, revision, apply=False, run=execute, audit_fn=audit,
+              endpoint_check=endpoint_health, compatible_fn=equivalent_source, backend=None, identity=None,
+              sleep=time.sleep):
+    started = time.monotonic()
+    backend = backend or cliproxy_host.backend()
+    checks = inspect(root, node, owner, revision, run, audit_fn, compatible_fn, backend, identity)
+    changed = False
+    blocked = {'PROXY_PLATFORM_MISMATCH', 'PROXY_IDENTITY_MISMATCH', 'PROXY_RECOVERY_REQUIRED',
+               'PROXY_SOURCE_DRIFT', 'PROXY_UPDATE_PENDING'}
+    # Two passes: an update installed in the first may surface declared
+    # settings (or stopped units) that the second then converges.
+    for _ in range(2 if apply and node == owner else 0):
+        codes = {item['code'] for item in checks}
+        if codes & (blocked - {'PROXY_UPDATE_PENDING'}):
+            break
+        if 'PROXY_UPDATE_PENDING' in codes:
+            # Every sync installs a pending update, including one that recreates
+            # the gateway (which interrupts in-flight inference for a moment).
+            changed = run(backend.install(sys.executable, SCRIPTS, revision), 1500)
+            if not changed:
+                break
+            checks = inspect(root, node, owner, revision, run, audit_fn, compatible_fn, backend, identity)
+            continue
+        changed = converge_units(root, checks, backend, run) or changed
+        if 'PROXY_CONFIG_PENDING' in codes:
+            # Self-healing and restart-free: the proxy hot-reloads its config.
+            changed = run(declared(root, apply=True), 600) or changed
+        checks = inspect(root, node, owner, revision, run, audit_fn, compatible_fn, backend, identity)
+        break
+    if node == owner and all(item['status'] == 'unchanged' for item in checks):
+        verified = endpoint_verified(root, endpoint_check, sleep=sleep)
+        checks.append(phase('PROXY_ENDPOINT_AUTH', 'unchanged' if verified else 'action-required',
+                            'Verify the existing endpoint/client credential. Provider inference is a separate gate; routine checks never attempt management logins.',
+                            'Authenticated public gateway client route',
+                            'Verified' if verified else 'Endpoint or authentication unavailable', True))
+    return {'version': 1, 'command': 'cliproxy fleet-sync', 'node': node,
+            'role': 'manager' if node == owner else 'worker', 'owner': owner,
+            'backend': backend.name, 'ok': all(item['status'] == 'unchanged' for item in checks),
+            'changed': changed, 'desiredRevision': revision, 'phases': checks,
+            'durationMs': round((time.monotonic() - started) * 1000)}
+
+
+def roles(definition):
+    """Validate definition v3 and return (manager id, worker ids)."""
+    manager = definition['manager']
+    if (definition.get('version') != 3 or manager.get('os') != 'macOS'
+            or not re.fullmatch(r'https://[A-Za-z0-9.-]+', str(definition['services']['proxy'].get('endpoint')))):
+        raise ValueError('Invalid definition')
+    workers = {worker['id'] for worker in definition['workers']}
+    if manager['id'] in workers:
+        raise ValueError('The manager is never a worker')
+    return manager['id'], workers
+
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument('--definition', type=pathlib.Path, required=True)
+    parser.add_argument('--node', required=True)
+    parser.add_argument('--revision', required=True)
+    parser.add_argument('--apply', action='store_true')
+    args = parser.parse_args()
+    owner, workers = roles(json.loads(args.definition.read_text()))
+    if not re.fullmatch('[a-f0-9]{40}', args.revision) or args.node not in workers | {owner}:
+        raise ValueError('Invalid selection')
+    backend = cliproxy_host.backend()
+    identity = cliproxy_host.local_node_id() if args.node == owner else None
+    result = reconcile(cliproxy_host.default_root(), args.node, owner, args.revision, args.apply,
+                       backend=backend, identity=identity)
+    print(json.dumps(result))
+    return 0 if result['ok'] else 1
+
+
+if __name__ == '__main__':
+    try:
+        raise SystemExit(main())
+    except Exception:
+        print(json.dumps({'version': 1, 'ok': False, 'code': 'PROXY_RECONCILE_FAILED',
+                          'summary': 'Inspect reviewed definition, singleton identity and local permissions; raw errors withheld.'}))
+        raise SystemExit(1) from None

package/cliproxy/scripts/initialize

@@ -0,0 +1,84 @@
+#!/usr/bin/env python3
+"""Materialize local state from existing cloud secrets; never seed Vault."""
+
+import sys
+
+sys.dont_write_bytecode = True
+
+import pathlib as _pathlib
+
+sys.path.insert(0, str(_pathlib.Path(__file__).resolve().parent))
+import cliproxy_host
+import fleet_config
+
+
+import hashlib
+import importlib.util
+import json
+import os
+import pathlib
+import urllib.request
+
+root = cliproxy_host.default_root().resolve()
+os.umask(0o077)
+state = root / "state"
+for directory in ["status", "secrets"]:
+    (state / directory).mkdir(parents=True, exist_ok=True)
+fields = {
+    "client-key": "CLIPROXY_FLEET_CLIENT_API_KEY",
+    "management-key": "CLIPROXY_FLEET_MANAGEMENT_KEY",
+    "restic-password": "CLIPROXY_FLEET_RESTIC_PASSWORD",
+}
+missing = [name for name in fields if not (state / "secrets" / name).exists()]
+if missing:
+    spec = importlib.util.spec_from_file_location(
+        "vault_access", root / "scripts/vault-access.py"
+    )
+    vault = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(vault)
+    try:
+        data = vault.request(fleet_config.vault()["shared"], vault.token())["data"]["data"]
+        for name in missing:
+            if not data.get(fields[name]):
+                raise ValueError("Required registered secret missing")
+        for name in missing:
+            (state / "secrets" / name).write_text(data[fields[name]] + "\n")
+    except Exception:
+        raise SystemExit(
+            "Existing Vault secrets required. Run vault-backup-login, and manage key values through the OpenTofu Vault workflow; response suppressed."
+        )
+config = state / "runtime/config.yaml"
+if not config.exists():
+    raise SystemExit(
+        "Runtime cache missing. Recover from the cloud checkpoint with restore-cache; refusing to seed an empty deployment."
+    )
+panel = state / "runtime/static/management.html"
+if not panel.exists():
+    metadata = json.load(
+        urllib.request.urlopen(
+            "https://api.github.com/repos/router-for-me/Cli-Proxy-API-Management-Center/releases/tags/v1.27.2",
+            timeout=30,
+        )
+    )
+    asset = next(
+        asset for asset in metadata["assets"] if asset["name"] == "management.html"
+    )
+    data = urllib.request.urlopen(asset["browser_download_url"], timeout=60).read()
+    if (
+        hashlib.sha256(data).hexdigest()
+        != "2f6cf57a8ca4ace1fadde0280cbd41084f56999738d0e692a30b135420f7fc30"
+    ):
+        raise SystemExit("Dashboard checksum mismatch")
+    panel.write_bytes(data)
+for file in state.rglob("*"):
+    if file.is_symlink():
+        continue
+    file.chmod(0o700 if file.is_dir() else 0o600)
+    if os.geteuid() == 0:
+        os.chown(file, 1000, 1000)
+if os.geteuid() == 0:
+    os.chown(state, 1000, 1000)
+state.chmod(0o700)
+print(
+    "Initialized local state from existing cloud credentials; live configuration preserved."
+)

package/cliproxy/scripts/install-dependencies

@@ -0,0 +1,48 @@
+#!/usr/bin/env bash
+set -euo pipefail
+if [[ $(uname -s) == Darwin ]]; then
+  # Manager (macOS): per-user, never sudo, no Homebrew. Builds a private tools
+  # directory from the repository's pinned, checksum-locked toolchain:
+  #   tools/bin/python3  venv on mise's pinned Python with hash-locked PyYAML
+  #   tools/bin/restic   mise's pinned restic (mise.lock checksums)
+  # The LaunchAgents put tools/bin first on PATH, so jobs never depend on
+  # whatever python3/restic happens to be installed on the machine.
+  [[ $EUID != 0 ]] || { echo 'Do not use sudo on macOS; the manager installation is per-user.'; exit 1; }
+  here=$(cd "$(dirname "$0")/.." && pwd)
+  repo=$(cd "$here/../.." && pwd)
+  tools="$HOME/Library/Application Support/cliproxy-fleet/tools"
+  command -v mise >/dev/null || { echo 'mise is required: run the shared toolchain setup (bootstrap/README.md).'; exit 1; }
+  [[ -d /Applications/Docker.app ]] || { echo 'Docker Desktop (/Applications/Docker.app) is required.'; exit 1; }
+  cd "$repo"
+  mise install --quiet python uv restic
+  python=$(mise where python)/bin/python3
+  restic=$(mise where restic)/restic
+  [[ -x $restic ]] || restic=$(find "$(mise where restic)" -maxdepth 2 -type f -name 'restic*' -perm -u+x | head -1)
+  [[ -x $python && -x $restic ]] || { echo 'Pinned python/restic not found after mise install.'; exit 1; }
+  mkdir -p "$(dirname "$tools")"
+  chmod 700 "$(dirname "$tools")"
+  # Rebuild only when the pinned interpreter or lock changed.
+  stamp="$python $(shasum -a 256 "$here/requirements.lock" | cut -d' ' -f1)"
+  if [[ ! -x $tools/bin/python3 || $(cat "$tools/.pins" 2>/dev/null) != "$stamp" ]]; then
+    # A venv records its own path, so it is built where it runs.
+    rm -rf "$tools"
+    mise exec -- uv venv --quiet --python "$python" "$tools"
+    mise exec -- uv pip install --quiet --python "$tools/bin/python3" \
+      --require-hashes --no-deps -r "$here/requirements.lock"
+    printf '%s' "$stamp" > "$tools/.pins"
+  fi
+  ln -sfn "$restic" "$tools/bin/restic"
+  "$tools/bin/python3" -c 'import yaml' || { echo 'PyYAML is not importable from the tools venv.'; exit 1; }
+  "$tools/bin/restic" version >/dev/null || { echo 'restic does not run.'; exit 1; }
+  printf 'Manager prerequisites ready in %s. Start Docker Desktop (sign-in start) before installing.\n' "$tools"
+  exit 0
+fi
+# Legacy Linux owner (decommission-only): Ubuntu packages.
+[[ $EUID == 0 ]] || { echo 'Run with sudo.'; exit 1; }
+apt-get update
+apt-get install -y docker.io docker-compose-v2 restic python3-yaml curl openssl shellcheck
+systemctl enable --now docker
+if [[ -n ${SUDO_USER:-} && $SUDO_USER != root ]]; then
+  usermod -aG docker "$SUDO_USER"
+fi
+printf '\nDependencies installed. Return to Codex to continue deployment.\n'