@dev-anywhere/proxy 0.1.9 → 0.2.1

package/dist/chunk-NBRBO5GS.js

@@ -0,0 +1,1032 @@
+#!/usr/bin/env node
+
+// ../../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(),
+  state: z4.enum(sessionStateValues),
+  mode: z4.enum(sessionModeValues).optional(),
+  provider: z4.enum(providerValues),
+  // PTY 尺寸所有权:
+  // - local-terminal: 本地 terminal 进程持有真实 PTY，Web 只按原始 cols/rows 展示
+  // - proxy-hosted: serve 内托管 PTY，Web 可按视口请求 resize
+  ptyOwner: z4.enum(ptyOwnerValues).optional(),
+  lastActive: z4.number().optional()
+});
+var SessionCreatePayloadSchema = z4.object({
+  name: z4.string().optional(),
+  cwd: z4.string().optional(),
+  streamDelta: z4.boolean().optional()
+});
+var SessionListPayloadSchema = z4.object({
+  sessions: z4.array(SessionInfoSchema)
+});
+var SessionSwitchPayloadSchema = z4.object({
+  sessionId: IdSchema
+});
+var SessionTerminatePayloadSchema = z4.object({
+  sessionId: IdSchema
+});
+var SessionStatusPayloadSchema = z4.object({
+  sessionId: IdSchema,
+  state: z4.enum(sessionStateValues),
+  lastActive: z4.number()
+});
+var PtyStatePayloadSchema = z4.object({
+  state: z4.enum(ptySemanticStateValues),
+  title: z4.string().optional(),
+  tool: z4.string().optional()
+});
+var AgentStatusPayloadSchema = z4.object({
+  provider: z4.enum(providerValues),
+  phase: z4.enum(agentStatusPhaseValues),
+  seq: z4.number().int().nonnegative(),
+  updatedAt: z4.number(),
+  toolName: z4.string().optional(),
+  toolInput: z4.record(z4.string(), z4.unknown()).optional(),
+  permissionRequest: z4.object({
+    requestId: IdSchema,
+    toolName: z4.string(),
+    input: z4.record(z4.string(), z4.unknown())
+  }).optional(),
+  permissionResolution: z4.object({
+    requestId: IdSchema,
+    outcome: z4.enum(["allow", "deny"])
+  }).optional(),
+  summary: z4.string().optional()
+});
+
+// ../../packages/shared/dist/schemas/system.js
+import { z as z5 } from "zod";
+var HeartbeatPayloadSchema = z5.object({});
+var AuthPayloadSchema = z5.object({
+  pairingCode: z5.string().optional(),
+  token: z5.string().optional()
+});
+var SyncRequestPayloadSchema = z5.object({
+  lastSeq: z5.number().int().nonnegative()
+});
+var SyncResponsePayloadSchema = z5.object({
+  messages: z5.array(z5.record(z5.string(), z5.unknown()))
+});
+
+// ../../packages/shared/dist/schemas/envelope.js
+var BaseEnvelopeFields = {
+  seq: z6.number().int().nonnegative(),
+  timestamp: z6.number(),
+  source: z6.enum(["proxy", "client"]),
+  version: z6.string()
+};
+var SessionedEnvelopeFields = {
+  ...BaseEnvelopeFields,
+  sessionId: IdSchema
+};
+var MessageEnvelopeSchema = z6.discriminatedUnion("type", [
+  // chat (3)
+  z6.object({
+    ...SessionedEnvelopeFields,
+    type: z6.literal("user_input"),
+    payload: UserInputPayloadSchema
+  }),
+  z6.object({
+    ...SessionedEnvelopeFields,
+    type: z6.literal("assistant_message"),
+    payload: AssistantMessagePayloadSchema
+  }),
+  z6.object({
+    ...SessionedEnvelopeFields,
+    type: z6.literal("thinking"),
+    payload: ThinkingPayloadSchema
+  }),
+  // tool (4): 工具审批决策属于 relay control，不进入会话消息信封。
+  // tool_use_request: 审批流请求（proxy → client），toolId 是 approval requestId
+  z6.object({
+    ...SessionedEnvelopeFields,
+    type: z6.literal("tool_use_request"),
+    payload: ToolUseRequestPayloadSchema
+  }),
+  // tool_result: 工具执行结果（proxy → client），toolId 对应 assistant_tool_use / tool_use_request 的 toolId
+  z6.object({
+    ...SessionedEnvelopeFields,
+    type: z6.literal("tool_result"),
+    payload: ToolResultPayloadSchema
+  }),
+  // assistant_tool_use: 纯展示型工具调用（proxy → client），区别于 tool_use_request 无审批语义
+  // payload 结构复用 ToolUseRequestPayloadSchema；toolId 是 Claude 分配的 tool_use id
+  z6.object({
+    ...SessionedEnvelopeFields,
+    type: z6.literal("assistant_tool_use"),
+    payload: ToolUseRequestPayloadSchema
+  }),
+  // session (5)
+  z6.object({
+    ...SessionedEnvelopeFields,
+    type: z6.literal("session_create"),
+    payload: SessionCreatePayloadSchema
+  }),
+  // session_list 是全局广播 (列出所有 session), 不绑定具体 sessionId, 不携带该字段。
+  z6.object({
+    ...BaseEnvelopeFields,
+    type: z6.literal("session_list"),
+    payload: SessionListPayloadSchema
+  }),
+  z6.object({
+    ...SessionedEnvelopeFields,
+    type: z6.literal("session_switch"),
+    payload: SessionSwitchPayloadSchema
+  }),
+  z6.object({
+    ...SessionedEnvelopeFields,
+    type: z6.literal("session_terminate"),
+    payload: SessionTerminatePayloadSchema
+  }),
+  z6.object({
+    ...SessionedEnvelopeFields,
+    type: z6.literal("session_status"),
+    payload: SessionStatusPayloadSchema
+  }),
+  // system (5): 心跳 / 认证 / 同步——全局, 无 sessionId
+  z6.object({
+    ...BaseEnvelopeFields,
+    type: z6.literal("heartbeat"),
+    payload: HeartbeatPayloadSchema
+  }),
+  z6.object({
+    ...BaseEnvelopeFields,
+    type: z6.literal("auth"),
+    payload: AuthPayloadSchema
+  }),
+  z6.object({
+    ...BaseEnvelopeFields,
+    type: z6.literal("sync_request"),
+    payload: SyncRequestPayloadSchema
+  }),
+  z6.object({
+    ...BaseEnvelopeFields,
+    type: z6.literal("sync_response"),
+    payload: SyncResponsePayloadSchema
+  })
+]);
+
+// ../../packages/shared/dist/builders/index.js
+function buildMessage(type, sessionId, seq, payload, source) {
+  const envelope = {
+    seq,
+    ...sessionId !== null ? { sessionId } : {},
+    type,
+    payload,
+    timestamp: Date.now(),
+    source,
+    version: "1.0"
+  };
+  return MessageEnvelopeSchema.parse(envelope);
+}
+function serializeControl(msg) {
+  return JSON.stringify(msg);
+}
+
+// ../../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 createFSM(def) {
+  let state = def.initial;
+  const absorbing = computeAbsorbingSet(def.transitions);
+  const tryTransitionTo = (to) => {
+    const allowed = def.transitions[state];
+    if (!allowed?.includes(to)) {
+      def.onRejected?.(state, to, absorbing.has(state));
+      return false;
+    }
+    const from = state;
+    state = to;
+    def.onTransition?.(from, to);
+    return true;
+  };
+  return {
+    current: () => state,
+    is: (s) => state === s,
+    isIn: (ss) => ss.includes(state),
+    canTransitionTo: (to) => def.transitions[state]?.includes(to) ?? false,
+    transitionTo: (to) => {
+      if (!tryTransitionTo(to)) {
+        throw new Error(`Invalid FSM transition: ${state} -> ${to}`);
+      }
+    },
+    tryTransitionTo,
+    isInAbsorbingState: () => absorbing.has(state)
+  };
+}
+function defineFSM(transitions) {
+  const absorbing = computeAbsorbingSet(transitions);
+  return {
+    canTransition: (from, to) => transitions[from]?.includes(to) ?? false,
+    isAbsorbing: (state) => absorbing.has(state)
+  };
+}
+
+// ../../packages/shared/dist/schemas/relay-control.js
+import { z as z7 } from "zod";
+
+// ../../packages/shared/dist/constants/relay-errors.js
+var RelayErrorCode = {
+  NOT_REGISTERED: "NOT_REGISTERED",
+  NOT_BOUND: "NOT_BOUND",
+  PROXY_OFFLINE: "PROXY_OFFLINE",
+  INVALID_MESSAGE: "INVALID_MESSAGE",
+  UNSUPPORTED: "UNSUPPORTED",
+  INVALID_RANGE: "INVALID_RANGE"
+};
+
+// ../../packages/shared/dist/constants/control-errors.js
+var ControlErrorCode = {
+  INVALID_PATH: "INVALID_PATH",
+  PATH_NOT_FOUND: "PATH_NOT_FOUND",
+  PATH_NOT_DIRECTORY: "PATH_NOT_DIRECTORY",
+  PATH_ACCESS_DENIED: "PATH_ACCESS_DENIED",
+  PROXY_OFFLINE: "PROXY_OFFLINE",
+  SESSION_NOT_FOUND: "SESSION_NOT_FOUND",
+  PROVIDER_UNSUPPORTED: "PROVIDER_UNSUPPORTED",
+  WORKER_START_FAILED: "WORKER_START_FAILED",
+  PROCESS_START_FAILED: "PROCESS_START_FAILED",
+  UNKNOWN: "UNKNOWN"
+};
+
+// ../../packages/shared/dist/schemas/relay-control.js
+var ProxyInfoSchema = z7.object({
+  proxyId: IdSchema,
+  name: z7.string().optional(),
+  online: z7.boolean(),
+  sessions: z7.array(z7.string()).optional()
+});
+var AgentCliAvailabilitySchema = z7.object({
+  available: z7.boolean(),
+  command: z7.string().optional(),
+  error: z7.string().optional(),
+  suggestions: z7.array(z7.string()).optional()
+});
+var AgentCliStatusSchema = z7.object({
+  claude: AgentCliAvailabilitySchema,
+  codex: AgentCliAvailabilitySchema
+});
+var DirEntrySchema = z7.object({ name: z7.string(), isDir: z7.boolean() });
+var FileTreeGroupSchema = z7.object({
+  path: z7.string(),
+  entries: z7.array(DirEntrySchema)
+});
+var CommandEntrySchema = z7.object({
+  name: z7.string(),
+  description: z7.string(),
+  argumentHint: z7.string().optional(),
+  source: z7.string()
+});
+var HistorySessionSchema = z7.object({
+  id: z7.string(),
+  title: z7.string(),
+  projectDir: z7.string(),
+  updatedAt: z7.number(),
+  provider: z7.enum(providerValues).optional()
+});
+var SessionHistoryMessageSchema = z7.object({
+  role: z7.enum(["user", "assistant"]),
+  text: z7.string(),
+  timestamp: z7.number().optional(),
+  cursor: z7.string().optional()
+});
+var RequestIdShape = { requestId: IdSchema.optional() };
+var ControlErrorCodeSchema = z7.enum(Object.values(ControlErrorCode));
+var RequestErrorShape = {
+  error: z7.string().optional(),
+  errorCode: ControlErrorCodeSchema.optional()
+};
+var ClipboardImageMimeTypeSchema = z7.enum(["image/png", "image/jpeg", "image/webp", "image/gif"]);
+function control(type, shape, directions) {
+  return {
+    type,
+    directions: new Set(Array.isArray(directions) ? directions : directions ? [directions] : []),
+    schema: z7.object({
+      type: z7.literal(type),
+      ...shape ?? {}
+    })
+  };
+}
+var relayControlDefinitions = [
+  control("proxy_register", {
+    proxyId: IdSchema,
+    name: z7.string().optional()
+  }),
+  control("proxy_register_response", {
+    status: z7.enum(["new", "reconnected"])
+  }),
+  control("proxy_list_request", RequestIdShape),
+  control("proxy_list_response", {
+    ...RequestIdShape,
+    proxies: z7.array(ProxyInfoSchema)
+  }),
+  control("proxy_select", { ...RequestIdShape, proxyId: IdSchema }),
+  control("proxy_select_response", {
+    ...RequestIdShape,
+    success: z7.boolean(),
+    proxyId: IdSchema.optional(),
+    ...RequestErrorShape
+  }),
+  control("relay_error", {
+    code: z7.enum(Object.values(RelayErrorCode)),
+    message: z7.string()
+  }),
+  // 客户端注册协议
+  control("client_register", {
+    clientId: IdSchema
+  }),
+  control("client_register_response", {
+    status: z7.enum(["restored", "proxy_offline", "new"]),
+    proxyId: IdSchema.optional()
+  }),
+  // Proxy 离线通知
+  control("proxy_offline", {
+    proxyId: IdSchema
+  }),
+  // Proxy 主动断开，relay 立即清理资源
+  control("proxy_disconnect", {
+    proxyId: IdSchema
+  }),
+  // Proxy 重连后通知 client 恢复
+  control("proxy_online", {
+    proxyId: IdSchema
+  }),
+  // 目录列表请求与响应
+  control("dir_list_request", {
+    proxyId: IdSchema.optional(),
+    ...RequestIdShape,
+    path: z7.string()
+  }, "client_to_proxy"),
+  control("dir_list_response", { ...RequestIdShape, ...RequestErrorShape, entries: z7.array(DirEntrySchema), path: z7.string() }, "proxy_to_client"),
+  // 目录创建请求与响应
+  control("dir_create_request", { ...RequestIdShape, path: z7.string() }, "client_to_proxy"),
+  control("dir_create_response", {
+    ...RequestIdShape,
+    ...RequestErrorShape,
+    path: z7.string(),
+    success: z7.boolean()
+  }, "proxy_to_client"),
+  // 命令列表推送，proxy 将可用命令列表推给 client
+  control("command_list_push", { commands: z7.array(CommandEntrySchema) }, "proxy_to_client"),
+  // 文件树推送: 按目录分组, 首组 path 即为 session cwd
+  // 前端直接把每组写入 tree[path], 与 dir_list_response 共享 cache slot
+  control("file_tree_push", {
+    groups: z7.array(FileTreeGroupSchema)
+  }, "proxy_to_client"),
+  // 会话列表请求与权限模式变更
+  control("session_list", void 0, ["client_to_proxy", "proxy_to_client"]),
+  control("permission_mode_change", {
+    mode: z7.enum(["default", "auto_accept", "plan"]),
+    // sessionId 可选：传入时 proxy 按该会话的 mode 分叉（PTY 发 Tab ANSI），未传走全局日志行为
+    sessionId: IdSchema.optional()
+  }, "client_to_proxy"),
+  // 会话历史浏览
+  control("session_history_request", RequestIdShape, "client_to_proxy"),
+  control("session_history_response", { ...RequestIdShape, sessions: z7.array(HistorySessionSchema) }, "proxy_to_client"),
+  // PTY 语义状态，从 Envelope 迁移到 Control 层
+  control("pty_state", { sessionId: IdSchema, payload: PtyStatePayloadSchema }, "proxy_to_client"),
+  // Provider 语义状态，来自 Claude/Codex hook 等结构化事件，不从 PTY 字节推断
+  control("agent_status", { sessionId: IdSchema, payload: AgentStatusPayloadSchema }, "proxy_to_client"),
+  // 终端标题变化，proxy -> client
+  control("terminal_title", { sessionId: IdSchema, title: z7.string() }, "proxy_to_client"),
+  // 终端尺寸变化，proxy -> client
+  control("terminal_resize", { sessionId: IdSchema, cols: z7.number().int().positive(), rows: z7.number().int().positive() }, "proxy_to_client"),
+  control("terminal_resize_request", { sessionId: IdSchema, cols: z7.number().int().positive(), rows: z7.number().int().positive() }, "client_to_proxy"),
+  // 远程终止 JSON 会话，client -> proxy
+  control("session_terminate", { sessionId: IdSchema }, "client_to_proxy"),
+  // 中断当前 turn，client -> proxy，SIGINT 到 worker 进程让 claude CLI abort 当前流
+  control("session_worker_abort", { sessionId: IdSchema }, "client_to_proxy"),
+  // turn 完成信号，proxy -> client，对应 claude stream-json 的 result 事件
+  control("turn_result", {
+    sessionId: IdSchema,
+    success: z7.boolean(),
+    isError: z7.boolean(),
+    // stream-json result.result 是本轮最终文本。assistant_message 流丢失或 CLI 未发增量时，
+    // Web 用它作为 JSON 模式兜底展示，避免 turn 已结束但界面空白。
+    result: z7.string().optional()
+  }, "proxy_to_client"),
+  // 客户端发送到 PTY 的原始字节（ANSI 序列），不追加换行
+  control("remote_input_raw", { sessionId: IdSchema, data: z7.string() }, "client_to_proxy"),
+  control("clipboard_image_upload", {
+    ...RequestIdShape,
+    sessionId: IdSchema,
+    mimeType: ClipboardImageMimeTypeSchema,
+    dataBase64: z7.string().min(1),
+    fileName: z7.string().optional()
+  }, "client_to_proxy"),
+  control("clipboard_image_upload_response", {
+    ...RequestIdShape,
+    ...RequestErrorShape,
+    sessionId: IdSchema,
+    success: z7.boolean(),
+    // success=false 时 proxy 没有有效 path 可填；保持 optional 以避免占位空字符串通过校验。
+    path: z7.string().optional()
+  }, "proxy_to_client"),
+  control("image_preview_request", {
+    ...RequestIdShape,
+    sessionId: IdSchema,
+    path: z7.string().min(1)
+  }, "client_to_proxy"),
+  control("image_preview_response", {
+    ...RequestIdShape,
+    ...RequestErrorShape,
+    sessionId: IdSchema,
+    success: z7.boolean(),
+    // 同 clipboard_image_upload_response：失败时 proxy 不一定有路径。
+    path: z7.string().optional(),
+    mimeType: ClipboardImageMimeTypeSchema.optional(),
+    dataBase64: z7.string().optional(),
+    size: z7.number().int().nonnegative().optional()
+  }, "proxy_to_client"),
+  // 客户端询问 proxy 的环境信息 (home 路径等), client -> proxy -> response
+  // FilePathPicker 用 homePath 作为 select 模式下的默认起点, 新建会话时打开即可浏览
+  control("proxy_info_request", RequestIdShape, "client_to_proxy"),
+  control("proxy_info", { ...RequestIdShape, homePath: z7.string(), agentCli: AgentCliStatusSchema }, "proxy_to_client"),
+  control("agent_cli_config_update", { ...RequestIdShape, provider: z7.enum(providerValues), path: z7.string().min(1) }, "client_to_proxy"),
+  control("agent_cli_config_update_response", {
+    ...RequestIdShape,
+    provider: z7.enum(providerValues),
+    agentCli: AgentCliStatusSchema.optional(),
+    ...RequestErrorShape
+  }, "proxy_to_client"),
+  // 远程创建 JSON 会话，client -> proxy -> response
+  control("session_create", {
+    ...RequestIdShape,
+    cwd: z7.string(),
+    provider: z7.enum(providerValues),
+    mode: z7.enum(sessionModeValues).optional(),
+    resumeSessionId: z7.string().optional(),
+    // 透传给 claude CLI 的 --permission-mode, undefined 时 proxy 兜底为 "default"
+    permissionMode: z7.enum(["default", "auto", "acceptEdits", "plan", "bypassPermissions", "dontAsk"]).optional()
+  }, "client_to_proxy"),
+  control("session_create_response", {
+    ...RequestIdShape,
+    // 失败路径只送 errorCode/error, sessionId 此时无语义。成功路径才有 id。
+    sessionId: IdSchema.optional(),
+    mode: z7.enum(sessionModeValues).optional(),
+    provider: z7.enum(providerValues).optional(),
+    ptyOwner: z7.enum(ptyOwnerValues).optional(),
+    ...RequestErrorShape
+  }, "proxy_to_client"),
+  // 客户端请求会话历史消息，client -> proxy
+  control("session_messages_request", {
+    ...RequestIdShape,
+    sessionId: IdSchema,
+    limit: z7.number().int().min(1).max(200).optional(),
+    before: z7.string().optional()
+  }, "client_to_proxy"),
+  // 客户端请求会话资源（命令列表 + 文件树），client -> proxy
+  control("session_resources_request", { ...RequestIdShape, sessionId: IdSchema }, "client_to_proxy"),
+  control("session_resources_response", {
+    ...RequestIdShape,
+    ...RequestErrorShape,
+    sessionId: IdSchema,
+    commands: z7.array(CommandEntrySchema),
+    groups: z7.array(FileTreeGroupSchema)
+  }, "proxy_to_client"),
+  // 客户端请求当前 provider 语义状态；不经 relay 缓存，由 proxy 返回当前值
+  control("agent_status_request", { ...RequestIdShape, sessionId: IdSchema.optional() }, "client_to_proxy"),
+  control("agent_status_response", {
+    ...RequestIdShape,
+    statuses: z7.array(z7.object({ sessionId: IdSchema, payload: AgentStatusPayloadSchema }))
+  }, "proxy_to_client"),
+  // 客户端确认已收到审批请求；proxy 只记录送达状态，不把它当成用户决策
+  control("permission_request_delivered", { sessionId: IdSchema, requestId: IdSchema }, "client_to_proxy"),
+  control("tool_approve", { sessionId: IdSchema, payload: ToolApprovePayloadSchema }, "client_to_proxy"),
+  control("tool_deny", { sessionId: IdSchema, payload: ToolDenyPayloadSchema }, "client_to_proxy"),
+  // proxy 确认用户决策已进入 provider/worker 路径；web 用它更新审批卡片状态
+  control("permission_decision_result", {
+    sessionId: IdSchema,
+    requestId: IdSchema,
+    outcome: z7.enum(["allow", "deny"]),
+    delivered: z7.boolean(),
+    message: z7.string().optional()
+  }, "proxy_to_client"),
+  // proxy 推送当前 pending 的工具审批列表，client 据此恢复审批卡片
+  control("pending_approvals_push", {
+    sessionId: IdSchema,
+    approvals: z7.array(z7.object({
+      requestId: IdSchema,
+      toolName: z7.string(),
+      input: z7.record(z7.string(), z7.unknown())
+    }))
+  }, "proxy_to_client"),
+  // 恢复会话时推送历史消息，proxy -> client
+  control("session_history_messages", {
+    ...RequestIdShape,
+    sessionId: IdSchema,
+    before: z7.string().optional(),
+    messages: z7.array(SessionHistoryMessageSchema),
+    hasMore: z7.boolean().optional(),
+    nextBefore: z7.string().optional()
+  }, "proxy_to_client"),
+  // proxy 重连后同步活跃 session 列表给 relay。session_sync 由 relay 自消费（更新 proxy-session
+  // 关联）不转发给 client，因此**没有** direction 标注——RelayControlDirection 只描述转发流。
+  control("session_sync", {
+    sessions: z7.array(z7.object({
+      id: z7.string(),
+      mode: z7.enum(sessionModeValues),
+      provider: z7.enum(providerValues),
+      ptyOwner: z7.enum(ptyOwnerValues).optional(),
+      state: z7.enum(sessionStateValues)
+    }))
+  }),
+  // PTY 会话订阅，client -> proxy，触发 terminal serialize() 返回当前状态
+  control("session_subscribe", { sessionId: IdSchema, requestId: IdSchema.optional() }, "client_to_proxy"),
+  // PTY 会话快照，proxy -> client，serialize() 的全量终端状态
+  control("session_snapshot", {
+    sessionId: IdSchema,
+    cols: z7.number().int().positive(),
+    rows: z7.number().int().positive(),
+    data: z7.string(),
+    outputSeq: z7.number().int().nonnegative(),
+    requestId: IdSchema.optional()
+  }, "proxy_to_client")
+];
+var relayControlSchemas = relayControlDefinitions.map((definition) => definition.schema);
+var RelayControlSchema = z7.discriminatedUnion("type", relayControlSchemas);
+var ProxyToClientRelayControlTypes = new Set(relayControlDefinitions.filter((definition) => definition.directions.has("proxy_to_client")).map((definition) => definition.type));
+var ClientToProxyRelayControlTypes = new Set(relayControlDefinitions.filter((definition) => definition.directions.has("client_to_proxy")).map((definition) => definition.type));
+
+// ../../packages/shared/dist/constants/session.js
+var SessionState = {
+  IDLE: "idle",
+  WORKING: "working",
+  WAITING_APPROVAL: "waiting_approval",
+  ERROR: "error",
+  TERMINATED: "terminated"
+};
+
+// ../../packages/shared/dist/binary-frame.js
+var SID_LEN_BYTES = 1;
+var SEQ_BYTES = 4;
+var HEADER_FIXED_BYTES = SID_LEN_BYTES + SEQ_BYTES;
+function encodeBinaryFrame(sessionId, outputSeq, data) {
+  const sidBytes = new TextEncoder().encode(sessionId);
+  if (sidBytes.length === 0 || sidBytes.length > 255) {
+    throw new RangeError(`sessionId byte length must be 1-255, got ${sidBytes.length} (sessionId=${sessionId})`);
+  }
+  if (!Number.isInteger(outputSeq) || outputSeq < 0 || outputSeq > 4294967295) {
+    throw new RangeError(`outputSeq must be a uint32, got ${outputSeq}`);
+  }
+  const frame = new Uint8Array(SID_LEN_BYTES + sidBytes.length + SEQ_BYTES + data.length);
+  frame[0] = sidBytes.length;
+  frame.set(sidBytes, SID_LEN_BYTES);
+  const seqOffset = SID_LEN_BYTES + sidBytes.length;
+  new DataView(frame.buffer, frame.byteOffset + seqOffset, SEQ_BYTES).setUint32(0, outputSeq, true);
+  frame.set(data, seqOffset + SEQ_BYTES);
+  return frame;
+}
+function decodeBinaryFrame(view) {
+  if (view.length < SID_LEN_BYTES + SEQ_BYTES)
+    return null;
+  const sidLen = view[0];
+  if (sidLen === 0)
+    return null;
+  if (view.length < SID_LEN_BYTES + sidLen + SEQ_BYTES)
+    return null;
+  const sessionId = new TextDecoder().decode(view.subarray(SID_LEN_BYTES, SID_LEN_BYTES + sidLen));
+  const seqOffset = SID_LEN_BYTES + sidLen;
+  const outputSeq = new DataView(view.buffer, view.byteOffset + seqOffset, SEQ_BYTES).getUint32(0, true);
+  const data = view.subarray(seqOffset + SEQ_BYTES);
+  return { sessionId, outputSeq, data };
+}
+
+// src/ipc/ipc-protocol.ts
+import { z as z8 } from "zod";
+
+// src/ipc/line-buffer.ts
+import { Transform } from "stream";
+import { StringDecoder } from "string_decoder";
+var LineBuffer = class extends Transform {
+  buffer = "";
+  decoder = new StringDecoder("utf8");
+  _transform(chunk, _encoding, callback) {
+    this.buffer += typeof chunk === "string" ? chunk : this.decoder.write(chunk);
+    const segments = this.buffer.split("\n");
+    this.buffer = segments.pop();
+    for (const segment of segments) {
+      if (segment.length > 0) {
+        this.push(segment);
+      }
+    }
+    callback();
+  }
+  _flush(callback) {
+    const tail = this.decoder.end();
+    if (tail.length > 0) this.buffer += tail;
+    if (this.buffer.length > 0) {
+      this.push(this.buffer);
+      this.buffer = "";
+    }
+    callback();
+  }
+};
+
+// src/ipc/ipc-protocol.ts
+var IPC_BINARY_MARKER = 0;
+function encodeBinaryIpcFrame(sessionId, data, outputSeq) {
+  const inner = encodeBinaryFrame(sessionId, outputSeq, data);
+  const frame = Buffer.alloc(1 + 4 + inner.length);
+  frame[0] = IPC_BINARY_MARKER;
+  frame.writeUInt32LE(inner.length, 1);
+  frame.set(inner, 5);
+  return frame;
+}
+var sessionStateValues2 = Object.values(SessionState);
+var ProviderHookContextSchema = z8.object({
+  provider: z8.enum(["claude", "codex"]),
+  sessionId: z8.string(),
+  hookUrl: z8.string(),
+  marker: z8.string(),
+  token: z8.string()
+});
+var IpcMessageSchema = z8.discriminatedUnion("type", [
+  // 客户端请求创建新会话，sessionId 可选用于重连时复用
+  z8.object({
+    type: z8.literal("session_create_request"),
+    name: z8.string().optional(),
+    mode: z8.enum(["pty", "json"]),
+    provider: z8.enum(["claude", "codex"]),
+    cwd: z8.string(),
+    pid: z8.number(),
+    sessionId: z8.string().optional()
+  }),
+  // 服务端响应创建会话
+  z8.object({
+    type: z8.literal("session_create_response"),
+    sessionId: z8.string(),
+    error: z8.string().optional(),
+    hook: ProviderHookContextSchema.optional()
+  }),
+  // 客户端请求终止会话
+  z8.object({
+    type: z8.literal("session_terminate_request"),
+    sessionId: z8.string()
+  }),
+  // 服务端响应终止会话
+  z8.object({
+    type: z8.literal("session_terminate_response"),
+    sessionId: z8.string(),
+    success: z8.boolean()
+  }),
+  // 客户端向服务端注册 PTY 会话
+  z8.object({
+    type: z8.literal("pty_register"),
+    sessionId: z8.string(),
+    pid: z8.number()
+  }),
+  // 客户端取消注册 PTY 会话
+  z8.object({
+    type: z8.literal("pty_deregister"),
+    sessionId: z8.string()
+  }),
+  // 输入，从服务端转发到客户端的 PTY stdin（手机远程输入注入）
+  z8.object({
+    type: z8.literal("pty_input"),
+    sessionId: z8.string(),
+    data: z8.string()
+  }),
+  // serve → terminal：Web 端移除本地终端会话时，只断开远程视图，不杀本地 CLI。
+  z8.object({
+    type: z8.literal("pty_detach"),
+    sessionId: z8.string()
+  }),
+  // 服务端广播会话状态变更
+  z8.object({
+    type: z8.literal("session_status_update"),
+    sessionId: z8.string(),
+    state: z8.enum(sessionStateValues2)
+  }),
+  // 错误响应
+  z8.object({
+    type: z8.literal("error"),
+    message: z8.string(),
+    code: z8.string().optional()
+  }),
+  // 客户端请求服务状态（含 relay 连接信息和 worker 状态）
+  z8.object({
+    type: z8.literal("service_status_request")
+  }),
+  // 服务端响应增强版服务状态
+  z8.object({
+    type: z8.literal("service_status_response"),
+    config: z8.object({
+      profile: z8.string().optional(),
+      relayName: z8.string(),
+      relayNameSource: z8.enum(["cli", "profile"]),
+      relayUrl: z8.string().optional(),
+      relayUrlSource: z8.enum(["env", "file", "none"]),
+      relayTokenSource: z8.enum(["env", "file", "none"]),
+      hookPort: z8.number(),
+      hookPortSource: z8.enum(["env", "file", "default"])
+    }),
+    relay: z8.object({
+      connected: z8.boolean(),
+      proxyId: z8.string(),
+      reconnectAttempt: z8.number(),
+      queueDepth: z8.number()
+    }).nullable(),
+    sessions: z8.array(
+      z8.object({
+        id: z8.string(),
+        mode: z8.enum(["pty", "json"]),
+        state: z8.enum(sessionStateValues2),
+        createdAt: z8.string(),
+        name: z8.string().optional(),
+        hasWorker: z8.boolean()
+      })
+    )
+  }),
+  // terminal → serve：终端标题变化，由 xterm onTitleChange 触发
+  z8.object({
+    type: z8.literal("pty_title_change"),
+    sessionId: z8.string(),
+    title: z8.string()
+  }),
+  // terminal → serve：local runtime 观察到的 PTY 语义事件。
+  z8.object({
+    type: z8.literal("pty_semantic_event"),
+    sessionId: z8.string(),
+    state: z8.enum(ptySemanticStateValues),
+    title: z8.string().optional(),
+    tool: z8.string().optional()
+  }),
+  // terminal → serve：终端尺寸变化
+  z8.object({
+    type: z8.literal("pty_resize"),
+    sessionId: z8.string(),
+    cols: z8.number(),
+    rows: z8.number()
+  }),
+  // serve → terminal：请求 HeadlessTerminal serialize() 快照
+  z8.object({
+    type: z8.literal("pty_subscribe"),
+    sessionId: z8.string(),
+    requestId: z8.string().optional()
+  }),
+  // terminal → serve：serialize() 结果
+  z8.object({
+    type: z8.literal("pty_snapshot"),
+    sessionId: z8.string(),
+    cols: z8.number(),
+    rows: z8.number(),
+    data: z8.string(),
+    outputSeq: z8.number().int().nonnegative(),
+    requestId: z8.string().optional()
+  }),
+  // serve → terminal：relay 连接状态变更，供终端给用户显示 remote viewing 是否通畅
+  z8.object({
+    type: z8.literal("bridge_status"),
+    connected: z8.boolean()
+  })
+]);
+var WorkerMessageSchema = z8.discriminatedUnion("type", [
+  // serve → worker: 发送用户输入给 claude
+  z8.object({
+    type: z8.literal("worker_input"),
+    content: z8.string()
+  }),
+  // serve → worker: 停止 claude 进程
+  z8.object({
+    type: z8.literal("worker_stop")
+  }),
+  // serve → worker: 工具审批响应
+  z8.object({
+    type: z8.literal("worker_approval_response"),
+    requestId: z8.string(),
+    behavior: z8.enum(["allow", "deny"]),
+    message: z8.string().optional()
+  }),
+  // worker → serve: claude 输出事件（带序列号）
+  z8.object({
+    type: z8.literal("worker_event"),
+    seq: z8.number(),
+    event: z8.record(z8.string(), z8.unknown())
+  }),
+  // worker → serve: claude 进程退出
+  z8.object({
+    type: z8.literal("worker_exit"),
+    code: z8.number()
+  }),
+  // worker → serve: 工具审批请求
+  z8.object({
+    type: z8.literal("worker_approval_request"),
+    requestId: z8.string(),
+    toolName: z8.string(),
+    input: z8.record(z8.string(), z8.unknown())
+  }),
+  // worker → serve: worker 就绪，claude 已启动
+  z8.object({
+    type: z8.literal("worker_ready"),
+    pid: z8.number()
+  }),
+  // worker → serve: 从 stream-json 的 system.init 事件捕获 Claude CLI 侧的 session ID
+  // proxy 拿它来读 ~/.claude/projects/.../<id>.jsonl 历史或后续 --resume
+  z8.object({
+    type: z8.literal("worker_claude_session_id"),
+    sessionId: z8.string()
+  }),
+  // serve → worker: 将指定工具加入会话白名单，后续同名工具自动审批
+  z8.object({
+    type: z8.literal("worker_whitelist_add"),
+    toolName: z8.string()
+  })
+]);
+function serializeWorkerMsg(msg) {
+  return JSON.stringify(msg) + "\n";
+}
+function createWorkerReader(stream, onMessage, onProtocolError) {
+  const lineBuffer = new LineBuffer();
+  lineBuffer.on("data", (line) => {
+    const str = typeof line === "string" ? line : line.toString();
+    if (str.length === 0) return;
+    try {
+      const raw = JSON.parse(str);
+      const result = WorkerMessageSchema.safeParse(raw);
+      if (result.success) {
+        onMessage(result.data);
+      } else {
+        onProtocolError?.(
+          new Error(`Worker message validation failed: ${result.error.message}`),
+          str
+        );
+      }
+    } catch (err) {
+      onProtocolError?.(new Error("Worker message parse error", { cause: err }), str);
+    }
+  });
+  stream.pipe(lineBuffer);
+}
+function serializeIpc(msg) {
+  return JSON.stringify(msg) + "\n";
+}
+function createIpcReader(stream, onMessage, onBinaryFrame, onProtocolError) {
+  let buf = Buffer.alloc(0);
+  let disposed = false;
+  function drain() {
+    while (buf.length > 0) {
+      if (buf[0] === IPC_BINARY_MARKER) {
+        if (buf.length < 5) return;
+        const payloadLen = buf.readUInt32LE(1);
+        const totalFrameLen = 1 + 4 + payloadLen;
+        if (buf.length < totalFrameLen) return;
+        const decoded = decodeBinaryFrame(buf.subarray(5, totalFrameLen));
+        if (decoded && onBinaryFrame) {
+          onBinaryFrame(decoded.sessionId, Buffer.from(decoded.data), decoded.outputSeq);
+        }
+        buf = buf.subarray(totalFrameLen);
+      } else {
+        const newlineIdx = buf.indexOf(10);
+        if (newlineIdx === -1) return;
+        const line = buf.subarray(0, newlineIdx).toString("utf-8");
+        buf = buf.subarray(newlineIdx + 1);
+        if (line.length === 0) continue;
+        try {
+          const raw = JSON.parse(line);
+          const result = IpcMessageSchema.safeParse(raw);
+          if (result.success) {
+            onMessage(result.data);
+          } else {
+            onProtocolError?.(
+              new Error(`IPC message validation failed: ${result.error.message}`),
+              line
+            );
+          }
+        } catch (err) {
+          onProtocolError?.(new Error("IPC message parse error", { cause: err }), line);
+        }
+      }
+    }
+  }
+  function onData(chunk) {
+    if (disposed) return;
+    const incoming = typeof chunk === "string" ? Buffer.from(chunk) : chunk;
+    buf = Buffer.concat([buf, incoming]);
+    drain();
+  }
+  stream.on("data", onData);
+  return () => {
+    disposed = true;
+    stream.off("data", onData);
+  };
+}
+
+export {
+  providerValues,
+  MessageEnvelopeSchema,
+  buildMessage,
+  serializeControl,
+  ControlErrorCode,
+  RelayControlSchema,
+  SessionState,
+  encodeBinaryFrame,
+  createFSM,
+  defineFSM,
+  LineBuffer,
+  encodeBinaryIpcFrame,
+  serializeWorkerMsg,
+  createWorkerReader,
+  serializeIpc,
+  createIpcReader
+};
+//# sourceMappingURL=chunk-NBRBO5GS.js.map