@dev-anywhere/relay 0.3.14 → 0.4.3

package/dist/chunk-DFVUNUQH.js

@@ -1,1705 +0,0 @@
-#!/usr/bin/env node
-
-// src/server.ts
-import express from "express";
-import { existsSync } from "fs";
-import { createServer } from "http";
-import { homedir } from "os";
-import { dirname as dirname2, resolve } from "path";
-import { fileURLToPath as fileURLToPath2 } from "url";
-import { WebSocketServer } from "ws";
-
-// src/registry.ts
-import { WebSocket } from "ws";
-
-// ../../packages/shared/dist/schemas/envelope.js
-import { z as z6 } from "zod";
-
-// ../../packages/shared/dist/schemas/id.js
-import { z } from "zod";
-var MAX_ID_LENGTH = 256;
-var IdSchema = z.string().min(1).max(MAX_ID_LENGTH);
-
-// ../../packages/shared/dist/schemas/chat.js
-import { z as z2 } from "zod";
-var UserInputPayloadSchema = z2.object({
-  text: z2.string().min(1),
-  messageId: z2.string().min(1).optional()
-});
-var AssistantMessagePayloadSchema = z2.object({
-  text: z2.string(),
-  isPartial: z2.boolean()
-});
-var ThinkingPayloadSchema = z2.object({
-  text: z2.string()
-});
-
-// ../../packages/shared/dist/schemas/tool.js
-import { z as z3 } from "zod";
-var ToolUseRequestPayloadSchema = z3.object({
-  toolName: z3.string(),
-  toolId: IdSchema,
-  parameters: z3.record(z3.string(), z3.unknown())
-});
-var ToolApprovePayloadSchema = z3.object({
-  toolId: IdSchema,
-  whitelistTool: z3.boolean().optional()
-});
-var ToolDenyPayloadSchema = z3.object({
-  toolId: IdSchema,
-  reason: z3.string().optional()
-});
-var ToolResultPayloadSchema = z3.object({
-  toolId: IdSchema,
-  result: z3.unknown(),
-  isError: z3.boolean()
-});
-
-// ../../packages/shared/dist/schemas/session.js
-import { z as z4 } from "zod";
-
-// ../../packages/shared/dist/constants/enums.js
-var providerValues = ["claude", "codex"];
-var ptyOwnerValues = ["local-terminal", "proxy-hosted"];
-var sessionModeValues = ["pty", "json"];
-
-// ../../packages/shared/dist/constants/pty.js
-var PtySemanticState = {
-  WORKING: "working",
-  TURN_COMPLETE: "turn_complete",
-  APPROVAL_WAIT: "approval_wait"
-};
-var ptySemanticStateValues = [
-  PtySemanticState.WORKING,
-  PtySemanticState.TURN_COMPLETE,
-  PtySemanticState.APPROVAL_WAIT
-];
-
-// ../../packages/shared/dist/schemas/session.js
-var sessionStateValues = [
-  "idle",
-  "working",
-  "waiting_approval",
-  "error",
-  "terminated"
-];
-var agentStatusPhaseValues = [
-  "idle",
-  "thinking",
-  "tool_use",
-  "outputting",
-  "waiting_permission",
-  "error"
-];
-var SessionInfoSchema = z4.object({
-  sessionId: IdSchema,
-  name: z4.string().optional(),
-  // cwd 只用于展示完整路径/tooltip，不作为前端路由或权限判断来源。
-  cwd: z4.string().optional(),
-  // true 表示 name 是用户显式命名，PTY UI 不再让 OSC terminal_title 覆盖它。
-  nameLocked: z4.boolean().optional(),
-  state: z4.enum(sessionStateValues),
-  mode: z4.enum(sessionModeValues).optional(),
-  provider: z4.enum(providerValues),
-  // PTY 尺寸所有权:
-  // - local-terminal: 本地 terminal 进程持有真实 PTY，Web 只按原始 cols/rows 展示
-  // - proxy-hosted: serve 内托管 PTY，Web 可按视口请求 resize
-  ptyOwner: z4.enum(ptyOwnerValues).optional(),
-  lastActive: z4.number().optional()
-});
-var SessionCreatePayloadSchema = z4.object({
-  name: z4.string().optional(),
-  cwd: z4.string().optional(),
-  streamDelta: z4.boolean().optional()
-});
-var SessionListPayloadSchema = z4.object({
-  sessions: z4.array(SessionInfoSchema)
-});
-var SessionSwitchPayloadSchema = z4.object({
-  sessionId: IdSchema
-});
-var SessionTerminatePayloadSchema = z4.object({
-  sessionId: IdSchema
-});
-var SessionStatusPayloadSchema = z4.object({
-  sessionId: IdSchema,
-  state: z4.enum(sessionStateValues),
-  lastActive: z4.number()
-});
-var PtyStatePayloadSchema = z4.object({
-  state: z4.enum(ptySemanticStateValues),
-  title: z4.string().optional(),
-  tool: z4.string().optional()
-});
-var AgentStatusPayloadSchema = z4.object({
-  provider: z4.enum(providerValues),
-  phase: z4.enum(agentStatusPhaseValues),
-  seq: z4.number().int().nonnegative(),
-  updatedAt: z4.number(),
-  toolName: z4.string().optional(),
-  toolInput: z4.record(z4.string(), z4.unknown()).optional(),
-  permissionRequest: z4.object({
-    requestId: IdSchema,
-    toolName: z4.string(),
-    input: z4.record(z4.string(), z4.unknown())
-  }).optional(),
-  permissionResolution: z4.object({
-    requestId: IdSchema,
-    outcome: z4.enum(["allow", "deny"])
-  }).optional(),
-  summary: z4.string().optional()
-});
-
-// ../../packages/shared/dist/schemas/system.js
-import { z as z5 } from "zod";
-var HeartbeatPayloadSchema = z5.object({});
-var AuthPayloadSchema = z5.object({
-  pairingCode: z5.string().optional(),
-  token: z5.string().optional()
-});
-var SyncRequestPayloadSchema = z5.object({
-  lastSeq: z5.number().int().nonnegative()
-});
-var SyncResponsePayloadSchema = z5.object({
-  messages: z5.array(z5.record(z5.string(), z5.unknown()))
-});
-
-// ../../packages/shared/dist/schemas/envelope.js
-var BaseEnvelopeFields = {
-  seq: z6.number().int().nonnegative(),
-  timestamp: z6.number(),
-  source: z6.enum(["proxy", "client"]),
-  version: z6.string()
-};
-var SessionedEnvelopeFields = {
-  ...BaseEnvelopeFields,
-  sessionId: IdSchema
-};
-var MessageEnvelopeSchema = z6.discriminatedUnion("type", [
-  // chat (3)
-  z6.object({
-    ...SessionedEnvelopeFields,
-    type: z6.literal("user_input"),
-    payload: UserInputPayloadSchema
-  }),
-  z6.object({
-    ...SessionedEnvelopeFields,
-    type: z6.literal("assistant_message"),
-    payload: AssistantMessagePayloadSchema
-  }),
-  z6.object({
-    ...SessionedEnvelopeFields,
-    type: z6.literal("thinking"),
-    payload: ThinkingPayloadSchema
-  }),
-  // tool (4): 工具审批决策属于 relay control，不进入会话消息信封。
-  // tool_use_request: 审批流请求（proxy → client），toolId 是 approval requestId
-  z6.object({
-    ...SessionedEnvelopeFields,
-    type: z6.literal("tool_use_request"),
-    payload: ToolUseRequestPayloadSchema
-  }),
-  // tool_result: 工具执行结果（proxy → client），toolId 对应 assistant_tool_use / tool_use_request 的 toolId
-  z6.object({
-    ...SessionedEnvelopeFields,
-    type: z6.literal("tool_result"),
-    payload: ToolResultPayloadSchema
-  }),
-  // assistant_tool_use: 纯展示型工具调用（proxy → client），区别于 tool_use_request 无审批语义
-  // payload 结构复用 ToolUseRequestPayloadSchema；toolId 是 Claude 分配的 tool_use id
-  z6.object({
-    ...SessionedEnvelopeFields,
-    type: z6.literal("assistant_tool_use"),
-    payload: ToolUseRequestPayloadSchema
-  }),
-  // session (5)
-  z6.object({
-    ...SessionedEnvelopeFields,
-    type: z6.literal("session_create"),
-    payload: SessionCreatePayloadSchema
-  }),
-  // session_list 是全局广播 (列出所有 session), 不绑定具体 sessionId, 不携带该字段。
-  z6.object({
-    ...BaseEnvelopeFields,
-    type: z6.literal("session_list"),
-    payload: SessionListPayloadSchema
-  }),
-  z6.object({
-    ...SessionedEnvelopeFields,
-    type: z6.literal("session_switch"),
-    payload: SessionSwitchPayloadSchema
-  }),
-  z6.object({
-    ...SessionedEnvelopeFields,
-    type: z6.literal("session_terminate"),
-    payload: SessionTerminatePayloadSchema
-  }),
-  z6.object({
-    ...SessionedEnvelopeFields,
-    type: z6.literal("session_status"),
-    payload: SessionStatusPayloadSchema
-  }),
-  // system (5): 心跳 / 认证 / 同步——全局, 无 sessionId
-  z6.object({
-    ...BaseEnvelopeFields,
-    type: z6.literal("heartbeat"),
-    payload: HeartbeatPayloadSchema
-  }),
-  z6.object({
-    ...BaseEnvelopeFields,
-    type: z6.literal("auth"),
-    payload: AuthPayloadSchema
-  }),
-  z6.object({
-    ...BaseEnvelopeFields,
-    type: z6.literal("sync_request"),
-    payload: SyncRequestPayloadSchema
-  }),
-  z6.object({
-    ...BaseEnvelopeFields,
-    type: z6.literal("sync_response"),
-    payload: SyncResponsePayloadSchema
-  })
-]);
-
-// ../../packages/shared/dist/builders/index.js
-function serializeControl(msg) {
-  return JSON.stringify(msg);
-}
-
-// ../../packages/shared/dist/schemas/relay-control.js
-import { z as z7 } 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 = z7.object({
-  proxyId: IdSchema,
-  name: z7.string().optional(),
-  online: z7.boolean(),
-  sessions: z7.array(z7.string()).optional()
-});
-var AgentCliAvailabilitySchema = z7.object({
-  available: z7.boolean(),
-  command: z7.string().optional(),
-  error: z7.string().optional(),
-  suggestions: z7.array(z7.string()).optional()
-});
-var AgentCliStatusSchema = z7.object({
-  claude: AgentCliAvailabilitySchema,
-  codex: AgentCliAvailabilitySchema
-});
-var DirEntrySchema = z7.object({ name: z7.string(), isDir: z7.boolean() });
-var FileTreeGroupSchema = z7.object({
-  path: z7.string(),
-  entries: z7.array(DirEntrySchema)
-});
-var CommandEntrySchema = z7.object({
-  name: z7.string(),
-  description: z7.string(),
-  argumentHint: z7.string().optional(),
-  source: z7.string()
-});
-var HistorySessionSchema = z7.object({
-  id: z7.string(),
-  title: z7.string(),
-  projectDir: z7.string(),
-  updatedAt: z7.number(),
-  provider: z7.enum(providerValues).optional()
-});
-var SessionHistoryMessageSchema = z7.object({
-  role: z7.enum(["user", "assistant"]),
-  text: z7.string(),
-  timestamp: z7.number().optional(),
-  cursor: z7.string().optional()
-});
-var RequestIdShape = { requestId: IdSchema.optional() };
-var ControlErrorCodeSchema = z7.enum(Object.values(ControlErrorCode));
-var RequestErrorShape = {
-  error: z7.string().optional(),
-  errorCode: ControlErrorCodeSchema.optional()
-};
-var ClipboardImageMimeTypeSchema = z7.enum(["image/png", "image/jpeg", "image/webp", "image/gif"]);
-function control(type, shape, directions) {
-  return {
-    type,
-    directions: new Set(Array.isArray(directions) ? directions : directions ? [directions] : []),
-    schema: z7.object({
-      type: z7.literal(type),
-      ...shape ?? {}
-    })
-  };
-}
-var relayControlDefinitions = [
-  control("proxy_register", {
-    proxyId: IdSchema,
-    name: z7.string().optional()
-  }),
-  control("proxy_register_response", {
-    status: z7.enum(["new", "reconnected"])
-  }),
-  control("proxy_list_request", RequestIdShape),
-  control("proxy_list_response", {
-    ...RequestIdShape,
-    proxies: z7.array(ProxyInfoSchema)
-  }),
-  control("proxy_select", { ...RequestIdShape, proxyId: IdSchema }),
-  control("proxy_select_response", {
-    ...RequestIdShape,
-    success: z7.boolean(),
-    proxyId: IdSchema.optional(),
-    ...RequestErrorShape
-  }),
-  control("relay_error", {
-    code: z7.enum(Object.values(RelayErrorCode)),
-    message: z7.string(),
-    // 可选 requestId: relay 把 client 发来 raw 的 requestId 字段透传回来,
-    // client 侧 waitForMessage 据此把对应 pending request 立即拒掉而不必等到 timeout。
-    requestId: IdSchema.optional()
-  }),
-  // 客户端注册协议
-  control("client_register", {
-    clientId: IdSchema
-  }),
-  control("client_register_response", {
-    status: z7.enum(["restored", "proxy_offline", "new"]),
-    proxyId: IdSchema.optional()
-  }),
-  // Proxy 离线通知
-  control("proxy_offline", {
-    proxyId: IdSchema
-  }),
-  // Proxy 主动断开，relay 立即清理资源
-  control("proxy_disconnect", {
-    proxyId: IdSchema
-  }),
-  // Proxy 重连后通知 client 恢复
-  control("proxy_online", {
-    proxyId: IdSchema
-  }),
-  // 目录列表请求与响应
-  control("dir_list_request", {
-    proxyId: IdSchema.optional(),
-    ...RequestIdShape,
-    path: z7.string()
-  }, "client_to_proxy"),
-  control("dir_list_response", { ...RequestIdShape, ...RequestErrorShape, entries: z7.array(DirEntrySchema), path: z7.string() }, "proxy_to_client"),
-  // 目录创建请求与响应
-  control("dir_create_request", { ...RequestIdShape, path: z7.string() }, "client_to_proxy"),
-  control("dir_create_response", {
-    ...RequestIdShape,
-    ...RequestErrorShape,
-    path: z7.string(),
-    success: z7.boolean()
-  }, "proxy_to_client"),
-  // 命令列表推送，proxy 将可用命令列表推给 client
-  control("command_list_push", { commands: z7.array(CommandEntrySchema) }, "proxy_to_client"),
-  // 文件树推送: 按目录分组, 首组 path 即为 session cwd
-  // 前端直接把每组写入 tree[path], 与 dir_list_response 共享 cache slot
-  control("file_tree_push", {
-    groups: z7.array(FileTreeGroupSchema)
-  }, "proxy_to_client"),
-  // 会话列表请求与权限模式变更
-  control("session_list", void 0, ["client_to_proxy", "proxy_to_client"]),
-  control("permission_mode_change", {
-    mode: z7.enum(["default", "auto_accept", "plan"]),
-    // sessionId 可选：传入时 proxy 按该会话的 mode 分叉（PTY 发 Tab ANSI），未传走全局日志行为
-    sessionId: IdSchema.optional()
-  }, "client_to_proxy"),
-  // 会话历史浏览
-  control("session_history_request", RequestIdShape, "client_to_proxy"),
-  control("session_history_response", { ...RequestIdShape, sessions: z7.array(HistorySessionSchema) }, "proxy_to_client"),
-  // PTY 语义状态，从 Envelope 迁移到 Control 层
-  control("pty_state", { sessionId: IdSchema, payload: PtyStatePayloadSchema }, "proxy_to_client"),
-  // Provider 语义状态，来自 Claude/Codex hook 等结构化事件，不从 PTY 字节推断
-  control("agent_status", { sessionId: IdSchema, payload: AgentStatusPayloadSchema }, "proxy_to_client"),
-  // 终端标题变化，proxy -> client
-  control("terminal_title", { sessionId: IdSchema, title: z7.string() }, "proxy_to_client"),
-  // 终端尺寸变化，proxy -> client
-  control("terminal_resize", { sessionId: IdSchema, cols: z7.number().int().positive(), rows: z7.number().int().positive() }, "proxy_to_client"),
-  control("terminal_resize_request", { sessionId: IdSchema, cols: z7.number().int().positive(), rows: z7.number().int().positive() }, "client_to_proxy"),
-  // 远程终止 JSON 会话，client -> proxy
-  control("session_terminate", { sessionId: IdSchema }, "client_to_proxy"),
-  control("session_rename", { ...RequestIdShape, sessionId: IdSchema, name: z7.string() }, "client_to_proxy"),
-  control("session_rename_response", {
-    ...RequestIdShape,
-    sessionId: IdSchema,
-    success: z7.boolean(),
-    name: z7.string().optional(),
-    ...RequestErrorShape
-  }, "proxy_to_client"),
-  // 中断当前 turn，client -> proxy，SIGINT 到 worker 进程让 claude CLI abort 当前流
-  control("session_worker_abort", { sessionId: IdSchema }, "client_to_proxy"),
-  // turn 完成信号，proxy -> client，对应 claude stream-json 的 result 事件
-  control("turn_result", {
-    sessionId: IdSchema,
-    success: z7.boolean(),
-    isError: z7.boolean(),
-    // stream-json result.result 是本轮最终文本。assistant_message 流丢失或 CLI 未发增量时，
-    // Web 用它作为 JSON 模式兜底展示，避免 turn 已结束但界面空白。
-    result: z7.string().optional()
-  }, "proxy_to_client"),
-  // 客户端发送到 PTY 的原始字节（ANSI 序列），不追加换行
-  control("remote_input_raw", { sessionId: IdSchema, data: z7.string() }, "client_to_proxy"),
-  control("clipboard_image_upload", {
-    ...RequestIdShape,
-    sessionId: IdSchema,
-    mimeType: ClipboardImageMimeTypeSchema,
-    dataBase64: z7.string().min(1),
-    fileName: z7.string().optional()
-  }, "client_to_proxy"),
-  control("clipboard_image_upload_response", {
-    ...RequestIdShape,
-    ...RequestErrorShape,
-    sessionId: IdSchema,
-    success: z7.boolean(),
-    // success=false 时 proxy 没有有效 path 可填；保持 optional 以避免占位空字符串通过校验。
-    path: z7.string().optional()
-  }, "proxy_to_client"),
-  control("image_preview_request", {
-    ...RequestIdShape,
-    sessionId: IdSchema,
-    path: z7.string().min(1)
-  }, "client_to_proxy"),
-  control("image_preview_response", {
-    ...RequestIdShape,
-    ...RequestErrorShape,
-    sessionId: IdSchema,
-    success: z7.boolean(),
-    // 同 clipboard_image_upload_response：失败时 proxy 不一定有路径。
-    path: z7.string().optional(),
-    mimeType: ClipboardImageMimeTypeSchema.optional(),
-    dataBase64: z7.string().optional(),
-    size: z7.number().int().nonnegative().optional()
-  }, "proxy_to_client"),
-  // 任意文件下载: 与 image_preview 形状对称, 只是 mimeType 不限定为图片;
-  // 单租户场景下 path 任意 (不受 previewRoots 限制), 由 proxy 端 size cap 兜底。
-  control("file_download_request", {
-    ...RequestIdShape,
-    sessionId: IdSchema,
-    path: z7.string().min(1)
-  }, "client_to_proxy"),
-  control("file_download_response", {
-    ...RequestIdShape,
-    ...RequestErrorShape,
-    sessionId: IdSchema,
-    success: z7.boolean(),
-    path: z7.string().optional(),
-    mimeType: z7.string().optional(),
-    dataBase64: z7.string().optional(),
-    size: z7.number().int().nonnegative().optional()
-  }, "proxy_to_client"),
-  // 任意文件上传: 复用 clipboard_image_upload 的形状, mimeType 放开 + fileName 必填,
-  // 由 proxy 端写入 session cwd 的 .dev-anywhere/uploads/ 子目录, 返回相对路径供 web 拼成 @path。
-  control("file_upload_request", {
-    ...RequestIdShape,
-    sessionId: IdSchema,
-    mimeType: z7.string().min(1),
-    dataBase64: z7.string().min(1),
-    fileName: z7.string().min(1)
-  }, "client_to_proxy"),
-  control("file_upload_response", {
-    ...RequestIdShape,
-    ...RequestErrorShape,
-    sessionId: IdSchema,
-    success: z7.boolean(),
-    path: z7.string().optional()
-  }, "proxy_to_client"),
-  // 客户端询问 proxy 的环境信息 (home 路径等), client -> proxy -> response
-  // FilePathPicker 用 homePath 作为 select 模式下的默认起点, 新建会话时打开即可浏览
-  control("proxy_info_request", RequestIdShape, "client_to_proxy"),
-  control("proxy_info", { ...RequestIdShape, homePath: z7.string(), agentCli: AgentCliStatusSchema }, "proxy_to_client"),
-  control("agent_cli_config_update", { ...RequestIdShape, provider: z7.enum(providerValues), path: z7.string().min(1) }, "client_to_proxy"),
-  control("agent_cli_config_update_response", {
-    ...RequestIdShape,
-    provider: z7.enum(providerValues),
-    agentCli: AgentCliStatusSchema.optional(),
-    ...RequestErrorShape
-  }, "proxy_to_client"),
-  // 远程创建 JSON 会话，client -> proxy -> response
-  control("session_create", {
-    ...RequestIdShape,
-    cwd: z7.string(),
-    provider: z7.enum(providerValues),
-    mode: z7.enum(sessionModeValues).optional(),
-    resumeSessionId: z7.string().optional(),
-    // 透传给 claude CLI 的 --permission-mode, undefined 时 proxy 兜底为 "default"
-    permissionMode: z7.enum(["default", "auto", "acceptEdits", "plan", "bypassPermissions", "dontAsk"]).optional()
-  }, "client_to_proxy"),
-  control("session_create_response", {
-    ...RequestIdShape,
-    // 失败路径只送 errorCode/error, sessionId 此时无语义。成功路径才有 id。
-    sessionId: IdSchema.optional(),
-    mode: z7.enum(sessionModeValues).optional(),
-    provider: z7.enum(providerValues).optional(),
-    ptyOwner: z7.enum(ptyOwnerValues).optional(),
-    ...RequestErrorShape
-  }, "proxy_to_client"),
-  // 客户端请求会话历史消息，client -> proxy
-  control("session_messages_request", {
-    ...RequestIdShape,
-    sessionId: IdSchema,
-    limit: z7.number().int().min(1).max(200).optional(),
-    before: z7.string().optional()
-  }, "client_to_proxy"),
-  // 客户端请求会话资源（命令列表 + 文件树），client -> proxy
-  control("session_resources_request", { ...RequestIdShape, sessionId: IdSchema }, "client_to_proxy"),
-  control("session_resources_response", {
-    ...RequestIdShape,
-    ...RequestErrorShape,
-    sessionId: IdSchema,
-    commands: z7.array(CommandEntrySchema),
-    groups: z7.array(FileTreeGroupSchema)
-  }, "proxy_to_client"),
-  // 客户端请求当前 provider 语义状态；不经 relay 缓存，由 proxy 返回当前值
-  control("agent_status_request", { ...RequestIdShape, sessionId: IdSchema.optional() }, "client_to_proxy"),
-  control("agent_status_response", {
-    ...RequestIdShape,
-    statuses: z7.array(z7.object({ sessionId: IdSchema, payload: AgentStatusPayloadSchema }))
-  }, "proxy_to_client"),
-  // 客户端确认已收到审批请求；proxy 只记录送达状态，不把它当成用户决策
-  control("permission_request_delivered", { sessionId: IdSchema, requestId: IdSchema }, "client_to_proxy"),
-  control("tool_approve", { sessionId: IdSchema, payload: ToolApprovePayloadSchema }, "client_to_proxy"),
-  control("tool_deny", { sessionId: IdSchema, payload: ToolDenyPayloadSchema }, "client_to_proxy"),
-  // proxy 确认用户决策已进入 provider/worker 路径；web 用它更新审批卡片状态
-  control("permission_decision_result", {
-    sessionId: IdSchema,
-    requestId: IdSchema,
-    outcome: z7.enum(["allow", "deny"]),
-    delivered: z7.boolean(),
-    message: z7.string().optional()
-  }, "proxy_to_client"),
-  // proxy 推送当前 pending 的工具审批列表，client 据此恢复审批卡片
-  control("pending_approvals_push", {
-    sessionId: IdSchema,
-    approvals: z7.array(z7.object({
-      requestId: IdSchema,
-      toolName: z7.string(),
-      input: z7.record(z7.string(), z7.unknown())
-    }))
-  }, "proxy_to_client"),
-  // 恢复会话时推送历史消息，proxy -> client
-  control("session_history_messages", {
-    ...RequestIdShape,
-    sessionId: IdSchema,
-    before: z7.string().optional(),
-    messages: z7.array(SessionHistoryMessageSchema),
-    hasMore: z7.boolean().optional(),
-    nextBefore: z7.string().optional()
-  }, "proxy_to_client"),
-  // proxy 重连后同步活跃 session 列表给 relay。session_sync 由 relay 自消费（更新 proxy-session
-  // 关联）不转发给 client，因此**没有** direction 标注——RelayControlDirection 只描述转发流。
-  control("session_sync", {
-    sessions: z7.array(z7.object({
-      id: z7.string(),
-      mode: z7.enum(sessionModeValues),
-      provider: z7.enum(providerValues),
-      ptyOwner: z7.enum(ptyOwnerValues).optional(),
-      cwd: z7.string().optional(),
-      name: z7.string().optional(),
-      nameLocked: z7.boolean().optional(),
-      state: z7.enum(sessionStateValues)
-    }))
-  }),
-  // PTY 会话订阅，client -> proxy，触发 terminal serialize() 返回当前状态
-  control("session_subscribe", { sessionId: IdSchema, requestId: IdSchema.optional() }, "client_to_proxy"),
-  // PTY 会话快照，proxy -> client，serialize() 的全量终端状态
-  control("session_snapshot", {
-    sessionId: IdSchema,
-    cols: z7.number().int().positive(),
-    rows: z7.number().int().positive(),
-    data: z7.string(),
-    outputSeq: z7.number().int().nonnegative(),
-    requestId: IdSchema.optional()
-  }, "proxy_to_client")
-];
-var relayControlSchemas = relayControlDefinitions.map((definition) => definition.schema);
-var RelayControlSchema = z7.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/binary-frame.js
-var SID_LEN_BYTES = 1;
-var SEQ_BYTES = 4;
-var HEADER_FIXED_BYTES = SID_LEN_BYTES + SEQ_BYTES;
-
-// ../../packages/shared/dist/state-machine.js
-function computeAbsorbingSet(transitions) {
-  const absorbing = /* @__PURE__ */ new Set();
-  const entries = Object.entries(transitions);
-  for (const [s, outs] of entries) {
-    if (outs.length === 0)
-      absorbing.add(s);
-  }
-  let changed = true;
-  while (changed) {
-    changed = false;
-    for (const [s, outs] of entries) {
-      if (absorbing.has(s))
-        continue;
-      if (outs.length > 0 && outs.every((t) => absorbing.has(t))) {
-        absorbing.add(s);
-        changed = true;
-      }
-    }
-  }
-  return absorbing;
-}
-function defineFSM(transitions) {
-  const absorbing = computeAbsorbingSet(transitions);
-  return {
-    canTransition: (from, to) => transitions[from]?.includes(to) ?? false,
-    isAbsorbing: (state) => absorbing.has(state)
-  };
-}
-
-// src/registry.ts
-var proxyConnectionFSM = defineFSM({
-  online: ["offline"],
-  offline: ["online"]
-});
-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";
-  }
-  // 显式状态转换，校验 from 状态匹配后更新 connectionState
-  transitionProxy(proxyId, from, to) {
-    if (!proxyConnectionFSM.canTransition(from, to)) {
-      throw new Error(`Invalid proxy transition: ${from} -> ${to}`);
-    }
-    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();
-    }
-  }
-  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 && binding.ws.readyState === WebSocket.OPEN) 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";
-
-// src/version.ts
-import { readFileSync } from "fs";
-import { dirname, join } from "path";
-import { fileURLToPath } from "url";
-function readRelayVersion() {
-  const packageJsonPath = join(dirname(fileURLToPath(import.meta.url)), "..", "package.json");
-  const pkg = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
-  return pkg.version ?? "unknown";
-}
-var RELAY_VERSION = readRelayVersion();
-
-// src/health.ts
-function bearerToken(authHeader) {
-  const match = /^Bearer\s+(.+)$/i.exec(authHeader ?? "");
-  return match?.[1] ?? null;
-}
-function healthRouter(registry, options = {}) {
-  const router = Router();
-  const proxyTokenRequired = options.proxyTokenRequired ?? false;
-  const clientTokenRequired = options.clientTokenRequired ?? false;
-  router.get("/health", (_req, res) => {
-    res.json({
-      status: "ok",
-      version: RELAY_VERSION,
-      uptime: process.uptime(),
-      auth: {
-        proxyTokenRequired,
-        clientTokenRequired
-      }
-    });
-  });
-  router.get("/api/auth/client", (req, res) => {
-    if (!clientTokenRequired) {
-      res.status(204).end();
-      return;
-    }
-    const token = bearerToken(req.get("authorization"));
-    if (options.validateClientToken?.(token)) {
-      res.status(204).end();
-      return;
-    }
-    res.status(401).json({ error: "invalid_client_token" });
-  });
-  router.get("/api/admin/client-token", (req, res) => {
-    if (!proxyTokenRequired) {
-      res.status(401).json({ error: "proxy_token_required" });
-      return;
-    }
-    const token = bearerToken(req.get("authorization"));
-    if (!options.validateProxyToken?.(token)) {
-      res.status(401).json({ error: "invalid_proxy_token" });
-      return;
-    }
-    const clientToken = options.getClientToken?.() ?? null;
-    if (!clientToken) {
-      res.status(204).end();
-      return;
-    }
-    res.json({ clientToken });
-  });
-  function requireProxyTokenIfConfigured(req, res) {
-    if (!proxyTokenRequired) return true;
-    const token = bearerToken(req.get("authorization"));
-    if (options.validateProxyToken?.(token)) return true;
-    res.status(401).json({ error: "invalid_proxy_token" });
-    return false;
-  }
-  router.get("/status", (_req, res) => {
-    res.json({
-      version: RELAY_VERSION,
-      proxyCount: registry.listProxies().length,
-      clientCount: registry.countClients(),
-      uptime: process.uptime()
-    });
-  });
-  router.get("/api/status", (req, res) => {
-    if (!requireProxyTokenIfConfigured(req, res)) return;
-    res.json({
-      version: RELAY_VERSION,
-      proxyCount: registry.listProxies().length,
-      clientCount: registry.countClients(),
-      uptime: process.uptime(),
-      bindings: registry.getClientDetails()
-    });
-  });
-  router.get("/api/proxies", (req, res) => {
-    if (!requireProxyTokenIfConfigured(req, res)) return;
-    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) => {
-    if (!requireProxyTokenIfConfigured(req, res)) return;
-    res.json(registry.getClientDetails());
-  });
-  return router;
-}
-
-// src/handlers/proxy.ts
-import { WebSocket as WebSocket3 } from "ws";
-
-// 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 extractRequestIdFromRaw(raw) {
-  try {
-    const parsed = JSON.parse(raw);
-    if (parsed && typeof parsed === "object" && typeof parsed.requestId === "string") {
-      return parsed.requestId;
-    }
-  } catch {
-  }
-  return void 0;
-}
-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;
-  if ("sessionId" in message) {
-    registry.addSessionToProxy(proxyId, message.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");
-    const requestId = extractRequestIdFromRaw(raw);
-    clientWs.send(
-      JSON.stringify({
-        type: "relay_error",
-        code: RelayErrorCode.INVALID_MESSAGE,
-        message: result.error,
-        ...requestId ? { requestId } : {}
-      })
-    );
-    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;
-var MAX_JSON_MESSAGE_SIZE = 1 * 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 rejectNotRegistered(ws) {
-  ws.send(
-    JSON.stringify({
-      type: "relay_error",
-      code: RelayErrorCode.NOT_REGISTERED,
-      message: "Proxy must register before sending messages"
-    })
-  );
-}
-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;
-    }
-    if (data.length > MAX_JSON_MESSAGE_SIZE) {
-      logger.warn(
-        { size: data.length, proxyId: proxyWs.proxyId },
-        "JSON message rejected: exceeds max size"
-      );
-      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(
-        serializeControl({
-          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.unregisterProxy(proxyWs.proxyId);
-        logger.info(
-          { proxyId: proxyWs.proxyId },
-          "Proxy gracefully disconnected, resources cleaned"
-        );
-        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;
-      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) {
-          rejectNotRegistered(proxyWs);
-          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) {
-        rejectNotRegistered(proxyWs);
-        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", (code, reason) => {
-    if (!proxyWs.proxyId) return;
-    const closeMeta = { code, reason: reason.toString() || void 0 };
-    const current = registry.getProxy(proxyWs.proxyId);
-    if (current && current !== proxyWs) {
-      logger.info(
-        { proxyId: proxyWs.proxyId, ...closeMeta },
-        "Old proxy ws closed after being superseded by reconnect, skipping offline transition"
-      );
-      return;
-    }
-    notifyClientsProxyOffline(proxyWs.proxyId, registry, logger, chaos);
-    try {
-      registry.transitionProxy(proxyWs.proxyId, "online", "offline");
-    } catch (err) {
-      logger.debug(
-        { proxyId: proxyWs.proxyId, err: String(err) },
-        "transitionProxy on close skipped"
-      );
-    }
-    logger.info(
-      { proxyId: proxyWs.proxyId, ...closeMeta },
-      "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";
-var MAX_JSON_MESSAGE_SIZE2 = 1 * 1024 * 1024;
-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 rejectNotBound(ws) {
-  ws.send(
-    JSON.stringify({
-      type: "relay_error",
-      code: RelayErrorCode.NOT_BOUND,
-      message: "Client is not bound to any proxy"
-    })
-  );
-}
-function rejectProxySelect(ws, requestId, proxyId) {
-  ws.send(
-    JSON.stringify({
-      type: "proxy_select_response",
-      requestId,
-      success: false,
-      errorCode: ControlErrorCode.PROXY_OFFLINE,
-      error: `Proxy not online: ${proxyId}`
-    })
-  );
-}
-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;
-    }
-    if (data.length > MAX_JSON_MESSAGE_SIZE2) {
-      logger.warn(
-        { size: data.length, clientId: clientWs.clientId },
-        "JSON message rejected: exceeds max size"
-      );
-      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 = clientWs.boundProxyId;
-        if (!targetProxyId) {
-          rejectNotBound(clientWs);
-          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)) {
-          rejectProxySelect(clientWs, msg.requestId, msg.proxyId);
-          return;
-        }
-        if (!clientWs.clientId) {
-          clientWs.clientId = `anon-${nanoid(10)}`;
-        }
-        const bound = registry.bindClientById(clientWs.clientId, msg.proxyId, clientWs);
-        if (!bound) {
-          rejectProxySelect(clientWs, msg.requestId, 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) {
-        rejectNotBound(clientWs);
-        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);
-    if (clientWs.clientId) {
-      registry.unbindClientById(clientWs.clientId);
-    }
-    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
-var MODULE_DIR = dirname2(fileURLToPath2(import.meta.url));
-var PACKAGED_FONTS_DIR = resolve(MODULE_DIR, "../assets/fonts");
-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;
-  const allowedOriginsSet = options.allowedOrigins && options.allowedOrigins.length > 0 ? new Set(options.allowedOrigins) : null;
-  const checkOrigin = (origin) => {
-    if (!allowedOriginsSet) return true;
-    return typeof origin === "string" && allowedOriginsSet.has(origin);
-  };
-  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` : `${homedir()}/.dev-anywhere/relay-data/fonts`;
-  const fontAssetDir = options.fontAssetDir ?? PACKAGED_FONTS_DIR;
-  app.use(
-    "/fonts",
-    (req, res, next) => {
-      res.setHeader("Access-Control-Allow-Origin", "*");
-      next();
-    },
-    express.static(fontsDir, {
-      maxAge: "30d",
-      immutable: true
-    })
-  );
-  if (existsSync(fontAssetDir)) {
-    app.use(
-      "/fonts",
-      express.static(fontAssetDir, {
-        maxAge: "30d",
-        immutable: true
-      })
-    );
-  }
-  app.use(
-    healthRouter(registry, {
-      proxyTokenRequired,
-      clientTokenRequired,
-      validateClientToken: (token) => token === clientToken,
-      validateProxyToken: (token) => token === proxyToken,
-      getClientToken: () => clientToken ?? null
-    })
-  );
-  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;
-    const origin = request.headers.origin;
-    if (!checkOrigin(origin)) {
-      logger.warn(
-        { ip: request.socket.remoteAddress, origin: origin ?? "(missing)", pathname },
-        "rejected upgrade: origin not in allowedOrigins"
-      );
-      socket.write("HTTP/1.1 403 Forbidden\r\n\r\n");
-      socket.destroy();
-      return;
-    }
-    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((resolve2, reject) => {
-      proxyWss.close((err) => {
-        if (err) reject(err);
-        else resolve2();
-      });
-    });
-    await new Promise((resolve2, reject) => {
-      clientWss.close((err) => {
-        if (err) reject(err);
-        else resolve2();
-      });
-    });
-    await new Promise((resolve2, reject) => {
-      httpServer.close((err) => {
-        if (err) reject(err);
-        else resolve2();
-      });
-    });
-  }
-  return { httpServer, registry, close };
-}
-
-export {
-  RELAY_VERSION,
-  parseRelayChaosFromEnv,
-  createRelayServer
-};
-//# sourceMappingURL=chunk-DFVUNUQH.js.map