refactor(gastown): Town-centric refactor — Phase A: Consolidate control plane (#419)

cloudflare-gastown/container/Dockerfile

@@ -19,7 +19,10 @@ RUN apt-get update && \
 # explicitly install the platform-specific binary package alongside the CLI.
 # Also install @kilocode/plugin globally so repo-local tools (e.g.
 # .opencode/tool/*.ts) can resolve it without a local node_modules.
-RUN npm install -g @kilocode/cli @kilocode/cli-linux-x64 @kilocode/plugin
+# Install both glibc and musl variants — the CLI's binary resolver may
+# pick either depending on the detected libc.
+RUN npm install -g @kilocode/cli @kilocode/cli-linux-x64 @kilocode/cli-linux-x64-musl @kilocode/plugin && \
+    ln -s "$(which kilo)" /usr/local/bin/opencode
 
 # Create workspace directories
 RUN mkdir -p /workspace/rigs /app

cloudflare-gastown/container/Dockerfile.dev

@@ -17,7 +17,11 @@ RUN apt-get update && \
 # Install Kilo CLI globally via npm (needs real Node.js runtime).
 # npm's global install does not resolve optionalDependencies, so we must
 # explicitly install the platform-specific binary package alongside the CLI.
-RUN npm install -g @kilocode/cli @kilocode/cli-linux-arm64
+# Install both glibc and musl variants — the CLI's binary resolver may
+# pick either depending on the detected libc. bun:1-slim is Debian (glibc)
+# but the resolver sometimes misdetects; installing both is safe.
+RUN npm install -g @kilocode/cli @kilocode/cli-linux-arm64 @kilocode/cli-linux-arm64-musl && \
+    ln -s "$(which kilo)" /usr/local/bin/opencode
 
 # Create workspace directories
 RUN mkdir -p /workspace/rigs /app

cloudflare-gastown/container/plugin/client.ts

@@ -27,16 +27,18 @@ export class GastownClient {
   private token: string;
   private agentId: string;
   private rigId: string;
+  private townId: string;
 
   constructor(env: GastownEnv) {
     this.baseUrl = env.apiUrl.replace(/\/+$/, '');
     this.token = env.sessionToken;
     this.agentId = env.agentId;
     this.rigId = env.rigId;
+    this.townId = env.townId;
   }
 
   private rigPath(path: string): string {
-    return `${this.baseUrl}/api/rigs/${this.rigId}${path}`;
+    return `${this.baseUrl}/api/towns/${this.townId}/rigs/${this.rigId}${path}`;
   }
 
   private agentPath(path: string): string {
@@ -294,18 +296,20 @@ export function createClientFromEnv(): GastownClient {
   const sessionToken = process.env.GASTOWN_SESSION_TOKEN;
   const agentId = process.env.GASTOWN_AGENT_ID;
   const rigId = process.env.GASTOWN_RIG_ID;
+  const townId = process.env.GASTOWN_TOWN_ID;
 
-  if (!apiUrl || !sessionToken || !agentId || !rigId) {
+  if (!apiUrl || !sessionToken || !agentId || !rigId || !townId) {
     const missing = [
       !apiUrl && 'GASTOWN_API_URL',
       !sessionToken && 'GASTOWN_SESSION_TOKEN',
       !agentId && 'GASTOWN_AGENT_ID',
       !rigId && 'GASTOWN_RIG_ID',
+      !townId && 'GASTOWN_TOWN_ID',
     ].filter(Boolean);
     throw new Error(`Missing required Gastown environment variables: ${missing.join(', ')}`);
   }
 
-  return new GastownClient({ apiUrl, sessionToken, agentId, rigId });
+  return new GastownClient({ apiUrl, sessionToken, agentId, rigId, townId });
 }
 
 export function createMayorClientFromEnv(): MayorGastownClient {

cloudflare-gastown/container/plugin/types.ts

@@ -83,6 +83,7 @@ export type GastownEnv = {
   sessionToken: string;
   agentId: string;
   rigId: string;
+  townId: string;
 };
 
 // Environment variable config for the mayor (town-scoped)

cloudflare-gastown/container/src/agent-runner.ts

@@ -2,6 +2,7 @@ import type { Config } from '@kilocode/sdk';
 import { writeFile } from 'node:fs/promises';
 import { cloneRepo, createWorktree } from './git-manager';
 import { startAgent } from './process-manager';
+import { getCurrentTownConfig } from './control-server';
 import type { ManagedAgent, StartAgentRequest } from './types';
 
 /**
@@ -18,22 +19,29 @@ function resolveEnv(request: StartAgentRequest, key: string): string | undefined
  * the Kilo LLM gateway. Mirrors the pattern in cloud-agent-next's
  * session-service.ts getSaferEnvVars().
  */
-function buildKiloConfigContent(kilocodeToken: string): string {
+function buildKiloConfigContent(kilocodeToken: string, model?: string): string {
+  const resolvedModel = model ?? 'anthropic/claude-sonnet-4.6';
   return JSON.stringify({
     provider: {
       kilo: {
         options: {
           apiKey: kilocodeToken,
           kilocodeToken,
         },
+        // Explicitly register models so the kilo server doesn't reject them
+        // before routing to the gateway. The gateway handles actual validation.
+        models: {
+          [resolvedModel]: {},
+          'anthropic/claude-haiku-4.5': {},
+        },
       },
     },
     // Override the small model (used for title generation) to a valid
     // kilo-provider model. Without this, kilo serve defaults to
     // openai/gpt-5-nano which doesn't exist in the kilo provider,
     // causing ProviderModelNotFoundError that kills the entire prompt loop.
     small_model: 'anthropic/claude-haiku-4.5',
-    model: 'anthropic/claude-sonnet-4.6',
+    model: resolvedModel,
     // Override the title agent to use a valid model (same as small_model).
     // kilo serve v1.0.23 resolves title model independently and the
     // small_model fallback doesn't prevent ProviderModelNotFoundError.
@@ -108,6 +116,7 @@ function buildAgentEnv(request: StartAgentRequest): Record<string, string> {
     GASTOWN_AGENT_ID: request.agentId,
     GASTOWN_RIG_ID: request.rigId,
     GASTOWN_TOWN_ID: request.townId,
+    GASTOWN_AGENT_ROLE: request.role,
 
     GIT_AUTHOR_NAME: `${request.name} (gastown)`,
     GIT_AUTHOR_EMAIL: `${request.name}@gastown.local`,
@@ -127,11 +136,26 @@ function buildAgentEnv(request: StartAgentRequest): Record<string, string> {
     }
   }
 
+  // Fall back to X-Town-Config for KILOCODE_TOKEN if not in request or process.env
+  if (!env.KILOCODE_TOKEN) {
+    const townConfig = getCurrentTownConfig();
+    const tokenFromConfig =
+      townConfig && typeof townConfig.kilocode_token === 'string'
+        ? townConfig.kilocode_token
+        : undefined;
+    console.log(
+      `[buildAgentEnv] KILOCODE_TOKEN fallback: townConfig=${townConfig ? 'present' : 'null'} hasToken=${!!tokenFromConfig} requestEnvKeys=${Object.keys(request.envVars ?? {}).join(',')}`
+    );
+    if (tokenFromConfig) {
+      env.KILOCODE_TOKEN = tokenFromConfig;
+    }
+  }
+
   // Build KILO_CONFIG_CONTENT so kilo serve can authenticate LLM calls.
   // Must also set OPENCODE_CONFIG_CONTENT — kilo serve checks both names.
   const kilocodeToken = env.KILOCODE_TOKEN;
   if (kilocodeToken) {
-    const configJson = buildKiloConfigContent(kilocodeToken);
+    const configJson = buildKiloConfigContent(kilocodeToken, request.model);
     env.KILO_CONFIG_CONTENT = configJson;
     env.OPENCODE_CONFIG_CONTENT = configJson;
     console.log(`[buildAgentEnv] KILO_CONFIG_CONTENT set (model=${JSON.parse(configJson).model})`);

cloudflare-gastown/container/src/completion-reporter.ts

@@ -27,7 +27,7 @@ export async function reportAgentCompleted(
 
   const url =
     agent.completionCallbackUrl ??
-    `${apiUrl}/api/rigs/${agent.rigId}/agents/${agent.agentId}/completed`;
+    `${apiUrl}/api/towns/${agent.townId}/rigs/${agent.rigId}/agents/${agent.agentId}/completed`;
   try {
     const response = await fetch(url, {
       method: 'POST',

cloudflare-gastown/container/src/control-server.ts

@@ -9,6 +9,7 @@ import {
   getUptime,
   stopAll,
   getAgentEvents,
+  registerEventSink,
 } from './process-manager';
 import { startHeartbeat, stopHeartbeat } from './heartbeat';
 import { mergeBranch } from './git-manager';
@@ -25,6 +26,32 @@ const streamTickets = new Map<string, { agentId: string; expiresAt: number }>();
 
 export const app = new Hono();
 
+// Apply town config from X-Town-Config header (sent by TownDO on every request)
+let currentTownConfig: Record<string, unknown> | null = null;
+
+/** Get the latest town config delivered via X-Town-Config header. */
+export function getCurrentTownConfig(): Record<string, unknown> | null {
+  return currentTownConfig;
+}
+
+app.use('*', async (c, next) => {
+  const configHeader = c.req.header('X-Town-Config');
+  if (configHeader) {
+    try {
+      const parsed = JSON.parse(configHeader);
+      currentTownConfig = parsed;
+      const hasToken =
+        typeof parsed.kilocode_token === 'string' && parsed.kilocode_token.length > 0;
+      console.log(
+        `[control-server] X-Town-Config received: hasKilocodeToken=${hasToken} keys=${Object.keys(parsed).join(',')}`
+      );
+    } catch {
+      console.warn('[control-server] X-Town-Config header malformed');
+    }
+  }
+  await next();
+});
+
 // Log method, path, status, and duration for every request
 app.use('*', async (c, next) => {
   const start = performance.now();
@@ -261,7 +288,10 @@ app.onError((err, c) => {
 });
 
 /**
- * Start the control server using Bun.serve + Hono.
+ * Start the control server using Bun.serve + Hono, with WebSocket support.
+ *
+ * The /ws endpoint provides a multiplexed event stream for all agents.
+ * SDK events from process-manager are forwarded to all connected WS clients.
  */
 export function startControlServer(): void {
   const PORT = 8080;
@@ -284,9 +314,109 @@ export function startControlServer(): void {
   process.on('SIGTERM', () => void shutdown());
   process.on('SIGINT', () => void shutdown());
 
-  Bun.serve({
+  // Track connected WebSocket clients with optional agent filter
+  type WSClient = import('bun').ServerWebSocket<{ agentId: string | null }>;
+  const wsClients = new Set<WSClient>();
+
+  // Agent stream URL patterns (the container receives the full path from the worker)
+  const AGENT_STREAM_RE = /\/agents\/([^/]+)\/stream$/;
+
+  // Register an event sink that forwards agent events to WS clients
+  registerEventSink((agentId, event, data) => {
+    const frame = JSON.stringify({
+      agentId,
+      event,
+      data,
+      timestamp: new Date().toISOString(),
+    });
+    for (const ws of wsClients) {
+      try {
+        // If the client subscribed to a specific agent, only send that agent's events
+        const filter = ws.data.agentId;
+        if (filter && filter !== agentId) continue;
+        ws.send(frame);
+      } catch {
+        wsClients.delete(ws);
+      }
+    }
+  });
+
+  Bun.serve<{ agentId: string | null }>({
     port: PORT,
-    fetch: app.fetch,
+    fetch(req, server) {
+      const url = new URL(req.url);
+      const pathname = url.pathname;
+
+      // WebSocket upgrade: match /ws OR /agents/:id/stream (with any prefix)
+      const isWsUpgrade = req.headers.get('upgrade')?.toLowerCase() === 'websocket';
+      if (isWsUpgrade) {
+        let agentId: string | null = null;
+
+        if (pathname === '/ws') {
+          agentId = url.searchParams.get('agentId');
+        } else {
+          const match = pathname.match(AGENT_STREAM_RE);
+          if (match) agentId = match[1];
+        }
+
+        // Accept upgrade if the path matches any WS pattern
+        if (pathname === '/ws' || AGENT_STREAM_RE.test(pathname)) {
+          const upgraded = server.upgrade(req, { data: { agentId } });
+          if (upgraded) return undefined;
+          return new Response('WebSocket upgrade failed', { status: 400 });
+        }
+      }
+
+      // All other requests go through Hono
+      return app.fetch(req);
+    },
+    websocket: {
+      open(ws) {
+        wsClients.add(ws);
+        const agentFilter = ws.data.agentId ?? 'all';
+        console.log(
+          `[control-server] WebSocket connected: agent=${agentFilter} (${wsClients.size} total)`
+        );
+
+        // Send in-memory backfill for this session's events.
+        // This covers late-joining clients within the same container lifecycle.
+        // For historical events after container restarts, clients query the
+        // AgentDO via the worker's GET /agents/:id/events endpoint.
+        if (ws.data.agentId) {
+          const events = getAgentEvents(ws.data.agentId, 0);
+          for (const evt of events) {
+            try {
+              ws.send(
+                JSON.stringify({
+                  agentId: ws.data.agentId,
+                  event: evt.event,
+                  data: evt.data,
+                  timestamp: evt.timestamp,
+                })
+              );
+            } catch {
+              break;
+            }
+          }
+        }
+      },
+      message(ws, message) {
+        // Handle subscribe messages from client
+        try {
+          const msg = JSON.parse(String(message));
+          if (msg.type === 'subscribe' && msg.agentId) {
+            ws.data.agentId = msg.agentId;
+            console.log(`[control-server] WebSocket subscribed to agent=${msg.agentId}`);
+          }
+        } catch {
+          // Ignore
+        }
+      },
+      close(ws) {
+        wsClients.delete(ws);
+        console.log(`[control-server] WebSocket disconnected (${wsClients.size} total)`);
+      },
+    },
   });
 
   console.log(`Town container control server listening on port ${PORT}`);