@my-life-buddies/cli 0.1.2

package/dist/bin/preview.js

@@ -0,0 +1,1429 @@
+// apps/preview/src/controller.ts
+import { readBuddyConfig } from "./core.js";
+
+// apps/preview/src/device-preview.ts
+function createBuddyPreviewUrl(buddyId) {
+  if (!/^[a-zA-Z0-9._-]{1,124}-dev$/u.test(buddyId)) {
+    throw new TypeError("\u771F\u673A\u9884\u89C8\u9700\u8981\u4E0D\u8D85\u8FC7 128 \u5B57\u7B26\u7684\u5F00\u53D1\u7248 Buddy ID");
+  }
+  return `mlb://preview?${new URLSearchParams({ buddyId })}`;
+}
+
+// apps/preview/src/controller.ts
+var TERMINAL_RUN_STATUSES = /* @__PURE__ */ new Set(["completed", "failed", "cancelled"]);
+function publicFailure(cause) {
+  const publicMessage = typeof cause === "object" && cause !== null && "publicMessage" in cause && typeof cause.publicMessage === "string" && cause.publicMessage.trim() && cause.publicMessage.length <= 512 && !/[\u0000-\u001f\u007f]/u.test(cause.publicMessage) ? cause.publicMessage : void 0;
+  if (typeof cause === "object" && cause !== null && "code" in cause && typeof cause.code === "string" && cause.code.trim()) {
+    return { code: cause.code, message: publicMessage ?? "DEV \u4F1A\u8BDD\u672A\u80FD\u5B8C\u6210" };
+  }
+  return { code: "DEV_START_FAILED", message: "DEV \u4F1A\u8BDD\u542F\u52A8\u5931\u8D25" };
+}
+var PreviewController = class {
+  #projectRoot;
+  #devStarter;
+  #readConfig;
+  #readBuddyDetails;
+  #now;
+  #listeners = /* @__PURE__ */ new Set();
+  #simulatorListeners = /* @__PURE__ */ new Set();
+  #runs = /* @__PURE__ */ new Map();
+  #outputWatchers = /* @__PURE__ */ new Map();
+  #failedOutputRuns = /* @__PURE__ */ new Set();
+  #observedActiveRuns = /* @__PURE__ */ new Set();
+  #events = [];
+  #runOrdinal = 0;
+  #state = Object.freeze({ phase: "idle", revision: 0 });
+  #handle;
+  #simulator;
+  #startController;
+  #startPromise;
+  #messages = [];
+  #simulatorState = Object.freeze({ messages: Object.freeze([]) });
+  #lastActiveRunId;
+  #eventSequence = 0;
+  constructor(options) {
+    this.#projectRoot = options.projectRoot;
+    this.#devStarter = options.devStarter;
+    this.#readConfig = options.readConfig ?? ((root) => readBuddyConfig(root));
+    this.#readBuddyDetails = options.readBuddyDetails;
+    this.#now = options.now ?? (() => /* @__PURE__ */ new Date());
+  }
+  get projectRoot() {
+    return this.#projectRoot;
+  }
+  state() {
+    return this.#state;
+  }
+  async project() {
+    return this.#readConfig(this.#projectRoot);
+  }
+  async buddyDetails() {
+    if (!this.#readBuddyDetails) return this.#state.ready?.buddy ?? null;
+    const config = await this.project();
+    return this.#readBuddyDetails(config.buddyId);
+  }
+  subscribe(listener) {
+    this.#listeners.add(listener);
+    return () => this.#listeners.delete(listener);
+  }
+  subscribeSimulator(listener) {
+    this.#simulatorListeners.add(listener);
+    return () => this.#simulatorListeners.delete(listener);
+  }
+  simulatorSnapshot() {
+    return this.#simulatorState;
+  }
+  start() {
+    if (this.#startPromise) return this.#startPromise;
+    if (this.#state.phase === "ready") return Promise.resolve(this.#state);
+    if (this.#state.phase === "stopping") {
+      return Promise.reject(Object.assign(new Error("DEV \u4F1A\u8BDD\u6B63\u5728\u505C\u6B62"), { code: "DEV_STOPPING" }));
+    }
+    const controller = new AbortController();
+    this.#startController = controller;
+    this.#record({ channel: "dev", type: "dev.start_requested", summary: "\u8BF7\u6C42\u542F\u52A8 DEV \u4F1A\u8BDD" });
+    this.#setState({ phase: "starting" });
+    const startPromise = this.#devStarter.start({
+      projectRoot: this.#projectRoot,
+      signal: controller.signal,
+      onLog: ({ source, text: text2 }) => {
+        if (controller.signal.aborted) return;
+        this.#record({ channel: "dev", type: source, summary: text2.slice(0, 8224) });
+        this.#notifySimulator();
+      }
+    }).then(({ handle, ready, simulator }) => {
+      if (controller.signal.aborted) {
+        return handle.close().then(() => this.#setState({ phase: "idle" }));
+      }
+      this.#handle = handle;
+      this.#simulator = simulator;
+      this.#record({
+        channel: "dev",
+        type: "dev.ready",
+        summary: ready.agentId ? `Agent ${ready.agentId} \u5DF2\u5C31\u7EEA` : "Agent \u5DF2\u5C31\u7EEA"
+      });
+      void handle.closed.then(
+        () => {
+          if (this.#handle === handle) {
+            this.#handle = void 0;
+            this.#simulator = void 0;
+            this.#stopOutputWatchers();
+            this.#record({ channel: "dev", type: "dev.closed", summary: "DEV \u4F1A\u8BDD\u5DF2\u7ED3\u675F" });
+            this.#setState({ phase: "idle" });
+          }
+        },
+        (cause) => {
+          if (this.#handle === handle) {
+            this.#handle = void 0;
+            this.#simulator = void 0;
+            this.#stopOutputWatchers();
+            this.#record({ channel: "dev", type: "dev.failed", summary: "DEV \u4F1A\u8BDD\u5F02\u5E38\u7ED3\u675F" });
+            this.#setState({ phase: "failed", error: publicFailure(cause) });
+          }
+        }
+      );
+      return this.#setState({ phase: "ready", ready });
+    }).catch((cause) => {
+      if (controller.signal.aborted) return this.#setState({ phase: "idle" });
+      this.#record({ channel: "dev", type: "dev.start_failed", summary: "DEV \u4F1A\u8BDD\u542F\u52A8\u5931\u8D25" });
+      return this.#setState({ phase: "failed", error: publicFailure(cause) });
+    }).finally(() => {
+      if (this.#startController === controller) this.#startController = void 0;
+      if (this.#startPromise === startPromise) this.#startPromise = void 0;
+    });
+    this.#startPromise = startPromise;
+    return startPromise;
+  }
+  async stop() {
+    if (this.#state.phase === "idle") return this.#state;
+    if (this.#state.phase === "stopping") return this.#state;
+    this.#setState({ phase: "stopping" });
+    this.#record({ channel: "dev", type: "dev.stop_requested", summary: "\u8BF7\u6C42\u505C\u6B62 DEV \u4F1A\u8BDD" });
+    this.#startController?.abort(new Error("Preview requested DEV stop"));
+    const handle = this.#handle;
+    this.#handle = void 0;
+    this.#simulator = void 0;
+    this.#stopOutputWatchers();
+    try {
+      if (handle) await handle.close();
+      if (this.#startPromise) await this.#startPromise.catch(() => void 0);
+      this.#record({ channel: "dev", type: "dev.stopped", summary: "DEV \u4F1A\u8BDD\u5DF2\u505C\u6B62" });
+      return this.#setState({ phase: "idle" });
+    } catch (cause) {
+      this.#setState({ phase: "failed", error: publicFailure(cause) });
+      throw cause;
+    }
+  }
+  async close() {
+    await this.stop();
+    this.#listeners.clear();
+    this.#simulatorListeners.clear();
+  }
+  async simulatorState(signal) {
+    const state = await this.#requiredSimulator().state({ signal });
+    return this.#observeSimulatorState(state);
+  }
+  async sendSimulatorMessage(input, signal) {
+    const started = this.#now();
+    this.#record({ channel: "client", type: "message.send", summary: "\u53D1\u9001\u4E00\u6761\u79C1\u804A\u6D88\u606F" });
+    const accepted = await this.#requiredSimulator().send(input, { signal });
+    if (this.#runs.has(accepted.runId)) return accepted;
+    const acceptedAt = this.#now();
+    const latency = Math.max(0, acceptedAt.getTime() - started.getTime());
+    this.#upsertRun({
+      runId: accepted.runId,
+      messageId: accepted.messageId,
+      status: "accepted",
+      startedAt: started.toISOString(),
+      updatedAt: acceptedAt.toISOString(),
+      acceptLatencyMs: latency
+    });
+    this.#lastActiveRunId = accepted.runId;
+    this.#record({
+      channel: "app_server",
+      type: "run.accepted",
+      summary: "App Server \u5DF2\u63A5\u53D7\u6D88\u606F\uFF0C\u5DF2\u8BB0\u5F55\u53D1\u9001\u56DE\u6267",
+      runId: accepted.runId,
+      durationMs: latency
+    });
+    this.#simulatorState = Object.freeze({
+      messages: Object.freeze([
+        ...this.#simulatorState.messages.filter((message2) => message2.messageId !== accepted.messageId),
+        Object.freeze({
+          messageId: accepted.messageId,
+          role: "user",
+          text: input.text,
+          createdAt: acceptedAt.toISOString()
+        })
+      ]),
+      latestRun: Object.freeze({ runId: accepted.runId, status: "pending" }),
+      activeRun: Object.freeze({ runId: accepted.runId, status: "pending" })
+    });
+    this.#messages = this.#simulatorState.messages;
+    this.#notifySimulator();
+    this.#startOutputWatcher(this.#requiredSimulator(), accepted.runId);
+    return accepted;
+  }
+  async cancelSimulatorRun(runId, signal) {
+    this.#record({
+      channel: "client",
+      type: "run.cancel_requested",
+      // Local debug event, not an MLB SSE event.
+      summary: "\u5F00\u53D1\u8005\u8BF7\u6C42\u505C\u6B62\u5F53\u524D\u56DE\u590D",
+      runId
+    });
+    const result = await this.#requiredSimulator().cancel(runId, { signal });
+    if (result.status === "cancel_requested") {
+      this.#updateRunStatus(runId, "cancel_requested");
+      if (this.#simulatorState.activeRun?.runId === runId) {
+        this.#simulatorState = Object.freeze({
+          messages: this.#simulatorState.messages,
+          latestRun: Object.freeze({ runId, status: "cancel_requested" }),
+          activeRun: Object.freeze({ runId, status: "cancel_requested" }),
+          ...this.#simulatorState.streaming?.runId === runId ? { streaming: this.#simulatorState.streaming } : {}
+        });
+      }
+    }
+    this.#record({
+      channel: "app_server",
+      type: `run.${result.status}`,
+      summary: result.status === "cancel_requested" ? "App Server \u5DF2\u63A5\u53D7\u505C\u6B62\u8BF7\u6C42" : "Run \u5DF2\u7ECF\u7ED3\u675F",
+      runId
+    });
+    if (result.status === "already_terminal") {
+      await this.simulatorState(signal).catch(() => this.#notifySimulator());
+    } else {
+      this.#notifySimulator();
+    }
+    return result;
+  }
+  debugSnapshot() {
+    return Object.freeze({
+      source: "observed",
+      generatedAt: this.#now().toISOString(),
+      runs: Object.freeze([...this.#runs.values()].reverse()),
+      events: Object.freeze([...this.#events].reverse()),
+      messages: Object.freeze([...this.#messages])
+    });
+  }
+  devicePairing() {
+    const pairing = this.#state.phase === "ready" ? this.#state.ready?.devicePairing : void 0;
+    if (pairing) {
+      try {
+        if (pairing.url === createBuddyPreviewUrl(this.#state.ready?.agentId ?? "") && pairing.url.length <= 2048 && (pairing.code === void 0 || /^[A-Z0-9-]{4,32}$/iu.test(pairing.code)) && (pairing.expiresAt === void 0 || Number.isFinite(Date.parse(pairing.expiresAt)))) {
+          return Object.freeze({
+            status: "ready",
+            url: pairing.url,
+            ...pairing.code === void 0 ? {} : { code: pairing.code },
+            ...pairing.expiresAt === void 0 ? {} : { expiresAt: pairing.expiresAt }
+          });
+        }
+      } catch {
+      }
+    }
+    return Object.freeze({
+      status: "unavailable",
+      reason: this.#state.phase !== "ready" ? "\u8BF7\u5148\u542F\u52A8 DEV \u4F1A\u8BDD" : pairing ? "\u5F53\u524D DEV \u73AF\u5883\u8FD4\u56DE\u4E86\u65E0\u6548\u7684\u771F\u673A\u5165\u53E3" : "\u5F53\u524D DEV \u4F1A\u8BDD\u5C1A\u672A\u63D0\u4F9B\u642D\u642D App \u9884\u89C8\u94FE\u63A5"
+    });
+  }
+  #requiredSimulator() {
+    if (this.#state.phase !== "ready" || !this.#simulator) {
+      throw Object.assign(new Error("\u6A21\u62DF\u5668\u9700\u8981\u5148\u542F\u52A8 DEV \u4F1A\u8BDD"), {
+        code: "SIMULATOR_NOT_READY",
+        status: 409,
+        publicMessage: "\u8BF7\u5148\u542F\u52A8 DEV \u4F1A\u8BDD"
+      });
+    }
+    return this.#simulator;
+  }
+  #observeSimulatorState(state) {
+    const previousStreaming = this.#simulatorState.streaming;
+    const incomingActiveRun = state.activeRun;
+    const existingActiveRun = incomingActiveRun ? this.#runs.get(incomingActiveRun.runId) : void 0;
+    if (existingActiveRun && TERMINAL_RUN_STATUSES.has(existingActiveRun.status)) {
+      this.#notifySimulator();
+      return this.#simulatorState;
+    }
+    let streaming = state.streaming ?? (incomingActiveRun?.runId === previousStreaming?.runId ? previousStreaming : void 0);
+    if (streaming && previousStreaming?.runId === streaming.runId) {
+      if (streaming.nextSequence < previousStreaming.nextSequence) {
+        streaming = previousStreaming;
+      } else if (streaming.nextSequence === previousStreaming.nextSequence && streaming.text !== previousStreaming.text) {
+        throw Object.assign(new Error("App Server \u6539\u5199\u4E86\u5DF2\u89C2\u5BDF\u5230\u7684\u6D41\u5F0F\u6587\u5B57"), {
+          code: "OUTPUT_STREAM_PROTOCOL_ERROR",
+          publicMessage: "App Server \u8FD4\u56DE\u4E86\u4E0D\u4E00\u81F4\u7684\u6D41\u5F0F\u72B6\u6001"
+        });
+      } else if (streaming.nextSequence > previousStreaming.nextSequence && !streaming.text.startsWith(previousStreaming.text)) {
+        throw Object.assign(new Error("App Server \u6539\u5199\u4E86\u5DF2\u89C2\u5BDF\u5230\u7684\u6D41\u5F0F\u6587\u5B57"), {
+          code: "OUTPUT_STREAM_PROTOCOL_ERROR",
+          publicMessage: "App Server \u8FD4\u56DE\u4E86\u4E0D\u4E00\u81F4\u7684\u6D41\u5F0F\u72B6\u6001"
+        });
+      }
+    }
+    this.#simulatorState = Object.freeze({
+      messages: Object.freeze([...state.messages]),
+      ...state.latestRun === void 0 ? {} : { latestRun: Object.freeze({ ...state.latestRun }) },
+      ...state.activeRun === void 0 ? {} : { activeRun: Object.freeze({ ...state.activeRun }) },
+      ...streaming === void 0 ? {} : { streaming: Object.freeze({ ...streaming }) }
+    });
+    this.#messages = this.#simulatorState.messages;
+    const now = this.#now();
+    const active = this.#simulatorState.activeRun;
+    if (active) {
+      this.#observedActiveRuns.add(active.runId);
+      const existing2 = this.#runs.get(active.runId);
+      const restoredFirstTextLatency = existing2?.firstTextLatencyMs ?? (this.#simulatorState.streaming?.runId === active.runId && this.#simulatorState.streaming.nextSequence > 0 && this.#simulatorState.streaming.text.length > 0 ? Math.max(0, now.getTime() - Date.parse(existing2?.startedAt ?? now.toISOString())) : void 0);
+      this.#upsertRun({
+        runId: active.runId,
+        ...existing2?.messageId ? { messageId: existing2.messageId } : {},
+        status: active.status,
+        startedAt: existing2?.startedAt ?? now.toISOString(),
+        updatedAt: now.toISOString(),
+        ...existing2?.acceptLatencyMs === void 0 ? {} : { acceptLatencyMs: existing2.acceptLatencyMs },
+        ...restoredFirstTextLatency === void 0 ? {} : { firstTextLatencyMs: restoredFirstTextLatency }
+      });
+      if (existing2?.firstTextLatencyMs === void 0 && restoredFirstTextLatency !== void 0) {
+        this.#record({
+          channel: "app_server",
+          type: "run.output.restored",
+          summary: "\u4ECE App Server \u72B6\u6001\u6062\u590D\u5F53\u524D\u6D41\u5F0F\u6587\u5B57",
+          runId: active.runId,
+          durationMs: restoredFirstTextLatency
+        });
+      }
+      if (this.#lastActiveRunId !== active.runId || existing2?.status !== active.status) {
+        this.#record({
+          channel: "app_server",
+          type: `run.${active.status}`,
+          summary: active.status === "pending" ? "Run \u6B63\u5728\u7B49\u5F85 Agent" : "Agent \u6B63\u5728\u5904\u7406 Run",
+          runId: active.runId
+        });
+      }
+      this.#lastActiveRunId = active.runId;
+      if (this.#simulator) this.#startOutputWatcher(this.#simulator, active.runId);
+      this.#notifySimulator();
+      return this.#simulatorState;
+    }
+    if (!this.#lastActiveRunId) {
+      this.#notifySimulator();
+      return this.#simulatorState;
+    }
+    const runId = this.#lastActiveRunId;
+    const existing = this.#runs.get(runId);
+    if (existing && !["completed", "failed", "cancelled"].includes(existing.status)) {
+      const assistant = [...this.#simulatorState.messages].reverse().find((message2) => message2.role === "assistant" && Date.parse(message2.createdAt) >= Date.parse(existing.startedAt));
+      const elapsed = Math.max(0, now.getTime() - Date.parse(existing.startedAt));
+      const terminalStatus = this.#simulatorState.latestRun?.runId === runId && (this.#simulatorState.latestRun.status === "completed" || this.#simulatorState.latestRun.status === "failed" || this.#simulatorState.latestRun.status === "cancelled") ? this.#simulatorState.latestRun.status : void 0;
+      if (!assistant && !terminalStatus && !this.#observedActiveRuns.has(runId) && elapsed < 5e3) {
+        this.#notifySimulator();
+        return this.#simulatorState;
+      }
+      const completedAt = assistant && Number.isFinite(Date.parse(assistant.createdAt)) ? new Date(assistant.createdAt) : now;
+      const status = terminalStatus ?? "completed";
+      this.#upsertRun({
+        ...existing,
+        status,
+        updatedAt: now.toISOString(),
+        completedAt: completedAt.toISOString(),
+        responseTimeMs: Math.max(0, completedAt.getTime() - Date.parse(existing.startedAt)),
+        completion: assistant ? "reply" : "no_reply"
+      });
+      this.#record({
+        channel: "app_server",
+        type: `run.${status}`,
+        summary: assistant ? "\u5B8C\u6574\u56DE\u590D\u5DF2\u8FD4\u56DE\uFF0C\u672C\u5730\u56DE\u5408\u7ED3\u675F" : status === "failed" ? "Agent \u672C\u5730\u56DE\u5408\u6267\u884C\u5931\u8D25\uFF0C\u672A\u4EA7\u751F\u7528\u6237\u56DE\u590D" : status === "cancelled" ? "Agent \u672C\u5730\u56DE\u5408\u5DF2\u53D6\u6D88\uFF0C\u672A\u5B8C\u6210\u56DE\u590D\u5DF2\u4F5C\u5E9F" : "\u672C\u5730\u56DE\u5408\u5DF2\u7ED3\u675F\uFF0C\u672A\u89C2\u5BDF\u5230\u65B0\u7684\u5B8C\u6574\u56DE\u590D",
+        runId,
+        durationMs: Math.max(0, completedAt.getTime() - Date.parse(existing.startedAt))
+      });
+      this.#stopOutputWatcher(runId);
+    }
+    this.#observedActiveRuns.delete(runId);
+    this.#lastActiveRunId = void 0;
+    this.#notifySimulator();
+    return this.#simulatorState;
+  }
+  #startOutputWatcher(simulator, runId) {
+    if (!simulator.watchOutput || this.#outputWatchers.has(runId) || this.#failedOutputRuns.has(runId)) return;
+    const controller = new AbortController();
+    this.#outputWatchers.set(runId, controller);
+    void simulator.watchOutput(runId, {
+      signal: controller.signal,
+      onEvent: (event) => this.#observeOutputEvent(event)
+    }).catch((cause) => {
+      if (controller.signal.aborted) return;
+      this.#failedOutputRuns.add(runId);
+      this.#record({
+        channel: "app_server",
+        type: "run.output.disconnected",
+        summary: cause && typeof cause === "object" && "status" in cause && cause.status === 401 ? "MLB \u767B\u5F55\u5DF2\u5931\u6548\uFF0C\u8BF7\u91CD\u65B0\u767B\u5F55\u540E\u91CD\u542F DEV" : "\u6D41\u5F0F\u8FDE\u63A5\u4E2D\u65AD\uFF0C\u6A21\u62DF\u5668\u5C06\u4F7F\u7528 App Server \u72B6\u6001\u6062\u590D",
+        runId
+      });
+      this.#notifySimulator();
+      void this.simulatorState().catch(() => void 0);
+    }).finally(() => {
+      if (this.#outputWatchers.get(runId) === controller) this.#outputWatchers.delete(runId);
+    });
+  }
+  async #observeOutputEvent(event) {
+    if (event.type === "reset") {
+      if (this.#simulatorState.streaming?.runId === event.runId) {
+        const { streaming: _streaming, ...state } = this.#simulatorState;
+        this.#simulatorState = Object.freeze(state);
+        this.#notifySimulator();
+      }
+      return;
+    }
+    const now = this.#now();
+    const existing = this.#runs.get(event.runId);
+    if (event.type === "delta") {
+      if (existing && TERMINAL_RUN_STATUSES.has(existing.status) || this.#simulatorState.latestRun?.runId === event.runId && TERMINAL_RUN_STATUSES.has(this.#simulatorState.latestRun.status)) {
+        return;
+      }
+      const previous = this.#simulatorState.streaming;
+      const expected = previous?.runId === event.runId ? previous.nextSequence : 0;
+      if (event.sequence < expected) return;
+      if (event.sequence > expected) {
+        throw Object.assign(new Error("App Server \u8FD4\u56DE\u7684\u6D41\u5F0F\u5E8F\u53F7\u4E0D\u8FDE\u7EED"), { code: "OUTPUT_SEQUENCE_MISMATCH" });
+      }
+      const text2 = `${previous?.runId === event.runId ? previous.text : ""}${event.text}`;
+      const firstTextLatencyMs = existing?.firstTextLatencyMs ?? (existing ? Math.max(0, now.getTime() - Date.parse(existing.startedAt)) : void 0);
+      if (existing) {
+        this.#upsertRun({
+          ...existing,
+          status: "running",
+          updatedAt: now.toISOString(),
+          ...firstTextLatencyMs === void 0 ? {} : { firstTextLatencyMs }
+        });
+      }
+      this.#simulatorState = Object.freeze({
+        messages: this.#simulatorState.messages,
+        latestRun: Object.freeze({ runId: event.runId, status: "running" }),
+        activeRun: Object.freeze({ runId: event.runId, status: "running" }),
+        streaming: Object.freeze({
+          runId: event.runId,
+          text: text2,
+          nextSequence: event.sequence + 1,
+          updatedAt: now.toISOString()
+        })
+      });
+      this.#record({
+        channel: "app_server",
+        type: event.sequence === 0 ? "run.output.started" : "run.output.delta",
+        summary: event.sequence === 0 ? "\u9996\u6BB5\u6D41\u5F0F\u6587\u5B57\u5DF2\u5230\u8FBE" : `\u6536\u5230\u7B2C ${event.sequence + 1} \u6BB5\u6D41\u5F0F\u6587\u5B57`,
+        runId: event.runId,
+        ...firstTextLatencyMs === void 0 || event.sequence !== 0 ? {} : { durationMs: firstTextLatencyMs }
+      });
+      this.#notifySimulator();
+      return;
+    }
+    this.#record({
+      channel: "app_server",
+      type: `run.output.${event.type}`,
+      summary: event.type === "completed" ? "\u6D41\u5F0F\u8F93\u51FA\u5B8C\u6210\uFF0C\u6B63\u5728\u786E\u8BA4\u6B63\u5F0F\u56DE\u590D" : event.type === "failed" ? "\u672C\u5730\u56DE\u5408\u5931\u8D25\uFF0C\u4E34\u65F6\u6D41\u5F0F\u6587\u5B57\u5DF2\u4F5C\u5E9F" : "\u672C\u5730\u56DE\u5408\u5DF2\u53D6\u6D88\uFF0C\u4E34\u65F6\u6D41\u5F0F\u6587\u5B57\u5DF2\u4F5C\u5E9F",
+      runId: event.runId
+    });
+    if (event.type !== "completed") {
+      this.#simulatorState = Object.freeze({
+        messages: this.#simulatorState.messages,
+        latestRun: Object.freeze({ runId: event.runId, status: event.status })
+      });
+      this.#notifySimulator();
+    }
+    await this.simulatorState().catch(() => void 0);
+  }
+  #stopOutputWatchers() {
+    for (const controller of this.#outputWatchers.values()) {
+      controller.abort(new Error("Preview DEV session closed"));
+    }
+    this.#outputWatchers.clear();
+    this.#failedOutputRuns.clear();
+  }
+  #stopOutputWatcher(runId) {
+    this.#failedOutputRuns.delete(runId);
+    const controller = this.#outputWatchers.get(runId);
+    if (!controller) return;
+    this.#outputWatchers.delete(runId);
+    controller.abort(new Error("Agent local turn reached a terminal state"));
+  }
+  #notifySimulator() {
+    if (this.#simulatorListeners.size === 0) return;
+    const value = Object.freeze({ state: this.#simulatorState, debug: this.debugSnapshot() });
+    for (const listener of this.#simulatorListeners) {
+      try {
+        listener(value);
+      } catch {
+      }
+    }
+  }
+  #upsertRun(run) {
+    const ordinal = this.#runs.get(run.runId)?.ordinal ?? ++this.#runOrdinal;
+    this.#runs.set(run.runId, Object.freeze({ ...run, ordinal }));
+    while (this.#runs.size > 100) {
+      const oldest = this.#runs.keys().next().value;
+      if (!oldest) break;
+      this.#runs.delete(oldest);
+    }
+  }
+  #updateRunStatus(runId, status) {
+    const existing = this.#runs.get(runId);
+    if (!existing) return;
+    this.#upsertRun({ ...existing, status, updatedAt: this.#now().toISOString() });
+  }
+  #record(input) {
+    this.#eventSequence += 1;
+    this.#events.push(Object.freeze({
+      ...input,
+      eventId: `event-${this.#eventSequence}`,
+      timestamp: this.#now().toISOString()
+    }));
+    if (this.#events.length > 300) this.#events.splice(0, this.#events.length - 300);
+  }
+  #setState(next) {
+    this.#state = Object.freeze({ ...next, revision: this.#state.revision + 1 });
+    for (const listener of this.#listeners) {
+      try {
+        listener(this.#state);
+      } catch {
+      }
+    }
+    return this.#state;
+  }
+};
+
+// apps/preview/src/server.ts
+import { randomBytes, timingSafeEqual } from "node:crypto";
+import { readFileSync } from "node:fs";
+import { createServer } from "node:http";
+import { createRequire } from "node:module";
+import QRCode from "qrcode";
+var LOOPBACK_HOSTS = /* @__PURE__ */ new Set(["127.0.0.1", "::1", "localhost"]);
+var SESSION_COOKIE = "buddy_preview_session";
+var require2 = createRequire(import.meta.url);
+var BRAND_ICON = Buffer.from(
+  readFileSync(new URL("../web/assets/developer-platform-icon.png.base64", import.meta.url), "utf8").trim(),
+  "base64"
+);
+var WEB_ASSETS = Object.freeze(/* @__PURE__ */ new Map([
+  ["/", {
+    contentType: "text/html; charset=utf-8",
+    body: readFileSync(new URL("../web/index.html", import.meta.url))
+  }],
+  ["/assets/app.css", {
+    contentType: "text/css; charset=utf-8",
+    body: readFileSync(new URL("../web/app.css", import.meta.url))
+  }],
+  ["/assets/tokens.css", {
+    contentType: "text/css; charset=utf-8",
+    body: readFileSync(new URL("../web/tokens.css", import.meta.url))
+  }],
+  ["/assets/brand.css", {
+    contentType: "text/css; charset=utf-8",
+    body: readFileSync(new URL("../web/brand.css", import.meta.url))
+  }],
+  ["/assets/app.js", {
+    contentType: "text/javascript; charset=utf-8",
+    body: readFileSync(new URL("../web/app.js", import.meta.url))
+  }],
+  ["/assets/developer-platform-icon.png", {
+    contentType: "image/png",
+    body: BRAND_ICON
+  }],
+  ["/assets/iphone-16-max.js", {
+    contentType: "text/javascript; charset=utf-8",
+    body: readFileSync(require2.resolve("@sneas/telephone/iphone-16-max.js"))
+  }]
+]));
+function closeServer(server) {
+  if (!server.listening) return Promise.resolve();
+  return new Promise((resolve, reject) => {
+    server.close((error) => error ? reject(error) : resolve());
+  });
+}
+function writeHeaders(response) {
+  response.setHeader("Cache-Control", "no-store");
+  response.setHeader("X-Content-Type-Options", "nosniff");
+  response.setHeader("Referrer-Policy", "no-referrer");
+  response.setHeader("Cross-Origin-Opener-Policy", "same-origin");
+  response.setHeader(
+    "Content-Security-Policy",
+    // Telephone injects its frame CSS into a shadow root and updates one inline sizing variable.
+    "default-src 'self'; connect-src 'self'; img-src 'self' data:; script-src 'self'; style-src 'self' 'unsafe-inline'; object-src 'none'; frame-ancestors 'none'; base-uri 'none'; form-action 'self'"
+  );
+}
+function staticAsset(response, asset) {
+  response.statusCode = 200;
+  writeHeaders(response);
+  response.setHeader("Content-Type", asset.contentType);
+  response.setHeader("Content-Length", asset.body.length);
+  response.end(asset.body);
+}
+function json(response, status, body) {
+  const encoded = JSON.stringify(body);
+  response.statusCode = status;
+  writeHeaders(response);
+  response.setHeader("Content-Type", "application/json; charset=utf-8");
+  response.setHeader("Content-Length", Buffer.byteLength(encoded));
+  response.end(encoded);
+}
+function safeEqual(left, right) {
+  const a = Buffer.from(left);
+  const b = Buffer.from(right);
+  return a.length === b.length && timingSafeEqual(a, b);
+}
+function cookieValue(request, name) {
+  for (const part of request.headers.cookie?.split(";") ?? []) {
+    const separator = part.indexOf("=");
+    if (separator < 0) continue;
+    if (part.slice(0, separator).trim() === name) return part.slice(separator + 1).trim();
+  }
+  return void 0;
+}
+function requestUrl(request, origin) {
+  try {
+    return new URL(request.url ?? "/", origin);
+  } catch {
+    return null;
+  }
+}
+function allowedHost(request, port) {
+  const value = request.headers.host;
+  if (!value) return false;
+  try {
+    const parsed = new URL(`http://${value}`);
+    return LOOPBACK_HOSTS.has(parsed.hostname.replace(/^\[|\]$/gu, "")) && Number(parsed.port || 80) === port;
+  } catch {
+    return false;
+  }
+}
+function allowedOrigin(request, origin) {
+  const value = request.headers.origin;
+  return value === void 0 || value === origin.origin;
+}
+function apiError(response, status, code, message2) {
+  json(response, status, { error: { code, message: message2 } });
+}
+async function readJsonBody(request, maximumBytes = 64 * 1024) {
+  const contentType = request.headers["content-type"]?.split(";", 1)[0]?.trim().toLowerCase();
+  if (contentType !== "application/json") {
+    throw Object.assign(new Error("\u9700\u8981 application/json"), { code: "JSON_REQUIRED", status: 415 });
+  }
+  const declared = Number(request.headers["content-length"] ?? 0);
+  if (!Number.isFinite(declared) || declared < 0 || declared > maximumBytes) {
+    throw Object.assign(new Error("\u8BF7\u6C42\u6B63\u6587\u8FC7\u5927"), { code: "BODY_TOO_LARGE", status: 413 });
+  }
+  const chunks = [];
+  let size = 0;
+  for await (const chunk of request) {
+    const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+    size += buffer.length;
+    if (size > maximumBytes) {
+      throw Object.assign(new Error("\u8BF7\u6C42\u6B63\u6587\u8FC7\u5927"), { code: "BODY_TOO_LARGE", status: 413 });
+    }
+    chunks.push(buffer);
+  }
+  try {
+    return JSON.parse(Buffer.concat(chunks).toString("utf8"));
+  } catch {
+    throw Object.assign(new Error("\u8BF7\u6C42\u6B63\u6587\u4E0D\u662F\u6709\u6548 JSON"), { code: "INVALID_JSON", status: 400 });
+  }
+}
+function exactObject(value, keys) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+  const object2 = value;
+  const expected = new Set(keys);
+  return Object.keys(object2).length === keys.length && Object.keys(object2).every((key) => expected.has(key)) ? object2 : null;
+}
+function safeIdentifier(value, maximumLength = 200) {
+  return typeof value === "string" && value.length > 0 && value.length <= maximumLength && !/[\u0000-\u001f\u007f]/u.test(value);
+}
+function requestFailure(cause) {
+  if (typeof cause === "object" && cause !== null) {
+    const status = "status" in cause && typeof cause.status === "number" && Number.isInteger(cause.status) && cause.status >= 400 && cause.status <= 599 ? cause.status : 502;
+    const code = "code" in cause && safeIdentifier(cause.code, 80) ? cause.code : "SIMULATOR_REQUEST_FAILED";
+    const message2 = "publicMessage" in cause && typeof cause.publicMessage === "string" && cause.publicMessage.length <= 512 && !/[\u0000-\u001f\u007f]/u.test(cause.publicMessage) ? cause.publicMessage : status < 500 && cause instanceof Error ? cause.message : "\u6A21\u62DF\u5668\u8BF7\u6C42\u672A\u80FD\u5B8C\u6210";
+    return { status, code, message: message2 };
+  }
+  return { status: 502, code: "SIMULATOR_REQUEST_FAILED", message: "\u6A21\u62DF\u5668\u8BF7\u6C42\u672A\u80FD\u5B8C\u6210" };
+}
+function publicProject(config) {
+  return {
+    buddyId: config.buddyId,
+    runtime: { language: config.runtime.language },
+    ...config.model === void 0 ? {} : { model: config.model }
+  };
+}
+async function startPreviewControlServer(options) {
+  const host = options.host ?? "127.0.0.1";
+  const port = options.port ?? 0;
+  if (!LOOPBACK_HOSTS.has(host)) throw new TypeError("Preview control server must bind to loopback");
+  if (!Number.isSafeInteger(port) || port < 0 || port > 65535) throw new TypeError("Preview port must be 0\u201365535");
+  const sessionToken = randomBytes(32).toString("base64url");
+  let bootstrapAvailable = true;
+  let origin;
+  const listeners = /* @__PURE__ */ new Set();
+  let eventRevision = 0;
+  const publish = (event, value) => {
+    eventRevision += 1;
+    const payload = `id: ${eventRevision}
+event: ${event}
+data: ${JSON.stringify(value)}
+
+`;
+    for (const response of listeners) {
+      try {
+        response.write(payload);
+      } catch {
+        listeners.delete(response);
+      }
+    }
+  };
+  const unsubscribeDev = options.controller.subscribe((state) => publish("dev.state", state));
+  const unsubscribeSimulator = options.controller.subscribeSimulator((value) => publish("simulator.state", value));
+  const server = createServer(async (request, response) => {
+    if (!origin) return apiError(response, 503, "PREVIEW_STARTING", "Preview \u6B63\u5728\u542F\u52A8");
+    if (!allowedHost(request, Number(origin.port)) || !allowedOrigin(request, origin)) {
+      return apiError(response, 403, "PREVIEW_ORIGIN_FORBIDDEN", "\u8BF7\u6C42\u6765\u6E90\u4E0D\u53D7\u4FE1\u4EFB");
+    }
+    const url = requestUrl(request, origin);
+    if (!url) return apiError(response, 400, "INVALID_URL", "\u8BF7\u6C42\u5730\u5740\u65E0\u6548");
+    if (request.method === "GET" && bootstrapAvailable && url.pathname === `/bootstrap/${sessionToken}`) {
+      bootstrapAvailable = false;
+      response.statusCode = 303;
+      writeHeaders(response);
+      response.setHeader(
+        "Set-Cookie",
+        `${SESSION_COOKIE}=${sessionToken}; HttpOnly; SameSite=Strict; Path=/; Max-Age=43200`
+      );
+      response.setHeader("Location", "/");
+      response.end();
+      return;
+    }
+    const suppliedToken = cookieValue(request, SESSION_COOKIE);
+    if (!suppliedToken || !safeEqual(suppliedToken, sessionToken)) {
+      return apiError(response, 401, "PREVIEW_UNAUTHORIZED", "\u9700\u8981\u4ECE CLI \u63D0\u4F9B\u7684\u4E00\u6B21\u6027\u5165\u53E3\u6253\u5F00 Preview");
+    }
+    if (request.method === "GET") {
+      const asset = WEB_ASSETS.get(url.pathname);
+      if (asset) return staticAsset(response, asset);
+    }
+    if (request.method === "GET" && url.pathname === "/api/project") {
+      try {
+        return json(response, 200, { project: publicProject(await options.controller.project()) });
+      } catch {
+        return apiError(response, 422, "PROJECT_CONFIG_INVALID", "\u9879\u76EE\u914D\u7F6E\u65E0\u6CD5\u8BFB\u53D6\u6216\u6821\u9A8C\u5931\u8D25");
+      }
+    }
+    if (request.method === "GET" && url.pathname === "/api/dev") {
+      return json(response, 200, { state: options.controller.state() });
+    }
+    if (request.method === "GET" && url.pathname === "/api/buddy") {
+      try {
+        return json(response, 200, { buddy: await options.controller.buddyDetails() });
+      } catch (cause) {
+        const failure = requestFailure(cause);
+        return apiError(response, failure.status, failure.code, failure.message);
+      }
+    }
+    if (request.method === "GET" && url.pathname === "/api/debug") {
+      return json(response, 200, { debug: options.controller.debugSnapshot() });
+    }
+    if (request.method === "GET" && url.pathname === "/api/device/pairing") {
+      const pairing = options.controller.devicePairing();
+      if (pairing.status !== "ready") return json(response, 200, { pairing });
+      const qrCodeDataUrl = await QRCode.toDataURL(pairing.url, {
+        errorCorrectionLevel: "M",
+        margin: 4,
+        width: 256
+      });
+      const current = options.controller.devicePairing();
+      return json(response, 200, { pairing: current.status === "ready" && current.url === pairing.url ? { ...current, qrCodeDataUrl } : current });
+    }
+    if (request.method === "GET" && url.pathname === "/api/simulator/state") {
+      try {
+        return json(response, 200, { state: await options.controller.simulatorState() });
+      } catch (cause) {
+        const failure = requestFailure(cause);
+        return apiError(response, failure.status, failure.code, failure.message);
+      }
+    }
+    if (request.method === "GET" && url.pathname === "/api/events") {
+      response.statusCode = 200;
+      writeHeaders(response);
+      response.setHeader("Content-Type", "text/event-stream; charset=utf-8");
+      response.setHeader("Connection", "keep-alive");
+      eventRevision += 1;
+      response.write(`id: ${eventRevision}
+event: dev.state
+data: ${JSON.stringify(options.controller.state())}
+
+`);
+      eventRevision += 1;
+      response.write(`id: ${eventRevision}
+event: simulator.state
+data: ${JSON.stringify({
+        state: options.controller.simulatorSnapshot(),
+        debug: options.controller.debugSnapshot()
+      })}
+
+`);
+      listeners.add(response);
+      request.once("close", () => listeners.delete(response));
+      return;
+    }
+    if (request.method === "POST" && url.pathname === "/api/dev/start") {
+      if (Number(request.headers["content-length"] ?? 0) > 0) {
+        return apiError(response, 400, "BODY_NOT_ALLOWED", "\u8BE5\u64CD\u4F5C\u4E0D\u63A5\u53D7\u8BF7\u6C42\u6B63\u6587");
+      }
+      void options.controller.start();
+      return json(response, 202, { state: options.controller.state() });
+    }
+    if (request.method === "POST" && url.pathname === "/api/dev/stop") {
+      if (Number(request.headers["content-length"] ?? 0) > 0) {
+        return apiError(response, 400, "BODY_NOT_ALLOWED", "\u8BE5\u64CD\u4F5C\u4E0D\u63A5\u53D7\u8BF7\u6C42\u6B63\u6587");
+      }
+      try {
+        return json(response, 200, { state: await options.controller.stop() });
+      } catch {
+        return apiError(response, 500, "DEV_STOP_FAILED", "DEV \u4F1A\u8BDD\u672A\u80FD\u5B89\u5168\u505C\u6B62\uFF0C\u8BF7\u68C0\u67E5\u672C\u5730\u8FDB\u7A0B");
+      }
+    }
+    if (request.method === "POST" && url.pathname === "/api/simulator/messages") {
+      try {
+        const body = exactObject(await readJsonBody(request), ["text", "idempotencyKey"]);
+        if (!body || typeof body.text !== "string" || !body.text.trim() || Buffer.byteLength(body.text, "utf8") > 32 * 1024 || !safeIdentifier(body.idempotencyKey, 128)) {
+          return apiError(response, 400, "INVALID_MESSAGE", "\u6D88\u606F\u6216\u5E42\u7B49\u6807\u8BC6\u4E0D\u7B26\u5408\u8981\u6C42");
+        }
+        const accepted = await options.controller.sendSimulatorMessage({
+          text: body.text,
+          idempotencyKey: body.idempotencyKey
+        });
+        return json(response, 202, accepted);
+      } catch (cause) {
+        const failure = requestFailure(cause);
+        return apiError(response, failure.status, failure.code, failure.message);
+      }
+    }
+    const cancelMatch = /^\/api\/simulator\/runs\/([^/]+)\/cancel$/u.exec(url.pathname);
+    if (request.method === "POST" && cancelMatch) {
+      if (Number(request.headers["content-length"] ?? 0) > 0) {
+        return apiError(response, 400, "BODY_NOT_ALLOWED", "\u8BE5\u64CD\u4F5C\u4E0D\u63A5\u53D7\u8BF7\u6C42\u6B63\u6587");
+      }
+      let runId;
+      try {
+        runId = decodeURIComponent(cancelMatch[1]);
+      } catch {
+        return apiError(response, 400, "INVALID_RUN_ID", "Run ID \u4E0D\u7B26\u5408\u8981\u6C42");
+      }
+      if (!safeIdentifier(runId)) return apiError(response, 400, "INVALID_RUN_ID", "Run ID \u4E0D\u7B26\u5408\u8981\u6C42");
+      try {
+        return json(response, 200, await options.controller.cancelSimulatorRun(runId));
+      } catch (cause) {
+        const failure = requestFailure(cause);
+        return apiError(response, failure.status, failure.code, failure.message);
+      }
+    }
+    return apiError(response, 404, "NOT_FOUND", "\u63A5\u53E3\u4E0D\u5B58\u5728");
+  });
+  try {
+    await new Promise((resolve, reject) => {
+      server.once("error", reject);
+      server.listen(port, host, () => {
+        server.off("error", reject);
+        resolve();
+      });
+    });
+    const address = server.address();
+    if (!address) throw new Error("Preview server has no address");
+    const urlHost = address.address.includes(":") ? `[${address.address}]` : address.address;
+    origin = new URL(`http://${urlHost}:${address.port}`);
+  } catch (cause) {
+    unsubscribeDev();
+    unsubscribeSimulator();
+    await closeServer(server).catch(() => void 0);
+    throw cause;
+  }
+  const bootstrapUrl = new URL(`/bootstrap/${sessionToken}`, origin);
+  return Object.freeze({
+    origin,
+    bootstrapUrl,
+    async close() {
+      unsubscribeDev();
+      unsubscribeSimulator();
+      for (const response of listeners) response.end();
+      listeners.clear();
+      let controllerFailure;
+      try {
+        await options.controller.close();
+      } catch (cause) {
+        controllerFailure = cause;
+      }
+      await closeServer(server);
+      if (controllerFailure !== void 0) throw controllerFailure;
+    }
+  });
+}
+
+// apps/preview/src/mlb-simulator.ts
+import { createHash } from "node:crypto";
+import { normalizePlatformUrl } from "./core.js";
+
+// apps/preview/src/mlb-events.ts
+import { randomUUID } from "node:crypto";
+import { WebSocket } from "ws";
+var MlbEventStreamError = class extends Error {
+  constructor(message2, status = 502, retryable = true) {
+    super(message2);
+    this.status = status;
+    this.retryable = retryable;
+    this.publicMessage = message2;
+  }
+  status;
+  retryable;
+  code = "MLB_EVENT_STREAM_FAILED";
+  publicMessage;
+};
+var MlbAppCommandError = class extends Error {
+  constructor(message2, status = 502) {
+    super(message2);
+    this.status = status;
+    this.publicMessage = message2;
+  }
+  status;
+  code = "MLB_REQUEST_FAILED";
+  publicMessage;
+};
+function appSocket(url, token) {
+  return new WebSocket(url, {
+    headers: { Authorization: `Bearer ${token}` },
+    followRedirects: false,
+    handshakeTimeout: 1e4,
+    maxPayload: 64 * 1024,
+    perMessageDeflate: false
+  });
+}
+async function mlbAppCommand(url, token, method, params, options = {}) {
+  if (options.signal?.aborted) throw options.signal.reason;
+  const requestId = randomUUID();
+  const socket = appSocket(url, token);
+  return await new Promise((resolve, reject) => {
+    let settled = false;
+    let ready = false;
+    let sent = false;
+    const cleanup = () => {
+      clearTimeout(timer);
+      options.signal?.removeEventListener("abort", abort);
+      if (socket.readyState !== WebSocket.CLOSED) socket.terminate();
+    };
+    const finish = (value) => {
+      if (settled) return;
+      settled = true;
+      cleanup();
+      resolve(value);
+    };
+    const fail = (cause) => {
+      if (settled) return;
+      settled = true;
+      cleanup();
+      reject(cause);
+    };
+    const abort = () => fail(options.signal?.reason);
+    const timer = setTimeout(() => fail(new MlbAppCommandError("MLB WebSocket \u547D\u4EE4\u7B49\u5F85\u8D85\u65F6")), 3e4);
+    timer.unref();
+    options.signal?.addEventListener("abort", abort, { once: true });
+    socket.on("error", () => fail(new MlbAppCommandError("\u65E0\u6CD5\u8FDE\u63A5 MLB WebSocket")));
+    socket.on("unexpected-response", (_request, response) => {
+      const status = response.statusCode ?? 502;
+      fail(new MlbAppCommandError(
+        status === 401 ? "MLB \u767B\u5F55\u5DF2\u5931\u6548\uFF0C\u8BF7\u91CD\u65B0\u767B\u5F55\u540E\u91CD\u542F DEV" : `MLB WebSocket \u63E1\u624B\u5931\u8D25\uFF08HTTP ${status}\uFF09`,
+        status
+      ));
+      response.destroy();
+    });
+    socket.on("close", (code) => fail(code === 4401 ? new MlbAppCommandError("MLB \u767B\u5F55\u5DF2\u5931\u6548\uFF0C\u8BF7\u91CD\u65B0\u767B\u5F55\u540E\u91CD\u542F DEV", 401) : new MlbAppCommandError("MLB WebSocket \u8FDE\u63A5\u4E2D\u65AD")));
+    socket.on("message", (raw, binary) => {
+      if (settled) return;
+      try {
+        if (binary) throw new Error("binary");
+        const bytes = Array.isArray(raw) ? Buffer.concat(raw) : Buffer.isBuffer(raw) ? raw : Buffer.from(raw);
+        const frame = JSON.parse(bytes.toString("utf8"));
+        const data = frame.data;
+        if (!frame || frame.v !== 1 || !data || typeof data !== "object" || Array.isArray(data)) {
+          throw new Error("envelope");
+        }
+        if (frame.type === "event") {
+          if (!ready) {
+            if (frame.event !== "ready" || data.resync !== true || typeof data.connectionId !== "string" || !data.connectionId) throw new Error("ready required");
+            ready = true;
+            if (!sent) {
+              sent = true;
+              socket.send(JSON.stringify({ v: 1, type: "request", requestId, method, params }));
+            }
+          }
+          return;
+        }
+        if (frame.type !== "response" || !ready || frame.requestId !== requestId || !Number.isSafeInteger(frame.status) || frame.status < 100 || frame.status > 599) {
+          throw new Error("response");
+        }
+        const status = frame.status;
+        if (status >= 200 && status < 300) {
+          finish(data);
+          return;
+        }
+        const serverMessage = data.error;
+        fail(new MlbAppCommandError(
+          typeof serverMessage === "string" && serverMessage.trim() ? serverMessage.slice(0, 512) : status >= 500 ? "MLB Server \u6682\u65F6\u4E0D\u53EF\u7528" : "\u6A21\u62DF\u5668\u8BF7\u6C42\u672A\u80FD\u5B8C\u6210",
+          status
+        ));
+      } catch {
+        fail(new MlbAppCommandError("MLB WebSocket \u8FD4\u56DE\u4E86\u65E0\u6548\u547D\u4EE4\u56DE\u6267"));
+      }
+    });
+    if (options.signal?.aborted) abort();
+  });
+}
+async function* mlbAppEvents(url, token, options = {}) {
+  if (options.signal?.aborted) return;
+  const socket = appSocket(url, token);
+  const queue = [];
+  let queuedBytes = 0;
+  let ready = false;
+  let ended = false;
+  let failure;
+  let wake;
+  const finish = (cause) => {
+    if (ended) return;
+    ended = true;
+    failure = cause;
+    wake?.();
+  };
+  let timer = setTimeout(() => finish(new MlbEventStreamError("MLB WebSocket \u672A\u5B8C\u6210\u521D\u59CB\u5316")), 1e4);
+  timer.unref();
+  const heartbeat = () => {
+    if (!ready || ended) return;
+    clearTimeout(timer);
+    timer = setTimeout(() => finish(new MlbEventStreamError("MLB WebSocket \u5FC3\u8DF3\u4E2D\u65AD")), 6e4);
+    timer.unref();
+  };
+  const abort = () => finish();
+  socket.on("ping", heartbeat);
+  socket.on("error", () => finish(new MlbEventStreamError("\u65E0\u6CD5\u8FDE\u63A5 MLB WebSocket")));
+  socket.on("unexpected-response", (_request, response) => {
+    const status = response.statusCode ?? 502;
+    finish(new MlbEventStreamError(
+      status === 401 ? "MLB \u767B\u5F55\u5DF2\u5931\u6548\uFF0C\u8BF7\u91CD\u65B0\u767B\u5F55\u540E\u91CD\u542F DEV" : `MLB WebSocket \u63E1\u624B\u5931\u8D25\uFF08HTTP ${status}\uFF09`,
+      status,
+      status >= 500 || status === 429
+    ));
+    response.destroy();
+  });
+  socket.on("close", (code) => finish(code === 4401 ? new MlbEventStreamError("MLB \u767B\u5F55\u5DF2\u5931\u6548\uFF0C\u8BF7\u91CD\u65B0\u767B\u5F55\u540E\u91CD\u542F DEV", 401, false) : new MlbEventStreamError("MLB WebSocket \u8FDE\u63A5\u4E2D\u65AD", 502, ![1002, 1003, 1007, 1008, 1009].includes(code))));
+  socket.on("message", (raw, binary) => {
+    if (ended) return;
+    try {
+      if (binary) throw new Error("binary");
+      const bytes = Array.isArray(raw) ? Buffer.concat(raw) : Buffer.isBuffer(raw) ? raw : Buffer.from(raw);
+      const frame = JSON.parse(bytes.toString("utf8"));
+      if (!frame || frame.v !== 1 || frame.type !== "event" || typeof frame.event !== "string" || !frame.data || typeof frame.data !== "object" || Array.isArray(frame.data)) throw new Error("envelope");
+      if (!ready && frame.event !== "ready") throw new Error("ready required");
+      if (frame.event === "ready" && (frame.data.resync !== true || typeof frame.data.connectionId !== "string" || !frame.data.connectionId)) throw new Error("invalid ready");
+      ready = true;
+      heartbeat();
+      queuedBytes += bytes.byteLength;
+      if (queuedBytes > 1024 * 1024 || queue.length >= 1024) {
+        finish(new MlbEventStreamError("MLB \u4E8B\u4EF6\u63A5\u6536\u79EF\u538B\uFF0C\u6B63\u5728\u91CD\u65B0\u540C\u6B65"));
+        return;
+      }
+      queue.push({ frame: { event: frame.event, data: frame.data }, bytes: bytes.byteLength });
+      wake?.();
+    } catch {
+      finish(new MlbEventStreamError("MLB WebSocket \u8FD4\u56DE\u4E86\u65E0\u6548\u4E8B\u4EF6", 502, false));
+    }
+  });
+  options.signal?.addEventListener("abort", abort, { once: true });
+  if (options.signal?.aborted) abort();
+  try {
+    while (!ended) {
+      const item = queue.shift();
+      if (item) {
+        queuedBytes -= item.bytes;
+        yield item.frame;
+      } else {
+        await new Promise((resolve) => {
+          wake = resolve;
+        });
+        wake = void 0;
+      }
+    }
+    if (failure && !options.signal?.aborted) throw failure;
+  } finally {
+    ended = true;
+    clearTimeout(timer);
+    options.signal?.removeEventListener("abort", abort);
+    if (socket.readyState !== WebSocket.CLOSED) socket.terminate();
+  }
+}
+
+// apps/preview/src/buddy-details.ts
+function invalid() {
+  throw Object.assign(new Error("MLB \u8FD4\u56DE\u7684\u5F00\u53D1\u7248\u642D\u5B50\u8BE6\u60C5\u4E0D\u7B26\u5408\u63A5\u53E3\u7EA6\u5B9A"), {
+    code: "BUDDY_DETAILS_INVALID",
+    status: 502,
+    publicMessage: "MLB \u8FD4\u56DE\u7684\u5F00\u53D1\u7248\u642D\u5B50\u8BE6\u60C5\u4E0D\u7B26\u5408\u63A5\u53E3\u7EA6\u5B9A"
+  });
+}
+function record(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return invalid();
+  return value;
+}
+function text(value, multiline = false) {
+  if (typeof value !== "string" || Buffer.byteLength(value) > 32 * 1024 || (multiline ? /[\u0000-\u0008\u000b\u000c\u000e-\u001f\u007f]/u : /[\u0000-\u001f\u007f]/u).test(value)) return invalid();
+  return value;
+}
+function nullableText(value, multiline = false) {
+  return value === null ? null : text(value, multiline);
+}
+function parsePreviewBuddyDetails(value, expectedId) {
+  const source = record(value);
+  if (source.id !== expectedId || source.isDev !== true || typeof source.name !== "string" || !source.name.trim() || source.privateId !== null && (typeof source.privateId !== "string" || !/^p_[a-zA-Z0-9_-]{1,253}$/u.test(source.privateId)) || !Number.isSafeInteger(source.addedCount) || source.addedCount < 0) return invalid();
+  return Object.freeze({
+    id: expectedId,
+    isDev: true,
+    name: text(source.name),
+    avatar: nullableText(source.avatar),
+    tagline: nullableText(source.tagline),
+    intro: nullableText(source.intro, true),
+    creatorUserId: nullableText(source.creatorUserId),
+    creatorUserName: nullableText(source.creatorUserName),
+    creatorUserAvatar: nullableText(source.creatorUserAvatar),
+    privateId: source.privateId,
+    addedCount: source.addedCount
+  });
+}
+
+// apps/preview/src/mlb-simulator.ts
+function safeText(value, name, maximum = 4096) {
+  if (typeof value !== "string" || !value.trim() || value.length > maximum || /[\u0000-\u001f\u007f]/u.test(value)) {
+    throw new TypeError(`${name} is invalid`);
+  }
+  return value;
+}
+function endpoint(base, path) {
+  return new URL(path.replace(/^\//u, ""), base);
+}
+function object(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+}
+function httpError(status, value) {
+  const serverMessage = object(value)?.error;
+  const message2 = typeof serverMessage === "string" && serverMessage.trim() ? serverMessage.slice(0, 512) : status >= 500 ? "MLB Server \u6682\u65F6\u4E0D\u53EF\u7528" : "\u6A21\u62DF\u5668\u8BF7\u6C42\u672A\u80FD\u5B8C\u6210";
+  return Object.assign(new Error(message2), {
+    code: "MLB_REQUEST_FAILED",
+    status,
+    publicMessage: message2
+  });
+}
+function message(value, index) {
+  const input = object(value);
+  if (!input || typeof input.author !== "string") return null;
+  const role = input.author === "buddy" ? "assistant" : input.author === "user" || input.author === "owner" ? "user" : void 0;
+  if (!role) return null;
+  const messageId = safeText(input.id, `messages[${index}].id`, 256);
+  if (typeof input.text !== "string" || Buffer.byteLength(input.text, "utf8") > 48 * 1024) {
+    throw new Error(`messages[${index}].text is invalid`);
+  }
+  if (input.type === "tool" && !input.text.trim()) return null;
+  if (typeof input.timestamp !== "number" || !Number.isFinite(input.timestamp)) {
+    throw new Error(`messages[${index}].timestamp is invalid`);
+  }
+  return Object.freeze({
+    messageId,
+    role,
+    text: input.text,
+    createdAt: new Date(input.timestamp).toISOString()
+  });
+}
+function localReceipt(prefix, value) {
+  return `${prefix}-${createHash("sha256").update(value).digest("hex").slice(0, 20)}`;
+}
+function waitForRetry(milliseconds, signal) {
+  if (signal?.aborted) return Promise.reject(signal.reason);
+  return new Promise((resolve, reject) => {
+    const abort = () => {
+      clearTimeout(timer);
+      reject(signal?.reason);
+    };
+    const timer = setTimeout(() => {
+      signal?.removeEventListener("abort", abort);
+      resolve();
+    }, milliseconds);
+    signal?.addEventListener("abort", abort, { once: true });
+  });
+}
+var MlbSimulatorClient = class {
+  #baseUrl;
+  #buddyId;
+  #accessToken;
+  #fetch;
+  #sending = false;
+  #lastSend;
+  #privateId;
+  #privatePromise;
+  #active;
+  #latest;
+  #streaming;
+  #messages = Object.freeze([]);
+  constructor(options) {
+    this.#baseUrl = normalizePlatformUrl(options.baseUrl);
+    this.#buddyId = safeText(options.buddyId, "buddyId", 256);
+    if (!this.#buddyId.endsWith("-dev")) {
+      throw new TypeError("MLB simulator buddyId must use the -dev identity");
+    }
+    this.#accessToken = safeText(options.auth.developerAccessToken, "developerAccessToken", 16384);
+    this.#fetch = options.fetch ?? globalThis.fetch;
+    if (typeof this.#fetch !== "function") throw new TypeError("A Fetch API implementation is required");
+  }
+  /** Reading a profile must not add the Buddy or trigger a welcome message. */
+  async details(options = {}) {
+    const signal = AbortSignal.any([AbortSignal.timeout(3e4), ...options.signal ? [options.signal] : []]);
+    const details = parsePreviewBuddyDetails(await this.#request("GET", `/app/buddies/${encodeURIComponent(this.#buddyId)}`, { signal }), this.#buddyId);
+    this.#privateId = details.privateId ?? void 0;
+    return details;
+  }
+  async state(options = {}) {
+    const privateId = await this.#ensurePrivate(options.signal);
+    const value = await this.#request("GET", `/app/privates/${encodeURIComponent(privateId)}`, {
+      signal: options.signal
+    });
+    const body = object(value);
+    const conversation = object(body?.private);
+    if (!body || conversation?.id !== privateId || conversation?.buddyId !== this.#buddyId || !Array.isArray(body.messages) || typeof body.replying !== "boolean") {
+      throw httpError(502, { error: "MLB Server \u8FD4\u56DE\u4E86\u65E0\u6CD5\u8BC6\u522B\u7684\u79C1\u804A\u72B6\u6001" });
+    }
+    this.#messages = Object.freeze(body.messages.map((item, index) => message(item, index)).filter((item) => item !== null));
+    if (this.#active) {
+      const replied = this.#messages.some((item) => item.role === "assistant" && Date.parse(item.createdAt) > this.#active.messageTimestamp);
+      if (body.replying) {
+        this.#active = Object.freeze({ ...this.#active, observedReplying: true });
+        this.#latest = Object.freeze({ runId: this.#active.runId, status: "running" });
+      } else if (replied) {
+        this.#latest = Object.freeze({ runId: this.#active.runId, status: "completed" });
+        this.#active = void 0;
+        this.#streaming = void 0;
+      } else if (this.#active.observedReplying) {
+        this.#latest = Object.freeze({ runId: this.#active.runId, status: "failed" });
+        this.#active = void 0;
+        this.#streaming = void 0;
+      }
+    }
+    return Object.freeze({
+      messages: this.#messages,
+      ...this.#latest === void 0 ? {} : { latestRun: this.#latest },
+      ...this.#active === void 0 ? {} : {
+        activeRun: Object.freeze({
+          runId: this.#active.runId,
+          status: body.replying ? "running" : "pending"
+        })
+      },
+      ...this.#streaming === void 0 ? {} : { streaming: this.#streaming }
+    });
+  }
+  async send(input, options = {}) {
+    if (typeof input.text !== "string" || !input.text.trim() || Buffer.byteLength(input.text, "utf8") > 32 * 1024) {
+      throw new TypeError("message text is invalid");
+    }
+    const idempotencyKey = safeText(input.idempotencyKey, "idempotencyKey", 128);
+    if (this.#lastSend?.key === idempotencyKey) {
+      if (this.#lastSend.text !== input.text.trim()) throw httpError(409, { error: "\u540C\u4E00\u6761\u6D88\u606F\u4E0D\u80FD\u6539\u5199\u5185\u5BB9" });
+      return this.#lastSend.receipt;
+    }
+    if (this.#active || this.#sending) {
+      throw Object.assign(new Error("\u4E0A\u4E00\u8F6E\u56DE\u590D\u5C1A\u672A\u7ED3\u675F"), {
+        code: "TURN_IN_PROGRESS",
+        status: 409,
+        publicMessage: "\u8BF7\u7B49\u5F85\u5F53\u524D\u56DE\u590D\u5B8C\u6210\u540E\u518D\u53D1\u9001"
+      });
+    }
+    this.#sending = true;
+    try {
+      const privateId = await this.#ensurePrivate(options.signal);
+      const clientMessageId = localReceipt("client", idempotencyKey);
+      let value;
+      try {
+        const url = endpoint(this.#baseUrl, "/app/ws");
+        url.protocol = url.protocol === "https:" ? "wss:" : "ws:";
+        value = await mlbAppCommand(url, this.#accessToken, "message.send", {
+          kind: "private",
+          id: privateId,
+          message: input.text,
+          clientMessageId
+        }, { signal: options.signal });
+        const receipt2 = object(value);
+        if (receipt2?.ok !== true || receipt2.clientMessageId !== clientMessageId || typeof receipt2.messageId !== "string" || !receipt2.messageId.trim() || !Number.isSafeInteger(receipt2.timestamp) || receipt2.timestamp < 0 || typeof receipt2.shouldReply !== "boolean") {
+          throw httpError(502, { error: "MLB \u6D88\u606F\u56DE\u6267\u65E0\u6548" });
+        }
+        safeText(receipt2.messageId, "receipt.messageId", 256);
+      } catch (cause) {
+        if (cause && typeof cause === "object" && "status" in cause && typeof cause.status === "number" && cause.status >= 400 && cause.status < 500) throw cause;
+        throw Object.assign(new Error("\u53D1\u9001\u7ED3\u679C\u5C1A\u672A\u786E\u8BA4\uFF0C\u8BF7\u5237\u65B0\u804A\u5929\u8BB0\u5F55\u540E\u518D\u91CD\u8BD5"), {
+          code: "MLB_SEND_OUTCOME_UNKNOWN",
+          status: 502,
+          publicMessage: "\u53D1\u9001\u7ED3\u679C\u5C1A\u672A\u786E\u8BA4\uFF0C\u8BF7\u5237\u65B0\u804A\u5929\u8BB0\u5F55\u540E\u518D\u91CD\u8BD5"
+        });
+      }
+      const receipt = object(value);
+      const runId = localReceipt("turn", idempotencyKey);
+      const messageId = safeText(receipt.messageId, "receipt.messageId", 256);
+      this.#active = receipt.shouldReply ? Object.freeze({
+        runId,
+        messageTimestamp: receipt.timestamp,
+        observedReplying: false
+      }) : void 0;
+      this.#latest = Object.freeze({ runId, status: receipt.shouldReply ? "pending" : "completed" });
+      this.#streaming = void 0;
+      const accepted = Object.freeze({ messageId, runId });
+      this.#lastSend = { key: idempotencyKey, text: input.text.trim(), receipt: accepted };
+      return accepted;
+    } finally {
+      this.#sending = false;
+    }
+  }
+  async cancel(_runId, _options = {}) {
+    throw Object.assign(new Error("\u5F53\u524D MLB \u534F\u8BAE\u5C1A\u672A\u63D0\u4F9B\u7EC8\u6B62\u56DE\u590D\u63A5\u53E3"), {
+      code: "TURN_CANCEL_UNSUPPORTED",
+      status: 501,
+      publicMessage: "\u5F53\u524D\u7248\u672C\u6682\u4E0D\u652F\u6301\u7EC8\u6B62\u56DE\u590D"
+    });
+  }
+  async watchOutput(runId, options) {
+    const safeRunId = safeText(runId, "runId", 256);
+    const privateId = await this.#ensurePrivate(options.signal);
+    const url = endpoint(this.#baseUrl, "/app/ws");
+    url.protocol = url.protocol === "https:" ? "wss:" : "ws:";
+    let sequence = 0;
+    const reset = async () => {
+      sequence = 0;
+      this.#streaming = void 0;
+      await options.onEvent({ type: "reset", runId: safeRunId });
+    };
+    for (let reconnects = 0; !options.signal?.aborted; reconnects++) {
+      try {
+        for await (const frame of mlbAppEvents(url, this.#accessToken, {
+          signal: options.signal
+        })) {
+          const { data } = frame;
+          if (frame.event === "ready") {
+            await reset();
+          } else if (data.kind !== "private" || data.id !== privateId || data.buddyId !== this.#buddyId) {
+            continue;
+          }
+          if (frame.event === "delta" && typeof data.text === "string" && data.text.length > 0) {
+            const text2 = `${this.#streaming?.runId === safeRunId ? this.#streaming.text : ""}${data.text}`;
+            if (Buffer.byteLength(text2, "utf8") > 48 * 1024) throw new MlbEventStreamError("MLB \u6D41\u5F0F\u56DE\u590D\u8D85\u8FC7\u5927\u5C0F\u9650\u5236", 502, false);
+            this.#streaming = Object.freeze({ runId: safeRunId, text: text2, nextSequence: sequence + 1, updatedAt: (/* @__PURE__ */ new Date()).toISOString() });
+            await options.onEvent({ type: "delta", runId: safeRunId, sequence, text: data.text });
+            sequence++;
+            continue;
+          }
+          if (frame.event !== "chat" && frame.event !== "ready") continue;
+          const state = await this.state({ signal: options.signal });
+          if (state.latestRun?.runId === safeRunId && (state.latestRun.status === "completed" || state.latestRun.status === "failed")) {
+            await options.onEvent({ type: state.latestRun.status, runId: safeRunId, status: state.latestRun.status });
+            return;
+          }
+        }
+        if (options.signal?.aborted) return;
+      } catch (cause) {
+        if (options.signal?.aborted) return;
+        await reset();
+        const status = object(cause)?.status;
+        if (cause instanceof MlbEventStreamError && !cause.retryable || typeof status === "number" && status >= 400 && status < 500 && status !== 429 || reconnects >= 4) throw cause;
+      }
+      await waitForRetry(Math.min(1e3, (reconnects + 1) * 150), options.signal);
+    }
+  }
+  async #ensurePrivate(signal) {
+    if (this.#privateId) return this.#privateId;
+    if (!this.#privatePromise) {
+      const pending = this.#request(
+        "POST",
+        "/app/privates",
+        { signal, body: { buddyId: this.#buddyId } }
+      ).then((value) => {
+        const body = object(value);
+        if (body?.ok !== true || typeof body.id !== "string" || !/^p_[a-zA-Z0-9_-]{1,253}$/u.test(body.id)) {
+          throw httpError(502, { error: "MLB \u521B\u5EFA\u79C1\u804A\u54CD\u5E94\u7F3A\u5C11\u6709\u6548\u7684 privateId" });
+        }
+        this.#privateId = body.id;
+        return body.id;
+      }).finally(() => {
+        if (this.#privatePromise === pending) this.#privatePromise = void 0;
+      });
+      this.#privatePromise = pending;
+    }
+    return this.#privatePromise;
+  }
+  async #request(method, path, options) {
+    const headers = new Headers({
+      Accept: "application/json",
+      Authorization: `Bearer ${this.#accessToken}`
+    });
+    if (options.body !== void 0) headers.set("Content-Type", "application/json");
+    const response = await this.#fetch(endpoint(this.#baseUrl, path), {
+      method,
+      headers,
+      ...options.body === void 0 ? {} : { body: JSON.stringify(options.body) },
+      signal: AbortSignal.any([AbortSignal.timeout(3e4), ...options.signal ? [options.signal] : []]),
+      redirect: "error"
+    });
+    const value = await response.json().catch(() => void 0);
+    if (!response.ok) throw httpError(response.status, value);
+    return value;
+  }
+};
+export {
+  MlbSimulatorClient,
+  PreviewController,
+  createBuddyPreviewUrl,
+  startPreviewControlServer
+};
+//# sourceMappingURL=preview.js.map