@dev-anywhere/relay 0.0.1

package/dist/chunk-TBYEKF42.js

@@ -0,0 +1,1487 @@
+#!/usr/bin/env node
+
+// src/server.ts
+import express from "express";
+import { createServer } from "http";
+import { homedir as homedir2 } from "os";
+import { WebSocketServer } from "ws";
+
+// src/registry.ts
+import { WebSocket } from "ws";
+var RelayRegistry = class {
+  proxyStates = /* @__PURE__ */ new Map();
+  clientBindings = /* @__PURE__ */ new Map();
+  connectedClients = /* @__PURE__ */ new Set();
+  registerProxy(proxyId, ws, name) {
+    const existing = this.proxyStates.get(proxyId);
+    if (existing) {
+      if (existing.ws && existing.ws.readyState === WebSocket.OPEN) {
+        existing.ws.terminate();
+      }
+      existing.ws = ws;
+      existing.connectionState = "online";
+      existing.disconnectedAt = null;
+      if (name !== void 0) existing.name = name;
+      return "reconnected";
+    }
+    this.proxyStates.set(proxyId, {
+      ws,
+      connectionState: "online",
+      sessions: /* @__PURE__ */ new Set(),
+      disconnectedAt: null,
+      name
+    });
+    return "new";
+  }
+  // 标记 proxy 离线，保留所有状态等待重连，不设超时
+  // 清理只在 proxy 主动退出（proxy_disconnect）或 relay 启动清理废弃数据时发生
+  markProxyOffline(proxyId) {
+    const state = this.proxyStates.get(proxyId);
+    if (!state) return;
+    state.ws = null;
+    state.connectionState = "offline";
+    state.disconnectedAt = Date.now();
+  }
+  // 显式状态转换，校验 from 状态匹配后更新 connectionState
+  transitionProxy(proxyId, from, to) {
+    if (from === to) {
+      throw new Error(`Invalid proxy transition: ${from} -> ${to} (same state)`);
+    }
+    const state = this.proxyStates.get(proxyId);
+    if (!state) {
+      throw new Error(`Proxy not found: ${proxyId}`);
+    }
+    if (state.connectionState !== from) {
+      throw new Error(
+        `Proxy ${proxyId} state mismatch: expected ${from}, actual ${state.connectionState}`
+      );
+    }
+    state.connectionState = to;
+    if (to === "offline") {
+      state.ws = null;
+      state.disconnectedAt = Date.now();
+    }
+  }
+  // 显式客户端状态转换，校验 from 状态匹配后更新 connectionState
+  transitionClient(clientId, from, to) {
+    if (from === to) {
+      throw new Error(`Invalid client transition: ${from} -> ${to} (same state)`);
+    }
+    const binding = this.clientBindings.get(clientId);
+    if (!binding) {
+      throw new Error(`Client not found: ${clientId}`);
+    }
+    if (binding.connectionState !== from) {
+      throw new Error(
+        `Client ${clientId} state mismatch: expected ${from}, actual ${binding.connectionState}`
+      );
+    }
+    binding.connectionState = to;
+  }
+  getProxyConnectionState(proxyId) {
+    return this.proxyStates.get(proxyId)?.connectionState;
+  }
+  getClientConnectionState(clientId) {
+    return this.clientBindings.get(clientId)?.connectionState;
+  }
+  // 彻底清理 proxy 状态和客户端绑定
+  cleanupProxy(proxyId) {
+    const state = this.proxyStates.get(proxyId);
+    if (!state) return;
+    for (const [clientId, binding] of this.clientBindings) {
+      if (binding.proxyId === proxyId) {
+        this.clientBindings.delete(clientId);
+      }
+    }
+    this.proxyStates.delete(proxyId);
+  }
+  unregisterProxy(proxyId) {
+    this.cleanupProxy(proxyId);
+  }
+  getProxy(proxyId) {
+    const state = this.proxyStates.get(proxyId);
+    return state?.ws ?? void 0;
+  }
+  isProxyOnline(proxyId) {
+    const state = this.proxyStates.get(proxyId);
+    if (!state || state.connectionState !== "online") return false;
+    if (!state.ws || state.ws.readyState !== WebSocket.OPEN) return false;
+    return true;
+  }
+  // proxy 是否存在（含宽限期中的）
+  hasProxy(proxyId) {
+    return this.proxyStates.has(proxyId);
+  }
+  listProxies() {
+    return Array.from(this.proxyStates.keys());
+  }
+  // 返回 proxyId、name、online 的列表，用于 proxy_list_response
+  listProxiesWithName() {
+    return Array.from(this.proxyStates.entries()).map(([proxyId, state]) => ({
+      proxyId,
+      ...state.name !== void 0 ? { name: state.name } : {},
+      online: state.connectionState === "online"
+    }));
+  }
+  getProxyName(proxyId) {
+    return this.proxyStates.get(proxyId)?.name;
+  }
+  // 将 sessionId 关联到 proxy
+  addSessionToProxy(proxyId, sessionId) {
+    const state = this.proxyStates.get(proxyId);
+    if (state) {
+      state.sessions.add(sessionId);
+    }
+  }
+  // 通过 sessionId 反查所属 proxyId
+  getProxyForSession(sessionId) {
+    for (const [proxyId, state] of this.proxyStates) {
+      if (state.sessions.has(sessionId)) {
+        return proxyId;
+      }
+    }
+    return void 0;
+  }
+  // 获取 proxy 关联的所有 sessionId
+  getSessionsForProxy(proxyId) {
+    const state = this.proxyStates.get(proxyId);
+    return state ? Array.from(state.sessions) : [];
+  }
+  // clientId 绑定方式
+  bindClientById(clientId, proxyId, ws) {
+    if (!this.proxyStates.has(proxyId)) {
+      return false;
+    }
+    this.clientBindings.set(clientId, { proxyId, ws, connectionState: "bound" });
+    return true;
+  }
+  updateClientSocket(clientId, ws) {
+    const binding = this.clientBindings.get(clientId);
+    if (binding) {
+      binding.ws = ws;
+    }
+  }
+  // 断开客户端 WebSocket 但保留绑定关系，重连时可恢复
+  unbindClientById(clientId) {
+    const binding = this.clientBindings.get(clientId);
+    if (binding) {
+      binding.ws = null;
+    }
+  }
+  getClientBinding(clientId) {
+    return this.clientBindings.get(clientId);
+  }
+  // 获取绑定到指定 proxy 的所有活跃客户端 WebSocket
+  getClientsForProxy(proxyId) {
+    const clients = [];
+    for (const [, binding] of this.clientBindings) {
+      if (binding.proxyId === proxyId && binding.ws && binding.ws.readyState === WebSocket.OPEN) {
+        clients.push(binding.ws);
+      }
+    }
+    return clients;
+  }
+  countClients() {
+    let count = 0;
+    for (const [, binding] of this.clientBindings) {
+      if (binding.ws) count++;
+    }
+    return count;
+  }
+  addClientWs(ws) {
+    this.connectedClients.add(ws);
+  }
+  removeClientWs(ws) {
+    this.connectedClients.delete(ws);
+  }
+  getAllClientWs() {
+    const clients = [];
+    for (const ws of this.connectedClients) {
+      if (ws.readyState === WebSocket.OPEN) {
+        clients.push(ws);
+      }
+    }
+    return clients;
+  }
+  // 获取单个 proxy 的详细状态信息
+  getProxyDetail(proxyId) {
+    const state = this.proxyStates.get(proxyId);
+    if (!state) return void 0;
+    return {
+      proxyId,
+      ...state.name !== void 0 ? { name: state.name } : {},
+      online: state.connectionState === "online",
+      connectionState: state.connectionState,
+      sessions: Array.from(state.sessions),
+      disconnectedAt: state.disconnectedAt
+    };
+  }
+  // 获取所有客户端绑定的详细信息
+  getClientDetails() {
+    const details = [];
+    for (const [clientId, binding] of this.clientBindings) {
+      details.push({
+        clientId,
+        proxyId: binding.proxyId,
+        online: binding.ws !== null && binding.ws !== void 0 && binding.ws.readyState === WebSocket.OPEN,
+        connectionState: binding.connectionState
+      });
+    }
+    return details;
+  }
+};
+
+// src/health.ts
+import { Router } from "express";
+function healthRouter(registry) {
+  const router = Router();
+  router.get("/health", (_req, res) => {
+    res.json({
+      status: "ok",
+      uptime: process.uptime()
+    });
+  });
+  router.get("/status", (_req, res) => {
+    res.json({
+      proxyCount: registry.listProxies().length,
+      clientCount: registry.countClients(),
+      uptime: process.uptime()
+    });
+  });
+  router.get("/api/status", (_req, res) => {
+    res.json({
+      proxyCount: registry.listProxies().length,
+      clientCount: registry.countClients(),
+      uptime: process.uptime(),
+      bindings: registry.getClientDetails()
+    });
+  });
+  router.get("/api/proxies", (_req, res) => {
+    const proxyIds = registry.listProxies();
+    const details = proxyIds.map((id) => registry.getProxyDetail(id)).filter((d) => d !== void 0);
+    res.json(details);
+  });
+  router.get("/api/clients", (_req, res) => {
+    res.json(registry.getClientDetails());
+  });
+  return router;
+}
+
+// src/handlers/proxy.ts
+import { WebSocket as WebSocket3 } from "ws";
+
+// ../../packages/shared/dist/schemas/envelope.js
+import { z as z5 } from "zod";
+
+// ../../packages/shared/dist/schemas/chat.js
+import { z } from "zod";
+var UserInputPayloadSchema = z.object({
+  text: z.string().min(1)
+});
+var AssistantMessagePayloadSchema = z.object({
+  text: z.string(),
+  isPartial: z.boolean()
+});
+var ThinkingPayloadSchema = z.object({
+  text: z.string()
+});
+
+// ../../packages/shared/dist/schemas/tool.js
+import { z as z2 } from "zod";
+var ToolUseRequestPayloadSchema = z2.object({
+  toolName: z2.string(),
+  toolId: z2.string(),
+  parameters: z2.record(z2.string(), z2.unknown())
+});
+var ToolApprovePayloadSchema = z2.object({
+  toolId: z2.string(),
+  whitelistTool: z2.boolean().optional()
+});
+var ToolDenyPayloadSchema = z2.object({
+  toolId: z2.string(),
+  reason: z2.string().optional()
+});
+var ToolResultPayloadSchema = z2.object({
+  toolId: z2.string(),
+  result: z2.unknown(),
+  isError: z2.boolean()
+});
+
+// ../../packages/shared/dist/schemas/session.js
+import { z as z3 } from "zod";
+var sessionStateValues = ["idle", "working", "waiting_approval", "error", "terminated"];
+var providerValues = ["claude", "codex"];
+var ptyOwnerValues = ["local-terminal", "proxy-hosted"];
+var agentStatusPhaseValues = [
+  "idle",
+  "thinking",
+  "tool_use",
+  "outputting",
+  "waiting_permission",
+  "error"
+];
+var SessionInfoSchema = z3.object({
+  sessionId: z3.string(),
+  name: z3.string().optional(),
+  state: z3.enum(sessionStateValues),
+  mode: z3.enum(["pty", "json"]).optional(),
+  provider: z3.enum(providerValues),
+  // PTY 尺寸所有权:
+  // - local-terminal: 本地 terminal 进程持有真实 PTY，Web 只按原始 cols/rows 展示
+  // - proxy-hosted: serve 内托管 PTY，Web 可按视口请求 resize
+  ptyOwner: z3.enum(ptyOwnerValues).optional(),
+  lastActive: z3.number().optional()
+});
+var SessionCreatePayloadSchema = z3.object({
+  name: z3.string().optional(),
+  cwd: z3.string().optional(),
+  streamDelta: z3.boolean().optional()
+});
+var SessionListPayloadSchema = z3.object({
+  sessions: z3.array(SessionInfoSchema)
+});
+var SessionSwitchPayloadSchema = z3.object({
+  sessionId: z3.string()
+});
+var SessionTerminatePayloadSchema = z3.object({
+  sessionId: z3.string()
+});
+var SessionStatusPayloadSchema = z3.object({
+  sessionId: z3.string(),
+  state: z3.enum(sessionStateValues),
+  lastActive: z3.number()
+});
+var PtyStatePayloadSchema = z3.object({
+  state: z3.enum(["working", "turn_complete", "approval_wait", "mid_pause"]),
+  title: z3.string().optional(),
+  tool: z3.string().optional()
+});
+var AgentStatusPayloadSchema = z3.object({
+  provider: z3.enum(providerValues),
+  phase: z3.enum(agentStatusPhaseValues),
+  seq: z3.number().int().nonnegative(),
+  updatedAt: z3.number(),
+  toolName: z3.string().optional(),
+  toolInput: z3.record(z3.string(), z3.unknown()).optional(),
+  permissionRequest: z3.object({
+    requestId: z3.string(),
+    toolName: z3.string(),
+    input: z3.record(z3.string(), z3.unknown())
+  }).optional(),
+  permissionResolution: z3.object({
+    requestId: z3.string(),
+    outcome: z3.enum(["allow", "deny"])
+  }).optional(),
+  summary: z3.string().optional()
+});
+
+// ../../packages/shared/dist/schemas/system.js
+import { z as z4 } from "zod";
+var HeartbeatPayloadSchema = z4.object({});
+var AuthPayloadSchema = z4.object({
+  pairingCode: z4.string().optional(),
+  token: z4.string().optional()
+});
+var SyncRequestPayloadSchema = z4.object({
+  lastSeq: z4.number().int().nonnegative()
+});
+var SyncResponsePayloadSchema = z4.object({
+  messages: z4.array(z4.record(z4.string(), z4.unknown()))
+});
+
+// ../../packages/shared/dist/schemas/envelope.js
+var BaseEnvelopeFields = {
+  seq: z5.number().int().nonnegative(),
+  sessionId: z5.string(),
+  timestamp: z5.number(),
+  source: z5.enum(["proxy", "client"]),
+  version: z5.string()
+};
+var MessageEnvelopeSchema = z5.discriminatedUnion("type", [
+  // chat (3)
+  z5.object({
+    ...BaseEnvelopeFields,
+    type: z5.literal("user_input"),
+    payload: UserInputPayloadSchema
+  }),
+  z5.object({
+    ...BaseEnvelopeFields,
+    type: z5.literal("assistant_message"),
+    payload: AssistantMessagePayloadSchema
+  }),
+  z5.object({
+    ...BaseEnvelopeFields,
+    type: z5.literal("thinking"),
+    payload: ThinkingPayloadSchema
+  }),
+  // tool (4): 工具审批决策属于 relay control，不进入会话消息信封。
+  // tool_use_request: 审批流请求（proxy → client），toolId 是 approval requestId
+  z5.object({
+    ...BaseEnvelopeFields,
+    type: z5.literal("tool_use_request"),
+    payload: ToolUseRequestPayloadSchema
+  }),
+  // tool_result: 工具执行结果（proxy → client），toolId 对应 assistant_tool_use / tool_use_request 的 toolId
+  z5.object({
+    ...BaseEnvelopeFields,
+    type: z5.literal("tool_result"),
+    payload: ToolResultPayloadSchema
+  }),
+  // assistant_tool_use: 纯展示型工具调用（proxy → client），区别于 tool_use_request 无审批语义
+  // payload 结构复用 ToolUseRequestPayloadSchema；toolId 是 Claude 分配的 tool_use id
+  z5.object({
+    ...BaseEnvelopeFields,
+    type: z5.literal("assistant_tool_use"),
+    payload: ToolUseRequestPayloadSchema
+  }),
+  // session (5)
+  z5.object({
+    ...BaseEnvelopeFields,
+    type: z5.literal("session_create"),
+    payload: SessionCreatePayloadSchema
+  }),
+  z5.object({
+    ...BaseEnvelopeFields,
+    type: z5.literal("session_list"),
+    payload: SessionListPayloadSchema
+  }),
+  z5.object({
+    ...BaseEnvelopeFields,
+    type: z5.literal("session_switch"),
+    payload: SessionSwitchPayloadSchema
+  }),
+  z5.object({
+    ...BaseEnvelopeFields,
+    type: z5.literal("session_terminate"),
+    payload: SessionTerminatePayloadSchema
+  }),
+  z5.object({
+    ...BaseEnvelopeFields,
+    type: z5.literal("session_status"),
+    payload: SessionStatusPayloadSchema
+  }),
+  // system (5)
+  z5.object({
+    ...BaseEnvelopeFields,
+    type: z5.literal("heartbeat"),
+    payload: HeartbeatPayloadSchema
+  }),
+  z5.object({
+    ...BaseEnvelopeFields,
+    type: z5.literal("auth"),
+    payload: AuthPayloadSchema
+  }),
+  z5.object({
+    ...BaseEnvelopeFields,
+    type: z5.literal("sync_request"),
+    payload: SyncRequestPayloadSchema
+  }),
+  z5.object({
+    ...BaseEnvelopeFields,
+    type: z5.literal("sync_response"),
+    payload: SyncResponsePayloadSchema
+  })
+]);
+
+// ../../packages/shared/dist/schemas/relay-control.js
+import { z as z6 } from "zod";
+
+// ../../packages/shared/dist/constants/relay-errors.js
+var RelayErrorCode = {
+  NOT_REGISTERED: "NOT_REGISTERED",
+  NOT_BOUND: "NOT_BOUND",
+  PROXY_OFFLINE: "PROXY_OFFLINE",
+  INVALID_MESSAGE: "INVALID_MESSAGE",
+  UNSUPPORTED: "UNSUPPORTED",
+  INVALID_RANGE: "INVALID_RANGE"
+};
+
+// ../../packages/shared/dist/constants/control-errors.js
+var ControlErrorCode = {
+  INVALID_PATH: "INVALID_PATH",
+  PATH_NOT_FOUND: "PATH_NOT_FOUND",
+  PATH_NOT_DIRECTORY: "PATH_NOT_DIRECTORY",
+  PATH_ACCESS_DENIED: "PATH_ACCESS_DENIED",
+  PROXY_OFFLINE: "PROXY_OFFLINE",
+  SESSION_NOT_FOUND: "SESSION_NOT_FOUND",
+  PROVIDER_UNSUPPORTED: "PROVIDER_UNSUPPORTED",
+  WORKER_START_FAILED: "WORKER_START_FAILED",
+  PROCESS_START_FAILED: "PROCESS_START_FAILED",
+  UNKNOWN: "UNKNOWN"
+};
+
+// ../../packages/shared/dist/schemas/relay-control.js
+var ProxyInfoSchema = z6.object({
+  proxyId: z6.string(),
+  name: z6.string().optional(),
+  online: z6.boolean(),
+  sessions: z6.array(z6.string()).optional()
+});
+var AgentCliAvailabilitySchema = z6.object({
+  available: z6.boolean(),
+  command: z6.string().optional(),
+  error: z6.string().optional(),
+  suggestions: z6.array(z6.string()).optional()
+});
+var AgentCliStatusSchema = z6.object({
+  claude: AgentCliAvailabilitySchema,
+  codex: AgentCliAvailabilitySchema
+});
+var DirEntrySchema = z6.object({ name: z6.string(), isDir: z6.boolean() });
+var FileTreeGroupSchema = z6.object({
+  path: z6.string(),
+  entries: z6.array(DirEntrySchema)
+});
+var CommandEntrySchema = z6.object({
+  name: z6.string(),
+  description: z6.string(),
+  argumentHint: z6.string().optional(),
+  source: z6.string()
+});
+var HistorySessionSchema = z6.object({
+  id: z6.string(),
+  title: z6.string(),
+  projectDir: z6.string(),
+  updatedAt: z6.number(),
+  provider: z6.enum(["claude", "codex"]).optional()
+});
+var RequestIdShape = { requestId: z6.string().min(1).optional() };
+var ControlErrorCodeSchema = z6.enum(Object.values(ControlErrorCode));
+var RequestErrorShape = {
+  error: z6.string().optional(),
+  errorCode: ControlErrorCodeSchema.optional()
+};
+function control(type, shape, directions) {
+  return {
+    type,
+    directions: new Set(Array.isArray(directions) ? directions : directions ? [directions] : []),
+    schema: z6.object({
+      type: z6.literal(type),
+      ...shape ?? {}
+    })
+  };
+}
+var relayControlDefinitions = [
+  control("proxy_register", {
+    proxyId: z6.string().min(1),
+    name: z6.string().optional()
+  }),
+  control("proxy_register_response", {
+    status: z6.enum(["new", "reconnected"])
+  }),
+  control("proxy_list_request", RequestIdShape),
+  control("proxy_list_response", {
+    ...RequestIdShape,
+    proxies: z6.array(ProxyInfoSchema)
+  }),
+  control("proxy_select", { ...RequestIdShape, proxyId: z6.string().min(1) }),
+  control("proxy_select_response", {
+    ...RequestIdShape,
+    success: z6.boolean(),
+    proxyId: z6.string().optional(),
+    ...RequestErrorShape
+  }),
+  control("relay_error", {
+    code: z6.enum(Object.values(RelayErrorCode)),
+    message: z6.string()
+  }),
+  // 客户端注册协议
+  control("client_register", {
+    clientId: z6.string().min(1)
+  }),
+  control("client_register_response", {
+    status: z6.enum(["restored", "proxy_offline", "new"]),
+    proxyId: z6.string().optional()
+  }),
+  // Proxy 离线通知
+  control("proxy_offline", {
+    proxyId: z6.string()
+  }),
+  // Proxy 主动断开，relay 立即清理资源
+  control("proxy_disconnect", {
+    proxyId: z6.string().min(1)
+  }),
+  // Proxy 重连后通知 client 恢复
+  control("proxy_online", {
+    proxyId: z6.string().min(1)
+  }),
+  // 目录列表请求与响应
+  control("dir_list_request", {
+    proxyId: z6.string().min(1).optional(),
+    ...RequestIdShape,
+    path: z6.string()
+  }, "client_to_proxy"),
+  control("dir_list_response", { ...RequestIdShape, ...RequestErrorShape, entries: z6.array(DirEntrySchema), path: z6.string() }, "proxy_to_client"),
+  // 目录创建请求与响应
+  control("dir_create_request", { ...RequestIdShape, path: z6.string() }, "client_to_proxy"),
+  control("dir_create_response", {
+    ...RequestIdShape,
+    ...RequestErrorShape,
+    path: z6.string(),
+    success: z6.boolean()
+  }, "proxy_to_client"),
+  // 命令列表推送，proxy 将可用命令列表推给 client
+  control("command_list_push", { commands: z6.array(CommandEntrySchema) }, "proxy_to_client"),
+  // 文件树推送: 按目录分组, 首组 path 即为 session cwd
+  // 前端直接把每组写入 tree[path], 与 dir_list_response 共享 cache slot
+  control("file_tree_push", {
+    groups: z6.array(FileTreeGroupSchema)
+  }, "proxy_to_client"),
+  // 会话列表请求与权限模式变更
+  control("session_list", void 0, ["client_to_proxy", "proxy_to_client"]),
+  control("permission_mode_change", {
+    mode: z6.enum(["default", "auto_accept", "plan"]),
+    // sessionId 可选：传入时 proxy 按该会话的 mode 分叉（PTY 发 Tab ANSI），未传走全局日志行为
+    sessionId: z6.string().optional()
+  }, "client_to_proxy"),
+  // 会话历史浏览
+  control("session_history_request", RequestIdShape, "client_to_proxy"),
+  control("session_history_response", { ...RequestIdShape, sessions: z6.array(HistorySessionSchema) }, "proxy_to_client"),
+  // PTY 语义状态，从 Envelope 迁移到 Control 层
+  control("pty_state", { sessionId: z6.string(), payload: PtyStatePayloadSchema }, "proxy_to_client"),
+  // Provider 语义状态，来自 Claude/Codex hook 等结构化事件，不从 PTY 字节推断
+  control("agent_status", { sessionId: z6.string(), payload: AgentStatusPayloadSchema }, "proxy_to_client"),
+  // 终端标题变化，proxy -> client
+  control("terminal_title", { sessionId: z6.string(), title: z6.string() }, "proxy_to_client"),
+  // 终端尺寸变化，proxy -> client
+  control("terminal_resize", { sessionId: z6.string(), cols: z6.number().int().positive(), rows: z6.number().int().positive() }, "proxy_to_client"),
+  control("terminal_resize_request", { sessionId: z6.string(), cols: z6.number().int().positive(), rows: z6.number().int().positive() }, "client_to_proxy"),
+  // 远程终止 JSON 会话，client -> proxy
+  control("session_terminate", { sessionId: z6.string() }, "client_to_proxy"),
+  // 中断当前 turn，client -> proxy，SIGINT 到 worker 进程让 claude CLI abort 当前流
+  control("session_worker_abort", { sessionId: z6.string() }, "client_to_proxy"),
+  // turn 完成信号，proxy -> client，对应 claude stream-json 的 result 事件
+  control("turn_result", {
+    sessionId: z6.string(),
+    success: z6.boolean(),
+    isError: z6.boolean(),
+    // stream-json result.result 是本轮最终文本。assistant_message 流丢失或 CLI 未发增量时，
+    // Web 用它作为 JSON 模式兜底展示，避免 turn 已结束但界面空白。
+    result: z6.string().optional()
+  }, "proxy_to_client"),
+  // 客户端发送到 PTY 的原始字节（ANSI 序列），不追加换行
+  control("remote_input_raw", { sessionId: z6.string().min(1), data: z6.string() }, "client_to_proxy"),
+  // 客户端询问 proxy 的环境信息 (home 路径等), client -> proxy -> response
+  // FilePathPicker 用 homePath 作为 select 模式下的默认起点, 新建会话时打开即可浏览
+  control("proxy_info_request", RequestIdShape, "client_to_proxy"),
+  control("proxy_info", { ...RequestIdShape, homePath: z6.string(), agentCli: AgentCliStatusSchema }, "proxy_to_client"),
+  control("agent_cli_config_update", { ...RequestIdShape, provider: z6.enum(["claude", "codex"]), path: z6.string().min(1) }, "client_to_proxy"),
+  control("agent_cli_config_update_response", {
+    ...RequestIdShape,
+    provider: z6.enum(["claude", "codex"]),
+    agentCli: AgentCliStatusSchema.optional(),
+    ...RequestErrorShape
+  }, "proxy_to_client"),
+  // 远程创建 JSON 会话，client -> proxy -> response
+  control("session_create", {
+    ...RequestIdShape,
+    cwd: z6.string(),
+    provider: z6.enum(["claude", "codex"]),
+    mode: z6.enum(["json", "pty"]).optional(),
+    resumeSessionId: z6.string().optional(),
+    // 透传给 claude CLI 的 --permission-mode, undefined 时 proxy 兜底为 "default"
+    permissionMode: z6.enum(["default", "auto", "acceptEdits", "plan", "bypassPermissions", "dontAsk"]).optional()
+  }, "client_to_proxy"),
+  control("session_create_response", {
+    ...RequestIdShape,
+    sessionId: z6.string(),
+    mode: z6.enum(["json", "pty"]).optional(),
+    provider: z6.enum(["claude", "codex"]).optional(),
+    ptyOwner: z6.enum(["local-terminal", "proxy-hosted"]).optional(),
+    ...RequestErrorShape
+  }, "proxy_to_client"),
+  // 客户端请求会话历史消息，client -> proxy
+  control("session_messages_request", { ...RequestIdShape, sessionId: z6.string() }, "client_to_proxy"),
+  // 客户端请求会话资源（命令列表 + 文件树），client -> proxy
+  control("session_resources_request", { ...RequestIdShape, sessionId: z6.string() }, "client_to_proxy"),
+  control("session_resources_response", {
+    ...RequestIdShape,
+    ...RequestErrorShape,
+    sessionId: z6.string(),
+    commands: z6.array(CommandEntrySchema),
+    groups: z6.array(FileTreeGroupSchema)
+  }, "proxy_to_client"),
+  // 客户端请求当前 provider 语义状态；不经 relay 缓存，由 proxy 返回当前值
+  control("agent_status_request", { ...RequestIdShape, sessionId: z6.string().optional() }, "client_to_proxy"),
+  control("agent_status_response", {
+    ...RequestIdShape,
+    statuses: z6.array(z6.object({ sessionId: z6.string(), payload: AgentStatusPayloadSchema }))
+  }, "proxy_to_client"),
+  // 客户端确认已收到审批请求；proxy 只记录送达状态，不把它当成用户决策
+  control("permission_request_delivered", { sessionId: z6.string(), requestId: z6.string() }, "client_to_proxy"),
+  control("tool_approve", { sessionId: z6.string(), payload: ToolApprovePayloadSchema }, "client_to_proxy"),
+  control("tool_deny", { sessionId: z6.string(), payload: ToolDenyPayloadSchema }, "client_to_proxy"),
+  // proxy 确认用户决策已进入 provider/worker 路径；web 用它更新审批卡片状态
+  control("permission_decision_result", {
+    sessionId: z6.string(),
+    requestId: z6.string(),
+    outcome: z6.enum(["allow", "deny"]),
+    delivered: z6.boolean(),
+    message: z6.string().optional()
+  }, "proxy_to_client"),
+  // proxy 推送当前 pending 的工具审批列表，client 据此恢复审批卡片
+  control("pending_approvals_push", {
+    sessionId: z6.string(),
+    approvals: z6.array(z6.object({
+      requestId: z6.string(),
+      toolName: z6.string(),
+      input: z6.record(z6.string(), z6.unknown())
+    }))
+  }, "proxy_to_client"),
+  // 恢复会话时推送历史消息，proxy -> client
+  control("session_history_messages", {
+    ...RequestIdShape,
+    sessionId: z6.string(),
+    messages: z6.array(z6.object({
+      role: z6.enum(["user", "assistant"]),
+      text: z6.string(),
+      timestamp: z6.number().optional()
+    }))
+  }, "proxy_to_client"),
+  // proxy 重连后同步活跃 session 列表给 relay
+  control("session_sync", {
+    sessions: z6.array(z6.object({
+      id: z6.string(),
+      mode: z6.enum(["pty", "json"]),
+      provider: z6.enum(["claude", "codex"]),
+      ptyOwner: z6.enum(["local-terminal", "proxy-hosted"]).optional(),
+      state: z6.string()
+    }))
+  }),
+  // PTY 会话订阅，client -> proxy，触发 terminal serialize() 返回当前状态
+  control("session_subscribe", { sessionId: z6.string(), requestId: z6.string().optional() }, "client_to_proxy"),
+  // PTY 会话快照，proxy -> client，serialize() 的全量终端状态
+  control("session_snapshot", {
+    sessionId: z6.string(),
+    cols: z6.number().int().positive(),
+    rows: z6.number().int().positive(),
+    data: z6.string(),
+    outputSeq: z6.number().int().nonnegative(),
+    requestId: z6.string().optional()
+  }, "proxy_to_client")
+];
+var relayControlSchemas = relayControlDefinitions.map((definition) => definition.schema);
+var RelayControlSchema = z6.discriminatedUnion("type", relayControlSchemas);
+var ProxyToClientRelayControlTypes = new Set(relayControlDefinitions.filter((definition) => definition.directions.has("proxy_to_client")).map((definition) => definition.type));
+function isProxyToClientRelayControlType(type) {
+  return ProxyToClientRelayControlTypes.has(type);
+}
+var ClientToProxyRelayControlTypes = new Set(relayControlDefinitions.filter((definition) => definition.directions.has("client_to_proxy")).map((definition) => definition.type));
+function isClientToProxyRelayControlType(type) {
+  return ClientToProxyRelayControlTypes.has(type);
+}
+
+// ../../packages/shared/dist/logger.js
+import { lstatSync, mkdirSync, readdirSync, renameSync, statSync, symlinkSync, unlinkSync } from "fs";
+import { homedir } from "os";
+import { basename, join } from "path";
+import pino from "pino";
+var DEFAULT_LOG_DIR = `${homedir()}/.dev-anywhere/logs`;
+var DEFAULT_LOG_RETENTION = 50;
+var PROCESS_LOG_RUN_ID = sanitizeRunId(process.env.DEV_ANYWHERE_LOG_RUN_ID ?? `${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-")}-${process.pid}`);
+function sanitizeRunId(runId) {
+  return runId.replace(/[^a-zA-Z0-9._-]/g, "_");
+}
+function linkLatestLog(logDir, name, filePath, runId) {
+  const latestPath = join(logDir, `${name}.log`);
+  try {
+    const stat = lstatSync(latestPath);
+    if (stat.isSymbolicLink()) {
+      unlinkSync(latestPath);
+    } else {
+      renameSync(latestPath, join(logDir, `${name}-legacy-${runId}.log`));
+    }
+  } catch (err) {
+    const code = err.code;
+    if (code !== "ENOENT")
+      return;
+  }
+  try {
+    symlinkSync(basename(filePath), latestPath);
+  } catch {
+  }
+}
+function resolveRetention() {
+  const raw = process.env.DEV_ANYWHERE_LOG_RETENTION;
+  if (!raw)
+    return DEFAULT_LOG_RETENTION;
+  const parsed = Number.parseInt(raw, 10);
+  return Number.isFinite(parsed) && parsed >= 0 ? parsed : DEFAULT_LOG_RETENTION;
+}
+function pruneOldLogs(logDir, name, currentFilePath) {
+  const keep = resolveRetention();
+  if (keep === 0)
+    return;
+  const currentFileName = basename(currentFilePath);
+  const prefix = `${name}-`;
+  const candidates = readdirSync(logDir).filter((entry) => entry.startsWith(prefix) && entry.endsWith(".log") && entry !== currentFileName).map((entry) => {
+    const path = join(logDir, entry);
+    try {
+      return { path, mtimeMs: statSync(path).mtimeMs };
+    } catch {
+      return null;
+    }
+  }).filter((entry) => entry !== null).sort((a, b) => b.mtimeMs - a.mtimeMs);
+  for (const stale of candidates.slice(Math.max(0, keep - 1))) {
+    try {
+      unlinkSync(stale.path);
+    } catch {
+    }
+  }
+}
+function createLogger(options) {
+  const { name, level = "info", logDir = DEFAULT_LOG_DIR, stdout = false, silent = false } = options;
+  if (silent) {
+    return pino({ level: "silent" });
+  }
+  mkdirSync(logDir, { recursive: true });
+  const runId = PROCESS_LOG_RUN_ID;
+  const filePath = join(logDir, `${name}-${runId}.log`);
+  linkLatestLog(logDir, name, filePath, runId);
+  pruneOldLogs(logDir, name, filePath);
+  const streams = [{ stream: pino.destination(filePath) }];
+  if (stdout) {
+    streams.unshift({ stream: process.stdout });
+  }
+  return pino({ level }, pino.multistream(streams));
+}
+
+// src/router.ts
+import { WebSocket as WebSocket2 } from "ws";
+function parseMessage(data) {
+  let parsed;
+  try {
+    parsed = JSON.parse(data);
+  } catch {
+    return { kind: "invalid", error: "Invalid JSON" };
+  }
+  const controlResult = RelayControlSchema.safeParse(parsed);
+  if (controlResult.success) {
+    return { kind: "control", message: controlResult.data };
+  }
+  const envelopeResult = MessageEnvelopeSchema.safeParse(parsed);
+  if (envelopeResult.success) {
+    return { kind: "envelope", message: envelopeResult.data, raw: data };
+  }
+  return { kind: "invalid", error: "Message matches neither RelayControl nor MessageEnvelope" };
+}
+function routeProxyMessage(raw, proxyId, registry, logger, chaos) {
+  const result = parseMessage(raw);
+  if (result.kind === "invalid") {
+    logger.warn({ proxyId, error: result.error }, "Invalid message from proxy");
+    return;
+  }
+  if (result.kind === "control") {
+    logger.warn({ proxyId }, "Control message in routeProxyMessage, should be handled by handler");
+    return;
+  }
+  const { message } = result;
+  const { sessionId } = message;
+  registry.addSessionToProxy(proxyId, sessionId);
+  const clients = registry.getClientsForProxy(proxyId);
+  for (const clientWs of clients) {
+    if (clientWs.readyState === WebSocket2.OPEN) {
+      if (chaos) chaos.send(clientWs, raw, { direction: "proxy_to_client", type: message.type });
+      else clientWs.send(raw);
+    }
+  }
+}
+function routeClientMessage(raw, proxyId, clientWs, registry, logger, chaos) {
+  const result = parseMessage(raw);
+  if (result.kind === "invalid") {
+    logger.warn({ error: result.error }, "Invalid message from client");
+    return;
+  }
+  if (result.kind === "control") {
+    logger.warn("Control message in routeClientMessage, should be handled by handler");
+    return;
+  }
+  const proxyWs = registry.getProxy(proxyId);
+  if (!proxyWs || proxyWs.readyState !== WebSocket2.OPEN) {
+    clientWs.send(
+      JSON.stringify({
+        type: "relay_error",
+        code: RelayErrorCode.PROXY_OFFLINE,
+        message: `Proxy ${proxyId} is not available`
+      })
+    );
+    return;
+  }
+  if (chaos) chaos.send(proxyWs, raw, { direction: "client_to_proxy", type: result.message.type });
+  else proxyWs.send(raw);
+}
+
+// src/handlers/proxy.ts
+var MAX_BINARY_FRAME_SIZE = 10 * 1024 * 1024;
+function notifyClientsProxyOffline(proxyId, registry, logger, chaos) {
+  const clients = registry.getClientsForProxy(proxyId);
+  const msg = JSON.stringify({ type: "proxy_offline", proxyId });
+  for (const clientWs of clients) {
+    if (chaos) chaos.send(clientWs, msg, { direction: "proxy_to_client", type: "proxy_offline" });
+    else clientWs.send(msg);
+  }
+  logger.info({ proxyId, clientCount: clients.length }, "Notified clients of proxy offline");
+}
+function notifyClientsProxyOnline(proxyId, registry, logger, chaos) {
+  const clients = registry.getClientsForProxy(proxyId);
+  const msg = JSON.stringify({ type: "proxy_online", proxyId });
+  for (const clientWs of clients) {
+    if (chaos) chaos.send(clientWs, msg, { direction: "proxy_to_client", type: "proxy_online" });
+    else clientWs.send(msg);
+  }
+  logger.info({ proxyId, clientCount: clients.length }, "Notified clients of proxy online");
+}
+function broadcastProxyList(registry, chaos) {
+  const proxies = registry.listProxiesWithName().map((p) => ({
+    ...p,
+    sessions: registry.getSessionsForProxy(p.proxyId)
+  }));
+  const msg = JSON.stringify({ type: "proxy_list_response", proxies });
+  for (const clientWs of registry.getAllClientWs()) {
+    if (chaos)
+      chaos.send(clientWs, msg, { direction: "proxy_to_client", type: "proxy_list_response" });
+    else clientWs.send(msg);
+  }
+}
+function handleProxyConnection(ws, registry, logger, chaos) {
+  const proxyWs = ws;
+  proxyWs.isAlive = true;
+  proxyWs.on("pong", () => {
+    proxyWs.isAlive = true;
+  });
+  proxyWs.on("message", (data, isBinary) => {
+    if (isBinary) {
+      if (data.length < 2 || data.length > MAX_BINARY_FRAME_SIZE) {
+        logger.warn({ size: data.length }, "Binary frame rejected: invalid size");
+        return;
+      }
+      const sessionIdLen = data[0];
+      if (sessionIdLen === 0 || sessionIdLen > 255 || data.length < 1 + sessionIdLen) {
+        logger.warn(
+          { sessionIdLen, dataLen: data.length },
+          "Binary frame rejected: malformed sessionId prefix"
+        );
+        return;
+      }
+      if (!proxyWs.proxyId) {
+        logger.warn("Binary frame from unregistered proxy, dropped");
+        return;
+      }
+      const clients = registry.getClientsForProxy(proxyWs.proxyId);
+      for (const clientWs of clients) {
+        if (clientWs.readyState === WebSocket3.OPEN) {
+          clientWs.send(data);
+        }
+      }
+      return;
+    }
+    const raw = data.toString();
+    const result = parseMessage(raw);
+    if (result.kind === "control" && result.message.type === "proxy_register") {
+      const { proxyId, name } = result.message;
+      const status = registry.registerProxy(proxyId, proxyWs, name);
+      proxyWs.proxyId = proxyId;
+      logger.info({ proxyId, status }, "Proxy registered");
+      proxyWs.send(
+        JSON.stringify({
+          type: "proxy_register_response",
+          status
+        })
+      );
+      if (status === "reconnected") {
+        notifyClientsProxyOnline(proxyId, registry, logger, chaos);
+      }
+      broadcastProxyList(registry, chaos);
+      return;
+    }
+    if (result.kind === "control" && result.message.type === "proxy_disconnect") {
+      if (proxyWs.proxyId) {
+        notifyClientsProxyOffline(proxyWs.proxyId, registry, logger, chaos);
+        registry.markProxyOffline(proxyWs.proxyId);
+        logger.info({ proxyId: proxyWs.proxyId }, "Proxy gracefully disconnected, marked offline");
+        proxyWs.proxyId = void 0;
+        broadcastProxyList(registry, chaos);
+      }
+      return;
+    }
+    if (result.kind === "control" && result.message.type === "session_sync") {
+      if (!proxyWs.proxyId) return;
+      const sessions = result.message.sessions;
+      if (Array.isArray(sessions)) {
+        for (const s of sessions) {
+          registry.addSessionToProxy(proxyWs.proxyId, s.id);
+        }
+        logger.info({ proxyId: proxyWs.proxyId, count: sessions.length }, "Session sync received");
+      }
+      return;
+    }
+    if (result.kind === "control") {
+      if (isProxyToClientRelayControlType(result.message.type)) {
+        if (!proxyWs.proxyId) {
+          proxyWs.send(
+            JSON.stringify({
+              type: "relay_error",
+              code: RelayErrorCode.NOT_REGISTERED,
+              message: "Proxy must register before sending messages"
+            })
+          );
+          return;
+        }
+        const clients = registry.getClientsForProxy(proxyWs.proxyId);
+        for (const clientWs of clients) {
+          if (clientWs.readyState === WebSocket3.OPEN) {
+            if (chaos) {
+              chaos.send(clientWs, raw, {
+                direction: "proxy_to_client",
+                type: result.message.type
+              });
+            } else {
+              clientWs.send(raw);
+            }
+          }
+        }
+        logger.info(
+          { proxyId: proxyWs.proxyId, type: result.message.type, clientCount: clients.length },
+          "Forwarded control message from proxy to clients"
+        );
+        return;
+      }
+      logger.warn({ type: result.message.type }, "Unexpected control message from proxy");
+      return;
+    }
+    if (result.kind === "envelope") {
+      if (!proxyWs.proxyId) {
+        proxyWs.send(
+          JSON.stringify({
+            type: "relay_error",
+            code: RelayErrorCode.NOT_REGISTERED,
+            message: "Proxy must register before sending messages"
+          })
+        );
+        return;
+      }
+      routeProxyMessage(raw, proxyWs.proxyId, registry, logger, chaos);
+      return;
+    }
+    if (result.kind === "invalid") {
+      logger.error({ error: result.error, raw: raw.slice(0, 200) }, "Invalid message from proxy");
+      proxyWs.send(
+        JSON.stringify({
+          type: "relay_error",
+          code: RelayErrorCode.INVALID_MESSAGE,
+          message: `${result.error} | raw: ${raw.slice(0, 200)}`
+        })
+      );
+      return;
+    }
+  });
+  proxyWs.on("close", () => {
+    if (proxyWs.proxyId) {
+      notifyClientsProxyOffline(proxyWs.proxyId, registry, logger, chaos);
+      try {
+        registry.transitionProxy(proxyWs.proxyId, "online", "offline");
+      } catch {
+      }
+      logger.info(
+        { proxyId: proxyWs.proxyId },
+        "Proxy disconnected, state preserved for reconnect"
+      );
+      broadcastProxyList(registry, chaos);
+    }
+  });
+  proxyWs.on("error", (err) => {
+    logger.error({ err, proxyId: proxyWs.proxyId }, "Proxy WebSocket error");
+  });
+}
+
+// src/handlers/client.ts
+import { WebSocket as WebSocket4 } from "ws";
+import { nanoid } from "nanoid";
+function handleClientRegister(clientId, clientWs, registry, logger) {
+  clientWs.clientId = clientId;
+  const binding = registry.getClientBinding(clientId);
+  if (!binding) {
+    clientWs.send(
+      JSON.stringify({
+        type: "client_register_response",
+        status: "new"
+      })
+    );
+    logger.info({ clientId, status: "new" }, "Client registered");
+    return;
+  }
+  const { proxyId } = binding;
+  registry.updateClientSocket(clientId, clientWs);
+  clientWs.boundProxyId = proxyId;
+  if (!registry.isProxyOnline(proxyId)) {
+    clientWs.send(
+      JSON.stringify({
+        type: "client_register_response",
+        status: "proxy_offline",
+        proxyId
+      })
+    );
+    logger.info({ clientId, proxyId, status: "proxy_offline" }, "Client registered");
+    return;
+  }
+  clientWs.send(
+    JSON.stringify({
+      type: "client_register_response",
+      status: "restored",
+      proxyId
+    })
+  );
+  logger.info({ clientId, proxyId, status: "restored" }, "Client registered");
+}
+function handleClientConnection(ws, registry, logger, chaos) {
+  const clientWs = ws;
+  clientWs.isAlive = true;
+  registry.addClientWs(clientWs);
+  clientWs.on("pong", () => {
+    clientWs.isAlive = true;
+  });
+  clientWs.on("message", (data, isBinary) => {
+    if (isBinary) {
+      return;
+    }
+    const raw = data.toString();
+    const result = parseMessage(raw);
+    if (result.kind === "control") {
+      const msg = result.message;
+      logger.info(
+        { type: msg.type, clientId: clientWs.clientId, bound: clientWs.boundProxyId },
+        "Client message received"
+      );
+      if (msg.type === "client_register") {
+        handleClientRegister(msg.clientId, clientWs, registry, logger);
+        return;
+      }
+      if (msg.type === "proxy_list_request") {
+        const proxies = registry.listProxiesWithName().map((p) => ({
+          ...p,
+          sessions: registry.getSessionsForProxy(p.proxyId)
+        }));
+        const response = JSON.stringify({
+          type: "proxy_list_response",
+          requestId: msg.requestId,
+          proxies
+        });
+        if (chaos) {
+          chaos.send(clientWs, response, {
+            direction: "proxy_to_client",
+            type: "proxy_list_response"
+          });
+        } else {
+          clientWs.send(response);
+        }
+        return;
+      }
+      if (isClientToProxyRelayControlType(msg.type)) {
+        const targetProxyId = ("proxyId" in msg ? msg.proxyId : void 0) || clientWs.boundProxyId;
+        if (!targetProxyId) {
+          clientWs.send(
+            JSON.stringify({
+              type: "relay_error",
+              code: RelayErrorCode.NOT_BOUND,
+              message: "Client is not bound to any proxy"
+            })
+          );
+          return;
+        }
+        const proxyWs = registry.getProxy(targetProxyId);
+        if (proxyWs && proxyWs.readyState === WebSocket4.OPEN) {
+          if (chaos) chaos.send(proxyWs, raw, { direction: "client_to_proxy", type: msg.type });
+          else proxyWs.send(raw);
+        } else {
+          clientWs.send(
+            JSON.stringify({
+              type: "relay_error",
+              code: RelayErrorCode.PROXY_OFFLINE,
+              message: `Proxy ${targetProxyId} is not available`
+            })
+          );
+        }
+        return;
+      }
+      if (msg.type === "proxy_select") {
+        if (!registry.isProxyOnline(msg.proxyId)) {
+          clientWs.send(
+            JSON.stringify({
+              type: "proxy_select_response",
+              requestId: msg.requestId,
+              success: false,
+              errorCode: ControlErrorCode.PROXY_OFFLINE,
+              error: `Proxy not online: ${msg.proxyId}`
+            })
+          );
+          return;
+        }
+        if (!clientWs.clientId) {
+          clientWs.clientId = `anon-${nanoid(10)}`;
+        }
+        const bound = registry.bindClientById(clientWs.clientId, msg.proxyId, clientWs);
+        if (!bound) {
+          clientWs.send(
+            JSON.stringify({
+              type: "proxy_select_response",
+              requestId: msg.requestId,
+              success: false,
+              errorCode: ControlErrorCode.PROXY_OFFLINE,
+              error: `Proxy not online: ${msg.proxyId}`
+            })
+          );
+          return;
+        }
+        clientWs.boundProxyId = msg.proxyId;
+        const response = JSON.stringify({
+          type: "proxy_select_response",
+          requestId: msg.requestId,
+          success: true,
+          proxyId: msg.proxyId
+        });
+        if (chaos) {
+          chaos.send(clientWs, response, {
+            direction: "proxy_to_client",
+            type: "proxy_select_response"
+          });
+        } else {
+          clientWs.send(response);
+        }
+        logger.info({ proxyId: msg.proxyId, clientId: clientWs.clientId }, "Client bound to proxy");
+        return;
+      }
+      clientWs.send(
+        JSON.stringify({
+          type: "relay_error",
+          code: RelayErrorCode.UNSUPPORTED,
+          message: `Unsupported control message: ${msg.type}`
+        })
+      );
+      return;
+    }
+    if (result.kind === "envelope") {
+      if (!clientWs.boundProxyId) {
+        clientWs.send(
+          JSON.stringify({
+            type: "relay_error",
+            code: RelayErrorCode.NOT_BOUND,
+            message: "Client is not bound to any proxy"
+          })
+        );
+        return;
+      }
+      routeClientMessage(raw, clientWs.boundProxyId, clientWs, registry, logger, chaos);
+      return;
+    }
+    logger.error({ error: result.error, raw: raw.slice(0, 200) }, "Invalid message from client");
+    clientWs.send(
+      JSON.stringify({
+        type: "relay_error",
+        code: RelayErrorCode.INVALID_MESSAGE,
+        message: `${result.error} | raw: ${raw.slice(0, 200)}`
+      })
+    );
+  });
+  clientWs.on("close", () => {
+    registry.removeClientWs(clientWs);
+    logger.info({ clientId: clientWs.clientId }, "Client disconnected");
+  });
+  clientWs.on("error", (err) => {
+    logger.error({ err }, "Client WebSocket error");
+  });
+}
+
+// src/heartbeat.ts
+function setupHeartbeat(wss, interval = 3e4) {
+  return setInterval(() => {
+    for (const ws of wss.clients) {
+      const sock = ws;
+      if (!sock.isAlive) {
+        sock.terminate();
+        continue;
+      }
+      sock.isAlive = false;
+      sock.ping();
+    }
+  }, interval);
+}
+
+// src/chaos.ts
+import { WebSocket as WebSocket5 } from "ws";
+function parseRelayChaosFromEnv(env) {
+  const enabled = env.DEV_ANYWHERE_RELAY_CHAOS === "1";
+  const types = env.DEV_ANYWHERE_RELAY_CHAOS_TYPES?.split(",").map((type) => type.trim()).filter(Boolean);
+  return {
+    enabled,
+    delayMs: parseInt(env.DEV_ANYWHERE_RELAY_CHAOS_DELAY_MS ?? "0", 10),
+    duplicate: env.DEV_ANYWHERE_RELAY_CHAOS_DUPLICATE === "1",
+    duplicateDelayMs: parseInt(env.DEV_ANYWHERE_RELAY_CHAOS_DUPLICATE_DELAY_MS ?? "10", 10),
+    reorder: env.DEV_ANYWHERE_RELAY_CHAOS_REORDER === "1",
+    reorderDelayMs: parseInt(env.DEV_ANYWHERE_RELAY_CHAOS_REORDER_DELAY_MS ?? "40", 10),
+    types: types && types.length > 0 ? new Set(types) : void 0
+  };
+}
+function createRelayChaos(options, logger) {
+  let sequence = 0;
+  function shouldAffect(meta) {
+    if (!options.enabled) return false;
+    if (options.types && !options.types.has(meta.type)) return false;
+    return true;
+  }
+  function sendNow(ws, data) {
+    if (ws.readyState === WebSocket5.OPEN) {
+      ws.send(data);
+    }
+  }
+  return {
+    send(ws, data, meta) {
+      if (!shouldAffect(meta)) {
+        sendNow(ws, data);
+        return;
+      }
+      sequence += 1;
+      const reorderDelay = options.reorder && sequence % 2 === 1 ? options.reorderDelayMs : 0;
+      const delayMs = Math.max(0, options.delayMs + reorderDelay);
+      logger.warn(
+        { direction: meta.direction, type: meta.type, delayMs, duplicate: options.duplicate },
+        "Relay chaos forwarding message"
+      );
+      setTimeout(() => sendNow(ws, data), delayMs);
+      if (options.duplicate) {
+        setTimeout(() => sendNow(ws, data), delayMs + options.duplicateDelayMs);
+      }
+    }
+  };
+}
+
+// src/server.ts
+function createRelayServer(options) {
+  const { heartbeatInterval = 3e4, logger, dataDir, proxyToken, clientToken, chaos } = options;
+  const proxyTokenRequired = typeof proxyToken === "string" && proxyToken.length > 0;
+  const clientTokenRequired = typeof clientToken === "string" && clientToken.length > 0;
+  if (!proxyTokenRequired) {
+    logger.warn(
+      "proxy auth token not set, /proxy endpoint is open \u2014 ok for dev, not for public relay"
+    );
+  }
+  if (!clientTokenRequired) {
+    logger.warn(
+      "client auth token not set, /client endpoint is open \u2014 ok for dev, not for public relay"
+    );
+  }
+  const registry = new RelayRegistry();
+  const relayChaos = chaos?.enabled ? createRelayChaos(chaos, logger) : void 0;
+  if (chaos?.enabled) {
+    logger.warn(
+      {
+        delayMs: chaos.delayMs,
+        duplicate: chaos.duplicate,
+        reorder: chaos.reorder,
+        types: chaos.types ? [...chaos.types] : "all"
+      },
+      "Relay chaos mode enabled"
+    );
+  }
+  const app = express();
+  const fontsDir = dataDir ? `${dataDir}/fonts` : `${homedir2()}/.dev-anywhere/relay-data/fonts`;
+  app.use(
+    "/fonts",
+    (req, res, next) => {
+      res.setHeader("Access-Control-Allow-Origin", "*");
+      next();
+    },
+    express.static(fontsDir, {
+      maxAge: "30d",
+      immutable: true
+    })
+  );
+  app.use(healthRouter(registry));
+  const httpServer = createServer(app);
+  const proxyWss = new WebSocketServer({ noServer: true });
+  const clientWss = new WebSocketServer({ noServer: true });
+  httpServer.on("upgrade", (request, socket, head) => {
+    const url = new URL(request.url ?? "/", "http://localhost");
+    const { pathname } = url;
+    if (pathname === "/proxy") {
+      if (proxyTokenRequired) {
+        const token = url.searchParams.get("token");
+        if (token !== proxyToken) {
+          logger.warn(
+            { ip: request.socket.remoteAddress },
+            "rejected /proxy upgrade: invalid token"
+          );
+          socket.write("HTTP/1.1 401 Unauthorized\r\n\r\n");
+          socket.destroy();
+          return;
+        }
+      }
+      proxyWss.handleUpgrade(request, socket, head, (ws) => {
+        proxyWss.emit("connection", ws, request);
+      });
+      return;
+    }
+    if (pathname === "/client") {
+      if (clientTokenRequired) {
+        const token = url.searchParams.get("token");
+        if (token !== clientToken) {
+          logger.warn(
+            { ip: request.socket.remoteAddress },
+            "rejected /client upgrade: invalid token"
+          );
+          socket.write("HTTP/1.1 401 Unauthorized\r\n\r\n");
+          socket.destroy();
+          return;
+        }
+      }
+      clientWss.handleUpgrade(request, socket, head, (ws) => {
+        clientWss.emit("connection", ws, request);
+      });
+      return;
+    }
+    socket.destroy();
+  });
+  proxyWss.on("connection", (ws) => {
+    handleProxyConnection(ws, registry, logger, relayChaos);
+  });
+  clientWss.on("connection", (ws) => {
+    handleClientConnection(ws, registry, logger, relayChaos);
+  });
+  const proxyHeartbeat = setupHeartbeat(proxyWss, heartbeatInterval);
+  const clientHeartbeat = setupHeartbeat(clientWss, heartbeatInterval);
+  async function close() {
+    clearInterval(proxyHeartbeat);
+    clearInterval(clientHeartbeat);
+    for (const ws of proxyWss.clients) {
+      ws.terminate();
+    }
+    for (const ws of clientWss.clients) {
+      ws.terminate();
+    }
+    await new Promise((resolve, reject) => {
+      proxyWss.close((err) => {
+        if (err) reject(err);
+        else resolve();
+      });
+    });
+    await new Promise((resolve, reject) => {
+      clientWss.close((err) => {
+        if (err) reject(err);
+        else resolve();
+      });
+    });
+    await new Promise((resolve, reject) => {
+      httpServer.close((err) => {
+        if (err) reject(err);
+        else resolve();
+      });
+    });
+  }
+  return { httpServer, registry, close };
+}
+
+export {
+  createLogger,
+  parseRelayChaosFromEnv,
+  createRelayServer
+};
+//# sourceMappingURL=chunk-TBYEKF42.js.map