@dev-anywhere/relay 0.3.14 → 0.4.3

package/dist/chunk-OJABHE5C.js

@@ -0,0 +1,3359 @@
+#!/usr/bin/env node
+
+// src/server.ts
+import express from "express";
+import { existsSync as existsSync2 } from "fs";
+import { createServer } from "http";
+import { homedir } from "os";
+import { dirname as dirname3, 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/schemas/voice.js
+import { z as z7 } from "zod";
+var voiceProviderValues = ["aliyun-bailian"];
+var voiceRegionValues = ["cn", "intl"];
+var voiceOptionSourceValues = ["official", "custom"];
+var voiceOptionGenderValues = ["male", "female", "unknown"];
+var VoiceProviderConfigSchema = z7.object({
+  provider: z7.enum(voiceProviderValues),
+  configured: z7.boolean(),
+  region: z7.enum(voiceRegionValues),
+  asrModel: z7.string().min(1),
+  ttsModel: z7.string().min(1),
+  ttsVoice: z7.string().min(1),
+  turnIdleSeconds: z7.number().int().positive().safe().default(3)
+}).strict();
+var VoiceConfigUpdateSchema = z7.object({
+  provider: z7.enum(voiceProviderValues).optional(),
+  apiKey: z7.string().min(1).optional(),
+  clearApiKey: z7.boolean().optional(),
+  region: z7.enum(voiceRegionValues).optional(),
+  asrModel: z7.string().min(1).optional(),
+  ttsModel: z7.string().min(1).optional(),
+  ttsVoice: z7.string().min(1).optional(),
+  turnIdleSeconds: z7.number().int().positive().safe().optional()
+}).strict();
+var VoiceOptionSchema = z7.object({
+  value: z7.string().min(1),
+  label: z7.string().min(1),
+  description: z7.string().min(1).optional(),
+  gender: z7.enum(voiceOptionGenderValues).optional(),
+  age: z7.string().min(1).optional(),
+  model: z7.string().min(1).optional(),
+  source: z7.enum(voiceOptionSourceValues)
+}).strict();
+var VoiceCapabilitiesSchema = z7.object({
+  asrModels: z7.array(VoiceOptionSchema),
+  ttsModels: z7.array(VoiceOptionSchema),
+  ttsVoices: z7.array(VoiceOptionSchema),
+  fetchedAt: z7.number().optional()
+}).strict();
+var BUNDLED_BAILIAN_ASR_MODELS = [
+  {
+    value: "qwen3-asr-flash-realtime",
+    label: "Qwen3 ASR Flash Realtime",
+    source: "official"
+  },
+  {
+    value: "qwen3-asr-flash-realtime-2026-02-10",
+    label: "Qwen3 ASR Flash Realtime \xB7 2026-02-10",
+    source: "official"
+  },
+  {
+    value: "qwen3-asr-flash-realtime-2025-10-27",
+    label: "Qwen3 ASR Flash Realtime \xB7 2025-10-27",
+    source: "official"
+  }
+];
+var BUNDLED_BAILIAN_TTS_MODELS = [
+  {
+    value: "cosyvoice-v3-flash",
+    label: "CosyVoice V3 Flash \xB7 \u7CFB\u7EDF\u97F3\u8272",
+    source: "official"
+  },
+  {
+    value: "cosyvoice-v3-plus",
+    label: "CosyVoice V3 Plus \xB7 \u7CFB\u7EDF\u97F3\u8272",
+    source: "official"
+  },
+  {
+    value: "cosyvoice-v3.5-flash",
+    label: "CosyVoice V3.5 Flash \xB7 \u81EA\u5B9A\u4E49\u97F3\u8272",
+    source: "official"
+  },
+  {
+    value: "cosyvoice-v3.5-plus",
+    label: "CosyVoice V3.5 Plus \xB7 \u81EA\u5B9A\u4E49\u97F3\u8272",
+    source: "official"
+  }
+];
+var BUNDLED_BAILIAN_TTS_VOICES = [
+  {
+    value: "longanyang",
+    label: "\u9F99\u5B89\u6D0B \xB7 \u7537 \xB7 \u9633\u5149\u5927\u7537\u5B69 \xB7 \u5E74\u9F84 20-30",
+    gender: "male",
+    age: "20-30",
+    model: "cosyvoice-v3-flash",
+    source: "official"
+  },
+  {
+    value: "longanhuan",
+    label: "\u9F99\u5B89\u6B22 \xB7 \u5973 \xB7 \u6B22\u8131\u5143\u6C14 \xB7 \u5E74\u9F84 20-30",
+    gender: "female",
+    age: "20-30",
+    model: "cosyvoice-v3-flash",
+    source: "official"
+  },
+  {
+    value: "longhuhu_v3",
+    label: "\u9F99\u547C\u547C \xB7 \u5973 \xB7 \u5929\u771F\u70C2\u6F2B\u5973\u7AE5 \xB7 \u5E74\u9F84 6-10",
+    gender: "female",
+    age: "6-10",
+    model: "cosyvoice-v3-flash",
+    source: "official"
+  },
+  {
+    value: "longpaopao_v3",
+    label: "\u9F99\u6CE1\u6CE1 \xB7 \u672A\u77E5 \xB7 \u98DE\u5929\u6CE1\u6CE1\u97F3 \xB7 \u5E74\u9F84 6-15",
+    gender: "unknown",
+    age: "6-15",
+    model: "cosyvoice-v3-flash",
+    source: "official"
+  },
+  {
+    value: "longjielidou_v3",
+    label: "\u9F99\u6770\u529B\u8C46 \xB7 \u7537 \xB7 \u9633\u5149\u987D\u76AE \xB7 \u5E74\u9F84 10",
+    gender: "male",
+    age: "10",
+    model: "cosyvoice-v3-flash",
+    source: "official"
+  },
+  {
+    value: "longxian_v3",
+    label: "\u9F99\u4ED9 \xB7 \u5973 \xB7 \u8C6A\u653E\u53EF\u7231 \xB7 \u5E74\u9F84 12",
+    gender: "female",
+    age: "12",
+    model: "cosyvoice-v3-flash",
+    source: "official"
+  },
+  {
+    value: "longling_v3",
+    label: "\u9F99\u94C3 \xB7 \u5973 \xB7 \u7A1A\u6C14\u5446\u677F \xB7 \u5E74\u9F84 10",
+    gender: "female",
+    age: "10",
+    model: "cosyvoice-v3-flash",
+    source: "official"
+  },
+  {
+    value: "longjiaxin_v3",
+    label: "\u9F99\u5609\u6B23 \xB7 \u5973 \xB7 \u4F18\u96C5\u7CA4\u8BED \xB7 \u5E74\u9F84 30-35",
+    gender: "female",
+    age: "30-35",
+    model: "cosyvoice-v3-flash",
+    source: "official"
+  },
+  {
+    value: "longanyue_v3",
+    label: "\u9F99\u5B89\u7CA4 \xB7 \u7537 \xB7 \u6B22\u8131\u7CA4\u8BED \xB7 \u5E74\u9F84 25-35",
+    gender: "male",
+    age: "25-35",
+    model: "cosyvoice-v3-flash",
+    source: "official"
+  },
+  {
+    value: "longlaotie_v3",
+    label: "\u9F99\u8001\u94C1 \xB7 \u7537 \xB7 \u4E1C\u5317\u76F4\u7387 \xB7 \u5E74\u9F84 25-30",
+    gender: "male",
+    age: "25-30",
+    model: "cosyvoice-v3-flash",
+    source: "official"
+  },
+  {
+    value: "longanyang",
+    label: "\u9F99\u5B89\u6D0B \xB7 \u7537 \xB7 \u9633\u5149\u5927\u7537\u5B69 \xB7 \u5E74\u9F84 20-30",
+    gender: "male",
+    age: "20-30",
+    model: "cosyvoice-v3-plus",
+    source: "official"
+  },
+  {
+    value: "longanhuan",
+    label: "\u9F99\u5B89\u6B22 \xB7 \u5973 \xB7 \u6B22\u8131\u5143\u6C14 \xB7 \u5E74\u9F84 20-30",
+    gender: "female",
+    age: "20-30",
+    model: "cosyvoice-v3-plus",
+    source: "official"
+  }
+];
+function cloneVoiceOption(option) {
+  return { ...option };
+}
+function createBundledBailianVoiceCapabilities(fetchedAt) {
+  return {
+    asrModels: BUNDLED_BAILIAN_ASR_MODELS.map(cloneVoiceOption),
+    ttsModels: BUNDLED_BAILIAN_TTS_MODELS.map(cloneVoiceOption),
+    ttsVoices: BUNDLED_BAILIAN_TTS_VOICES.map(cloneVoiceOption),
+    ...typeof fetchedAt === "number" ? { fetchedAt } : {}
+  };
+}
+var VoiceSummaryReasonSchema = z7.enum([
+  "code",
+  "table",
+  "diff",
+  "log",
+  "stack_trace",
+  "long_list",
+  "long_text",
+  "mixed",
+  "approval"
+]);
+
+// ../../packages/shared/dist/builders/index.js
+function serializeControl(msg) {
+  return JSON.stringify(msg);
+}
+
+// ../../packages/shared/dist/schemas/relay-control.js
+import { z as z8 } 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 = z8.object({
+  proxyId: IdSchema,
+  name: z8.string().optional(),
+  online: z8.boolean(),
+  sessions: z8.array(z8.string()).optional()
+});
+var AgentCliAvailabilitySchema = z8.object({
+  available: z8.boolean(),
+  command: z8.string().optional(),
+  error: z8.string().optional(),
+  suggestions: z8.array(z8.string()).optional()
+});
+var AgentCliStatusSchema = z8.object({
+  claude: AgentCliAvailabilitySchema,
+  codex: AgentCliAvailabilitySchema
+});
+var DirEntrySchema = z8.object({ name: z8.string(), isDir: z8.boolean() });
+var FileTreeGroupSchema = z8.object({
+  path: z8.string(),
+  entries: z8.array(DirEntrySchema)
+});
+var CommandEntrySchema = z8.object({
+  name: z8.string(),
+  description: z8.string(),
+  argumentHint: z8.string().optional(),
+  source: z8.string()
+});
+var HistorySessionSchema = z8.object({
+  id: z8.string(),
+  title: z8.string(),
+  projectDir: z8.string(),
+  updatedAt: z8.number(),
+  provider: z8.enum(providerValues).optional()
+});
+var SessionHistoryMessageSchema = z8.object({
+  role: z8.enum(["user", "assistant"]),
+  text: z8.string(),
+  timestamp: z8.number().optional(),
+  cursor: z8.string().optional()
+});
+var RequestIdShape = { requestId: IdSchema.optional() };
+var RequiredRequestIdShape = { requestId: IdSchema };
+var ControlErrorCodeSchema = z8.enum(Object.values(ControlErrorCode));
+var RequestErrorShape = {
+  error: z8.string().optional(),
+  errorCode: ControlErrorCodeSchema.optional()
+};
+var ClipboardImageMimeTypeSchema = z8.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: z8.object({
+      type: z8.literal(type),
+      ...shape ?? {}
+    })
+  };
+}
+var relayControlDefinitions = [
+  control("proxy_register", {
+    proxyId: IdSchema,
+    name: z8.string().optional()
+  }),
+  control("proxy_register_response", {
+    status: z8.enum(["new", "reconnected"])
+  }),
+  control("proxy_list_request", RequestIdShape),
+  control("proxy_list_response", {
+    ...RequestIdShape,
+    proxies: z8.array(ProxyInfoSchema)
+  }),
+  control("proxy_select", { ...RequestIdShape, proxyId: IdSchema }),
+  control("proxy_select_response", {
+    ...RequestIdShape,
+    success: z8.boolean(),
+    proxyId: IdSchema.optional(),
+    ...RequestErrorShape
+  }),
+  control("relay_error", {
+    code: z8.enum(Object.values(RelayErrorCode)),
+    message: z8.string(),
+    // 可选 requestId: relay 把 client 发来 raw 的 requestId 字段透传回来,
+    // client 侧 waitForMessage 据此把对应 pending request 立即拒掉而不必等到 timeout。
+    requestId: IdSchema.optional()
+  }),
+  // Voice Pilot config is relay-local: client reads/updates the relay's stored provider settings.
+  control("voice_config_request", RequestIdShape),
+  control("voice_config_response", {
+    ...RequestIdShape,
+    ...RequestErrorShape,
+    config: VoiceProviderConfigSchema.optional()
+  }),
+  control("voice_config_update", {
+    ...RequestIdShape,
+    config: VoiceConfigUpdateSchema
+  }),
+  control("voice_config_update_response", {
+    ...RequestIdShape,
+    ...RequestErrorShape,
+    success: z8.boolean(),
+    config: VoiceProviderConfigSchema.optional()
+  }),
+  control("voice_config_test", {
+    ...RequestIdShape,
+    config: VoiceConfigUpdateSchema.optional()
+  }),
+  control("voice_config_test_response", {
+    ...RequestIdShape,
+    ...RequestErrorShape,
+    success: z8.boolean(),
+    audioBase64: z8.string().optional(),
+    audioSampleRate: z8.number().int().positive().optional(),
+    audioEncoding: z8.literal("pcm_s16le").optional(),
+    transcript: z8.string().optional()
+  }),
+  control("voice_capabilities_request", {
+    ...RequestIdShape,
+    region: z8.enum(voiceRegionValues).optional()
+  }),
+  control("voice_capabilities_response", {
+    ...RequestIdShape,
+    ...RequestErrorShape,
+    capabilities: VoiceCapabilitiesSchema.optional()
+  }),
+  // Lightweight latency probes. These measure synthetic round-trip latency for the transport
+  // segments and intentionally stay separate from PTY input echo tracing.
+  control("latency_web_relay_ping", RequiredRequestIdShape),
+  control("latency_web_relay_pong", {
+    ...RequiredRequestIdShape,
+    relayNow: z8.number().optional()
+  }),
+  control("latency_relay_proxy_request", RequiredRequestIdShape),
+  control("latency_relay_proxy_response", {
+    ...RequiredRequestIdShape,
+    success: z8.boolean(),
+    rttMs: z8.number().nonnegative().optional(),
+    error: z8.string().optional()
+  }),
+  control("latency_relay_proxy_ping", {
+    ...RequiredRequestIdShape,
+    relayNow: z8.number().optional()
+  }),
+  control("latency_relay_proxy_pong", {
+    ...RequiredRequestIdShape,
+    proxyNow: z8.number().optional()
+  }),
+  control("latency_web_proxy_ping", RequiredRequestIdShape, "client_to_proxy"),
+  control("latency_web_proxy_pong", { ...RequiredRequestIdShape, proxyNow: z8.number().optional() }, "proxy_to_client"),
+  // 客户端注册协议
+  control("client_register", {
+    clientId: IdSchema
+  }),
+  control("client_register_response", {
+    status: z8.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: z8.string()
+  }, "client_to_proxy"),
+  control("dir_list_response", { ...RequestIdShape, ...RequestErrorShape, entries: z8.array(DirEntrySchema), path: z8.string() }, "proxy_to_client"),
+  // 目录创建请求与响应
+  control("dir_create_request", { ...RequestIdShape, path: z8.string() }, "client_to_proxy"),
+  control("dir_create_response", {
+    ...RequestIdShape,
+    ...RequestErrorShape,
+    path: z8.string(),
+    success: z8.boolean()
+  }, "proxy_to_client"),
+  // 命令列表推送，proxy 将可用命令列表推给 client
+  control("command_list_push", { commands: z8.array(CommandEntrySchema) }, "proxy_to_client"),
+  // 文件树推送: 按目录分组, 首组 path 即为 session cwd
+  // 前端直接把每组写入 tree[path], 与 dir_list_response 共享 cache slot
+  control("file_tree_push", {
+    groups: z8.array(FileTreeGroupSchema)
+  }, "proxy_to_client"),
+  // 会话列表请求与权限模式变更
+  control("session_list", void 0, ["client_to_proxy", "proxy_to_client"]),
+  control("permission_mode_change", {
+    mode: z8.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: z8.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: z8.string() }, "proxy_to_client"),
+  // 终端尺寸变化，proxy -> client
+  control("terminal_resize", { sessionId: IdSchema, cols: z8.number().int().positive(), rows: z8.number().int().positive() }, "proxy_to_client"),
+  control("terminal_resize_request", { sessionId: IdSchema, cols: z8.number().int().positive(), rows: z8.number().int().positive() }, "client_to_proxy"),
+  // 远程终止 JSON 会话，client -> proxy
+  control("session_terminate", { sessionId: IdSchema }, "client_to_proxy"),
+  control("session_rename", { ...RequestIdShape, sessionId: IdSchema, name: z8.string() }, "client_to_proxy"),
+  control("session_rename_response", {
+    ...RequestIdShape,
+    sessionId: IdSchema,
+    success: z8.boolean(),
+    name: z8.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: z8.boolean(),
+    isError: z8.boolean(),
+    // stream-json result.result 是本轮最终文本。assistant_message 流丢失或 CLI 未发增量时，
+    // Web 用它作为 JSON 模式兜底展示，避免 turn 已结束但界面空白。
+    result: z8.string().optional()
+  }, "proxy_to_client"),
+  // 客户端发送到 PTY 的原始字节（ANSI 序列），不追加换行
+  control("remote_input_raw", { sessionId: IdSchema, data: z8.string(), traceId: IdSchema.optional() }, "client_to_proxy"),
+  control("clipboard_image_upload", {
+    ...RequestIdShape,
+    sessionId: IdSchema,
+    mimeType: ClipboardImageMimeTypeSchema,
+    dataBase64: z8.string().min(1),
+    fileName: z8.string().optional()
+  }, "client_to_proxy"),
+  control("clipboard_image_upload_response", {
+    ...RequestIdShape,
+    ...RequestErrorShape,
+    sessionId: IdSchema,
+    success: z8.boolean(),
+    // success=false 时 proxy 没有有效 path 可填；保持 optional 以避免占位空字符串通过校验。
+    path: z8.string().optional()
+  }, "proxy_to_client"),
+  control("image_preview_request", {
+    ...RequestIdShape,
+    sessionId: IdSchema,
+    path: z8.string().min(1)
+  }, "client_to_proxy"),
+  control("image_preview_response", {
+    ...RequestIdShape,
+    ...RequestErrorShape,
+    sessionId: IdSchema,
+    success: z8.boolean(),
+    // 同 clipboard_image_upload_response：失败时 proxy 不一定有路径。
+    path: z8.string().optional(),
+    mimeType: ClipboardImageMimeTypeSchema.optional(),
+    dataBase64: z8.string().optional(),
+    size: z8.number().int().nonnegative().optional()
+  }, "proxy_to_client"),
+  // 任意文件下载: 与 image_preview 形状对称, 只是 mimeType 不限定为图片;
+  // 单租户场景下 path 任意 (不受 previewRoots 限制), 由 proxy 端 size cap 兜底。
+  control("file_download_request", {
+    ...RequestIdShape,
+    sessionId: IdSchema,
+    path: z8.string().min(1)
+  }, "client_to_proxy"),
+  control("file_download_response", {
+    ...RequestIdShape,
+    ...RequestErrorShape,
+    sessionId: IdSchema,
+    success: z8.boolean(),
+    path: z8.string().optional(),
+    mimeType: z8.string().optional(),
+    dataBase64: z8.string().optional(),
+    size: z8.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: z8.string().min(1),
+    dataBase64: z8.string().min(1),
+    fileName: z8.string().min(1)
+  }, "client_to_proxy"),
+  control("file_upload_response", {
+    ...RequestIdShape,
+    ...RequestErrorShape,
+    sessionId: IdSchema,
+    success: z8.boolean(),
+    path: z8.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: z8.string(), agentCli: AgentCliStatusSchema }, "proxy_to_client"),
+  control("agent_cli_config_update", { ...RequestIdShape, provider: z8.enum(providerValues), path: z8.string().min(1) }, "client_to_proxy"),
+  control("agent_cli_config_update_response", {
+    ...RequestIdShape,
+    provider: z8.enum(providerValues),
+    agentCli: AgentCliStatusSchema.optional(),
+    ...RequestErrorShape
+  }, "proxy_to_client"),
+  // 远程创建 JSON 会话，client -> proxy -> response
+  control("session_create", {
+    ...RequestIdShape,
+    cwd: z8.string(),
+    name: z8.string().optional(),
+    provider: z8.enum(providerValues),
+    mode: z8.enum(sessionModeValues).optional(),
+    resumeSessionId: z8.string().optional(),
+    // 透传给 claude CLI 的 --permission-mode, undefined 时 proxy 兜底为 "default"
+    permissionMode: z8.enum(["default", "auto", "acceptEdits", "plan", "bypassPermissions", "dontAsk"]).optional()
+  }, "client_to_proxy"),
+  control("session_create_response", {
+    ...RequestIdShape,
+    // 失败路径只送 errorCode/error, sessionId 此时无语义。成功路径才有 id。
+    sessionId: IdSchema.optional(),
+    name: z8.string().optional(),
+    nameLocked: z8.boolean().optional(),
+    mode: z8.enum(sessionModeValues).optional(),
+    provider: z8.enum(providerValues).optional(),
+    ptyOwner: z8.enum(ptyOwnerValues).optional(),
+    ...RequestErrorShape
+  }, "proxy_to_client"),
+  // 客户端请求会话历史消息，client -> proxy
+  control("session_messages_request", {
+    ...RequestIdShape,
+    sessionId: IdSchema,
+    limit: z8.number().int().min(1).max(200).optional(),
+    before: z8.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: z8.array(CommandEntrySchema),
+    groups: z8.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: z8.array(z8.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: z8.enum(["allow", "deny"]),
+    delivered: z8.boolean(),
+    message: z8.string().optional()
+  }, "proxy_to_client"),
+  // proxy 推送当前 pending 的工具审批列表，client 据此恢复审批卡片
+  control("pending_approvals_push", {
+    sessionId: IdSchema,
+    approvals: z8.array(z8.object({
+      requestId: IdSchema,
+      toolName: z8.string(),
+      input: z8.record(z8.string(), z8.unknown())
+    }))
+  }, "proxy_to_client"),
+  // Voice Pilot speech summaries are produced by proxy-side Claude Code so it can read project context.
+  control("voice_summary_request", {
+    ...RequestIdShape,
+    sessionId: IdSchema,
+    messageId: IdSchema,
+    text: z8.string().min(1),
+    reason: VoiceSummaryReasonSchema
+  }, "client_to_proxy"),
+  control("voice_summary_response", {
+    ...RequestIdShape,
+    ...RequestErrorShape,
+    sessionId: IdSchema,
+    messageId: IdSchema,
+    success: z8.boolean(),
+    summary: z8.string().min(1).optional()
+  }, "proxy_to_client"),
+  // 恢复会话时推送历史消息，proxy -> client
+  control("session_history_messages", {
+    ...RequestIdShape,
+    sessionId: IdSchema,
+    before: z8.string().optional(),
+    messages: z8.array(SessionHistoryMessageSchema),
+    hasMore: z8.boolean().optional(),
+    nextBefore: z8.string().optional()
+  }, "proxy_to_client"),
+  // proxy 重连后同步活跃 session 列表给 relay。session_sync 由 relay 自消费（更新 proxy-session
+  // 关联）不转发给 client，因此**没有** direction 标注——RelayControlDirection 只描述转发流。
+  control("session_sync", {
+    sessions: z8.array(z8.object({
+      id: z8.string(),
+      mode: z8.enum(sessionModeValues),
+      provider: z8.enum(providerValues),
+      ptyOwner: z8.enum(ptyOwnerValues).optional(),
+      cwd: z8.string().optional(),
+      name: z8.string().optional(),
+      nameLocked: z8.boolean().optional(),
+      state: z8.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: z8.number().int().positive(),
+    rows: z8.number().int().positive(),
+    data: z8.string(),
+    outputSeq: z8.number().int().nonnegative(),
+    requestId: IdSchema.optional()
+  }, "proxy_to_client")
+];
+var relayControlSchemas = relayControlDefinitions.map((definition) => definition.schema);
+var RelayControlSchema = z8.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 WebSocket4 } 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/latency-probes.ts
+import { performance } from "perf_hooks";
+import { WebSocket as WebSocket3 } from "ws";
+var DEFAULT_RELAY_PROXY_PROBE_TIMEOUT_MS = 3e3;
+var pendingRelayProxyProbes = /* @__PURE__ */ new Map();
+function keyFor(proxyId, requestId) {
+  return `${proxyId}:${requestId}`;
+}
+function sendClientResponse(clientWs, response, chaos) {
+  if (clientWs.readyState !== WebSocket3.OPEN) return;
+  const raw = serializeControl(response);
+  if (chaos) {
+    chaos.send(clientWs, raw, {
+      direction: "proxy_to_client",
+      type: "latency_relay_proxy_response"
+    });
+    return;
+  }
+  clientWs.send(raw);
+}
+function startRelayProxyLatencyProbe({
+  requestId,
+  proxyId,
+  proxyWs,
+  clientWs,
+  logger,
+  chaos,
+  timeoutMs = DEFAULT_RELAY_PROXY_PROBE_TIMEOUT_MS
+}) {
+  const key = keyFor(proxyId, requestId);
+  const existing = pendingRelayProxyProbes.get(key);
+  if (existing) {
+    clearTimeout(existing.timer);
+    pendingRelayProxyProbes.delete(key);
+  }
+  const startedAt = performance.now();
+  const timer = setTimeout(() => {
+    pendingRelayProxyProbes.delete(key);
+    sendClientResponse(
+      clientWs,
+      {
+        type: "latency_relay_proxy_response",
+        requestId,
+        success: false,
+        error: "Relay \u5230\u5F00\u53D1\u673A\u6D4B\u901F\u8D85\u65F6"
+      },
+      chaos
+    );
+    logger.warn({ proxyId, requestId }, "Relay-proxy latency probe timed out");
+  }, timeoutMs);
+  pendingRelayProxyProbes.set(key, {
+    proxyId,
+    requestId,
+    clientWs,
+    startedAt,
+    timer,
+    chaos
+  });
+  const raw = serializeControl({
+    type: "latency_relay_proxy_ping",
+    requestId,
+    relayNow: Date.now()
+  });
+  if (chaos) {
+    chaos.send(proxyWs, raw, { direction: "client_to_proxy", type: "latency_relay_proxy_ping" });
+    return;
+  }
+  proxyWs.send(raw);
+}
+function completeRelayProxyLatencyProbe({
+  proxyId,
+  requestId,
+  logger
+}) {
+  const key = keyFor(proxyId, requestId);
+  const pending = pendingRelayProxyProbes.get(key);
+  if (!pending) return false;
+  pendingRelayProxyProbes.delete(key);
+  clearTimeout(pending.timer);
+  const rttMs = performance.now() - pending.startedAt;
+  sendClientResponse(
+    pending.clientWs,
+    {
+      type: "latency_relay_proxy_response",
+      requestId,
+      success: true,
+      rttMs
+    },
+    pending.chaos
+  );
+  logger.debug({ proxyId, requestId, rttMs }, "Relay-proxy latency probe completed");
+  return true;
+}
+
+// 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 === WebSocket4.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" && result.message.type === "latency_relay_proxy_pong") {
+      if (!proxyWs.proxyId) {
+        rejectNotRegistered(proxyWs);
+        return;
+      }
+      const completed = completeRelayProxyLatencyProbe({
+        proxyId: proxyWs.proxyId,
+        requestId: result.message.requestId,
+        logger
+      });
+      if (!completed) {
+        logger.debug(
+          { proxyId: proxyWs.proxyId, requestId: result.message.requestId },
+          "Unmatched relay-proxy latency pong ignored"
+        );
+      }
+      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 === WebSocket4.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 WebSocket7 } from "ws";
+import { nanoid as nanoid3 } from "nanoid";
+
+// src/voice/bailian-asr.ts
+import { EventEmitter } from "events";
+import { nanoid } from "nanoid";
+import { WebSocket as WebSocket5 } from "ws";
+
+// src/voice/bailian-endpoints.ts
+var BAILIAN_HOSTS = {
+  cn: "wss://dashscope.aliyuncs.com",
+  intl: "wss://dashscope-intl.aliyuncs.com"
+};
+function bailianRealtimeUrl(region, model) {
+  const url = `${BAILIAN_HOSTS[region]}/api-ws/v1/realtime`;
+  return model ? `${url}?model=${encodeURIComponent(model)}` : url;
+}
+function bailianInferenceUrl(region) {
+  return `${BAILIAN_HOSTS[region]}/api-ws/v1/inference`;
+}
+
+// src/voice/bailian-asr.ts
+var OPEN = 1;
+var END_OF_SPEECH_SILENCE_MS = 1200;
+function defaultSocketFactory(url, options) {
+  return new WebSocket5(url, options);
+}
+function extractRealtimePreview(payload) {
+  if (!payload || typeof payload !== "object") return null;
+  const record = payload;
+  if (typeof record.text === "string" || typeof record.stash === "string") {
+    const text = typeof record.text === "string" ? record.text : "";
+    const stash = typeof record.stash === "string" ? record.stash : "";
+    const preview = `${text}${stash}`;
+    return preview.length > 0 ? preview : null;
+  }
+  const candidates = [
+    record.text,
+    record.transcript,
+    record.delta,
+    record.output && typeof record.output === "object" && record.output.text
+  ];
+  for (const candidate of candidates) {
+    if (typeof candidate === "string" && candidate.length > 0) return candidate;
+  }
+  return null;
+}
+function extractFinalText(payload) {
+  if (!payload || typeof payload !== "object") return null;
+  const record = payload;
+  const candidates = [
+    record.transcript,
+    record.text,
+    record.output && typeof record.output === "object" && record.output.text
+  ];
+  for (const candidate of candidates) {
+    if (typeof candidate === "string" && candidate.length > 0) return candidate;
+  }
+  return null;
+}
+function extractError(payload) {
+  if (!payload || typeof payload !== "object") return new Error("Bailian ASR error");
+  const record = payload;
+  const nested = record.error && typeof record.error === "object" ? record.error : null;
+  let message = "Bailian ASR error";
+  if (nested && typeof nested.message === "string") {
+    message = nested.message;
+  } else if (typeof record.message === "string") {
+    message = record.message;
+  }
+  return new Error(message);
+}
+var BailianAsrClientImpl = class extends EventEmitter {
+  constructor(config, socketFactory, eventIdFactory) {
+    super();
+    this.config = config;
+    this.eventIdFactory = eventIdFactory;
+    this.socket = socketFactory(bailianRealtimeUrl(config.region, config.model), {
+      headers: {
+        Authorization: `bearer ${config.apiKey}`,
+        "OpenAI-Beta": "realtime=v1"
+      }
+    });
+    this.socket.on("open", () => this.handleOpen());
+    this.socket.on("message", (data) => this.handleMessage(data));
+    this.socket.on(
+      "error",
+      (err) => this.emit("error", err instanceof Error ? err : new Error(String(err)))
+    );
+    this.socket.on(
+      "close",
+      (code, reason) => this.emit("closed", code, reason?.toString("utf8"))
+    );
+  }
+  config;
+  eventIdFactory;
+  socket;
+  isOpen = false;
+  isReady = false;
+  pending = [];
+  sendPcm(chunk) {
+    this.sendWhenReady({
+      event_id: this.eventIdFactory(),
+      type: "input_audio_buffer.append",
+      audio: chunk.toString("base64")
+    });
+  }
+  stop() {
+    this.sendWhenReady({
+      event_id: this.eventIdFactory(),
+      type: "session.finish"
+    });
+  }
+  close() {
+    this.socket.close();
+  }
+  handleOpen() {
+    this.isOpen = true;
+    this.sendNow({
+      event_id: this.eventIdFactory(),
+      type: "session.update",
+      session: {
+        modalities: ["text"],
+        input_audio_format: "pcm",
+        sample_rate: this.config.sampleRate,
+        input_audio_transcription: {
+          language: this.config.language
+        },
+        turn_detection: {
+          type: "server_vad",
+          threshold: 0,
+          silence_duration_ms: END_OF_SPEECH_SILENCE_MS
+        }
+      }
+    });
+  }
+  handleMessage(data) {
+    const text = typeof data === "string" ? data : Buffer.isBuffer(data) ? data.toString("utf8") : "";
+    if (!text) return;
+    let payload;
+    try {
+      payload = JSON.parse(text);
+    } catch {
+      return;
+    }
+    const record = payload;
+    const type = typeof record.type === "string" ? record.type : "";
+    if (type.includes("error")) {
+      this.emit("error", extractError(payload));
+      return;
+    }
+    if (type === "conversation.item.input_audio_transcription.failed") {
+      this.emit("error", extractError(payload));
+      return;
+    }
+    if (type === "session.updated") {
+      this.isReady = true;
+      this.emit("ready");
+      this.flushPending();
+      return;
+    }
+    if (type === "conversation.item.input_audio_transcription.text") {
+      const preview = extractRealtimePreview(payload);
+      if (preview) this.emit("partial", preview);
+      return;
+    }
+    if (type === "conversation.item.input_audio_transcription.completed" || type === "session.finished") {
+      const transcript = extractFinalText(payload);
+      if (transcript) {
+        this.emit("final", transcript);
+      }
+    }
+  }
+  sendWhenReady(payload) {
+    const message = JSON.stringify(payload);
+    if ((this.isOpen || this.socket.readyState === OPEN) && this.isReady) {
+      this.socket.send(message);
+      return;
+    }
+    this.pending.push(message);
+  }
+  sendNow(payload) {
+    this.socket.send(JSON.stringify(payload));
+  }
+  flushPending() {
+    for (const message of this.pending) {
+      this.socket.send(message);
+    }
+    this.pending = [];
+  }
+};
+function createBailianAsrClient(config, options = {}) {
+  return new BailianAsrClientImpl(
+    config,
+    options.socketFactory ?? defaultSocketFactory,
+    options.eventIdFactory ?? (() => `event_${nanoid()}`)
+  );
+}
+
+// src/voice/bailian-tts.ts
+import { EventEmitter as EventEmitter2 } from "events";
+import { nanoid as nanoid2 } from "nanoid";
+import { WebSocket as WebSocket6 } from "ws";
+var OPEN2 = 1;
+function defaultSocketFactory2(url, options) {
+  return new WebSocket6(url, options);
+}
+function errorFromPayload(payload) {
+  if (!payload || typeof payload !== "object") return new Error("Bailian TTS error");
+  const record = payload;
+  const header = record.header && typeof record.header === "object" ? record.header : null;
+  let message = "Bailian TTS error";
+  if (header && typeof header.error_message === "string") {
+    message = header.error_message;
+  } else if (typeof record.message === "string") {
+    message = record.message;
+  }
+  return new Error(message);
+}
+function eventFromPayload(payload) {
+  if (!payload || typeof payload !== "object") return "";
+  const record = payload;
+  const header = record.header && typeof record.header === "object" ? record.header : null;
+  const event = header ? header.event : void 0;
+  return typeof event === "string" ? event : "";
+}
+var BailianTtsClientImpl = class extends EventEmitter2 {
+  constructor(config, socketFactory, taskIdFactory) {
+    super();
+    this.config = config;
+    this.taskIdFactory = taskIdFactory;
+    this.socket = socketFactory(bailianInferenceUrl(config.region), {
+      headers: { Authorization: `bearer ${config.apiKey}` }
+    });
+    this.socket.on("open", () => this.handleOpen());
+    this.socket.on(
+      "message",
+      (data, isBinary) => this.handleMessage(data, isBinary)
+    );
+    this.socket.on(
+      "error",
+      (err) => this.emit("error", err instanceof Error ? err : new Error(String(err)))
+    );
+    this.socket.on(
+      "close",
+      (code, reason) => this.emit("closed", code, reason?.toString("utf8"))
+    );
+  }
+  config;
+  taskIdFactory;
+  socket;
+  isOpen = false;
+  current = null;
+  speak(text) {
+    if (this.current) {
+      throw new Error("Bailian TTS is already speaking");
+    }
+    this.current = { taskId: this.taskIdFactory(), text };
+    if (this.isOpen || this.socket.readyState === OPEN2) {
+      this.sendRunTask();
+    }
+  }
+  close() {
+    this.socket.close();
+  }
+  handleOpen() {
+    this.isOpen = true;
+    if (this.current) this.sendRunTask();
+  }
+  handleMessage(data, isBinary = false) {
+    const text = this.tryDecodeText(data, isBinary);
+    if (!text) {
+      const chunk = Buffer.isBuffer(data) ? data : Buffer.from(data);
+      this.emit("audio", chunk);
+      return;
+    }
+    let payload;
+    try {
+      payload = JSON.parse(text);
+    } catch {
+      const chunk = Buffer.isBuffer(data) ? data : Buffer.from(text);
+      this.emit("audio", chunk);
+      return;
+    }
+    const event = eventFromPayload(payload);
+    if (event === "task-started") {
+      this.emit("started");
+      this.sendTextAndFinish();
+      return;
+    }
+    if (event === "task-finished") {
+      this.emit("finished");
+      this.current = null;
+      return;
+    }
+    if (event === "task-failed" || event === "task-error") {
+      this.emit("error", errorFromPayload(payload));
+      this.current = null;
+    }
+  }
+  tryDecodeText(data, isBinary) {
+    if (typeof data === "string") return data;
+    if (isBinary) return null;
+    if (Buffer.isBuffer(data)) return data.toString("utf8");
+    return null;
+  }
+  sendRunTask() {
+    if (!this.current) return;
+    this.socket.send(
+      JSON.stringify({
+        header: {
+          action: "run-task",
+          task_id: this.current.taskId,
+          streaming: "duplex"
+        },
+        payload: {
+          task_group: "audio",
+          task: "tts",
+          function: "SpeechSynthesizer",
+          model: this.config.model,
+          input: {},
+          parameters: {
+            text_type: "PlainText",
+            voice: this.config.voice,
+            format: "pcm",
+            sample_rate: this.config.sampleRate
+          }
+        }
+      })
+    );
+  }
+  sendTextAndFinish() {
+    if (!this.current) return;
+    this.socket.send(
+      JSON.stringify({
+        header: { action: "continue-task", task_id: this.current.taskId },
+        payload: { input: { text: this.current.text } }
+      })
+    );
+    this.socket.send(
+      JSON.stringify({
+        header: { action: "finish-task", task_id: this.current.taskId },
+        payload: { input: {} }
+      })
+    );
+  }
+};
+function createBailianTtsClient(config, options = {}) {
+  return new BailianTtsClientImpl(
+    config,
+    options.socketFactory ?? defaultSocketFactory2,
+    options.taskIdFactory ?? (() => nanoid2())
+  );
+}
+
+// src/voice/config-test.ts
+var TEST_SAMPLE_RATE = 16e3;
+var ASR_TEST_CHUNK_BYTES = 3200;
+var ASR_TEST_CHUNK_INTERVAL_MS = 100;
+function mergeVoiceConfigForTest(current, update) {
+  return {
+    ...current,
+    provider: "aliyun-bailian",
+    ...update?.clearApiKey ? { apiKey: void 0 } : {},
+    ...update?.apiKey ? { apiKey: update.apiKey } : {},
+    ...update?.region ? { region: update.region } : {},
+    ...update?.asrModel ? { asrModel: update.asrModel } : {},
+    ...update?.ttsModel ? { ttsModel: update.ttsModel } : {},
+    ...update?.ttsVoice ? { ttsVoice: update.ttsVoice } : {},
+    ...update?.turnIdleSeconds ? { turnIdleSeconds: update.turnIdleSeconds } : {}
+  };
+}
+function createBailianVoiceConfigTester(options = {}) {
+  const ttsClientFactory = options.ttsClientFactory ?? createBailianTtsClient;
+  const asrClientFactory = options.asrClientFactory ?? createBailianAsrClient;
+  const sampleText = options.sampleText ?? "\u8BED\u97F3\u52A9\u624B\u6D4B\u8BD5";
+  const timeoutMs = options.timeoutMs ?? 8e3;
+  return {
+    async test(config) {
+      if (!config.apiKey) {
+        return Promise.reject(new Error("\u8BF7\u5148\u586B\u5199\u963F\u91CC\u4E91\u767E\u70BC API Key"));
+      }
+      const audio = await synthesizeTestAudio({
+        config,
+        sampleText,
+        timeoutMs,
+        clientFactory: ttsClientFactory
+      });
+      const transcript = await recognizeTestAudio({
+        config,
+        audio,
+        sampleText,
+        timeoutMs,
+        clientFactory: asrClientFactory
+      });
+      return { audio, sampleRate: TEST_SAMPLE_RATE, transcript };
+    }
+  };
+}
+function synthesizeTestAudio(options) {
+  const { config, sampleText, timeoutMs, clientFactory } = options;
+  const client = clientFactory({
+    apiKey: config.apiKey,
+    region: config.region,
+    model: config.ttsModel,
+    voice: config.ttsVoice,
+    sampleRate: TEST_SAMPLE_RATE
+  });
+  return new Promise((resolve2, reject) => {
+    let settled = false;
+    const chunks = [];
+    const timer = setTimeout(() => {
+      settle(new Error("TTS \u6D4B\u8BD5\u8D85\u65F6"));
+    }, timeoutMs);
+    function settle(error, audio) {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      client.close();
+      if (error) reject(error);
+      else resolve2(audio ?? Buffer.alloc(0));
+    }
+    client.on("audio", (chunk) => {
+      if (chunk.length > 0) chunks.push(chunk);
+    });
+    client.on("finished", () => {
+      if (chunks.length === 0) {
+        settle(new Error("TTS \u6D4B\u8BD5\u6CA1\u6709\u8FD4\u56DE\u97F3\u9891"));
+        return;
+      }
+      settle(void 0, Buffer.concat(chunks));
+    });
+    client.on("error", (error) => settle(error));
+    client.on("closed", () => {
+      if (!settled) settle(new Error("TTS \u6D4B\u8BD5\u8FDE\u63A5\u5DF2\u5173\u95ED"));
+    });
+    try {
+      client.speak(sampleText);
+    } catch (err) {
+      settle(err instanceof Error ? err : new Error("TTS \u6D4B\u8BD5\u542F\u52A8\u5931\u8D25"));
+    }
+  });
+}
+function recognizeTestAudio(options) {
+  const { config, audio, sampleText, timeoutMs, clientFactory } = options;
+  const client = clientFactory({
+    apiKey: config.apiKey,
+    region: config.region,
+    model: config.asrModel,
+    sampleRate: TEST_SAMPLE_RATE,
+    language: "zh"
+  });
+  return new Promise((resolve2, reject) => {
+    let settled = false;
+    let streamTimer = null;
+    const timer = setTimeout(() => {
+      settle(new Error("STT \u6D4B\u8BD5\u8D85\u65F6"));
+    }, timeoutMs);
+    function settle(error, transcript) {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      if (streamTimer) clearTimeout(streamTimer);
+      client.close();
+      if (error) reject(error);
+      else resolve2(transcript ?? "");
+    }
+    client.on("ready", () => {
+      let offset = 0;
+      const sendNextChunk = () => {
+        if (settled) return;
+        const chunk = audio.subarray(offset, offset + ASR_TEST_CHUNK_BYTES);
+        if (chunk.length > 0) {
+          client.sendPcm(chunk);
+          offset += chunk.length;
+        }
+        if (offset >= audio.length) {
+          client.stop();
+          return;
+        }
+        streamTimer = setTimeout(sendNextChunk, ASR_TEST_CHUNK_INTERVAL_MS);
+      };
+      sendNextChunk();
+    });
+    client.on("final", (transcript) => {
+      if (matchesExpectedTranscript(transcript, sampleText)) {
+        settle(void 0, transcript);
+        return;
+      }
+      settle(new Error(`STT \u6D4B\u8BD5\u8BC6\u522B\u7ED3\u679C\u4E0D\u5339\u914D\uFF1A${transcript}`));
+    });
+    client.on("error", (error) => settle(error));
+    client.on("closed", () => {
+      if (!settled) settle(new Error("STT \u6D4B\u8BD5\u8FDE\u63A5\u5DF2\u5173\u95ED"));
+    });
+  });
+}
+function matchesExpectedTranscript(actual, expected) {
+  return normalizeTranscript(actual).includes(normalizeTranscript(expected));
+}
+function normalizeTranscript(text) {
+  return text.replace(/[^\p{Script=Han}a-zA-Z0-9]/gu, "").toLowerCase();
+}
+
+// src/voice/client-controls.ts
+function handleVoiceConfigControl(msg, ws, store, logger, providers) {
+  if (msg.type === "voice_config_request") {
+    ws.send(
+      JSON.stringify({
+        type: "voice_config_response",
+        requestId: msg.requestId,
+        config: store.read()
+      })
+    );
+    return true;
+  }
+  if (msg.type === "voice_config_update") {
+    try {
+      const config = store.update(msg.config);
+      ws.send(
+        JSON.stringify({
+          type: "voice_config_update_response",
+          requestId: msg.requestId,
+          success: true,
+          config
+        })
+      );
+    } catch (err) {
+      logger.warn({ err }, "Voice config update failed");
+      ws.send(
+        JSON.stringify({
+          type: "voice_config_update_response",
+          requestId: msg.requestId,
+          success: false,
+          errorCode: ControlErrorCode.UNKNOWN,
+          error: err instanceof Error ? err.message : "Voice config update failed"
+        })
+      );
+    }
+    return true;
+  }
+  if (msg.type === "voice_capabilities_request") {
+    if (!providers) {
+      ws.send(
+        JSON.stringify({
+          type: "voice_capabilities_response",
+          requestId: msg.requestId,
+          errorCode: ControlErrorCode.UNKNOWN,
+          error: "Voice capabilities provider is not available"
+        })
+      );
+      return true;
+    }
+    const config = { ...store.readSecret(), ...msg.region ? { region: msg.region } : {} };
+    let provider;
+    try {
+      provider = providers.current(config);
+    } catch (err) {
+      logger.warn({ err }, "Voice capabilities provider resolution failed");
+      ws.send(
+        JSON.stringify({
+          type: "voice_capabilities_response",
+          requestId: msg.requestId,
+          errorCode: ControlErrorCode.UNKNOWN,
+          error: err instanceof Error ? err.message : "Voice capabilities request failed"
+        })
+      );
+      return true;
+    }
+    void provider.readCapabilities(config).then((capabilities) => {
+      ws.send(
+        JSON.stringify({
+          type: "voice_capabilities_response",
+          requestId: msg.requestId,
+          capabilities
+        })
+      );
+    }).catch((err) => {
+      logger.warn({ err }, "Voice capabilities request failed");
+      ws.send(
+        JSON.stringify({
+          type: "voice_capabilities_response",
+          requestId: msg.requestId,
+          errorCode: ControlErrorCode.UNKNOWN,
+          error: err instanceof Error ? err.message : "Voice capabilities request failed"
+        })
+      );
+    });
+    return true;
+  }
+  if (msg.type === "voice_config_test") {
+    if (!providers) {
+      ws.send(
+        JSON.stringify({
+          type: "voice_config_test_response",
+          requestId: msg.requestId,
+          success: false,
+          errorCode: ControlErrorCode.UNKNOWN,
+          error: "Voice config tester is not available"
+        })
+      );
+      return true;
+    }
+    const testConfig = mergeVoiceConfigForTest(store.readSecret(), msg.config);
+    let provider;
+    try {
+      provider = providers.current(testConfig);
+    } catch (err) {
+      logger.warn({ err }, "Voice config test provider resolution failed");
+      ws.send(
+        JSON.stringify({
+          type: "voice_config_test_response",
+          requestId: msg.requestId,
+          success: false,
+          errorCode: ControlErrorCode.UNKNOWN,
+          error: err instanceof Error ? err.message : "Voice config test failed"
+        })
+      );
+      return true;
+    }
+    void provider.testConfig(testConfig).then((result) => {
+      ws.send(
+        JSON.stringify({
+          type: "voice_config_test_response",
+          requestId: msg.requestId,
+          success: true,
+          ...result.audio ? { audioBase64: result.audio.toString("base64") } : {},
+          ...result.sampleRate ? { audioSampleRate: result.sampleRate } : {},
+          ...result.audio ? { audioEncoding: "pcm_s16le" } : {},
+          ...result.transcript ? { transcript: result.transcript } : {}
+        })
+      );
+    }).catch((err) => {
+      logger.warn({ err }, "Voice config test failed");
+      ws.send(
+        JSON.stringify({
+          type: "voice_config_test_response",
+          requestId: msg.requestId,
+          success: false,
+          errorCode: ControlErrorCode.UNKNOWN,
+          error: err instanceof Error ? err.message : "Voice config test failed"
+        })
+      );
+    });
+    return true;
+  }
+  return false;
+}
+
+// src/handlers/client.ts
+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 sendRelayProxyProbeFailure(ws, requestId, error, chaos) {
+  const response = serializeControl({
+    type: "latency_relay_proxy_response",
+    requestId,
+    success: false,
+    error
+  });
+  if (chaos) {
+    chaos.send(ws, response, {
+      direction: "proxy_to_client",
+      type: "latency_relay_proxy_response"
+    });
+    return;
+  }
+  ws.send(response);
+}
+function handleClientConnection(ws, registry, logger, chaos, voiceConfigStore, voiceProviders) {
+  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 (msg.type === "latency_web_relay_ping") {
+        const response = serializeControl({
+          type: "latency_web_relay_pong",
+          requestId: msg.requestId,
+          relayNow: Date.now()
+        });
+        if (chaos) {
+          chaos.send(clientWs, response, {
+            direction: "proxy_to_client",
+            type: "latency_web_relay_pong"
+          });
+        } else {
+          clientWs.send(response);
+        }
+        return;
+      }
+      if (msg.type === "latency_relay_proxy_request") {
+        const targetProxyId = clientWs.boundProxyId;
+        if (!targetProxyId) {
+          sendRelayProxyProbeFailure(clientWs, msg.requestId, "\u5F53\u524D\u672A\u8FDE\u63A5\u5F00\u53D1\u673A", chaos);
+          return;
+        }
+        const proxyWs = registry.getProxy(targetProxyId);
+        if (!proxyWs || proxyWs.readyState !== WebSocket7.OPEN) {
+          sendRelayProxyProbeFailure(
+            clientWs,
+            msg.requestId,
+            `\u5F00\u53D1\u673A ${targetProxyId} \u4E0D\u5728\u7EBF`,
+            chaos
+          );
+          return;
+        }
+        startRelayProxyLatencyProbe({
+          requestId: msg.requestId,
+          proxyId: targetProxyId,
+          proxyWs,
+          clientWs,
+          logger,
+          chaos
+        });
+        return;
+      }
+      if (voiceConfigStore && handleVoiceConfigControl(msg, clientWs, voiceConfigStore, logger, voiceProviders)) {
+        return;
+      }
+      if (isClientToProxyRelayControlType(msg.type)) {
+        const targetProxyId = clientWs.boundProxyId;
+        if (!targetProxyId) {
+          rejectNotBound(clientWs);
+          return;
+        }
+        const proxyWs = registry.getProxy(targetProxyId);
+        if (proxyWs && proxyWs.readyState === WebSocket7.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-${nanoid3(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 markAlive(ws) {
+  ws.isAlive = true;
+}
+function setupHeartbeat(wss, interval = 3e4) {
+  wss.on("connection", (ws) => {
+    markAlive(ws);
+    ws.on("pong", () => {
+      markAlive(ws);
+    });
+  });
+  return setInterval(() => {
+    for (const ws of wss.clients) {
+      const sock = ws;
+      if (sock.isAlive === false) {
+        sock.terminate();
+        continue;
+      }
+      sock.isAlive = false;
+      sock.ping();
+    }
+  }, interval);
+}
+
+// src/chaos.ts
+import { WebSocket as WebSocket8 } 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 === WebSocket8.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/voice/config-store.ts
+import { existsSync, mkdirSync, readFileSync as readFileSync2, writeFileSync } from "fs";
+import { dirname as dirname2, join as join2 } from "path";
+var DEFAULT_STORED_CONFIG = {
+  provider: "aliyun-bailian",
+  region: "cn",
+  asrModel: "qwen3-asr-flash-realtime",
+  ttsModel: "cosyvoice-v3-flash",
+  ttsVoice: "longanyang",
+  turnIdleSeconds: 3
+};
+function redacted(config) {
+  return VoiceProviderConfigSchema.parse({
+    provider: config.provider,
+    configured: Boolean(config.apiKey),
+    region: config.region,
+    asrModel: config.asrModel,
+    ttsModel: config.ttsModel,
+    ttsVoice: config.ttsVoice,
+    turnIdleSeconds: config.turnIdleSeconds
+  });
+}
+function mergeDefaults(defaults) {
+  return {
+    ...DEFAULT_STORED_CONFIG,
+    ...defaults
+  };
+}
+function parseStoredConfig(raw, fallback) {
+  if (!raw || typeof raw !== "object") return fallback;
+  const candidate = raw;
+  return {
+    ...fallback,
+    provider: "aliyun-bailian",
+    ...typeof candidate.apiKey === "string" && candidate.apiKey.length > 0 ? { apiKey: candidate.apiKey } : { apiKey: void 0 },
+    ...candidate.region === "cn" || candidate.region === "intl" ? { region: candidate.region } : {},
+    ...typeof candidate.asrModel === "string" && candidate.asrModel.length > 0 ? { asrModel: candidate.asrModel } : {},
+    ...typeof candidate.ttsModel === "string" && candidate.ttsModel.length > 0 ? { ttsModel: candidate.ttsModel } : {},
+    ...typeof candidate.ttsVoice === "string" && candidate.ttsVoice.length > 0 ? { ttsVoice: candidate.ttsVoice } : {},
+    ...typeof candidate.turnIdleSeconds === "number" && Number.isSafeInteger(candidate.turnIdleSeconds) && candidate.turnIdleSeconds > 0 ? { turnIdleSeconds: candidate.turnIdleSeconds } : {}
+  };
+}
+function createVoiceConfigStore(options = {}) {
+  const fallback = mergeDefaults(options.defaults);
+  const filePath = options.dataDir ? join2(options.dataDir, "voice-config.json") : null;
+  let memoryConfig = fallback;
+  function load() {
+    if (!filePath) return memoryConfig;
+    if (!existsSync(filePath)) return fallback;
+    try {
+      return parseStoredConfig(JSON.parse(readFileSync2(filePath, "utf8")), fallback);
+    } catch {
+      return fallback;
+    }
+  }
+  function save(config) {
+    if (!filePath) {
+      memoryConfig = config;
+      return;
+    }
+    mkdirSync(dirname2(filePath), { recursive: true });
+    writeFileSync(filePath, `${JSON.stringify(config, null, 2)}
+`, { mode: 384 });
+  }
+  return {
+    read() {
+      return redacted(load());
+    },
+    update(update) {
+      const parsed = VoiceConfigUpdateSchema.parse(update);
+      const current = load();
+      const next = {
+        ...current,
+        provider: "aliyun-bailian",
+        ...parsed.clearApiKey ? { apiKey: void 0 } : {},
+        ...parsed.apiKey ? { apiKey: parsed.apiKey } : {},
+        ...parsed.region ? { region: parsed.region } : {},
+        ...parsed.asrModel ? { asrModel: parsed.asrModel } : {},
+        ...parsed.ttsModel ? { ttsModel: parsed.ttsModel } : {},
+        ...parsed.ttsVoice ? { ttsVoice: parsed.ttsVoice } : {},
+        ...parsed.turnIdleSeconds ? { turnIdleSeconds: parsed.turnIdleSeconds } : {}
+      };
+      save(next);
+      return redacted(next);
+    },
+    readSecret() {
+      return load();
+    }
+  };
+}
+
+// src/voice/asr-ws.ts
+import { WebSocket as WebSocket9 } from "ws";
+function sendJson(ws, payload) {
+  if (ws.readyState === WebSocket9.OPEN) {
+    ws.send(JSON.stringify(payload));
+  }
+}
+function toBuffer(data) {
+  if (Buffer.isBuffer(data)) return data;
+  if (data instanceof ArrayBuffer) return Buffer.from(data);
+  return Buffer.concat(data);
+}
+function parseJson(data) {
+  try {
+    return JSON.parse(toBuffer(data).toString("utf8"));
+  } catch {
+    return null;
+  }
+}
+function isStartMessage(payload) {
+  if (!payload || typeof payload !== "object") return false;
+  const record = payload;
+  return record.type === "start" && typeof record.sessionId === "string";
+}
+function handleVoiceAsrConnection(ws, store, logger, providers) {
+  let provider = null;
+  function start(payload) {
+    const config = store.readSecret();
+    if (!config.apiKey) {
+      sendJson(ws, {
+        type: "error",
+        errorCode: "not_configured",
+        error: "Voice provider is not configured"
+      });
+      return;
+    }
+    provider?.close();
+    provider = providers.current(config).createAsrClient(config, {
+      sampleRate: payload.sampleRate ?? 16e3,
+      language: "zh"
+    });
+    provider.on("ready", () => sendJson(ws, { type: "ready" }));
+    provider.on("partial", (text) => sendJson(ws, { type: "partial", text }));
+    provider.on("final", (text) => sendJson(ws, { type: "final", text }));
+    provider.on(
+      "error",
+      (error) => sendJson(ws, { type: "error", error: error.message || "ASR failed" })
+    );
+    provider.on("closed", (code, reason) => sendJson(ws, { type: "closed", code, reason }));
+  }
+  ws.on("message", (data, isBinary) => {
+    if (isBinary) {
+      provider?.sendPcm(toBuffer(data));
+      return;
+    }
+    const payload = parseJson(data);
+    if (isStartMessage(payload)) {
+      start(payload);
+      return;
+    }
+    if (payload && typeof payload === "object" && payload.type === "stop") {
+      provider?.stop();
+    }
+  });
+  ws.on("close", () => {
+    provider?.close();
+    provider = null;
+  });
+  ws.on("error", (err) => {
+    logger.warn({ err }, "Voice ASR websocket error");
+    provider?.close();
+    provider = null;
+  });
+}
+
+// src/voice/tts-ws.ts
+import { WebSocket as WebSocket10 } from "ws";
+function sendJson2(ws, payload) {
+  if (ws.readyState === WebSocket10.OPEN) {
+    ws.send(JSON.stringify(payload));
+  }
+}
+function parseJson2(data) {
+  try {
+    const buffer = Buffer.isBuffer(data) ? data : data instanceof ArrayBuffer ? Buffer.from(data) : Buffer.concat(data);
+    return JSON.parse(buffer.toString("utf8"));
+  } catch {
+    return null;
+  }
+}
+function isSpeakMessage(payload) {
+  if (!payload || typeof payload !== "object") return false;
+  const record = payload;
+  return record.type === "speak" && typeof record.requestId === "string" && typeof record.text === "string" && record.text.length > 0;
+}
+function nowMs() {
+  return Date.now();
+}
+function buildStats(requestId, text, config) {
+  return {
+    requestId,
+    textChars: text.length,
+    provider: config.provider,
+    region: config.region,
+    ttsModel: config.ttsModel,
+    ttsVoice: config.ttsVoice,
+    startedAt: nowMs(),
+    firstAudioAt: null,
+    audioBytes: 0,
+    audioChunks: 0
+  };
+}
+function statsLogFields(stats) {
+  const currentTime = nowMs();
+  return {
+    requestId: stats.requestId,
+    textChars: stats.textChars,
+    provider: stats.provider,
+    region: stats.region,
+    ttsModel: stats.ttsModel,
+    ttsVoice: stats.ttsVoice,
+    audioBytes: stats.audioBytes,
+    audioChunks: stats.audioChunks,
+    durationMs: currentTime - stats.startedAt,
+    firstAudioMs: stats.firstAudioAt === null ? null : stats.firstAudioAt - stats.startedAt
+  };
+}
+function closeReasonText(reason) {
+  if (Buffer.isBuffer(reason)) return reason.toString("utf8");
+  return typeof reason === "string" ? reason : "";
+}
+function handleVoiceTtsConnection(ws, store, logger, providers) {
+  let provider = null;
+  let providerConfig = null;
+  let activeRequestId = null;
+  let activeStats = null;
+  function ensureProvider() {
+    if (provider && providerConfig) return { client: provider, config: providerConfig };
+    const config = store.readSecret();
+    if (!config.apiKey) {
+      sendJson2(ws, {
+        type: "error",
+        errorCode: "not_configured",
+        error: "Voice provider is not configured"
+      });
+      return null;
+    }
+    provider = providers.current(config).createTtsClient(config, {
+      sampleRate: 24e3
+    });
+    providerConfig = config;
+    provider.on("started", () => {
+      if (activeStats) logger.info(statsLogFields(activeStats), "Voice TTS started");
+      sendJson2(ws, { type: "started", requestId: activeRequestId });
+    });
+    provider.on("audio", (chunk) => {
+      if (activeStats) {
+        if (activeStats.firstAudioAt === null) activeStats.firstAudioAt = nowMs();
+        activeStats.audioBytes += chunk.byteLength;
+        activeStats.audioChunks += 1;
+      }
+      if (ws.readyState === WebSocket10.OPEN) ws.send(chunk);
+    });
+    provider.on("finished", () => {
+      if (activeStats) logger.info(statsLogFields(activeStats), "Voice TTS finished");
+      sendJson2(ws, { type: "finished", requestId: activeRequestId });
+      activeRequestId = null;
+      activeStats = null;
+    });
+    provider.on("error", (error) => {
+      if (activeStats) {
+        logger.warn(
+          { ...statsLogFields(activeStats), err: error },
+          "Voice TTS provider reported an error"
+        );
+      }
+      sendJson2(ws, {
+        type: "error",
+        requestId: activeRequestId,
+        error: error.message || "TTS failed"
+      });
+      activeRequestId = null;
+      activeStats = null;
+    });
+    provider.on("closed", (code, reason) => {
+      if (activeStats) {
+        logger.warn(
+          { ...statsLogFields(activeStats), code, reason },
+          "Voice TTS provider closed before finishing"
+        );
+        sendJson2(ws, {
+          type: "error",
+          requestId: activeRequestId,
+          errorCode: "provider_closed",
+          error: "Voice TTS provider closed before finishing"
+        });
+        activeRequestId = null;
+        activeStats = null;
+      } else {
+        logger.info({ code, reason }, "Voice TTS provider closed");
+        provider = null;
+        providerConfig = null;
+        return;
+      }
+      sendJson2(ws, { type: "closed", code, reason });
+      provider = null;
+      providerConfig = null;
+    });
+    return { client: provider, config };
+  }
+  ws.on("message", (data) => {
+    const payload = parseJson2(data);
+    if (!isSpeakMessage(payload)) return;
+    if (activeRequestId) {
+      sendJson2(ws, {
+        type: "error",
+        requestId: payload.requestId,
+        errorCode: "busy",
+        error: "Voice TTS is already speaking"
+      });
+      return;
+    }
+    const ensured = ensureProvider();
+    if (!ensured) return;
+    const { client, config } = ensured;
+    activeRequestId = payload.requestId;
+    activeStats = buildStats(payload.requestId, payload.text, config);
+    logger.info(statsLogFields(activeStats), "Voice TTS request received");
+    try {
+      client.speak(payload.text);
+    } catch (err) {
+      if (activeStats) {
+        logger.warn(
+          { ...statsLogFields(activeStats), err },
+          "Voice TTS request failed before provider accepted it"
+        );
+      }
+      sendJson2(ws, {
+        type: "error",
+        requestId: payload.requestId,
+        error: err instanceof Error ? err.message : "Voice TTS failed"
+      });
+      activeRequestId = null;
+      activeStats = null;
+    }
+  });
+  ws.on("close", (code, reason) => {
+    if (activeStats) {
+      logger.warn(
+        { ...statsLogFields(activeStats), code, reason: closeReasonText(reason) },
+        "Voice TTS client websocket closed before finishing"
+      );
+    }
+    const currentProvider = provider;
+    provider = null;
+    providerConfig = null;
+    activeRequestId = null;
+    activeStats = null;
+    currentProvider?.close();
+  });
+  ws.on("error", (err) => {
+    logger.warn({ err }, "Voice TTS websocket error");
+    provider?.close();
+    provider = null;
+    providerConfig = null;
+    activeRequestId = null;
+    activeStats = null;
+  });
+}
+
+// src/voice/capabilities.ts
+var CUSTOMIZATION_ENDPOINTS = {
+  cn: "https://dashscope.aliyuncs.com/api/v1/services/audio/tts/customization",
+  intl: "https://dashscope-intl.aliyuncs.com/api/v1/services/audio/tts/customization"
+};
+function modelFromCustomCosyVoiceId(voiceId) {
+  const match = voiceId.match(/^(cosyvoice-v3(?:\.5)?-(?:flash|plus))-/);
+  return match?.[1];
+}
+async function fetchCustomVoices(fetchImpl, config) {
+  if (!config.apiKey) return [];
+  const response = await fetchImpl(CUSTOMIZATION_ENDPOINTS[config.region], {
+    method: "POST",
+    headers: {
+      Authorization: `Bearer ${config.apiKey}`,
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify({
+      model: "voice-enrollment",
+      input: {
+        action: "list_voice",
+        page_size: 100,
+        page_index: 0
+      }
+    })
+  });
+  if (!response.ok) return [];
+  const payload = response.json();
+  const voiceList = (await payload).output?.voice_list ?? [];
+  return voiceList.filter((voice) => !voice.status || voice.status === "OK").flatMap((voice) => {
+    if (!voice.voice_id) return [];
+    const model = modelFromCustomCosyVoiceId(voice.voice_id);
+    return [
+      {
+        value: voice.voice_id,
+        label: [voice.voice_id, "\u81EA\u5B9A\u4E49", voice.voice_prompt].filter(Boolean).join(" \xB7 "),
+        ...model ? { model } : {},
+        source: "custom"
+      }
+    ];
+  });
+}
+function createBailianVoiceCapabilitiesProvider(options = {}) {
+  const fetchImpl = options.fetchImpl ?? globalThis.fetch;
+  const now = options.now ?? Date.now;
+  return {
+    async read(config) {
+      let customVoices;
+      try {
+        customVoices = await fetchCustomVoices(fetchImpl, config);
+      } catch {
+        customVoices = [];
+      }
+      const bundled = createBundledBailianVoiceCapabilities(now());
+      return {
+        ...bundled,
+        ttsVoices: [...bundled.ttsVoices, ...customVoices]
+      };
+    }
+  };
+}
+
+// src/voice/bailian-provider.ts
+function requireApiKey(config) {
+  if (!config.apiKey) throw new Error("Voice provider is not configured");
+  return config.apiKey;
+}
+function createBailianVoiceProvider(options = {}) {
+  const asrClientFactory = options.asrClientFactory ?? createBailianAsrClient;
+  const ttsClientFactory = options.ttsClientFactory ?? createBailianTtsClient;
+  const capabilitiesProvider = options.capabilitiesProvider ?? createBailianVoiceCapabilitiesProvider();
+  const configTester = options.configTester ?? createBailianVoiceConfigTester({
+    asrClientFactory,
+    ttsClientFactory
+  });
+  return {
+    id: "aliyun-bailian",
+    createAsrClient(config, clientOptions) {
+      return asrClientFactory({
+        apiKey: requireApiKey(config),
+        region: config.region,
+        model: config.asrModel,
+        sampleRate: clientOptions.sampleRate,
+        language: clientOptions.language
+      });
+    },
+    createTtsClient(config, clientOptions) {
+      return ttsClientFactory({
+        apiKey: requireApiKey(config),
+        region: config.region,
+        model: config.ttsModel,
+        voice: config.ttsVoice,
+        sampleRate: clientOptions.sampleRate
+      });
+    },
+    readCapabilities(config) {
+      return capabilitiesProvider.read(config);
+    },
+    testConfig(config) {
+      return configTester.test(config);
+    }
+  };
+}
+
+// src/voice/provider.ts
+function createVoiceProviderRegistry(adapters) {
+  const byId = /* @__PURE__ */ new Map();
+  for (const adapter of adapters) {
+    if (byId.has(adapter.id)) {
+      throw new Error(`Duplicate voice provider: ${adapter.id}`);
+    }
+    byId.set(adapter.id, adapter);
+  }
+  function require2(providerId) {
+    const adapter = byId.get(providerId);
+    if (!adapter) throw new Error(`Unsupported voice provider: ${providerId}`);
+    return adapter;
+  }
+  return {
+    current(config) {
+      return require2(config.provider);
+    },
+    require: require2
+  };
+}
+
+// src/server.ts
+var MODULE_DIR = dirname3(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 voiceConfigStore = createVoiceConfigStore({
+    dataDir,
+    defaults: options.voiceDefaults
+  });
+  const voiceProviders = options.voiceProviderRegistry ?? createVoiceProviderRegistry([
+    createBailianVoiceProvider({
+      asrClientFactory: options.voiceAsrClientFactory,
+      ttsClientFactory: options.voiceTtsClientFactory,
+      capabilitiesProvider: options.voiceCapabilitiesProvider,
+      configTester: options.voiceConfigTester
+    })
+  ]);
+  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 (existsSync2(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 });
+  const voiceAsrWss = new WebSocketServer({ noServer: true });
+  const voiceTtsWss = 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" || pathname === "/voice/asr" || pathname === "/voice/tts") {
+      if (clientTokenRequired) {
+        const token = url.searchParams.get("token");
+        if (token !== clientToken) {
+          logger.warn(
+            { ip: request.socket.remoteAddress, pathname },
+            "rejected client-side upgrade: invalid token"
+          );
+          socket.write("HTTP/1.1 401 Unauthorized\r\n\r\n");
+          socket.destroy();
+          return;
+        }
+      }
+      if (pathname === "/client") {
+        clientWss.handleUpgrade(request, socket, head, (ws) => {
+          clientWss.emit("connection", ws, request);
+        });
+      } else if (pathname === "/voice/asr") {
+        voiceAsrWss.handleUpgrade(request, socket, head, (ws) => {
+          voiceAsrWss.emit("connection", ws, request);
+        });
+      } else {
+        voiceTtsWss.handleUpgrade(request, socket, head, (ws) => {
+          voiceTtsWss.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, voiceConfigStore, voiceProviders);
+  });
+  voiceAsrWss.on("connection", (ws) => {
+    handleVoiceAsrConnection(ws, voiceConfigStore, logger, voiceProviders);
+  });
+  voiceTtsWss.on("connection", (ws) => {
+    handleVoiceTtsConnection(ws, voiceConfigStore, logger, voiceProviders);
+  });
+  const proxyHeartbeat = setupHeartbeat(proxyWss, heartbeatInterval);
+  const clientHeartbeat = setupHeartbeat(clientWss, heartbeatInterval);
+  const voiceAsrHeartbeat = setupHeartbeat(voiceAsrWss, heartbeatInterval);
+  const voiceTtsHeartbeat = setupHeartbeat(voiceTtsWss, heartbeatInterval);
+  async function close() {
+    clearInterval(proxyHeartbeat);
+    clearInterval(clientHeartbeat);
+    clearInterval(voiceAsrHeartbeat);
+    clearInterval(voiceTtsHeartbeat);
+    for (const ws of proxyWss.clients) {
+      ws.terminate();
+    }
+    for (const ws of clientWss.clients) {
+      ws.terminate();
+    }
+    for (const ws of voiceAsrWss.clients) {
+      ws.terminate();
+    }
+    for (const ws of voiceTtsWss.clients) {
+      ws.terminate();
+    }
+    await Promise.all([
+      new Promise((resolve2, reject) => {
+        proxyWss.close((err) => {
+          if (err) reject(err);
+          else resolve2();
+        });
+      }),
+      new Promise((resolve2, reject) => {
+        clientWss.close((err) => {
+          if (err) reject(err);
+          else resolve2();
+        });
+      }),
+      new Promise((resolve2, reject) => {
+        voiceAsrWss.close((err) => {
+          if (err) reject(err);
+          else resolve2();
+        });
+      }),
+      new Promise((resolve2, reject) => {
+        voiceTtsWss.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-OJABHE5C.js.map