@dev-anywhere/proxy 0.0.1

package/dist/chunk-QJ5CQDK7.js

@@ -0,0 +1,1038 @@
+#!/usr/bin/env node
+
+// src/common/paths.ts
+import { cpSync, existsSync, mkdirSync, writeFileSync } from "fs";
+import { homedir } from "os";
+import { dirname, resolve } from "path";
+import { fileURLToPath } from "url";
+var HOME = homedir();
+var APP_DIR = `${HOME}/.dev-anywhere`;
+var MODULE_DIR = dirname(fileURLToPath(import.meta.url));
+var SOURCE_FONT_ASSETS_DIR = resolve(MODULE_DIR, "../../assets/fonts");
+var DIST_FONT_ASSETS_DIR = resolve(MODULE_DIR, "../assets/fonts");
+var DEFAULT_FONT_FAMILY = "sarasa-fixed-sc";
+function tildify(cwd) {
+  return HOME ? cwd.replace(HOME, "~") : cwd;
+}
+var CONFIG_PATH = `${APP_DIR}/config.json`;
+var RUN_DIR = `${APP_DIR}/run`;
+var SOCK_PATH = `${RUN_DIR}/dev-anywhere.sock`;
+var PID_PATH = `${RUN_DIR}/dev-anywhere.pid`;
+var STOPPED_PATH = `${RUN_DIR}/stopped`;
+var DESIRED_ENV_PATH = `${RUN_DIR}/desired-env`;
+var STATE_DIR = `${APP_DIR}/state`;
+var SESSIONS_PATH = `${STATE_DIR}/sessions.json`;
+var DATA_DIR = `${APP_DIR}/data`;
+var RELAY_DATA_DIR = `${APP_DIR}/relay-data`;
+var FONT_DIR = `${RELAY_DATA_DIR}/fonts`;
+var LOG_DIR = `${APP_DIR}/logs`;
+var SERVICE_LOG_PATH = `${LOG_DIR}/service.log`;
+function sessionDir(sessionId) {
+  return `${DATA_DIR}/${sessionId}`;
+}
+function sessionPaths(sessionId) {
+  const dir = sessionDir(sessionId);
+  return {
+    dir,
+    workerSock: `${dir}/worker.sock`
+  };
+}
+function isInitialized() {
+  return existsSync(CONFIG_PATH);
+}
+var DEFAULT_CONFIG = `{
+  "defaultEnv": "local",
+  "envs": {
+    "local": {
+      "relayUrl": "ws://localhost:3100"
+    },
+    "cloud": {
+      "relayUrl": "wss://dev-anywhere.vita-tools.top",
+      "relayToken": ""
+    }
+  }
+}
+`;
+function copyFontFamilyIfMissing(targetFontsDir, source) {
+  const family = source.family ?? DEFAULT_FONT_FAMILY;
+  const sourceFamilyDir = `${source.dir}/${family}`;
+  const targetFamilyDir = `${targetFontsDir}/${family}`;
+  if (existsSync(targetFamilyDir) || !existsSync(sourceFamilyDir)) return false;
+  mkdirSync(targetFontsDir, { recursive: true });
+  cpSync(sourceFamilyDir, targetFamilyDir, { recursive: true });
+  return true;
+}
+function installFontAssetsFromSources(targetFontsDir, sources) {
+  for (const source of sources) {
+    if (copyFontFamilyIfMissing(targetFontsDir, source)) return true;
+  }
+  return false;
+}
+function installFontAssets() {
+  installFontAssetsFromSources(FONT_DIR, [
+    { dir: SOURCE_FONT_ASSETS_DIR, family: DEFAULT_FONT_FAMILY },
+    { dir: DIST_FONT_ASSETS_DIR, family: DEFAULT_FONT_FAMILY }
+  ]);
+}
+function initWorkspace() {
+  mkdirSync(RUN_DIR, { recursive: true });
+  mkdirSync(STATE_DIR, { recursive: true });
+  mkdirSync(DATA_DIR, { recursive: true });
+  mkdirSync(RELAY_DATA_DIR, { recursive: true });
+  mkdirSync(LOG_DIR, { recursive: true });
+  installFontAssets();
+  if (!existsSync(CONFIG_PATH)) {
+    writeFileSync(CONFIG_PATH, DEFAULT_CONFIG);
+  }
+}
+
+// ../../packages/shared/dist/schemas/envelope.js
+import { z as z5 } from "zod";
+
+// ../../packages/shared/dist/schemas/chat.js
+import { z } from "zod";
+var UserInputPayloadSchema = z.object({
+  text: z.string().min(1)
+});
+var AssistantMessagePayloadSchema = z.object({
+  text: z.string(),
+  isPartial: z.boolean()
+});
+var ThinkingPayloadSchema = z.object({
+  text: z.string()
+});
+
+// ../../packages/shared/dist/schemas/tool.js
+import { z as z2 } from "zod";
+var ToolUseRequestPayloadSchema = z2.object({
+  toolName: z2.string(),
+  toolId: z2.string(),
+  parameters: z2.record(z2.string(), z2.unknown())
+});
+var ToolApprovePayloadSchema = z2.object({
+  toolId: z2.string(),
+  whitelistTool: z2.boolean().optional()
+});
+var ToolDenyPayloadSchema = z2.object({
+  toolId: z2.string(),
+  reason: z2.string().optional()
+});
+var ToolResultPayloadSchema = z2.object({
+  toolId: z2.string(),
+  result: z2.unknown(),
+  isError: z2.boolean()
+});
+
+// ../../packages/shared/dist/schemas/session.js
+import { z as z3 } from "zod";
+var sessionStateValues = ["idle", "working", "waiting_approval", "error", "terminated"];
+var providerValues = ["claude", "codex"];
+var ptyOwnerValues = ["local-terminal", "proxy-hosted"];
+var agentStatusPhaseValues = [
+  "idle",
+  "thinking",
+  "tool_use",
+  "outputting",
+  "waiting_permission",
+  "error"
+];
+var SessionInfoSchema = z3.object({
+  sessionId: z3.string(),
+  name: z3.string().optional(),
+  state: z3.enum(sessionStateValues),
+  mode: z3.enum(["pty", "json"]).optional(),
+  provider: z3.enum(providerValues),
+  // PTY 尺寸所有权:
+  // - local-terminal: 本地 terminal 进程持有真实 PTY，Web 只按原始 cols/rows 展示
+  // - proxy-hosted: serve 内托管 PTY，Web 可按视口请求 resize
+  ptyOwner: z3.enum(ptyOwnerValues).optional(),
+  lastActive: z3.number().optional()
+});
+var SessionCreatePayloadSchema = z3.object({
+  name: z3.string().optional(),
+  cwd: z3.string().optional(),
+  streamDelta: z3.boolean().optional()
+});
+var SessionListPayloadSchema = z3.object({
+  sessions: z3.array(SessionInfoSchema)
+});
+var SessionSwitchPayloadSchema = z3.object({
+  sessionId: z3.string()
+});
+var SessionTerminatePayloadSchema = z3.object({
+  sessionId: z3.string()
+});
+var SessionStatusPayloadSchema = z3.object({
+  sessionId: z3.string(),
+  state: z3.enum(sessionStateValues),
+  lastActive: z3.number()
+});
+var PtyStatePayloadSchema = z3.object({
+  state: z3.enum(["working", "turn_complete", "approval_wait", "mid_pause"]),
+  title: z3.string().optional(),
+  tool: z3.string().optional()
+});
+var AgentStatusPayloadSchema = z3.object({
+  provider: z3.enum(providerValues),
+  phase: z3.enum(agentStatusPhaseValues),
+  seq: z3.number().int().nonnegative(),
+  updatedAt: z3.number(),
+  toolName: z3.string().optional(),
+  toolInput: z3.record(z3.string(), z3.unknown()).optional(),
+  permissionRequest: z3.object({
+    requestId: z3.string(),
+    toolName: z3.string(),
+    input: z3.record(z3.string(), z3.unknown())
+  }).optional(),
+  permissionResolution: z3.object({
+    requestId: z3.string(),
+    outcome: z3.enum(["allow", "deny"])
+  }).optional(),
+  summary: z3.string().optional()
+});
+
+// ../../packages/shared/dist/schemas/system.js
+import { z as z4 } from "zod";
+var HeartbeatPayloadSchema = z4.object({});
+var AuthPayloadSchema = z4.object({
+  pairingCode: z4.string().optional(),
+  token: z4.string().optional()
+});
+var SyncRequestPayloadSchema = z4.object({
+  lastSeq: z4.number().int().nonnegative()
+});
+var SyncResponsePayloadSchema = z4.object({
+  messages: z4.array(z4.record(z4.string(), z4.unknown()))
+});
+
+// ../../packages/shared/dist/schemas/envelope.js
+var BaseEnvelopeFields = {
+  seq: z5.number().int().nonnegative(),
+  sessionId: z5.string(),
+  timestamp: z5.number(),
+  source: z5.enum(["proxy", "client"]),
+  version: z5.string()
+};
+var MessageEnvelopeSchema = z5.discriminatedUnion("type", [
+  // chat (3)
+  z5.object({
+    ...BaseEnvelopeFields,
+    type: z5.literal("user_input"),
+    payload: UserInputPayloadSchema
+  }),
+  z5.object({
+    ...BaseEnvelopeFields,
+    type: z5.literal("assistant_message"),
+    payload: AssistantMessagePayloadSchema
+  }),
+  z5.object({
+    ...BaseEnvelopeFields,
+    type: z5.literal("thinking"),
+    payload: ThinkingPayloadSchema
+  }),
+  // tool (4): 工具审批决策属于 relay control，不进入会话消息信封。
+  // tool_use_request: 审批流请求（proxy → client），toolId 是 approval requestId
+  z5.object({
+    ...BaseEnvelopeFields,
+    type: z5.literal("tool_use_request"),
+    payload: ToolUseRequestPayloadSchema
+  }),
+  // tool_result: 工具执行结果（proxy → client），toolId 对应 assistant_tool_use / tool_use_request 的 toolId
+  z5.object({
+    ...BaseEnvelopeFields,
+    type: z5.literal("tool_result"),
+    payload: ToolResultPayloadSchema
+  }),
+  // assistant_tool_use: 纯展示型工具调用（proxy → client），区别于 tool_use_request 无审批语义
+  // payload 结构复用 ToolUseRequestPayloadSchema；toolId 是 Claude 分配的 tool_use id
+  z5.object({
+    ...BaseEnvelopeFields,
+    type: z5.literal("assistant_tool_use"),
+    payload: ToolUseRequestPayloadSchema
+  }),
+  // session (5)
+  z5.object({
+    ...BaseEnvelopeFields,
+    type: z5.literal("session_create"),
+    payload: SessionCreatePayloadSchema
+  }),
+  z5.object({
+    ...BaseEnvelopeFields,
+    type: z5.literal("session_list"),
+    payload: SessionListPayloadSchema
+  }),
+  z5.object({
+    ...BaseEnvelopeFields,
+    type: z5.literal("session_switch"),
+    payload: SessionSwitchPayloadSchema
+  }),
+  z5.object({
+    ...BaseEnvelopeFields,
+    type: z5.literal("session_terminate"),
+    payload: SessionTerminatePayloadSchema
+  }),
+  z5.object({
+    ...BaseEnvelopeFields,
+    type: z5.literal("session_status"),
+    payload: SessionStatusPayloadSchema
+  }),
+  // system (5)
+  z5.object({
+    ...BaseEnvelopeFields,
+    type: z5.literal("heartbeat"),
+    payload: HeartbeatPayloadSchema
+  }),
+  z5.object({
+    ...BaseEnvelopeFields,
+    type: z5.literal("auth"),
+    payload: AuthPayloadSchema
+  }),
+  z5.object({
+    ...BaseEnvelopeFields,
+    type: z5.literal("sync_request"),
+    payload: SyncRequestPayloadSchema
+  }),
+  z5.object({
+    ...BaseEnvelopeFields,
+    type: z5.literal("sync_response"),
+    payload: SyncResponsePayloadSchema
+  })
+]);
+
+// ../../packages/shared/dist/builders/index.js
+function buildMessage(type, sessionId, seq, payload, source) {
+  const envelope = {
+    seq,
+    sessionId,
+    type,
+    payload,
+    timestamp: Date.now(),
+    source,
+    version: "1.0"
+  };
+  return MessageEnvelopeSchema.parse(envelope);
+}
+
+// ../../packages/shared/dist/schemas/relay-control.js
+import { z as z6 } from "zod";
+
+// ../../packages/shared/dist/constants/relay-errors.js
+var RelayErrorCode = {
+  NOT_REGISTERED: "NOT_REGISTERED",
+  NOT_BOUND: "NOT_BOUND",
+  PROXY_OFFLINE: "PROXY_OFFLINE",
+  INVALID_MESSAGE: "INVALID_MESSAGE",
+  UNSUPPORTED: "UNSUPPORTED",
+  INVALID_RANGE: "INVALID_RANGE"
+};
+
+// ../../packages/shared/dist/constants/control-errors.js
+var ControlErrorCode = {
+  INVALID_PATH: "INVALID_PATH",
+  PATH_NOT_FOUND: "PATH_NOT_FOUND",
+  PATH_NOT_DIRECTORY: "PATH_NOT_DIRECTORY",
+  PATH_ACCESS_DENIED: "PATH_ACCESS_DENIED",
+  PROXY_OFFLINE: "PROXY_OFFLINE",
+  SESSION_NOT_FOUND: "SESSION_NOT_FOUND",
+  PROVIDER_UNSUPPORTED: "PROVIDER_UNSUPPORTED",
+  WORKER_START_FAILED: "WORKER_START_FAILED",
+  PROCESS_START_FAILED: "PROCESS_START_FAILED",
+  UNKNOWN: "UNKNOWN"
+};
+
+// ../../packages/shared/dist/schemas/relay-control.js
+var ProxyInfoSchema = z6.object({
+  proxyId: z6.string(),
+  name: z6.string().optional(),
+  online: z6.boolean(),
+  sessions: z6.array(z6.string()).optional()
+});
+var AgentCliAvailabilitySchema = z6.object({
+  available: z6.boolean(),
+  command: z6.string().optional(),
+  error: z6.string().optional(),
+  suggestions: z6.array(z6.string()).optional()
+});
+var AgentCliStatusSchema = z6.object({
+  claude: AgentCliAvailabilitySchema,
+  codex: AgentCliAvailabilitySchema
+});
+var DirEntrySchema = z6.object({ name: z6.string(), isDir: z6.boolean() });
+var FileTreeGroupSchema = z6.object({
+  path: z6.string(),
+  entries: z6.array(DirEntrySchema)
+});
+var CommandEntrySchema = z6.object({
+  name: z6.string(),
+  description: z6.string(),
+  argumentHint: z6.string().optional(),
+  source: z6.string()
+});
+var HistorySessionSchema = z6.object({
+  id: z6.string(),
+  title: z6.string(),
+  projectDir: z6.string(),
+  updatedAt: z6.number(),
+  provider: z6.enum(["claude", "codex"]).optional()
+});
+var RequestIdShape = { requestId: z6.string().min(1).optional() };
+var ControlErrorCodeSchema = z6.enum(Object.values(ControlErrorCode));
+var RequestErrorShape = {
+  error: z6.string().optional(),
+  errorCode: ControlErrorCodeSchema.optional()
+};
+function control(type, shape, directions) {
+  return {
+    type,
+    directions: new Set(Array.isArray(directions) ? directions : directions ? [directions] : []),
+    schema: z6.object({
+      type: z6.literal(type),
+      ...shape ?? {}
+    })
+  };
+}
+var relayControlDefinitions = [
+  control("proxy_register", {
+    proxyId: z6.string().min(1),
+    name: z6.string().optional()
+  }),
+  control("proxy_register_response", {
+    status: z6.enum(["new", "reconnected"])
+  }),
+  control("proxy_list_request", RequestIdShape),
+  control("proxy_list_response", {
+    ...RequestIdShape,
+    proxies: z6.array(ProxyInfoSchema)
+  }),
+  control("proxy_select", { ...RequestIdShape, proxyId: z6.string().min(1) }),
+  control("proxy_select_response", {
+    ...RequestIdShape,
+    success: z6.boolean(),
+    proxyId: z6.string().optional(),
+    ...RequestErrorShape
+  }),
+  control("relay_error", {
+    code: z6.enum(Object.values(RelayErrorCode)),
+    message: z6.string()
+  }),
+  // 客户端注册协议
+  control("client_register", {
+    clientId: z6.string().min(1)
+  }),
+  control("client_register_response", {
+    status: z6.enum(["restored", "proxy_offline", "new"]),
+    proxyId: z6.string().optional()
+  }),
+  // Proxy 离线通知
+  control("proxy_offline", {
+    proxyId: z6.string()
+  }),
+  // Proxy 主动断开，relay 立即清理资源
+  control("proxy_disconnect", {
+    proxyId: z6.string().min(1)
+  }),
+  // Proxy 重连后通知 client 恢复
+  control("proxy_online", {
+    proxyId: z6.string().min(1)
+  }),
+  // 目录列表请求与响应
+  control("dir_list_request", {
+    proxyId: z6.string().min(1).optional(),
+    ...RequestIdShape,
+    path: z6.string()
+  }, "client_to_proxy"),
+  control("dir_list_response", { ...RequestIdShape, ...RequestErrorShape, entries: z6.array(DirEntrySchema), path: z6.string() }, "proxy_to_client"),
+  // 目录创建请求与响应
+  control("dir_create_request", { ...RequestIdShape, path: z6.string() }, "client_to_proxy"),
+  control("dir_create_response", {
+    ...RequestIdShape,
+    ...RequestErrorShape,
+    path: z6.string(),
+    success: z6.boolean()
+  }, "proxy_to_client"),
+  // 命令列表推送，proxy 将可用命令列表推给 client
+  control("command_list_push", { commands: z6.array(CommandEntrySchema) }, "proxy_to_client"),
+  // 文件树推送: 按目录分组, 首组 path 即为 session cwd
+  // 前端直接把每组写入 tree[path], 与 dir_list_response 共享 cache slot
+  control("file_tree_push", {
+    groups: z6.array(FileTreeGroupSchema)
+  }, "proxy_to_client"),
+  // 会话列表请求与权限模式变更
+  control("session_list", void 0, ["client_to_proxy", "proxy_to_client"]),
+  control("permission_mode_change", {
+    mode: z6.enum(["default", "auto_accept", "plan"]),
+    // sessionId 可选：传入时 proxy 按该会话的 mode 分叉（PTY 发 Tab ANSI），未传走全局日志行为
+    sessionId: z6.string().optional()
+  }, "client_to_proxy"),
+  // 会话历史浏览
+  control("session_history_request", RequestIdShape, "client_to_proxy"),
+  control("session_history_response", { ...RequestIdShape, sessions: z6.array(HistorySessionSchema) }, "proxy_to_client"),
+  // PTY 语义状态，从 Envelope 迁移到 Control 层
+  control("pty_state", { sessionId: z6.string(), payload: PtyStatePayloadSchema }, "proxy_to_client"),
+  // Provider 语义状态，来自 Claude/Codex hook 等结构化事件，不从 PTY 字节推断
+  control("agent_status", { sessionId: z6.string(), payload: AgentStatusPayloadSchema }, "proxy_to_client"),
+  // 终端标题变化，proxy -> client
+  control("terminal_title", { sessionId: z6.string(), title: z6.string() }, "proxy_to_client"),
+  // 终端尺寸变化，proxy -> client
+  control("terminal_resize", { sessionId: z6.string(), cols: z6.number().int().positive(), rows: z6.number().int().positive() }, "proxy_to_client"),
+  control("terminal_resize_request", { sessionId: z6.string(), cols: z6.number().int().positive(), rows: z6.number().int().positive() }, "client_to_proxy"),
+  // 远程终止 JSON 会话，client -> proxy
+  control("session_terminate", { sessionId: z6.string() }, "client_to_proxy"),
+  // 中断当前 turn，client -> proxy，SIGINT 到 worker 进程让 claude CLI abort 当前流
+  control("session_worker_abort", { sessionId: z6.string() }, "client_to_proxy"),
+  // turn 完成信号，proxy -> client，对应 claude stream-json 的 result 事件
+  control("turn_result", {
+    sessionId: z6.string(),
+    success: z6.boolean(),
+    isError: z6.boolean(),
+    // stream-json result.result 是本轮最终文本。assistant_message 流丢失或 CLI 未发增量时，
+    // Web 用它作为 JSON 模式兜底展示，避免 turn 已结束但界面空白。
+    result: z6.string().optional()
+  }, "proxy_to_client"),
+  // 客户端发送到 PTY 的原始字节（ANSI 序列），不追加换行
+  control("remote_input_raw", { sessionId: z6.string().min(1), data: z6.string() }, "client_to_proxy"),
+  // 客户端询问 proxy 的环境信息 (home 路径等), client -> proxy -> response
+  // FilePathPicker 用 homePath 作为 select 模式下的默认起点, 新建会话时打开即可浏览
+  control("proxy_info_request", RequestIdShape, "client_to_proxy"),
+  control("proxy_info", { ...RequestIdShape, homePath: z6.string(), agentCli: AgentCliStatusSchema }, "proxy_to_client"),
+  control("agent_cli_config_update", { ...RequestIdShape, provider: z6.enum(["claude", "codex"]), path: z6.string().min(1) }, "client_to_proxy"),
+  control("agent_cli_config_update_response", {
+    ...RequestIdShape,
+    provider: z6.enum(["claude", "codex"]),
+    agentCli: AgentCliStatusSchema.optional(),
+    ...RequestErrorShape
+  }, "proxy_to_client"),
+  // 远程创建 JSON 会话，client -> proxy -> response
+  control("session_create", {
+    ...RequestIdShape,
+    cwd: z6.string(),
+    provider: z6.enum(["claude", "codex"]),
+    mode: z6.enum(["json", "pty"]).optional(),
+    resumeSessionId: z6.string().optional(),
+    // 透传给 claude CLI 的 --permission-mode, undefined 时 proxy 兜底为 "default"
+    permissionMode: z6.enum(["default", "auto", "acceptEdits", "plan", "bypassPermissions", "dontAsk"]).optional()
+  }, "client_to_proxy"),
+  control("session_create_response", {
+    ...RequestIdShape,
+    sessionId: z6.string(),
+    mode: z6.enum(["json", "pty"]).optional(),
+    provider: z6.enum(["claude", "codex"]).optional(),
+    ptyOwner: z6.enum(["local-terminal", "proxy-hosted"]).optional(),
+    ...RequestErrorShape
+  }, "proxy_to_client"),
+  // 客户端请求会话历史消息，client -> proxy
+  control("session_messages_request", { ...RequestIdShape, sessionId: z6.string() }, "client_to_proxy"),
+  // 客户端请求会话资源（命令列表 + 文件树），client -> proxy
+  control("session_resources_request", { ...RequestIdShape, sessionId: z6.string() }, "client_to_proxy"),
+  control("session_resources_response", {
+    ...RequestIdShape,
+    ...RequestErrorShape,
+    sessionId: z6.string(),
+    commands: z6.array(CommandEntrySchema),
+    groups: z6.array(FileTreeGroupSchema)
+  }, "proxy_to_client"),
+  // 客户端请求当前 provider 语义状态；不经 relay 缓存，由 proxy 返回当前值
+  control("agent_status_request", { ...RequestIdShape, sessionId: z6.string().optional() }, "client_to_proxy"),
+  control("agent_status_response", {
+    ...RequestIdShape,
+    statuses: z6.array(z6.object({ sessionId: z6.string(), payload: AgentStatusPayloadSchema }))
+  }, "proxy_to_client"),
+  // 客户端确认已收到审批请求；proxy 只记录送达状态，不把它当成用户决策
+  control("permission_request_delivered", { sessionId: z6.string(), requestId: z6.string() }, "client_to_proxy"),
+  control("tool_approve", { sessionId: z6.string(), payload: ToolApprovePayloadSchema }, "client_to_proxy"),
+  control("tool_deny", { sessionId: z6.string(), payload: ToolDenyPayloadSchema }, "client_to_proxy"),
+  // proxy 确认用户决策已进入 provider/worker 路径；web 用它更新审批卡片状态
+  control("permission_decision_result", {
+    sessionId: z6.string(),
+    requestId: z6.string(),
+    outcome: z6.enum(["allow", "deny"]),
+    delivered: z6.boolean(),
+    message: z6.string().optional()
+  }, "proxy_to_client"),
+  // proxy 推送当前 pending 的工具审批列表，client 据此恢复审批卡片
+  control("pending_approvals_push", {
+    sessionId: z6.string(),
+    approvals: z6.array(z6.object({
+      requestId: z6.string(),
+      toolName: z6.string(),
+      input: z6.record(z6.string(), z6.unknown())
+    }))
+  }, "proxy_to_client"),
+  // 恢复会话时推送历史消息，proxy -> client
+  control("session_history_messages", {
+    ...RequestIdShape,
+    sessionId: z6.string(),
+    messages: z6.array(z6.object({
+      role: z6.enum(["user", "assistant"]),
+      text: z6.string(),
+      timestamp: z6.number().optional()
+    }))
+  }, "proxy_to_client"),
+  // proxy 重连后同步活跃 session 列表给 relay
+  control("session_sync", {
+    sessions: z6.array(z6.object({
+      id: z6.string(),
+      mode: z6.enum(["pty", "json"]),
+      provider: z6.enum(["claude", "codex"]),
+      ptyOwner: z6.enum(["local-terminal", "proxy-hosted"]).optional(),
+      state: z6.string()
+    }))
+  }),
+  // PTY 会话订阅，client -> proxy，触发 terminal serialize() 返回当前状态
+  control("session_subscribe", { sessionId: z6.string(), requestId: z6.string().optional() }, "client_to_proxy"),
+  // PTY 会话快照，proxy -> client，serialize() 的全量终端状态
+  control("session_snapshot", {
+    sessionId: z6.string(),
+    cols: z6.number().int().positive(),
+    rows: z6.number().int().positive(),
+    data: z6.string(),
+    outputSeq: z6.number().int().nonnegative(),
+    requestId: z6.string().optional()
+  }, "proxy_to_client")
+];
+var relayControlSchemas = relayControlDefinitions.map((definition) => definition.schema);
+var RelayControlSchema = z6.discriminatedUnion("type", relayControlSchemas);
+var ProxyToClientRelayControlTypes = new Set(relayControlDefinitions.filter((definition) => definition.directions.has("proxy_to_client")).map((definition) => definition.type));
+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/logger.js
+import { lstatSync, mkdirSync as mkdirSync2, readdirSync, renameSync, statSync, symlinkSync, unlinkSync } from "fs";
+import { homedir as homedir2 } from "os";
+import { basename, join } from "path";
+import pino from "pino";
+var DEFAULT_LOG_DIR = `${homedir2()}/.dev-anywhere/logs`;
+var DEFAULT_LOG_RETENTION = 50;
+var PROCESS_LOG_RUN_ID = sanitizeRunId(process.env.DEV_ANYWHERE_LOG_RUN_ID ?? `${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-")}-${process.pid}`);
+function sanitizeRunId(runId) {
+  return runId.replace(/[^a-zA-Z0-9._-]/g, "_");
+}
+function linkLatestLog(logDir, name, filePath, runId) {
+  const latestPath = join(logDir, `${name}.log`);
+  try {
+    const stat = lstatSync(latestPath);
+    if (stat.isSymbolicLink()) {
+      unlinkSync(latestPath);
+    } else {
+      renameSync(latestPath, join(logDir, `${name}-legacy-${runId}.log`));
+    }
+  } catch (err) {
+    const code = err.code;
+    if (code !== "ENOENT")
+      return;
+  }
+  try {
+    symlinkSync(basename(filePath), latestPath);
+  } catch {
+  }
+}
+function resolveRetention() {
+  const raw = process.env.DEV_ANYWHERE_LOG_RETENTION;
+  if (!raw)
+    return DEFAULT_LOG_RETENTION;
+  const parsed = Number.parseInt(raw, 10);
+  return Number.isFinite(parsed) && parsed >= 0 ? parsed : DEFAULT_LOG_RETENTION;
+}
+function pruneOldLogs(logDir, name, currentFilePath) {
+  const keep = resolveRetention();
+  if (keep === 0)
+    return;
+  const currentFileName = basename(currentFilePath);
+  const prefix = `${name}-`;
+  const candidates = readdirSync(logDir).filter((entry) => entry.startsWith(prefix) && entry.endsWith(".log") && entry !== currentFileName).map((entry) => {
+    const path = join(logDir, entry);
+    try {
+      return { path, mtimeMs: statSync(path).mtimeMs };
+    } catch {
+      return null;
+    }
+  }).filter((entry) => entry !== null).sort((a, b) => b.mtimeMs - a.mtimeMs);
+  for (const stale of candidates.slice(Math.max(0, keep - 1))) {
+    try {
+      unlinkSync(stale.path);
+    } catch {
+    }
+  }
+}
+function createLogger(options) {
+  const { name, level = "info", logDir = DEFAULT_LOG_DIR, stdout = false, silent = false } = options;
+  if (silent) {
+    return pino({ level: "silent" });
+  }
+  mkdirSync2(logDir, { recursive: true });
+  const runId = PROCESS_LOG_RUN_ID;
+  const filePath = join(logDir, `${name}-${runId}.log`);
+  linkLatestLog(logDir, name, filePath, runId);
+  pruneOldLogs(logDir, name, filePath);
+  const streams = [{ stream: pino.destination(filePath) }];
+  if (stdout) {
+    streams.unshift({ stream: process.stdout });
+  }
+  return pino({ level }, pino.multistream(streams));
+}
+
+// src/ipc/ipc-protocol.ts
+import { z as z7 } from "zod";
+
+// src/ipc/line-buffer.ts
+import { Transform } from "stream";
+var LineBuffer = class extends Transform {
+  buffer = "";
+  _transform(chunk, _encoding, callback) {
+    this.buffer += typeof chunk === "string" ? chunk : chunk.toString();
+    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) {
+    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 sessionIdBuf = Buffer.from(sessionId, "utf-8");
+  const payloadLen = 1 + sessionIdBuf.length + 4 + data.length;
+  const frame = Buffer.alloc(1 + 4 + payloadLen);
+  let offset = 0;
+  frame[offset] = IPC_BINARY_MARKER;
+  offset += 1;
+  frame.writeUInt32LE(payloadLen, offset);
+  offset += 4;
+  frame[offset] = sessionIdBuf.length;
+  offset += 1;
+  sessionIdBuf.copy(frame, offset);
+  offset += sessionIdBuf.length;
+  frame.writeUInt32LE(outputSeq, offset);
+  offset += 4;
+  data.copy(frame, offset);
+  return frame;
+}
+var sessionStateValues2 = Object.values(SessionState);
+var ProviderHookContextSchema = z7.object({
+  provider: z7.enum(["claude", "codex"]),
+  sessionId: z7.string(),
+  hookUrl: z7.string(),
+  marker: z7.string(),
+  token: z7.string()
+});
+var IpcMessageSchema = z7.discriminatedUnion("type", [
+  // 客户端请求创建新会话，sessionId 可选用于重连时复用
+  z7.object({
+    type: z7.literal("session_create_request"),
+    name: z7.string().optional(),
+    mode: z7.enum(["pty", "json"]),
+    provider: z7.enum(["claude", "codex"]),
+    cwd: z7.string(),
+    pid: z7.number(),
+    sessionId: z7.string().optional()
+  }),
+  // 服务端响应创建会话
+  z7.object({
+    type: z7.literal("session_create_response"),
+    sessionId: z7.string(),
+    error: z7.string().optional(),
+    hook: ProviderHookContextSchema.optional()
+  }),
+  // 客户端请求终止会话
+  z7.object({
+    type: z7.literal("session_terminate_request"),
+    sessionId: z7.string()
+  }),
+  // 服务端响应终止会话
+  z7.object({
+    type: z7.literal("session_terminate_response"),
+    sessionId: z7.string(),
+    success: z7.boolean()
+  }),
+  // 客户端向服务端注册 PTY 会话
+  z7.object({
+    type: z7.literal("pty_register"),
+    sessionId: z7.string(),
+    pid: z7.number()
+  }),
+  // 客户端取消注册 PTY 会话
+  z7.object({
+    type: z7.literal("pty_deregister"),
+    sessionId: z7.string()
+  }),
+  // 输入，从服务端转发到客户端的 PTY stdin（手机远程输入注入）
+  z7.object({
+    type: z7.literal("pty_input"),
+    sessionId: z7.string(),
+    data: z7.string()
+  }),
+  // serve → terminal：Web 端移除本地终端会话时，只断开远程视图，不杀本地 CLI。
+  z7.object({
+    type: z7.literal("pty_detach"),
+    sessionId: z7.string()
+  }),
+  // 服务端广播会话状态变更
+  z7.object({
+    type: z7.literal("session_status_update"),
+    sessionId: z7.string(),
+    state: z7.enum(sessionStateValues2)
+  }),
+  // 错误响应
+  z7.object({
+    type: z7.literal("error"),
+    message: z7.string(),
+    code: z7.string().optional()
+  }),
+  // 客户端请求服务状态（含 relay 连接信息和 worker 状态）
+  z7.object({
+    type: z7.literal("service_status_request")
+  }),
+  // 服务端响应增强版服务状态
+  z7.object({
+    type: z7.literal("service_status_response"),
+    config: z7.object({
+      envName: z7.string().optional(),
+      envNameSource: z7.enum(["cli", "file", "single", "default", "none"]),
+      relayUrl: z7.string().optional(),
+      relayUrlSource: z7.enum(["env", "file", "none"]),
+      relayTokenSource: z7.enum(["env", "file", "none"]),
+      hookPort: z7.number(),
+      hookPortSource: z7.enum(["env", "file", "default"])
+    }),
+    relay: z7.object({
+      connected: z7.boolean(),
+      proxyId: z7.string(),
+      reconnectAttempt: z7.number(),
+      queueDepth: z7.number()
+    }).nullable(),
+    sessions: z7.array(
+      z7.object({
+        id: z7.string(),
+        mode: z7.enum(["pty", "json"]),
+        state: z7.enum(sessionStateValues2),
+        createdAt: z7.string(),
+        name: z7.string().optional(),
+        hasWorker: z7.boolean()
+      })
+    )
+  }),
+  // terminal → serve：终端标题变化，由 xterm onTitleChange 触发
+  z7.object({
+    type: z7.literal("pty_title_change"),
+    sessionId: z7.string(),
+    title: z7.string()
+  }),
+  // terminal → serve：local runtime 观察到的 PTY 语义事件。
+  // 下面 state 枚举必须与 src/common/osc-extractor.ts 的 PtySemanticState 保持一致。
+  z7.object({
+    type: z7.literal("pty_semantic_event"),
+    sessionId: z7.string(),
+    state: z7.enum(["working", "turn_complete", "approval_wait", "mid_pause"]),
+    title: z7.string().optional(),
+    tool: z7.string().optional()
+  }),
+  // terminal → serve：终端尺寸变化
+  z7.object({
+    type: z7.literal("pty_resize"),
+    sessionId: z7.string(),
+    cols: z7.number(),
+    rows: z7.number()
+  }),
+  // serve → terminal：请求 HeadlessTerminal serialize() 快照
+  z7.object({
+    type: z7.literal("pty_subscribe"),
+    sessionId: z7.string(),
+    requestId: z7.string().optional()
+  }),
+  // terminal → serve：serialize() 结果
+  z7.object({
+    type: z7.literal("pty_snapshot"),
+    sessionId: z7.string(),
+    cols: z7.number(),
+    rows: z7.number(),
+    data: z7.string(),
+    outputSeq: z7.number().int().nonnegative(),
+    requestId: z7.string().optional()
+  }),
+  // serve → terminal：relay 连接状态变更，供终端给用户显示 remote viewing 是否通畅
+  z7.object({
+    type: z7.literal("bridge_status"),
+    connected: z7.boolean()
+  })
+]);
+var WorkerMessageSchema = z7.discriminatedUnion("type", [
+  // serve → worker: 发送用户输入给 claude
+  z7.object({
+    type: z7.literal("worker_input"),
+    content: z7.string()
+  }),
+  // serve → worker: 停止 claude 进程
+  z7.object({
+    type: z7.literal("worker_stop")
+  }),
+  // serve → worker: 工具审批响应
+  z7.object({
+    type: z7.literal("worker_approval_response"),
+    requestId: z7.string(),
+    behavior: z7.enum(["allow", "deny"]),
+    message: z7.string().optional()
+  }),
+  // worker → serve: claude 输出事件（带序列号）
+  z7.object({
+    type: z7.literal("worker_event"),
+    seq: z7.number(),
+    event: z7.record(z7.string(), z7.unknown())
+  }),
+  // worker → serve: claude 进程退出
+  z7.object({
+    type: z7.literal("worker_exit"),
+    code: z7.number()
+  }),
+  // worker → serve: 工具审批请求
+  z7.object({
+    type: z7.literal("worker_approval_request"),
+    requestId: z7.string(),
+    toolName: z7.string(),
+    input: z7.record(z7.string(), z7.unknown())
+  }),
+  // worker → serve: worker 就绪，claude 已启动
+  z7.object({
+    type: z7.literal("worker_ready"),
+    pid: z7.number()
+  }),
+  // worker → serve: 从 stream-json 的 system.init 事件捕获 Claude CLI 侧的 session ID
+  // proxy 拿它来读 ~/.claude/projects/.../<id>.jsonl 历史或后续 --resume
+  z7.object({
+    type: z7.literal("worker_claude_session_id"),
+    sessionId: z7.string()
+  }),
+  // serve → worker: 将指定工具加入会话白名单，后续同名工具自动审批
+  z7.object({
+    type: z7.literal("worker_whitelist_add"),
+    toolName: z7.string()
+  })
+]);
+function serializeWorkerMsg(msg) {
+  return JSON.stringify(msg) + "\n";
+}
+function createWorkerReader(stream, onMessage) {
+  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 {
+        stream.emit(
+          "error",
+          new Error(`Worker message validation failed: ${result.error.message}`)
+        );
+      }
+    } catch (err) {
+      stream.emit("error", new Error("Worker message parse error", { cause: err }));
+    }
+  });
+  stream.pipe(lineBuffer);
+}
+function serializeIpc(msg) {
+  return JSON.stringify(msg) + "\n";
+}
+function createIpcReader(stream, onMessage, onBinaryFrame) {
+  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 payloadStart = 5;
+        const sessionIdLen = buf[payloadStart];
+        const sessionId = buf.subarray(payloadStart + 1, payloadStart + 1 + sessionIdLen).toString("utf-8");
+        const seqOffset = payloadStart + 1 + sessionIdLen;
+        const outputSeq = buf.readUInt32LE(seqOffset);
+        const ptyData = Buffer.from(buf.subarray(seqOffset + 4, totalFrameLen));
+        if (onBinaryFrame) {
+          onBinaryFrame(sessionId, ptyData, 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 {
+            stream.emit(
+              "error",
+              new Error(`IPC message validation failed: ${result.error.message}`)
+            );
+          }
+        } catch (err) {
+          stream.emit("error", new Error("IPC message parse error", { cause: err }));
+        }
+      }
+    }
+  }
+  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 {
+  tildify,
+  CONFIG_PATH,
+  SOCK_PATH,
+  PID_PATH,
+  STOPPED_PATH,
+  DESIRED_ENV_PATH,
+  SESSIONS_PATH,
+  DATA_DIR,
+  LOG_DIR,
+  SERVICE_LOG_PATH,
+  sessionPaths,
+  isInitialized,
+  initWorkspace,
+  buildMessage,
+  ControlErrorCode,
+  SessionState,
+  createLogger,
+  LineBuffer,
+  encodeBinaryIpcFrame,
+  serializeWorkerMsg,
+  createWorkerReader,
+  serializeIpc,
+  createIpcReader
+};
+//# sourceMappingURL=chunk-QJ5CQDK7.js.map