refactor(docker): simplify daemon architecture with direct asyncio server

- replace complex multiprocessing.Listener with asyncio-based Unix socket server
- remove entrypoint wrapper and gosu dependency in favor of direct daemon execution
- implement JSON-RPC 2.0 protocol instead of msgspec + msgpack binary protocol
- add file watching capabilities with watchdog for auto-recompile on changes
- update Dockerfile to run daemon directly with simplified dependencies
- modify docker-compose to use restart policy instead of supervisor pattern
- add comprehensive documentation for simplified daemon design
- update README with new usage patterns and simplified architecture overview

Author: zTgx

docker/Dockerfile

@@ -1,49 +1,48 @@
-# Single-stage image with cache-friendly layer ordering.
+# vectorless-code — Simplified Docker image for daemon-based architecture.
 #
-# Stable layers (reuse across releases):
-#   1. apt install gosu + create vcc user
-#   2. install uv
-#   3. writable-path setup (mkdir /var/vectorless_code, chown to vcc)
-#
-# Per-release layers (invalidate when the source tree changes):
-#   4. COPY . /vcc-src — build context
-#   5. `uv pip install "vectorless-code"` — installs package + deps
-#
-# Uses glibc-based slim image — vectorless ships pre-built Rust wheels.
+# The daemon now manages its own lifecycle (file watching, auto-restart),
+# so Docker just needs to start it and keep the container running.
+
 FROM python:3.12-slim
 
+# Install runtime dependencies
 RUN apt-get update \
-    && apt-get install -y --no-install-recommends gosu \
+    && apt-get install -y --no-install-recommends \
+        gcc \
+        g++ \
+        git \
     && rm -rf /var/lib/apt/lists/* \
     && groupadd -g 1000 vcc \
     && useradd -u 1000 -g 1000 -m vcc
 
+# Install uv for fast package installation
 RUN pip install --quiet uv
 
-# Writable paths the daemon needs, pre-chowned to vcc.
+# Create runtime directory for daemon socket
 RUN mkdir -p /var/vectorless_code \
     && chown -R vcc:vcc /var/vectorless_code
 
 WORKDIR /workspace
 
-# Runtime defaults — all overridable at `docker run -e ...` time.
+# Runtime environment variables
 ENV VECTORLESS_CODE_DIR=/workspace/.vectorless_code \
     VECTORLESS_CODE_RUNTIME_DIR=/var/vectorless_code \
-    VECTORLESS_CODE_DAEMON_SUPERVISED=1
-
-COPY docker/entrypoint.sh /entrypoint.sh
-RUN chmod +x /entrypoint.sh
-ENTRYPOINT ["/entrypoint.sh"]
+    VECTORLESS_DAEMON_SUPERVISED=1 \
+    PYTHONUNBUFFERED=1
 
-# ─── Per-release layer (last so only this one invalidates per release) ─────
-#
-# Default (PyPI flow): install vectorless-code from PyPI.
-# Release workflow / local tests override with:
-#   --build-arg VCC_INSTALL_SPEC=/vcc-src
-# to install from the source tree.
+# Install vectorless-code
+# Build mount for editable installs (faster iteration during dev)
+# Production builds override with:
+#   --build-arg VCC_INSTALL_SPEC=vectorless-code
 ARG VCC_INSTALL_SPEC=""
 RUN --mount=type=bind,source=.,target=/vcc-src,rw=true \
     if [ -z "$VCC_INSTALL_SPEC" ]; then \
-        VCC_INSTALL_SPEC="vectorless-code"; \
+        VCC_INSTALL_SPEC="/vcc-src[dev]"; \
     fi; \
     uv pip install --system "${VCC_INSTALL_SPEC}"
+
+# Switch to vcc user
+USER vcc
+
+# Default: run the daemon (it will manage itself)
+CMD ["python", "-m", "vectorless_code.daemon.server"]

docker/README.md

@@ -13,18 +13,19 @@ docker compose up -d
 # Linux (aligns file ownership with your host user)
 PUID=$(id -u) PGID=$(id -g) docker compose up -d
 
-# Then use the CLI normally
+# The daemon starts automatically and watches for file changes
+# Use the CLI from your host (if vcc is installed) or inside the container:
 docker compose exec vectorless-code vcc init
-docker compose exec vectorless-code vcc compile
-docker compose exec vectorless-code vcc ask "how does authentication work?"
+docker compose exec vectorless-code vcc status
 ```
 
-## Architecture
+## Simplified Architecture
 
-The container runs a **supervised daemon** that:
-- Keeps the container alive across daemon restarts
-- Auto-restarts when settings change
-- Gracefully handles `docker stop` via SIGTERM forwarding
+The container runs the **daemon directly**:
+- No entrypoint wrapper needed
+- Daemon manages its own lifecycle
+- File watching for auto-recompile
+- Auto-restart on settings changes
 
 ## Environment Variables
 
@@ -33,7 +34,7 @@ The container runs a **supervised daemon** that:
 | `VECTORLESS_HOST_PATH_MAPPING` | Map container paths to host paths | `/workspace=$HOME` |
 | `VECTORLESS_CODE_DIR` | Project config directory | `/workspace/.vectorless_code` |
 | `VECTORLESS_CODE_RUNTIME_DIR` | Daemon runtime directory | `/var/vectorless_code` |
-| `VECTORLESS_CODE_DAEMON_SUPERVISED` | Enable supervised mode | `1` |
+| `VECTORLESS_DAEMON_SUPERVISED` | Enable supervised mode | `1` |
 | `PUID` | Host user ID (Linux only) | - |
 | `PGID` | Host group ID (Linux only) | - |
 | `VCC_HOST_WORKSPACE` | Path to mount as workspace | `$HOME` |
@@ -43,22 +44,35 @@ The container runs a **supervised daemon** that:
 - `/workspace` — Your codebase (bind mount)
 - `/var/vectorless_code` — Daemon runtime data (named volume)
 
-## Daemon Management
+## Usage Examples
 
 ```bash
-# Check daemon status
-docker compose exec vectorless-code vcc daemon status
-
-# Restart daemon
-docker compose exec vectorless-code vcc daemon restart
+# From inside the container
+docker compose exec vectorless-code vcc status
+docker compose exec vectorless-code vcc ask "how does authentication work?"
 
-# Stop container (stops daemon)
-docker compose down
+# From host (if vcc is installed and daemon is exposed)
+vcc --daemon-addr /var/vectorless_code/daemon.sock status
 ```
 
 ## Notes
 
 - The daemon runs as the `vcc` user (UID 1000)
 - On Linux, use `PUID`/`PGID` to match your host user for file permissions
 - Cache is stored in `.vectorless_code/` within your workspace
-- The container auto-restarts the daemon on settings changes
+- The daemon automatically recompiles when source files change
+- Restart policy: `unless-stopped` (use `docker compose stop` to stop)
+
+## Pushing to Registry
+
+```bash
+# Tag for your registry
+docker tag vcc:latest ztgx/vectorless-code:latest
+
+# Push to Docker Hub
+docker push ztgx/vectorless-code:latest
+
+# With version tag
+docker tag vcc:latest ztgx/vectorless-code:0.1.1
+docker push ztgx/vectorless-code:0.1.1
+```

docker/docker-compose.yml

@@ -1,14 +1,7 @@
-# vectorless-code — Docker Compose quickstart.
+# vectorless-code — Docker Compose for simplified daemon architecture.
 #
-#   # macOS / Windows
-#   docker compose up -d
-#
-#   # Linux (aligns file ownership with your host user)
-#   PUID=$(id -u) PGID=$(id -g) docker compose up -d
-#
-# By default your home directory is mounted into the container as the
-# workspace. Set VCC_HOST_WORKSPACE=/path/to/code to mount a narrower
-# directory instead.
+# The daemon now runs directly without an entrypoint wrapper.
+# It manages its own lifecycle including file watching and auto-reindex.
 
 services:
   vectorless-code:
@@ -21,14 +14,13 @@ services:
       - ${VCC_HOST_WORKSPACE:-${HOME}}:/workspace
       - vectorless-data:/var/vectorless_code
     environment:
-      # Makes CLI and MCP output show your real paths
-      # (e.g. `/Users/you/myproject/...`) instead of container paths
-      # (e.g. `/workspace/myproject/...`).
+      # Path mapping for host path display in results
       VECTORLESS_HOST_PATH_MAPPING: /workspace=${VCC_HOST_WORKSPACE:-${HOME}}
-      # Linux only: set these so files written to your workspace are owned by
-      # you rather than root. Not needed on macOS / Windows — leave empty.
+      # Linux only: set these so files are owned by you
       PUID: ${PUID:-}
       PGID: ${PGID:-}
+    # Restart policy: restart unless manually stopped
+    restart: unless-stopped
 
 volumes:
   vectorless-data: