main: deployment source of truth + homelab sidecar scripts - CI (image build + npm publish) now triggers on main instead of release. - homelab/: version-controlled copies of the NAS-side lazy proxies (whisper-lazy, runpod-lazy) and the runpod-pod CLI.

54b88d3c278f20af11bb25f34e328844ed810328

permissionBRICK <40219477+permissionBRICK@users.noreply.github.com>

Parents: cd5f87400e939c2597aad154d502228c27aaa9ce

.gitlab-ci.yml+2 -2 Viewed

 build-image:
   stage: build
   only:
     - releasemain
   image: docker:latest
   services:
     - name: docker:dind

 publish-npm:
   stage: publish
   only:
     - releasemain
   image: node:24
   variables:
     npm_config_cache: .npm

homelab/README.md+15 -0 Viewed

 +# Homelab sidecar services
++
 +Version-controlled copies of the NAS-side scripts that support this
 +SillyTavern deployment. The deployed copies live on the unraid NAS; when
 +changing one, update both (scp to the NAS path + commit here).
++
 +| File | Deployed at | Purpose |
 +|---|---|---|
 +| `whisper-lazy-proxy.py` | `/mnt/user/appdata/whisper-lazy/proxy.py` (container `whisper-lazy`, :10300) | Wyoming lazy proxy: answers HA availability checks from cache, starts `faster-whisper` on demand, stops it after 15 min idle (frees GPU VRAM). |
 +| `runpod-lazy-proxy.py` | `/mnt/user/appdata/runpod-lazy/proxy.py` (container `runpod-lazy`, :8189) | ComfyUI-compatible lazy proxy for a volumeless RunPod GPU pod: wake-on-generate with model-group detection, `/lazy/status|warmup|shutdown|ping` control API for the SillyTavern warmup UI, NAS-side 15-min idle terminate. |
 +| `runpod-pod.sh` | `/boot/config/runpod-pod.sh` | CLI for the runpod-lazy control API (`status|warmup|shutdown|ping|watch`). |
++
 +Related: the RunPod worker image (ComfyUI + custom nodes + boot-time model
 +downloader) is built from github.com/permissionBRICK/comfyui-runpod-worker
 +(private repo, public GHCR package; mirrored on this GitGudLab).

homelab/runpod-lazy-proxy.py+325 -0 Viewed

 +#!/usr/bin/env python3
 +"""ComfyUI lazy proxy for a volumeless RunPod on-demand pod.
++
 +SillyTavern's fallback chain points at this proxy as a normal ComfyUI server;
 +the pod downloads its models at boot (boot-models.py in the image), so no
 +network volume or region lock is needed.
++
 +Control API (CORS-enabled, used by the ST warmup UI and the CLI script):
 +  GET  /lazy/status    -> {"state": "red"|"orange"|"green", ...}
 +  POST /lazy/warmup    -> start pod with MODELS=all (idempotent)
 +  POST /lazy/shutdown  -> terminate pod now
 +  POST /lazy/ping      -> keepalive (extends idle timer; never starts a pod)
++
 +Wake semantics: a ComfyUI /prompt POST arriving with no pod starts one that
 +downloads only the model group the workflow references (flux/qwen/all).
 +The idle timer lives HERE (NAS side): IDLE_SECONDS after the last activity
 +signal (comfy traffic or keepalive ping) the pod is terminated - regardless
 +of whether any frontend still exists.
++
 +stdlib only; runs on python:3.12-alpine.
 +"""
 +import json
 +import os
 +import threading
 +import time
 +import urllib.error
 +import urllib.request
 +from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
++
 +RUNPOD_KEY = os.environ['RUNPOD_KEY']
 +LISTEN_PORT = int(os.environ.get('LISTEN_PORT', '8189'))
 +IDLE_SECONDS = int(os.environ.get('IDLE_SECONDS', '900'))
 +DATACENTERS = [d for d in os.environ.get('DATACENTERS', '').split(',') if d]  # empty = any
 +CLOUD_TYPE = os.environ.get('CLOUD_TYPE', 'SECURE')
 +IMAGE = os.environ.get('IMAGE', 'ghcr.io/permissionbrick/comfyui-runpod-worker:latest')
 +GPU_TYPES = os.environ.get('GPU_TYPES', 'NVIDIA RTX 6000 Ada Generation,NVIDIA L40S,NVIDIA L40,NVIDIA RTX A6000,NVIDIA A40').split(',')
 +POD_NAME = os.environ.get('POD_NAME', 'comfyui-lazy')
 +START_TIMEOUT = int(os.environ.get('START_TIMEOUT', '1500'))
 +HF_TOKEN = os.environ.get('HF_TOKEN', '')
 +COMFY_ARGS = os.environ.get('COMFY_ARGS', '--listen 0.0.0.0 --port 8188 --use-pytorch-cross-attention')
 +CACHE_FILE = os.environ.get('CACHE_FILE', '/app/system_stats.cache')
++
 +# Model-group detection: filename fragment (lowercased) -> group
 +GROUP_HINTS = {'flux-2-klein': 'flux', 'flux2-klein': 'flux', 'flux2-vae': 'flux', 'qwen-rapid': 'qwen'}
++
 +state = {
 +    'pod_id': None,     # current pod id (may still be booting)
 +    'models': None,     # MODELS value the pod was created with
 +    'phase': 'red',     # red | orange | green
 +    'gpu': None,
 +    'since': time.time(),
 +    'last': time.monotonic(),
 +    'lock': threading.Lock(),
 +}
++
++
 +def log(*args):
 +    print(time.strftime('%H:%M:%S'), *args, flush=True)
++
++
 +def api(method, path, body=None):
 +    req = urllib.request.Request(
 +        f'https://rest.runpod.io/v1{path}',
 +        json.dumps(body).encode() if body is not None else None,
 +        {'Authorization': f'Bearer {RUNPOD_KEY}', 'Content-Type': 'application/json'},
 +        method=method)
 +    with urllib.request.urlopen(req, timeout=60) as resp:
 +        data = resp.read()
 +        return json.loads(data) if data else {}
++
++
 +def find_pod():
 +    try:
 +        for pod in api('GET', '/pods'):
 +            if pod.get('name') == POD_NAME and pod.get('desiredStatus') == 'RUNNING':
 +                return pod['id'], (pod.get('env') or {}).get('MODELS'), pod.get('machine', {}).get('gpuTypeId')
 +    except Exception as err:
 +        log('find_pod failed:', err)
 +    return None, None, None
++
++
 +def create_pod(models):
 +    body = {
 +        'name': POD_NAME,
 +        'imageName': IMAGE,
 +        'gpuTypeIds': GPU_TYPES,
 +        'gpuCount': 1,
 +        'cloudType': CLOUD_TYPE,
 +        'containerDiskInGb': 80,
 +        'ports': ['8188/http'],
 +        'env': {'MODELS': models, 'HF_TOKEN': HF_TOKEN},
 +        'dockerStartCmd': ['bash', '-c', f'python3 /boot-models.py && cd /comfyui && exec python main.py {COMFY_ARGS}'],
 +    }
 +    if DATACENTERS:
 +        body['dataCenterIds'] = DATACENTERS
 +    pod = api('POST', '/pods', body)
 +    log(f"pod created: {pod['id']} MODELS={models} {pod.get('machine', {}).get('gpuTypeId')} ${pod.get('costPerHr')}/hr")
 +    return pod['id'], pod.get('machine', {}).get('gpuTypeId')
++
++
 +def pod_url(pod_id):
 +    return f'https://{pod_id}-8188.proxy.runpod.net'
++
++
 +def upstream_ready(pod_id):
 +    try:
 +        with urllib.request.urlopen(pod_url(pod_id) + '/system_stats', timeout=5) as resp:
 +            if resp.status == 200:
 +                data = resp.read()
 +                with open(CACHE_FILE, 'wb') as f:
 +                    f.write(data)
 +                return True
 +    except Exception:
 +        pass
 +    return False
++
++
 +def groups_cover(have, need):
 +    if not have:
 +        return False
 +    have_set = set(have.split(','))
 +    need_set = set(need.split(','))
 +    return 'all' in have_set or need_set <= have_set
++
++
 +def ensure_pod(models='all', wait=True):
 +    """Ensures a pod covering the requested model groups; optionally waits for readiness."""
 +    with state['lock']:
 +        pod_id, have, gpu = (state['pod_id'], state['models'], state['gpu'])
 +        if not pod_id:
 +            pod_id, have, gpu = find_pod()
 +        if pod_id and not groups_cover(have, models):
 +            log(f'pod has MODELS={have}, need {models} - recreating with all')
 +            try:
 +                api('DELETE', f'/pods/{pod_id}')
 +            except Exception as err:
 +                log('delete failed:', err)
 +            pod_id, have, gpu = None, None, None
 +            models = 'all'
 +        if not pod_id:
 +            state['phase'] = 'orange'
 +            state['since'] = time.time()
 +            last_err = None
 +            for attempt in range(3):
 +                try:
 +                    pod_id, gpu = create_pod(models)
 +                    break
 +                except urllib.error.HTTPError as err:
 +                    last_err = err.read().decode()[:200]
 +                    log(f'create_pod attempt {attempt + 1} failed:', last_err)
 +                    time.sleep(5)
 +            if not pod_id:
 +                state['phase'] = 'red'
 +                raise RuntimeError(f'could not create pod: {last_err}')
 +            have = models
 +        state['pod_id'], state['models'], state['gpu'] = pod_id, have, gpu
 +        state['last'] = time.monotonic()
++
 +    if state['phase'] != 'green':
 +        state['phase'] = 'orange'
 +    if not wait:
 +        return pod_id
 +    deadline = time.monotonic() + START_TIMEOUT
 +    while time.monotonic() < deadline:
 +        if upstream_ready(pod_id):
 +            if state['phase'] != 'green':
 +                state['phase'] = 'green'
 +                state['since'] = time.time()
 +                log('pod ready:', pod_id)
 +            state['last'] = time.monotonic()
 +            return pod_id
 +        if state['pod_id'] != pod_id:
 +            raise RuntimeError('pod replaced while waiting')
 +        time.sleep(5)
 +    raise RuntimeError('pod not ready within START_TIMEOUT')
++
++
 +def detect_groups(workflow_bytes):
 +    try:
 +        text = workflow_bytes.decode('utf-8', 'replace').lower()
 +    except Exception:
 +        return 'all'
 +    found = {group for hint, group in GROUP_HINTS.items() if hint in text}
 +    if len(found) == 1:
 +        return found.pop()
 +    return 'all'
++
++
 +def idle_reaper():
 +    while True:
 +        time.sleep(30)
 +        idle = time.monotonic() - state['last']
 +        if idle > IDLE_SECONDS:
 +            pod_id = state['pod_id'] or find_pod()[0]
 +            if pod_id:
 +                log(f'idle {int(idle)}s - terminating pod')
 +                try:
 +                    api('DELETE', f'/pods/{pod_id}')
 +                except Exception as err:
 +                    log('terminate failed:', err)
 +            if pod_id or state['phase'] != 'red':
 +                state.update({'pod_id': None, 'models': None, 'gpu': None, 'phase': 'red', 'since': time.time()})
++
++
 +def status_body():
 +    # Refresh green-ness cheaply on demand
 +    pod_id = state['pod_id']
 +    if pod_id and state['phase'] != 'green' and upstream_ready(pod_id):
 +        state['phase'] = 'green'
 +        state['since'] = time.time()
 +    if not pod_id:
 +        found, have, gpu = find_pod()
 +        if found:
 +            state.update({'pod_id': found, 'models': have, 'gpu': gpu})
 +            state['phase'] = 'green' if upstream_ready(found) else 'orange'
 +        else:
 +            state['phase'] = 'red'
 +    return json.dumps({
 +        'state': state['phase'],
 +        'pod_id': state['pod_id'],
 +        'models': state['models'],
 +        'gpu': state['gpu'],
 +        'since': state['since'],
 +        'url': pod_url(state['pod_id']) if state['pod_id'] else None,
 +        'idle_seconds_left': max(0, IDLE_SECONDS - int(time.monotonic() - state['last'])) if state['pod_id'] else 0,
 +    }).encode()
++
++
 +class Proxy(BaseHTTPRequestHandler):
 +    protocol_version = 'HTTP/1.1'
++
 +    def log_message(self, fmt, *args):
 +        pass
++
 +    def _reply(self, code, data, ctype='application/json'):
 +        self.send_response(code)
 +        self.send_header('Content-Type', ctype or 'application/json')
 +        self.send_header('Content-Length', str(len(data)))
 +        self.send_header('Access-Control-Allow-Origin', '*')
 +        self.send_header('Access-Control-Allow-Methods', 'GET, POST, OPTIONS')
 +        self.send_header('Access-Control-Allow-Headers', 'Content-Type')
 +        self.end_headers()
 +        self.wfile.write(data)
++
 +    def do_OPTIONS(self):
 +        self._reply(204, b'')
++
 +    def _handle(self):
 +        length = int(self.headers.get('Content-Length') or 0)
 +        body = self.rfile.read(length) if length else None
 +        path = self.path.split('?')[0]
++
 +        # ---- control API ----
 +        if path == '/lazy/status':
 +            return self._reply(200, status_body())
 +        if path == '/lazy/ping':
 +            if state['pod_id']:
 +                state['last'] = time.monotonic()
 +            return self._reply(200, b'{"ok": true}')
 +        if path == '/lazy/warmup':
 +            threading.Thread(target=self._safe_ensure, args=('all',), daemon=True).start()
 +            state['phase'] = state['phase'] if state['phase'] == 'green' else 'orange'
 +            return self._reply(200, status_body())
 +        if path == '/lazy/shutdown':
 +            pod_id = state['pod_id'] or find_pod()[0]
 +            if pod_id:
 +                try:
 +                    api('DELETE', f'/pods/{pod_id}')
 +                except Exception as err:
 +                    return self._reply(500, json.dumps({'error': str(err)}).encode())
 +            state.update({'pod_id': None, 'models': None, 'gpu': None, 'phase': 'red', 'since': time.time()})
 +            return self._reply(200, status_body())
++
 +        # ---- comfy proxying ----
 +        state['last'] = time.monotonic()
 +        pod_id = state['pod_id']
 +        ready = pod_id and upstream_ready(pod_id)
 +        if not ready and self.command == 'GET' and path == '/system_stats':
 +            # Reachability probe while cold: answer from cache; do NOT wake.
 +            try:
 +                with open(CACHE_FILE, 'rb') as f:
 +                    return self._reply(200, f.read())
 +            except FileNotFoundError:
 +                return self._reply(200, json.dumps({'system': {'comfyui_version': 'cold'}, 'devices': []}).encode())
 +        if not ready:
 +            models = detect_groups(body) if (self.command == 'POST' and path == '/prompt' and body) else 'all'
 +            try:
 +                pod_id = ensure_pod(models)
 +            except Exception as err:
 +                log('ensure_pod failed:', err)
 +                return self._reply(502, json.dumps({'error': str(err)}).encode())
 +        try:
 +            req = urllib.request.Request(pod_url(pod_id) + self.path, body, method=self.command)
 +            for header in ('Content-Type', 'Accept'):
 +                if self.headers.get(header):
 +                    req.add_header(header, self.headers[header])
 +            with urllib.request.urlopen(req, timeout=300) as resp:
 +                self._reply(resp.status, resp.read(), resp.headers.get('Content-Type'))
 +        except urllib.error.HTTPError as err:
 +            self._reply(err.code, err.read())
 +        except Exception as err:
 +            log('upstream error:', err)
 +            self._reply(502, json.dumps({'error': str(err)}).encode())
 +        finally:
 +            state['last'] = time.monotonic()
++
 +    def _safe_ensure(self, models):
 +        try:
 +            ensure_pod(models)
 +        except Exception as err:
 +            log('warmup failed:', err)
++
 +    do_GET = _handle
 +    do_POST = _handle
++
++
 +def main():
 +    threading.Thread(target=idle_reaper, daemon=True).start()
 +    server = ThreadingHTTPServer(('0.0.0.0', LISTEN_PORT), Proxy)
 +    log(f'runpod-lazy v2 on :{LISTEN_PORT} (pod "{POD_NAME}", DCs {DATACENTERS or "any"}, idle {IDLE_SECONDS}s)')
 +    server.serve_forever()
++
++
 +if __name__ == '__main__':
 +    main()

homelab/runpod-pod.sh+15 -0 Viewed

 +#!/bin/sh
 +# CLI for the runpod-lazy proxy: status | warmup | shutdown | ping
 +# Usable by anyone (or any AI) without SillyTavern. Proxy owns the pod
 +# lifecycle; this only talks to its control API.
 +CMD="${1:-status}"
 +URL="${RUNPOD_LAZY_URL:-http://127.0.0.1:8189}"
 +case "$CMD" in
 +  status)   curl -s "$URL/lazy/status" ;;
 +  warmup)   curl -s -X POST "$URL/lazy/warmup" ;;
 +  shutdown) curl -s -X POST "$URL/lazy/shutdown" ;;
 +  ping)     curl -s -X POST "$URL/lazy/ping" ;;
 +  watch)    while true; do printf '%s ' "$(date +%H:%M:%S)"; curl -s "$URL/lazy/status"; echo; sleep 10; done ;;
 +  *) echo "usage: runpod-pod.sh [status|warmup|shutdown|ping|watch]"; exit 1 ;;
 +esac
 +echo

homelab/whisper-lazy-proxy.py+223 -0 Viewed

 +#!/usr/bin/env python3
 +"""Wyoming lazy proxy for faster-whisper.
++
 +Home Assistant talks to this proxy instead of faster-whisper directly.
 +- `describe` events are answered from a cached `info` response, so HA's
 +  availability checks never touch the backend.
 +- The first *real* event of a connection (e.g. `transcribe`) starts the
 +  faster-whisper container via the docker socket, replays the event, and
 +  relays bytes in both directions from then on.
 +- After IDLE_SECONDS without an active session the container is stopped
 +  again, freeing its VRAM.
++
 +stdlib only; runs on any python:3.12 image.
 +"""
 +import asyncio
 +import json
 +import os
 +import socket
 +import time
++
 +BACKEND_HOST = os.environ.get('BACKEND_HOST', '10.0.0.4')
 +BACKEND_PORT = int(os.environ.get('BACKEND_PORT', '10302'))
 +PROXY_PORT = int(os.environ.get('PROXY_PORT', '10300'))
 +IDLE_SECONDS = int(os.environ.get('IDLE_SECONDS', '900'))
 +CONTAINER = os.environ.get('CONTAINER', 'faster-whisper')
 +DOCKER_SOCK = os.environ.get('DOCKER_SOCK', '/var/run/docker.sock')
 +CACHE_FILE = os.environ.get('CACHE_FILE', '/app/info.cache')
 +START_TIMEOUT = int(os.environ.get('START_TIMEOUT', '180'))
++
 +state = {'active': 0, 'last': time.monotonic(), 'lock': None}
++
++
 +def log(*args):
 +    print(time.strftime('%H:%M:%S'), *args, flush=True)
++
++
 +def docker_api(method, path):
 +    """Minimal docker engine API call over the unix socket. Returns (status, body)."""
 +    sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
 +    sock.settimeout(60)
 +    sock.connect(DOCKER_SOCK)
 +    sock.sendall(f'{method} {path} HTTP/1.1\r\nHost: docker\r\nConnection: close\r\n\r\n'.encode())
 +    buf = b''
 +    while True:
 +        chunk = sock.recv(65536)
 +        if not chunk:
 +            break
 +        buf += chunk
 +    sock.close()
 +    head, _, body = buf.partition(b'\r\n\r\n')
 +    return int(head.split(b' ', 2)[1]), body
++
++
 +def backend_running():
 +    try:
 +        status, body = docker_api('GET', f'/containers/{CONTAINER}/json')
 +        if status != 200:
 +            return False
 +        text = body.decode('utf-8', 'replace')
 +        text = text[text.find('{'):text.rfind('}') + 1]
 +        return json.loads(text).get('State', {}).get('Running', False)
 +    except Exception as err:
 +        log('backend_running check failed:', err)
 +        return False
++
++
 +def start_container():
 +    status, _ = docker_api('POST', f'/containers/{CONTAINER}/start')
 +    return status in (204, 304)
++
++
 +def stop_container():
 +    status, _ = docker_api('POST', f'/containers/{CONTAINER}/stop?t=30')
 +    return status in (204, 304)
++
++
 +async def read_event(reader):
 +    """Reads one wyoming event; returns {'raw': bytes, 'type': str} or None on EOF."""
 +    line = await reader.readline()
 +    if not line:
 +        return None
 +    header = json.loads(line)
 +    extra = b''
 +    for key in ('data_length', 'payload_length'):
 +        length = int(header.get(key) or 0)
 +        if length:
 +            extra += await reader.readexactly(length)
 +    return {'raw': line + extra, 'type': header.get('type')}
++
++
 +async def ensure_backend():
 +    """Starts the backend container if needed and returns an open (reader, writer).
++
 +    A bare TCP connect is not proof of readiness: docker-proxy accepts on the
 +    published port as soon as the container starts, long before the Wyoming
 +    server listens. So readiness = a real describe -> info handshake.
 +    """
 +    async with state['lock']:
 +        deadline = time.monotonic() + START_TIMEOUT
 +        if not await asyncio.to_thread(backend_running):
 +            log('starting backend container')
 +            await asyncio.to_thread(start_container)
 +        while time.monotonic() < deadline:
 +            try:
 +                reader, writer = await asyncio.open_connection(BACKEND_HOST, BACKEND_PORT)
 +                writer.write(json.dumps({'type': 'describe', 'data': {}}).encode() + b'\n')
 +                await writer.drain()
 +                event = await asyncio.wait_for(read_event(reader), 5)
 +                if event and event['type'] == 'info':
 +                    # Connection is clean again after consuming the info event.
 +                    return reader, writer
 +                writer.close()
 +            except (OSError, asyncio.TimeoutError, asyncio.IncompleteReadError, json.JSONDecodeError):
 +                pass
 +            await asyncio.sleep(1)
 +        raise RuntimeError('backend did not come up within START_TIMEOUT')
++
++
 +async def refresh_cache():
 +    try:
 +        reader, writer = await asyncio.open_connection(BACKEND_HOST, BACKEND_PORT)
 +        writer.write(json.dumps({'type': 'describe', 'data': {}}).encode() + b'\n')
 +        await writer.drain()
 +        event = await asyncio.wait_for(read_event(reader), 20)
 +        writer.close()
 +        if event and event['type'] == 'info':
 +            with open(CACHE_FILE, 'wb') as f:
 +                f.write(event['raw'])
 +            log('info cache refreshed:', len(event['raw']), 'bytes')
 +    except Exception as err:
 +        log('cache refresh failed:', err)
++
++
 +async def pipe(reader, writer):
 +    try:
 +        while True:
 +            chunk = await reader.read(65536)
 +            if not chunk:
 +                break
 +            writer.write(chunk)
 +            await writer.drain()
 +    except (ConnectionResetError, BrokenPipeError):
 +        pass
 +    finally:
 +        try:
 +            writer.close()
 +        except Exception:
 +            pass
++
++
 +async def handle_client(client_reader, client_writer):
 +    peer = client_writer.get_extra_info('peername')
 +    backend = None
 +    try:
 +        while backend is None:
 +            event = await read_event(client_reader)
 +            if event is None:
 +                return
 +            if event['type'] == 'ping':
 +                client_writer.write(json.dumps({'type': 'pong', 'data': {}}).encode() + b'\n')
 +                await client_writer.drain()
 +                continue
 +            if event['type'] == 'describe' and os.path.exists(CACHE_FILE):
 +                with open(CACHE_FILE, 'rb') as f:
 +                    client_writer.write(f.read())
 +                await client_writer.drain()
 +                continue
 +            # Real work (or describe without a cache yet): wake the backend.
 +            state['active'] += 1
 +            state['last'] = time.monotonic()
 +            try:
 +                backend = await ensure_backend()
 +            except Exception as err:
 +                state['active'] -= 1
 +                state['last'] = time.monotonic()
 +                log('backend wake failed:', err)
 +                return
 +            log(f'session start from {peer} (trigger: {event["type"]})')
 +            backend[1].write(event['raw'])
 +            await backend[1].drain()
 +            asyncio.ensure_future(refresh_cache())
 +        await asyncio.gather(pipe(client_reader, backend[1]), pipe(backend[0], client_writer))
 +    except (ConnectionResetError, BrokenPipeError, asyncio.IncompleteReadError, json.JSONDecodeError) as err:
 +        log('client error:', err)
 +    finally:
 +        if backend is not None:
 +            state['active'] -= 1
 +            state['last'] = time.monotonic()
 +            log('session end, active:', state['active'])
 +        try:
 +            client_writer.close()
 +        except Exception:
 +            pass
++
++
 +async def idle_reaper():
 +    while True:
 +        await asyncio.sleep(30)
 +        idle = time.monotonic() - state['last']
 +        if state['active'] == 0 and idle > IDLE_SECONDS and await asyncio.to_thread(backend_running):
 +            log(f'idle for {int(idle)}s - stopping backend container')
 +            await asyncio.to_thread(stop_container)
++
++
 +async def main():
 +    state['lock'] = asyncio.Lock()
 +    if not os.path.exists(CACHE_FILE):
 +        log('no info cache - bootstrapping backend once to capture it')
 +        try:
 +            reader, writer = await ensure_backend()
 +            writer.close()
 +            await refresh_cache()
 +        except Exception as err:
 +            log('bootstrap failed (will retry on first request):', err)
 +    server = await asyncio.start_server(handle_client, '0.0.0.0', PROXY_PORT)
 +    log(f'wyoming lazy proxy listening on :{PROXY_PORT} -> {BACKEND_HOST}:{BACKEND_PORT} '
 +        f'(container {CONTAINER}, idle {IDLE_SECONDS}s)')
 +    async with server:
 +        await asyncio.gather(server.serve_forever(), idle_reaper())
++
++
 +if __name__ == '__main__':
 +    asyncio.run(main())