@my-life-buddies/cli 0.13.3 → 0.14.1

package/dist/bin/preview.js

@@ -9,6 +9,175 @@ function createBuddyPreviewUrl(buddyId) {
   return `mlb://preview?${new URLSearchParams({ buddyId })}`;
 }
 
+// apps/preview/src/runtime-diagnostics.ts
+function parseInspectedData(text2) {
+  let at = 0;
+  const space = () => {
+    while (/\s/u.test(text2[at] ?? "") && at < text2.length) at++;
+  };
+  const fail = () => {
+    throw new Error("Unsupported log data");
+  };
+  function string() {
+    const quote = text2[at++];
+    let result = "";
+    while (at < text2.length) {
+      const char = text2[at++];
+      if (char === quote) return result;
+      if (char !== "\\") {
+        result += char;
+        continue;
+      }
+      const escaped = text2[at++];
+      const escapes = { n: "\n", r: "\r", t: "	", b: "\b", f: "\f", v: "\v", "0": "\0", "\\": "\\", "'": "'", '"': '"', "`": "`", "$": "$" };
+      if (escaped === "x" || escaped === "u") {
+        const length = escaped === "x" ? 2 : 4;
+        const hex = text2.slice(at, at + length);
+        if (!new RegExp(`^[0-9a-fA-F]{${length}}$`, "u").test(hex)) fail();
+        result += String.fromCharCode(parseInt(hex, 16));
+        at += length;
+      } else if (escaped !== void 0 && Object.hasOwn(escapes, escaped)) result += escapes[escaped];
+      else fail();
+    }
+    return fail();
+  }
+  function value(depth = 0) {
+    if (depth > 40) fail();
+    space();
+    const char = text2[at];
+    if (char === "'" || char === '"' || char === "`") {
+      let result = string();
+      space();
+      while (text2[at] === "+") {
+        at++;
+        space();
+        if (!["'", '"', "`"].includes(text2[at] ?? "")) fail();
+        result += string();
+        space();
+      }
+      return result;
+    }
+    if (char === "{" || char === "[") {
+      const array = char === "[";
+      const end = array ? "]" : "}";
+      const result = /* @__PURE__ */ Object.create(null);
+      const items = [];
+      at++;
+      space();
+      while (text2[at] !== end) {
+        if (at >= text2.length) fail();
+        if (array) items.push(value(depth + 1));
+        else {
+          const quoted = ["'", '"', "`"].includes(text2[at] ?? "");
+          const key = quoted ? string() : /^[\w$]+/u.exec(text2.slice(at))?.[0];
+          if (key === void 0) return fail();
+          if (!quoted) at += key.length;
+          space();
+          if (text2[at++] !== ":" || Object.hasOwn(result, key)) fail();
+          result[key] = value(depth + 1);
+        }
+        space();
+        if (text2[at] === end) break;
+        if (text2[at++] !== ",") fail();
+        space();
+      }
+      at++;
+      return array ? items : result;
+    }
+    const literal = /^(true|false|null|undefined|[-+]?(?:\d+\.?\d*|\.\d+)(?:e[-+]?\d+)?)(?=[\s,\]}]|$)/iu.exec(text2.slice(at))?.[0];
+    if (!literal) return fail();
+    at += literal.length;
+    if (literal === "true") return true;
+    if (literal === "false") return false;
+    if (literal === "null" || literal === "undefined") return null;
+    const number = Number(literal);
+    return Number.isFinite(number) ? number : fail();
+  }
+  try {
+    if (text2.length > 98304) return void 0;
+    const result = value();
+    space();
+    return at === text2.length && result !== null && typeof result === "object" && !Array.isArray(result) ? result : void 0;
+  } catch {
+    return void 0;
+  }
+}
+var HEADER = /^(\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}\.\d{3}) \[[^\]\r\n]+\] (INFO|WARN|ERROR)\s+(.+)$/u;
+var MAX_RECORD = 98304;
+var MAX_BYTES = 15e5;
+var RuntimeDiagnostics = class {
+  #sequence = 0;
+  #records = [];
+  #active = /* @__PURE__ */ new Map();
+  #sizes = /* @__PURE__ */ new Map();
+  #bytes = 0;
+  #dropped = 0;
+  write(source, text2, observedAt) {
+    for (const line of text2.split(/\r?\n/u)) {
+      if (!line) continue;
+      const header = HEADER.exec(line);
+      const previousIndex = this.#records.findIndex((record3) => record3.id === this.#active.get(source));
+      const previous = this.#records[previousIndex];
+      const continuation = !header && previous && (/^\s/u.test(line) || line === "}");
+      let record2;
+      if (continuation) {
+        const raw = `${previous.raw}
+${line}`;
+        record2 = { ...previous, raw: raw.slice(0, MAX_RECORD), truncated: previous.truncated || raw.length > MAX_RECORD || line.endsWith(" \u2026[truncated]") };
+      } else {
+        const title = header ? header[3].replace(/ \{.*$/u, "") : line.slice(0, 180);
+        const time = header ? Date.parse(`${header[1].replace(" ", "T")}+08:00`) : NaN;
+        record2 = {
+          id: `runtime-${++this.#sequence}`,
+          timestamp: Number.isFinite(time) ? new Date(time).toISOString() : observedAt,
+          source,
+          level: header ? header[2].toLowerCase() : source === "agent.stderr" ? "error" : "info",
+          title,
+          kind: header && title === "\u6A21\u578B\u8BF7\u6C42\u4F53" ? "request" : header && title === "\u6A21\u578B\u54CD\u5E94" ? "response" : "log",
+          raw: line.slice(0, MAX_RECORD),
+          truncated: line.length > MAX_RECORD || line.endsWith(" \u2026[truncated]")
+        };
+        this.#active.set(source, record2.id);
+      }
+      if (!record2.truncated && line.trimEnd().endsWith("}")) {
+        const head = HEADER.exec(record2.raw.split("\n")[0]);
+        const offset = head ? record2.raw.indexOf(" {", record2.raw.indexOf(head[3])) : -1;
+        const data = offset < 0 ? void 0 : parseInspectedData(record2.raw.slice(offset + 1));
+        if (data) record2 = { ...record2, data, ...typeof data.convoKey === "string" ? { convoKey: data.convoKey } : {} };
+      }
+      if (continuation && previous.data) {
+        const { data: _data, convoKey: _convoKey, ...rawRecord } = record2;
+        record2 = rawRecord;
+      }
+      this.#bytes -= this.#sizes.get(record2.id) ?? 0;
+      const size = Buffer.byteLength(JSON.stringify(record2));
+      this.#sizes.set(record2.id, size);
+      this.#bytes += size;
+      if (continuation) this.#records[previousIndex] = record2;
+      else this.#records.push(record2);
+      while (this.#records.length > 200 || this.#bytes > MAX_BYTES) {
+        const removed = this.#records.shift();
+        this.#bytes -= this.#sizes.get(removed.id) ?? 0;
+        this.#sizes.delete(removed.id);
+        this.#dropped++;
+      }
+    }
+  }
+  boundary() {
+    this.#active.clear();
+  }
+  clear() {
+    this.#records = [];
+    this.#active.clear();
+    this.#sizes.clear();
+    this.#bytes = 0;
+    this.#dropped = 0;
+  }
+  snapshot() {
+    return { records: [...this.#records].reverse(), dropped: this.#dropped };
+  }
+};
+
 // apps/preview/src/controller.ts
 var TERMINAL_RUN_STATUSES = /* @__PURE__ */ new Set(["completed", "failed", "cancelled"]);
 function publicFailure(cause) {
@@ -31,8 +200,10 @@ var PreviewController = class {
   #failedOutputRuns = /* @__PURE__ */ new Set();
   #observedActiveRuns = /* @__PURE__ */ new Set();
   #events = [];
+  #diagnostics = new RuntimeDiagnostics();
   #runOrdinal = 0;
   #conversationRevision = 0;
+  #simulatorRevision = 0;
   #resetting = false;
   #sendingMessage = false;
   get resetting() {
@@ -78,7 +249,7 @@ var PreviewController = class {
     return () => this.#simulatorListeners.delete(listener);
   }
   simulatorSnapshot() {
-    return Object.freeze({ ...this.#simulatorState, conversationRevision: this.#conversationRevision });
+    return Object.freeze({ ...this.#simulatorState, conversationRevision: this.#conversationRevision, stateRevision: this.#simulatorRevision });
   }
   start() {
     if (this.#startPromise) return this.#startPromise;
@@ -87,6 +258,7 @@ var PreviewController = class {
       return Promise.reject(Object.assign(new Error("DEV \u4F1A\u8BDD\u6B63\u5728\u505C\u6B62"), { code: "DEV_STOPPING" }));
     }
     const controller = new AbortController();
+    this.#diagnostics.boundary();
     this.#startController = controller;
     this.#record({ channel: "dev", type: "dev.start_requested", summary: "\u8BF7\u6C42\u542F\u52A8 DEV \u4F1A\u8BDD" });
     this.#setState({ phase: "starting" });
@@ -95,7 +267,8 @@ var PreviewController = class {
       signal: controller.signal,
       onLog: ({ source, text: text2 }) => {
         if (controller.signal.aborted) return;
-        this.#record({ channel: "dev", type: source, summary: text2.slice(0, 8224) });
+        this.#diagnostics.write(source, text2, this.#now().toISOString());
+        this.#record({ channel: "dev", type: source, summary: text2.slice(0, 512) });
         this.#notifySimulator();
       }
     }).then(({ handle, ready, simulator }) => {
@@ -218,6 +391,7 @@ var PreviewController = class {
       this.#runs.clear();
       this.#observedActiveRuns.clear();
       this.#events.length = 0;
+      this.#diagnostics.clear();
       this.#runOrdinal = 0;
       this.#lastActiveRunId = void 0;
       this.#messages = Object.freeze([]);
@@ -235,7 +409,29 @@ var PreviewController = class {
       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;
+      if (this.#runs.has(accepted.runId)) {
+        if (this.#simulatorState.activeRun?.runId === accepted.runId && !this.#simulatorState.messages.some((message2) => message2.messageId === accepted.messageId)) {
+          this.#record({
+            channel: "app_server",
+            type: "message.accepted",
+            summary: "\u8FFD\u52A0\u6D88\u606F\u5DF2\u63A5\u6536",
+            runId: accepted.runId,
+            durationMs: Math.max(0, this.#now().getTime() - started.getTime())
+          });
+          this.#simulatorState = Object.freeze({
+            ...this.#simulatorState,
+            messages: Object.freeze([...this.#simulatorState.messages, Object.freeze({
+              messageId: accepted.messageId,
+              role: "user",
+              text: input.text,
+              createdAt: this.#now().toISOString()
+            })])
+          });
+          this.#messages = this.#simulatorState.messages;
+          this.#notifySimulator();
+        }
+        return accepted;
+      }
       const acceptedAt = this.#now();
       const latency = Math.max(0, acceptedAt.getTime() - started.getTime());
       this.#upsertRun({
@@ -314,7 +510,8 @@ var PreviewController = class {
       generatedAt: this.#now().toISOString(),
       runs: Object.freeze([...this.#runs.values()].reverse()),
       events: Object.freeze([...this.#events].reverse()),
-      messages: Object.freeze([...this.#messages])
+      messages: Object.freeze([...this.#messages]),
+      diagnostics: this.#diagnostics.snapshot()
     });
   }
   devicePairing() {
@@ -460,7 +657,7 @@ var PreviewController = class {
     void simulator.watchOutput(runId, {
       signal: controller.signal,
       onEvent: (event) => {
-        if (this.#resetting || simulator !== this.#simulator) return;
+        if (controller.signal.aborted || this.#resetting || simulator !== this.#simulator) return;
         return this.#observeOutputEvent(event);
       }
     }).catch((cause) => {
@@ -479,6 +676,14 @@ var PreviewController = class {
     });
   }
   async #observeOutputEvent(event) {
+    if (event.type === "state") {
+      if (event.resetStreaming) {
+        const { streaming: _streaming, ...state } = this.#simulatorState;
+        this.#simulatorState = Object.freeze(state);
+      }
+      this.#observeSimulatorState(event.state);
+      return;
+    }
     if (event.type === "reset") {
       if (this.#simulatorState.streaming?.runId === event.runId) {
         const { streaming: _streaming, ...state } = this.#simulatorState;
@@ -560,6 +765,7 @@ var PreviewController = class {
     controller.abort(new Error("Agent local turn reached a terminal state"));
   }
   #notifySimulator() {
+    this.#simulatorRevision++;
     if (this.#simulatorListeners.size === 0) return;
     const value = Object.freeze({ state: this.simulatorSnapshot(), debug: this.debugSnapshot() });
     for (const listener of this.#simulatorListeners) {
@@ -640,6 +846,7 @@ var WEB_ASSETS = Object.freeze(/* @__PURE__ */ new Map([
     contentType: "text/javascript; charset=utf-8",
     body: readFileSync(new URL("../web/app.js", import.meta.url))
   }],
+  ["/assets/diagnostics.js", { contentType: "text/javascript; charset=utf-8", body: readFileSync(new URL("../web/diagnostics.js", import.meta.url)) }],
   ["/assets/developer-platform-icon.png", {
     contentType: "image/png",
     body: BRAND_ICON
@@ -1463,7 +1670,7 @@ var MlbSimulatorClient = class {
         this.#active = void 0;
         this.#streaming = void 0;
       } else if (this.#active.observedReplying) {
-        this.#latest = Object.freeze({ runId: this.#active.runId, status: "failed" });
+        this.#latest = Object.freeze({ runId: this.#active.runId, status: "completed" });
         this.#active = void 0;
         this.#streaming = void 0;
       }
@@ -1490,11 +1697,11 @@ var MlbSimulatorClient = class {
       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",
+    if (this.#sending) {
+      throw Object.assign(new Error("\u6D88\u606F\u6B63\u5728\u53D1\u9001"), {
+        code: "SEND_IN_PROGRESS",
         status: 409,
-        publicMessage: "\u8BF7\u7B49\u5F85\u5F53\u524D\u56DE\u590D\u5B8C\u6210\u540E\u518D\u53D1\u9001"
+        publicMessage: "\u6D88\u606F\u6B63\u5728\u53D1\u9001\uFF0C\u8BF7\u7A0D\u5019"
       });
     }
     this.#sending = true;
@@ -1528,15 +1735,17 @@ var MlbSimulatorClient = class {
       }
       const receipt = object(value);
       const item = object(receipt.items[0]);
-      const runId = localReceipt("turn", idempotencyKey);
+      const runId = this.#active?.runId ?? localReceipt("turn", idempotencyKey);
       const messageId = safeText(item.messageId, "receipt.items[0].messageId", 256);
-      this.#active = receipt.shouldReply ? Object.freeze({
-        runId,
-        messageTimestamp: item.timestamp,
-        observedReplying: false
-      }) : void 0;
-      this.#latest = Object.freeze({ runId, status: receipt.shouldReply ? "pending" : "completed" });
-      this.#streaming = void 0;
+      if (!this.#active) {
+        this.#active = receipt.shouldReply ? Object.freeze({
+          runId,
+          messageTimestamp: item.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;
@@ -1604,6 +1813,7 @@ var MlbSimulatorClient = class {
     const url = endpoint(this.#baseUrl, "/app/ws");
     url.protocol = url.protocol === "https:" ? "wss:" : "ws:";
     let sequence = 0;
+    let assistantIds = new Set(this.#messages.filter((message2) => message2.role === "assistant").map((message2) => message2.messageId));
     const reset = async () => {
       sequence = 0;
       this.#streaming = void 0;
@@ -1629,11 +1839,21 @@ var MlbSimulatorClient = class {
             continue;
           }
           if (frame.event !== "chat" && frame.event !== "ready") continue;
-          const state = await this.state({ signal: options.signal });
+          let state = await this.state({ signal: options.signal });
+          const nextAssistantIds = new Set(state.messages.filter((message2) => message2.role === "assistant").map((message2) => message2.messageId));
+          const committedReply = [...nextAssistantIds].some((id) => !assistantIds.has(id));
+          assistantIds = nextAssistantIds;
+          if (committedReply && state.activeRun) {
+            sequence = 0;
+            this.#streaming = void 0;
+            const { streaming: _streaming, ...snapshot } = state;
+            state = snapshot;
+          }
           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;
           }
+          await options.onEvent({ type: "state", runId: safeRunId, state, resetStreaming: committedReply });
         }
         if (options.signal?.aborted) return;
       } catch (cause) {
@@ -1728,6 +1948,42 @@ async function connectPreviewBridge(options) {
   const initial = await attach();
   if (initial.reused) return { reused: true, completion: Promise.resolve(), async close() {
   } };
+  const pendingEvents = /* @__PURE__ */ new Map();
+  let eventSequence = 0;
+  let publishing;
+  let retryEvents;
+  const flushEvents = () => {
+    if (!initial.liveEvents || signal.aborted || publishing || retryEvents || !pendingEvents.size) return;
+    publishing = (async () => {
+      while (!signal.aborted && pendingEvents.size) {
+        const events = [...pendingEvents.values()].sort((a, b) => a.sequence - b.sequence);
+        try {
+          await call("api/preview/events", connectionId, { events });
+          for (const event of events) if (pendingEvents.get(event.type) === event) pendingEvents.delete(event.type);
+        } catch {
+          if (!signal.aborted) retryEvents = setTimeout(() => {
+            retryEvents = void 0;
+            flushEvents();
+          }, 500);
+          break;
+        }
+      }
+    })().finally(() => {
+      publishing = void 0;
+    });
+  };
+  const queueEvent = (type, value) => {
+    if (!initial.liveEvents || signal.aborted) return;
+    pendingEvents.set(type, { sequence: eventSequence++, type, value });
+    flushEvents();
+  };
+  const snapshotEvents = () => {
+    queueEvent("dev.state", options.controller.state());
+    queueEvent("simulator.state", { state: options.controller.simulatorSnapshot() });
+  };
+  const unsubscribeDev = options.controller.subscribe((state) => queueEvent("dev.state", state));
+  const unsubscribeSimulator = options.controller.subscribeSimulator(({ state }) => queueEvent("simulator.state", { state }));
+  snapshotEvents();
   const watchdog = setInterval(() => {
     if (Date.now() - lastContact < 1e4 || stopping || interrupted) return;
     interrupted = true;
@@ -1801,12 +2057,18 @@ async function connectPreviewBridge(options) {
           if (status === 410) {
             await options.controller.stop();
             if ((await attach()).reused) throw new Error("\u5F53\u524D\u5DE5\u7A0B\u5DF2\u6709\u5176\u4ED6 CLI \u8FDE\u63A5\uFF0C\u8BF7\u91CD\u65B0\u8FD0\u884C preview \u6253\u5F00\u540E\u53F0");
+            snapshotEvents();
           } else if (status && status >= 400 && status < 500 && status !== 429) throw cause;
         }
         await delay(replies.size ? 20 : 500, void 0, { signal }).catch(() => void 0);
       }
     } finally {
       clearInterval(watchdog);
+      unsubscribeDev();
+      unsubscribeSimulator();
+      if (retryEvents) clearTimeout(retryEvents);
+      shutdown.abort();
+      await publishing;
     }
   })();
   void completion.catch(() => void 0);