@baique/pi-web-sky 0.1.35 → 0.1.36

package/.next/trace-build

@@ -1 +1 @@
-[{"name":"run-webpack","duration":27382115,"timestamp":19454917504,"id":14,"parentId":1,"tags":{},"startTime":1788280988635,"traceId":"9678d98c14895f8d"},{"name":"run-typescript","duration":19825586,"timestamp":19482307922,"id":1004,"parentId":1,"tags":{},"startTime":1788281016025,"traceId":"9678d98c14895f8d"},{"name":"static-check","duration":3922639,"timestamp":19502214102,"id":1007,"parentId":1,"tags":{},"startTime":1788281035931,"traceId":"9678d98c14895f8d"},{"name":"static-generation","duration":6090787,"timestamp":19506566895,"id":1153,"parentId":1,"tags":{},"startTime":1788281040284,"traceId":"9678d98c14895f8d"},{"name":"collect-build-traces","duration":54685097,"timestamp":19506140492,"id":1150,"parentId":1,"tags":{},"startTime":1788281039858,"traceId":"9678d98c14895f8d"},{"name":"telemetry-flush","duration":70,"timestamp":19560830811,"id":1162,"parentId":1,"tags":{},"startTime":1788281094548,"traceId":"9678d98c14895f8d"},{"name":"next-build","duration":106024469,"timestamp":19454806423,"id":1,"tags":{"buildMode":"default","version":"16.3.1","bundler":"webpack","has-custom-webpack-config":"false","use-build-worker":"true"},"startTime":1788280988523,"traceId":"9678d98c14895f8d"}]
+[{"name":"run-webpack","duration":22650232,"timestamp":22590332853,"id":14,"parentId":1,"tags":{},"startTime":1788284124050,"traceId":"7bb8ae0dfe4d6fb8"},{"name":"run-typescript","duration":18061477,"timestamp":22612988890,"id":779,"parentId":1,"tags":{},"startTime":1788284146706,"traceId":"7bb8ae0dfe4d6fb8"},{"name":"static-check","duration":3027832,"timestamp":22631130170,"id":782,"parentId":1,"tags":{},"startTime":1788284164847,"traceId":"7bb8ae0dfe4d6fb8"},{"name":"static-generation","duration":5570297,"timestamp":22634582835,"id":928,"parentId":1,"tags":{},"startTime":1788284168300,"traceId":"7bb8ae0dfe4d6fb8"},{"name":"collect-build-traces","duration":52542703,"timestamp":22634161856,"id":925,"parentId":1,"tags":{},"startTime":1788284167879,"traceId":"7bb8ae0dfe4d6fb8"},{"name":"telemetry-flush","duration":52,"timestamp":22686708604,"id":937,"parentId":1,"tags":{},"startTime":1788284220426,"traceId":"7bb8ae0dfe4d6fb8"},{"name":"next-build","duration":96575927,"timestamp":22590132737,"id":1,"tags":{"buildMode":"default","version":"16.3.1","bundler":"webpack","has-custom-webpack-config":"false","use-build-worker":"true"},"startTime":1788284123850,"traceId":"7bb8ae0dfe4d6fb8"}]

package/bin/pi-web-sky.js

@@ -23,19 +23,10 @@ const { wireChildProcessLifecycle } = require("./process-lifecycle");
 const pkgDir = path.join(__dirname, "..");
 const nextDir = path.join(pkgDir, ".next");
 
-// Resolve next's CLI entry directly to avoid relying on .bin symlinks (which
-// may not exist when installed via npx).
-let nextBin;
-try {
-  nextBin = require.resolve("next/dist/bin/next", { paths: [pkgDir] });
-} catch {
-  // Fallback: locate next package root and derive the bin path manually.
-  try {
-    const nextPkg = require.resolve("next/package.json", { paths: [pkgDir] });
-    nextBin = path.join(path.dirname(nextPkg), "dist", "bin", "next");
-  } catch {
-    nextBin = path.join(pkgDir, "node_modules", "next", "dist", "bin", "next");
-  }
+const serverEntry = path.join(pkgDir, "server.mjs");
+if (!fs.existsSync(serverEntry)) {
+  console.error("Server entry not found. Please report this issue.");
+  process.exit(1);
 }
 
 const { port, hostname, openBrowser } = parseLaunchOptions();
@@ -59,15 +50,19 @@ if (!loopbackHostnames.has(hostname)) {
   }
 }
 
-const nextArgs = ["start", "-p", port];
-nextArgs.push("-H", hostname);
-
-// Always run next's JS entry with node directly — avoids .bin symlink issues
-// and path-with-spaces problems on Windows when shell: true is used.
-const child = spawn(process.execPath, [nextBin, ...nextArgs], {
+// 直接跑自定义 server（server.mjs）：HTTP 交 Next，WebSocket upgrade 分流到 tldraw
+// sync 房间（/connect/:boardId）。不能只跑 `next start`——那样 WS 后台不启动，
+// 看板永远 loading（0.1.35 生产 bug 根因）。
+const child = spawn(process.execPath, [serverEntry], {
   cwd: pkgDir,
   stdio: ["inherit", "pipe", "inherit"],
-  env: { ...process.env, PI_WEB_HOSTNAME: hostname },
+  env: {
+    ...process.env,
+    NODE_ENV: "production",
+    PORT: String(port),
+    HOSTNAME: hostname,
+    PI_WEB_HOSTNAME: hostname,
+  },
 });
 wireChildProcessLifecycle(child);
 

package/lib/agent-client.test.mjs

@@ -0,0 +1,64 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { createJiti } from "jiti";
+
+const jiti = createJiti(import.meta.url, {
+  interopDefault: true,
+  moduleCache: false,
+});
+const { AgentCommandError, isPromptRejectedError, sendAgentCommand } = await jiti.import("./agent-client.ts");
+
+test("agent command HTTP rejections are distinguishable from transport failures", async (t) => {
+  const originalFetch = globalThis.fetch;
+  t.after(() => {
+    globalThis.fetch = originalFetch;
+  });
+
+  globalThis.fetch = async () => new Response(
+    JSON.stringify({
+      error: "Authentication failed",
+      code: "prompt_rejected",
+      accepted: false,
+    }),
+    { status: 500, headers: { "Content-Type": "application/json" } },
+  );
+
+  await assert.rejects(
+    sendAgentCommand("session-id", { type: "prompt", message: "hello" }),
+    (error) => {
+      assert.equal(error instanceof AgentCommandError, true);
+      assert.equal(error.status, 500);
+      assert.equal(error.message, "Authentication failed");
+      assert.equal(error.code, "prompt_rejected");
+      assert.equal(error.accepted, false);
+      assert.equal(isPromptRejectedError(error), true);
+      return true;
+    },
+  );
+
+  const transportError = new TypeError("connection reset");
+  globalThis.fetch = async () => {
+    throw transportError;
+  };
+
+  await assert.rejects(
+    sendAgentCommand("session-id", { type: "prompt", message: "hello" }),
+    (error) => {
+      assert.equal(error, transportError);
+      assert.equal(error instanceof AgentCommandError, false);
+      assert.equal(isPromptRejectedError(error), false);
+      return true;
+    },
+  );
+});
+
+test("only an explicit negative prompt acknowledgement is definitive", () => {
+  assert.equal(
+    isPromptRejectedError(new AgentCommandError("proxy failure", 502)),
+    false,
+  );
+  assert.equal(
+    isPromptRejectedError(new AgentCommandError("generic API failure", 500, "internal_error", false)),
+    false,
+  );
+});

package/lib/agent-client.ts

@@ -0,0 +1,53 @@
+// Client-side helper for POST /api/agent/[id].
+//
+// Every /api/agent/[id] route returns one of:
+//   { success: true, data: <result> }
+//   { error: string }              (non-2xx)
+//
+// Call sites previously repeated the same 5-line fetch block 13× in
+// hooks/useAgentSession.ts. This helper collapses that down to one line.
+
+export class AgentCommandError extends Error {
+  constructor(
+    message: string,
+    public readonly status: number,
+    public readonly code?: string,
+    public readonly accepted?: boolean,
+  ) {
+    super(message);
+    this.name = "AgentCommandError";
+  }
+}
+
+export function isPromptRejectedError(error: unknown): error is AgentCommandError {
+  return error instanceof AgentCommandError
+    && error.code === "prompt_rejected"
+    && error.accepted === false;
+}
+
+export async function sendAgentCommand<T = unknown>(
+  sessionId: string,
+  command: Record<string, unknown>,
+): Promise<T> {
+  const res = await fetch(`/api/agent/${encodeURIComponent(sessionId)}`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(command),
+  });
+  const body = (await res.json().catch(() => ({}))) as {
+    success?: boolean;
+    data?: T;
+    error?: string;
+    code?: string;
+    accepted?: boolean;
+  };
+  if (!res.ok || body.error) {
+    throw new AgentCommandError(
+      body.error ?? `HTTP ${res.status}`,
+      res.status,
+      body.code,
+      body.accepted,
+    );
+  }
+  return body.data as T;
+}

package/lib/agent-event-connection.test.mjs

@@ -0,0 +1,193 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { createJiti } from "jiti";
+
+const jiti = createJiti(import.meta.url);
+const { AgentEventConnection } = await jiti.import("./agent-event-connection.ts");
+
+const CONNECTING = 0;
+const OPEN = 1;
+const CLOSED = 2;
+
+class FakeEventSource {
+  readyState = CONNECTING;
+  onmessage = null;
+  onerror = null;
+  closeCount = 0;
+
+  open() { this.readyState = OPEN; }
+  message(event) { this.onmessage?.({ data: JSON.stringify(event) }); }
+  error() {
+    this.readyState = CLOSED;
+    this.onerror?.(new Event("error"));
+  }
+  close() {
+    this.readyState = CLOSED;
+    this.closeCount += 1;
+  }
+}
+
+function createHarness({ readinessTimeoutMs = 100, reconnectDelayMs = 5 } = {}) {
+  const sources = [];
+  const events = [];
+  const unexpectedErrors = [];
+  let activeSession = "session-a";
+  let demand = false;
+  const connection = new AgentEventConnection({
+    createSource(sessionId) {
+      const source = new FakeEventSource();
+      source.sessionId = sessionId;
+      sources.push(source);
+      return source;
+    },
+    onEvent(event) { events.push(event); },
+    shouldMaintain: (sessionId) => demand && sessionId === activeSession,
+    readinessTimeoutMs,
+    reconnectDelayMs,
+    onUnexpectedError(error) { unexpectedErrors.push(error); },
+  });
+  return {
+    connection,
+    sources,
+    events,
+    unexpectedErrors,
+    setActiveSession(sessionId) { activeSession = sessionId; },
+    setDemand(value) { demand = value; },
+  };
+}
+
+const wait = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+const nextTurn = () => new Promise((resolve) => setImmediate(resolve));
+
+test("shares one source and waits past the former transport deadline", async () => {
+  const { connection, sources, events } = createHarness();
+  const first = connection.ensureConnected("session-a");
+  const second = connection.ensureConnected("session-a");
+
+  assert.equal(sources.length, 1);
+  sources[0].open();
+  await wait(20);
+  sources[0].message({ type: "connected" });
+  await Promise.all([first, second]);
+
+  sources[0].message({ type: "agent_start" });
+  assert.deepEqual(events.map((event) => event.type), ["connected", "agent_start"]);
+});
+
+test("times out all waiters and closes the stalled source", async () => {
+  const { connection, sources } = createHarness({ readinessTimeoutMs: 10 });
+  const first = connection.ensureConnected("session-a");
+  const second = connection.ensureConnected("session-a");
+
+  await assert.rejects(first, (error) => error.status === "ready_timeout");
+  await assert.rejects(second, (error) => error.status === "ready_timeout");
+  assert.equal(sources[0].closeCount, 1);
+});
+
+test("manual close rejects waiters and isolates late events", async () => {
+  const { connection, sources, events } = createHarness();
+  const abandoned = connection.ensureConnected("session-a");
+  const oldSource = sources[0];
+  connection.close();
+  await assert.rejects(abandoned, (error) => error.status === "closed");
+
+  const replacement = connection.ensureConnected("session-a");
+  oldSource.open();
+  oldSource.message({ type: "connected" });
+  await nextTurn();
+  assert.deepEqual(events, []);
+
+  sources[1].open();
+  sources[1].message({ type: "connected" });
+  await replacement;
+});
+
+test("surfaces startup errors without retrying or dispatching them", async () => {
+  const { connection, sources, events } = createHarness();
+  const ready = connection.ensureConnected("session-a");
+  sources[0].open();
+  sources[0].message({ type: "startup_error", errorMessage: "broken config" });
+
+  await assert.rejects(ready, (error) => (
+    error.status === "startup_error" && error.message === "broken config"
+  ));
+  await wait(10);
+  assert.equal(sources.length, 1);
+  assert.deepEqual(events, []);
+});
+
+test("replaces a previously connected CONNECTING source only once", async () => {
+  const { connection, sources } = createHarness();
+  const initial = connection.ensureConnected("session-a");
+  sources[0].open();
+  sources[0].message({ type: "connected" });
+  await initial;
+
+  sources[0].readyState = CONNECTING;
+  const first = connection.ensureConnected("session-a");
+  const second = connection.ensureConnected("session-a");
+  await nextTurn();
+  assert.equal(sources.length, 2);
+
+  sources[1].open();
+  sources[1].message({ type: "connected" });
+  await Promise.all([first, second]);
+});
+
+test("passive maintenance retries a transient failure once", async () => {
+  const { connection, sources, setDemand } = createHarness();
+  setDemand(true);
+  connection.maintain("session-a");
+  sources[0].error();
+  await wait(10);
+  assert.equal(sources.length, 2);
+
+  sources[1].open();
+  sources[1].message({ type: "connected" });
+  await wait(10);
+  assert.equal(sources.length, 2);
+});
+
+test("an explicit startup error cancels a pending passive retry", async () => {
+  const { connection, sources, setDemand } = createHarness();
+  setDemand(true);
+  connection.maintain("session-a");
+  sources[0].error();
+
+  const explicit = connection.ensureConnected("session-a");
+  sources[1].open();
+  sources[1].message({ type: "startup_error", errorMessage: "terminal" });
+  await assert.rejects(explicit, (error) => error.status === "startup_error");
+  await wait(10);
+  assert.equal(sources.length, 2);
+});
+
+test("dropped demand, session switches, and close cannot revive an old retry", async () => {
+  const first = createHarness();
+  first.setDemand(true);
+  first.connection.maintain("session-a");
+  first.sources[0].error();
+  first.setDemand(false);
+  await wait(10);
+  assert.equal(first.sources.length, 1);
+
+  const second = createHarness();
+  second.setDemand(true);
+  second.connection.maintain("session-a");
+  second.sources[0].error();
+  second.setActiveSession("session-b");
+  const ready = second.connection.ensureConnected("session-b");
+  second.sources[1].open();
+  second.sources[1].message({ type: "connected" });
+  await ready;
+  await wait(10);
+  assert.equal(second.sources.length, 2);
+
+  const closed = createHarness();
+  closed.setDemand(true);
+  closed.connection.maintain("session-a");
+  closed.sources[0].error();
+  closed.connection.close();
+  await wait(10);
+  assert.equal(closed.sources.length, 1);
+});

package/lib/agent-event-connection.ts

@@ -0,0 +1,202 @@
+import type { AgentEventLike } from "./agent-event-wire";
+
+export interface AgentEventSourceLike {
+  readonly readyState: number;
+  onmessage: ((event: MessageEvent<string>) => void) | null;
+  onerror: ((event: Event) => void) | null;
+  close(): void;
+}
+
+export type AgentEventConnectionStatus = "ready_timeout" | "startup_error" | "closed";
+
+export class AgentEventConnectionError extends Error {
+  constructor(public readonly status: AgentEventConnectionStatus, message?: string) {
+    super(message ?? (
+      status === "ready_timeout"
+        ? "Timed out starting the agent session. Please try again."
+        : "Failed to connect to the agent event stream. Please try again."
+    ));
+    this.name = "AgentEventConnectionError";
+  }
+}
+
+type Attempt = {
+  promise: Promise<void>;
+  ready: boolean;
+  succeed(): void;
+  fail(error: AgentEventConnectionError): void;
+};
+
+type Connection = {
+  sessionId: string;
+  source: AgentEventSourceLike;
+  attempt: Attempt;
+};
+
+export interface AgentEventConnectionOptions {
+  createSource(sessionId: string): AgentEventSourceLike;
+  onEvent(event: AgentEventLike): void;
+  shouldMaintain(sessionId: string): boolean;
+  readinessTimeoutMs: number;
+  reconnectDelayMs: number;
+  onUnexpectedError?(error: unknown): void;
+}
+
+const EVENT_SOURCE_OPEN = 1;
+
+/** Owns the EventSource, agent-readiness handshake, and passive reconnect. */
+export class AgentEventConnection {
+  private current: Connection | null = null;
+  private retry: { sessionId: string; timer: ReturnType<typeof setTimeout> } | null = null;
+  private retryGeneration = 0;
+
+  constructor(private readonly options: AgentEventConnectionOptions) {}
+
+  close(): void {
+    this.stopRetrying();
+    if (this.current) this.discard(this.current, new AgentEventConnectionError("closed"));
+  }
+
+  maintain(sessionId: string): void {
+    if (!this.options.shouldMaintain(sessionId)) return;
+    const retryGeneration = this.retryGeneration;
+    void this.ensureConnected(sessionId).catch((error) => {
+      if (retryGeneration !== this.retryGeneration) return;
+      if (error instanceof AgentEventConnectionError) {
+        if (error.status === "startup_error") this.stopRetrying();
+        else this.scheduleRetry(sessionId);
+      } else {
+        this.options.onUnexpectedError?.(error);
+      }
+    });
+  }
+
+  async ensureConnected(sessionId: string): Promise<void> {
+    while (true) {
+      let connection = this.current;
+      if (!connection || connection.sessionId !== sessionId) {
+        connection = this.open(sessionId);
+      } else if (
+        connection.attempt.ready
+        && connection.source.readyState === EVENT_SOURCE_OPEN
+      ) {
+        return;
+      }
+
+      await connection.attempt.promise;
+      if (this.current !== connection) {
+        if (this.current?.sessionId === sessionId) continue;
+        throw new AgentEventConnectionError("closed");
+      }
+      if (connection.source.readyState === EVENT_SOURCE_OPEN) return;
+
+      // A once-ready EventSource may otherwise remain CONNECTING indefinitely.
+      this.discard(connection, new AgentEventConnectionError("closed"));
+    }
+  }
+
+  private open(sessionId: string): Connection {
+    if (this.current) this.discard(this.current, new AgentEventConnectionError("closed"));
+
+    let source: AgentEventSourceLike;
+    try {
+      source = this.options.createSource(sessionId);
+    } catch (error) {
+      throw new AgentEventConnectionError(
+        "closed",
+        error instanceof Error ? error.message : String(error),
+      );
+    }
+
+    let settled = false;
+    let resolve!: () => void;
+    let reject!: (error: AgentEventConnectionError) => void;
+    const promise = new Promise<void>((resolvePromise, rejectPromise) => {
+      resolve = resolvePromise;
+      reject = rejectPromise;
+    });
+    const timeout = setTimeout(() => {
+      this.fail(connection, new AgentEventConnectionError("ready_timeout"));
+    }, this.options.readinessTimeoutMs);
+    const attempt: Attempt = {
+      promise,
+      ready: false,
+      succeed() {
+        if (settled) return;
+        settled = true;
+        clearTimeout(timeout);
+        resolve();
+      },
+      fail(error) {
+        if (settled) return;
+        settled = true;
+        clearTimeout(timeout);
+        reject(error);
+      },
+    };
+    const connection: Connection = { sessionId, source, attempt };
+    this.current = connection;
+
+    source.onmessage = (message) => {
+      if (this.current !== connection) return;
+      let event: AgentEventLike;
+      try {
+        event = JSON.parse(message.data) as AgentEventLike;
+      } catch {
+        return;
+      }
+
+      if (event.type === "connected") {
+        attempt.ready = true;
+        attempt.succeed();
+        this.stopRetrying();
+      } else if (event.type === "startup_error") {
+        const message = typeof event.errorMessage === "string" ? event.errorMessage : undefined;
+        this.fail(connection, new AgentEventConnectionError("startup_error", message));
+        return;
+      }
+      this.options.onEvent(event);
+    };
+    source.onerror = () => {
+      this.fail(connection, new AgentEventConnectionError("closed"));
+    };
+
+    return connection;
+  }
+
+  private fail(connection: Connection, error: AgentEventConnectionError): void {
+    if (this.current !== connection) return;
+    this.discard(connection, error);
+    if (error.status === "startup_error") this.stopRetrying();
+    else this.scheduleRetry(connection.sessionId);
+  }
+
+  private discard(connection: Connection, error: AgentEventConnectionError): void {
+    connection.attempt.fail(error);
+    connection.source.close();
+    if (this.current === connection) this.current = null;
+  }
+
+  private scheduleRetry(sessionId: string): void {
+    if (!this.options.shouldMaintain(sessionId)) return;
+    if (this.retry?.sessionId === sessionId) return;
+    this.clearRetry();
+
+    const timer = setTimeout(() => {
+      if (this.retry?.timer !== timer) return;
+      this.retry = null;
+      this.maintain(sessionId);
+    }, this.options.reconnectDelayMs);
+    this.retry = { sessionId, timer };
+  }
+
+  private stopRetrying(): void {
+    this.retryGeneration += 1;
+    this.clearRetry();
+  }
+
+  private clearRetry(): void {
+    if (this.retry) clearTimeout(this.retry.timer);
+    this.retry = null;
+  }
+}