@evandu/super-pi 0.1.98 → 0.1.100

package/bin/super-pi.js

@@ -5,6 +5,7 @@ import { mkdir, rm, writeFile } from "node:fs/promises";
 import { homedir } from "node:os";
 import { dirname, join, resolve } from "node:path";
 import { promisify } from "node:util";
+import { pathToFileURL } from "node:url";
 
 const execFileAsync = promisify(execFile);
 const root = resolve(import.meta.dirname, "..");
@@ -62,7 +63,7 @@ async function running(port) {
 }
 async function stop(port) { try { const headers = process.env.SUPER_PI_ACCESS_TOKEN ? { authorization: `Bearer ${process.env.SUPER_PI_ACCESS_TOKEN}` } : {}; const response = await fetch(`http://127.0.0.1:${port}/api/shutdown`, { method: "POST", headers, signal: AbortSignal.timeout(3000) }); return response.ok || response.status === 202; } catch { return false; } }
 function openBrowser(url) { const command = platform === "darwin" ? "open" : platform === "win32" ? "cmd.exe" : "xdg-open"; const args = platform === "darwin" ? [url] : platform === "win32" ? ["/c", "start", "", url] : [url]; spawn(command, args, { detached: true, stdio: "ignore", windowsHide: true }).unref(); }
-function usage() { console.log("Usage: super-pi|super_pi <start|stop|restart|update|autostart> [options]"); console.log("  autostart enable|disable|status  Configure startup at sign-in"); console.log("  --port PORT  Server port (default: 3080)"); console.log("  --host HOST  Server host (default: 0.0.0.0)"); console.log("  --no-browser  Do not open a browser"); }
+function usage() { console.log("Usage: super-pi|super_pi <start|stop|restart|update|diagnose|autostart> [options]"); console.log("  autostart enable|disable|status  Configure startup at sign-in"); console.log("  diagnose                       Measure where a message spends its time"); console.log("  --port PORT  Server port (default: 3080)"); console.log("  --host HOST  Server host (default: 0.0.0.0)"); console.log("  --no-browser  Do not open a browser"); }
 function paths() { if (platform === "win32") return { task: "Super Pi" }; if (platform === "darwin") return { file: join(home, "Library", "LaunchAgents", "com.evandu.super-pi.plist") }; return { file: join(process.env.XDG_CONFIG_HOME ?? join(home, ".config"), "systemd", "user", "super-pi.service") }; }
 async function system(command, args) { if (process.env.SUPER_PI_AUTOSTART_DRY_RUN === "1") { console.log(`[dry-run] ${command} ${args.join(" ")}`); return; } await execFileAsync(command, args, { windowsHide: true }); }
 async function enable(value) {
@@ -84,6 +85,25 @@ try {
   if (command === "help" || command === "--help" || command === "-h") { usage(); process.exit(0); }
   if (!command) { const value = options(args); await start(value); const url = `http://127.0.0.1:${value.port}`; if (value.browser) openBrowser(url); console.log(value.browser ? `Opened ${url}\n${runningBanner(url)}` : runningBanner(url)); process.exit(0); }
   if (command === "autostart" || command === "startup") { const action = args.shift()?.toLowerCase() ?? "status"; const value = options(args); if (action === "enable") await enable(value); else if (action === "disable") await disable(); else if (action === "status") await status(); else throw new Error("Autostart action must be enable, disable, or status."); process.exit(0); }
+  if (command === "diagnose" || command === "diagnose-latency") {
+    // MEASURE WHERE THE TIME GOES, ON THE MACHINE THAT IS COMPLAINING.
+    //
+    // It runs a throwaway server on its own port with its own data directory, so it never disturbs a
+    // session someone is in the middle of and never writes into their real conversations. What it prints
+    // is three spans that belong to DIFFERENT OWNERS - Super Pi, Super Pi, and the model - because
+    // conflating them is how two wrong root causes got written down before.
+    const turnsArg = args.find((a) => /^\d+$/.test(a));
+    const { diagnose, renderReport } = await import(pathToFileURL(join(root, "scripts", "diagnose.mjs")).href);
+    console.log(`Super Pi v${ownVersion().version} — diagnosing on ${process.platform}, node ${process.versions.node}`);
+    const result = await diagnose({
+      repositoryRoot: root,
+      turns: turnsArg ? Number.parseInt(turnsArg, 10) : 2,
+      onProgress: (line) => console.log(`  ${line}`),
+    });
+    console.log("");
+    console.log(renderReport(result));
+    process.exit(result.error ? 1 : 0);
+  }
   if (!["start", "stop", "restart", "update"].includes(command)) throw new Error(`Unknown command: ${command}`);
   if (command === "update") { const npm = platform === "win32" ? "npm.cmd" : "npm"; const args = prefix ? ["install", "--prefix", prefix, "@evandu/super-pi"] : ["install", "-g", "@evandu/super-pi"]; const child = spawn(npm, args, { stdio: "inherit", shell: platform === "win32", env: process.env }); const code = await new Promise((resolve) => child.on("close", resolve)); if (code !== 0) process.exit(code ?? 1); }
   const value = options(args);

package/dist/client/.super-pi-client-sources.json

@@ -24,5 +24,5 @@
     "src/client/types.ts": "6487df00c164370550b5977f9b23b17e22aff4bfb59dfe1e52200042340e3769",
     "src/client/vite-env.d.ts": "65996936fbb042915f7b74a200fcdde7e410f32a669b1ab9597cfaa4b0faddb5"
   },
-  "recordedAt": "2026-10-21T02:50:44.453Z"
+  "recordedAt": "2026-10-21T05:29:09.656Z"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@evandu/super-pi",
-  "version": "0.1.98",
+  "version": "0.1.100",
   "description": "Web control plane and companion for Pi",
   "license": "MIT",
   "type": "module",
@@ -20,7 +20,8 @@
     "scripts/restart-server.mjs",
     "README.md",
     "assets/knowledge-model",
-    "scripts/patch-brace-expansion.mjs"
+    "scripts/patch-brace-expansion.mjs",
+    "scripts/diagnose.mjs"
   ],
   "engines": {
     "node": ">=22.19.0"
@@ -42,6 +43,7 @@
     "scripts/stream-checkpoint.test.mjs",
     "scripts/stream-transport.test.mjs",
     "scripts/pi-session.test.mjs",
+    "scripts/diagnose-cli.test.mjs",
     "scripts/lan-access.test.mjs",
     "scripts/terminal-pty.test.mjs",
     "scripts/persistence-repository.test.mjs",

package/scripts/diagnose.mjs

@@ -0,0 +1,331 @@
+// `super_pi diagnose` — where the time goes when a message is slow.
+//
+// WHY THIS EXISTS AND WHY IT IS A COMMAND. The complaint that produced it was "it is slow, take this
+// many seconds, here are three of them" — and answering it from the developer's machine was wrong
+// twice, because the developer machine is fast and a wall clock does not transfer. So the measurement
+// has to run where the problem is, which means it has to ship with the product.
+//
+// WHAT IT PRINTS, AND WHY THAT SHAPE. Three spans, because they belong to DIFFERENT OWNERS and
+// conflating them is how two wrong root causes got written down:
+//
+//   1. picker data      -> Super Pi   (the catalog read)
+//   2. send -> waiting  -> Super Pi   (session build + first prompt)
+//   3. waiting -> text  -> the MODEL  (not ours, and it grows with the conversation)
+//
+// And under each, the STRUCTURE — how many Pi processes were started, how many sessions were built,
+// how many were reused. Structure is the part that survives the difference between a fast machine and a
+// slow one; seconds are not. If the process count is zero and a span is still long, the time is not in
+// Super Pi, and this says so rather than leaving it to be guessed at.
+import { spawn } from "node:child_process";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { pathToFileURL } from "node:url";
+
+/** The Node version Pi requires. Below it, module loading and jiti transpiling are measurably slower. */
+const PI_NODE_REQUIREMENT = "22.19.0";
+
+/**
+ * Compares two dotted versions.
+ *
+ * `localeCompare` would do this lexically and get "22.9.0" > "22.19.0" wrong - 9 sorts after 19 as
+ * characters - and a person whose Node is 22.9 would be told they satisfy a requirement they do not.
+ */
+function atLeast(actual, required) {
+  const left = String(actual).split(".").map((part) => Number.parseInt(part, 10) || 0);
+  const right = String(required).split(".").map((part) => Number.parseInt(part, 10) || 0);
+  for (let index = 0; index < Math.max(left.length, right.length); index += 1) {
+    const difference = (left[index] ?? 0) - (right[index] ?? 0);
+    if (difference !== 0) return difference >= 0;
+  }
+  return true;
+}
+
+/**
+ * Runs the diagnosis against a throwaway server and returns what it measured.
+ *
+ * A THROWAWAY SERVER, not the running one: it starts its own on a private port with its own data
+ * directory, so this never disturbs a session someone is in the middle of, and never writes into
+ * their real conversations. It also means the numbers describe a COLD machine's first conversation,
+ * which is the case being complained about.
+ */
+export async function diagnose({ repositoryRoot, turns = 2, onProgress = () => {} } = {}) {
+  const dataDir = mkdtempSync(join(tmpdir(), "super-pi-diagnose-"));
+  const port = 35000 + Math.floor(Math.random() * 4000);
+  const server = spawn(process.execPath, [join(repositoryRoot, "dist/server/index.js")], {
+    cwd: repositoryRoot,
+    env: {
+      ...process.env,
+      SUPER_PI_PORT: String(port),
+      SUPER_PI_HOST: "127.0.0.1",
+      SUPER_PI_RUNTIME: "pi",
+      SUPER_PI_DATA_DIR: dataDir,
+      SUPER_PI_PERSISTENCE: "json",
+      // The latency trace is what turns "it was slow" into "this step was slow".
+      SUPER_PI_TRACE_LATENCY: "1",
+    },
+    stdio: ["ignore", "pipe", "pipe"],
+  });
+  let log = "";
+  server.stdout.on("data", (chunk) => { log += chunk.toString(); });
+  server.stderr.on("data", (chunk) => { log += chunk.toString(); });
+  const stop = () => { try { server.kill(); } catch { /* already gone */ } };
+
+  const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+  const result = {
+    node: process.versions.node,
+    nodeOk: atLeast(process.versions.node, PI_NODE_REQUIREMENT),
+    required: PI_NODE_REQUIREMENT,
+  };
+  try {
+    onProgress("starting a throwaway server...");
+    const bootStart = Date.now();
+    let healthy = false;
+    for (let attempt = 0; attempt < 600; attempt += 1) {
+      try { if ((await fetch(`http://127.0.0.1:${port}/api/health`)).ok) { healthy = true; break; } } catch { /* not up yet */ }
+      await sleep(50);
+    }
+    result.bootMs = Date.now() - bootStart;
+    if (!healthy) {
+      result.error = "the server did not become healthy";
+      result.log = log.slice(-2000);
+      return result;
+    }
+
+    const { WebSocket } = await import("ws");
+    const socket = new WebSocket(`ws://127.0.0.1:${port}/ws`);
+    await new Promise((resolve, reject) => { socket.once("open", resolve); socket.once("error", reject); });
+    const events = [];
+    socket.on("message", (raw) => { try { events.push(JSON.parse(raw.toString())); } catch { /* not json */ } });
+    const send = (command) => socket.send(JSON.stringify(command));
+    const waitFor = async (predicate, label, timeoutMs = 240000) => {
+      const deadline = Date.now() + timeoutMs;
+      while (Date.now() < deadline) {
+        const hit = events.find(predicate);
+        if (hit) return hit;
+        await sleep(15);
+      }
+      throw new Error(`timed out waiting for ${label}`);
+    };
+
+    onProgress("creating a conversation...");
+    send({ type: "conversation.create", workspaceId: "workspace_default" });
+    await waitFor((e) => e.type === "state" && e.state.conversations.length > 0, "a conversation");
+    const conversation = events.filter((e) => e.type === "state").at(-1).state.conversations[0];
+
+    // Span 1: the picker.
+    const pickerStart = Date.now();
+    send({ type: "catalog.fetch", conversationId: conversation.id });
+    const catalog = await waitFor((e) => e.type === "model.catalog", "the model catalog");
+    result.pickerMs = Date.now() - pickerStart;
+    result.catalogSource = catalog.catalog?.source ?? catalog.source ?? "unknown";
+    result.models = (catalog.catalog?.models ?? catalog.models ?? []).length;
+
+    // Span 1b: THE PICKER AFTER A WORKSPACE DEFAULT IS SET.
+    //
+    // THIS IS THE PATH THE FIRST MEASUREMENT MISSED, and it is the one most people are actually on.
+    // `createConversation` copies the workspace's default model onto the new conversation, and it
+    // VALIDATES that default against the catalog first - so creating a conversation with a default
+    // model READS THE CATALOG, and a picker opened afterwards asks for the LEVELS of that model, which
+    // is a different catalog key. A measurement that never sets a default model never sees any of it.
+    //
+    // The report says which path it measured, because a number for a path nobody is on is worse than
+    // no number at all.
+    const defaultModel = (catalog.catalog?.models ?? catalog.models ?? []).find((m) => m.modelId)
+      ?? (catalog.catalog?.defaultModel ?? catalog.defaultModel);
+    if (defaultModel) {
+      onProgress("setting a workspace default model, then creating a conversation...");
+      send({
+        type: "workspace.settings",
+        workspaceId: "workspace_default",
+        model: { provider: defaultModel.provider, modelId: defaultModel.modelId },
+        thinkingLevel: null,
+      });
+      await sleep(400);
+      const withDefaultStart = Date.now();
+      send({ type: "conversation.create", workspaceId: "workspace_default" });
+      const withDefault = await waitFor((e) => e.type === "state"
+        && e.state.conversations.length >= 2, "a conversation with the workspace default");
+      result.conversationWithDefaultMs = Date.now() - withDefaultStart;
+      const withDefaultConversation = events.filter((e) => e.type === "state").at(-1).state.conversations[0];
+      // And the picker for THAT conversation, which is the one a person actually opens.
+      const defaultPickerStart = Date.now();
+      send({ type: "catalog.fetch", conversationId: withDefaultConversation.id });
+      // The conversation id is a SIBLING of the catalog, not inside it - `broadcastCatalog` sends
+      // `{ type, catalog, conversationId }` - and reading it from the wrong place times out on a
+      // catalog that has already arrived.
+      await waitFor((e) => e.type === "model.catalog" && e.conversationId === withDefaultConversation.id,
+        "the catalog for the conversation with a default model");
+      result.pickerWithDefaultMs = Date.now() - defaultPickerStart;
+    }
+
+    // Spans 2 and 3, per turn.
+    result.turns = [];
+    for (let turn = 1; turn <= turns; turn += 1) {
+      onProgress(`sending turn ${turn} of ${turns}...`);
+      const mark = events.length;
+      const logMark = log.length;
+      const sent = Date.now();
+      send({ type: "message.send", conversationId: conversation.id, content: `第${turn}问：请简短回答。` });
+      await waitFor((e, i) => i >= mark && e.type === "state"
+        && e.state.conversations.find((c) => c.id === conversation.id)?.status === "waiting", `turn ${turn} to report waiting`);
+      const waiting = Date.now();
+      await waitFor((e, i) => i >= mark && e.type === "message.delta" && e.conversationId === conversation.id, `turn ${turn}'s first character`);
+      const text = Date.now();
+      // Let the turn finish so the next one is a new turn rather than a queued one.
+      while (Date.now() < text + 120000) {
+        const done = events.slice(mark).some((e) => e.type === "state"
+          && e.state.conversations.find((c) => c.id === conversation.id)?.status === "completed");
+        if (done) break;
+        await sleep(30);
+      }
+      await sleep(250);
+      const added = log.slice(logMark);
+      result.turns.push({
+        turn,
+        toWaitingMs: waiting - sent,
+        toTextMs: text - sent,
+        modelMs: text - waiting,
+        spawned: (added.match(/phase=pi\.spawned/g) ?? []).length,
+        built: (added.match(/phase=session\.build\.begin/g) ?? []).length,
+        reused: (added.match(/phase=session\.reused/g) ?? []).length,
+      });
+    }
+    // Span 4: THE INTERRUPT.
+    //
+    // The second thing people report is "打断并回答 → 开始回答还要好十秒", and it is a DIFFERENT
+    // chain from sending a message: it waits for the running turn to unwind, waits for its slot, and
+    // only then asks the model. Those first two waits are Super Pi's, and they are the ones that can
+    // be slow; the model's share is the same as any other turn.
+    //
+    // So it is measured as its own span, with a tool running so there is something to interrupt.
+    onProgress("measuring the interrupt...");
+    const interruptMark = events.length;
+    const interruptLogMark = log.length;
+    send({
+      type: "message.send",
+      conversationId: conversation.id,
+      content: '用 bash 运行：node -e "setTimeout(()=>{},20000)"。等它跑完再回复。',
+    });
+    let toolStarted = false;
+    const toolDeadline = Date.now() + 60000;
+    while (!toolStarted && Date.now() < toolDeadline) {
+      toolStarted = events.slice(interruptMark).some((e) => e.type === "message.tools");
+      if (!toolStarted) await sleep(30);
+    }
+    if (toolStarted) {
+      // Queue the message that the interrupt will answer.
+      send({ type: "message.send", conversationId: conversation.id, content: "被打断的那条：只回答「第二」两个字。" });
+      let queued = null;
+      const queueDeadline = Date.now() + 60000;
+      while (!queued && Date.now() < queueDeadline) {
+        queued = events.filter((e) => e.type === "state").at(-1)?.state?.conversations
+          ?.find((c) => c.id === conversation.id)?.messages
+          ?.find((m) => m.content?.includes("被打断的那条") && m.delivery === "waiting");
+        if (!queued) await sleep(30);
+      }
+      if (queued) {
+        await sleep(800);
+        const clicked = Date.now();
+        send({ type: "message.interrupt", conversationId: conversation.id, messageId: queued.id });
+        let interruptWaiting = 0;
+        try {
+          await waitFor((e, i) => i >= interruptMark && e.type === "state"
+            && e.state.conversations.find((c) => c.id === conversation.id)?.status === "waiting"
+            && Date.now() > clicked, "the interrupted turn to report waiting", 60000);
+          interruptWaiting = Date.now() - clicked;
+          await waitFor((e, i) => i >= interruptMark && e.type === "message.delta" && e.conversationId === conversation.id
+            && Date.now() > clicked + 50, "the interrupted turn's first character", 180000);
+        } catch { /* reported as not measured below */ }
+        const interruptText = Date.now() - clicked;
+        const interruptLog = log.slice(interruptLogMark);
+        result.interrupt = {
+          toWaitingMs: interruptWaiting || undefined,
+          toTextMs: interruptText,
+          modelMs: interruptText - (interruptWaiting || 0),
+          spawned: (interruptLog.match(/phase=pi\.spawned/g) ?? []).length,
+          built: (interruptLog.match(/phase=session\.build\.begin/g) ?? []).length,
+          reused: (interruptLog.match(/phase=session\.reused/g) ?? []).length,
+        };
+      }
+    }
+
+    socket.close();
+  } catch (error) {
+    result.error = error instanceof Error ? error.message : String(error);
+    result.log = log.slice(-2000);
+  } finally {
+    stop();
+    await sleep(200);
+    rmSync(dataDir, { recursive: true, force: true });
+  }
+  return result;
+}
+
+/** Renders a diagnosis as the report a person reads. */
+export function renderReport(result) {
+  const lines = [];
+  const ms = (value) => (typeof value === "number" ? `${String(value).padStart(6)}ms` : "     ?");
+
+  lines.push(`Super Pi 延迟诊断 — ${new Date().toISOString()}`);
+  lines.push("");
+  lines.push(`  Node ${result.node}   (Pi 要求 >= ${result.required}：${result.nodeOk ? "满足" : "过低"})`);
+  lines.push(`  server 就绪耗时 ${ms(result.bootMs)}`);
+
+  if (result.error) {
+    lines.push("");
+    lines.push(`  失败：${result.error}`);
+    if (result.log) lines.push(result.log.split("\n").map((l) => `  | ${l}`).join("\n"));
+    return lines.join("\n");
+  }
+
+  lines.push("");
+  lines.push("  每一段耗时                    耗时      归属");
+  lines.push(`  1. picker 有数据            ${ms(result.pickerMs)}   Super Pi   （catalog 读取）`);
+  if (typeof result.conversationWithDefaultMs === "number") {
+    lines.push(`  1b. 建会话（工作区有默认模型） ${ms(result.conversationWithDefaultMs)}   Super Pi   （建会话要校验默认模型，会再读一次 catalog）`);
+    lines.push(`  1c. 该会话的 picker        ${ms(result.pickerWithDefaultMs)}   Super Pi   （带默认模型时读的是另一份 catalog）`);
+  } else {
+    lines.push("  1b/1c. 未测：这次没有可用的模型来设工作区默认模型");
+  }
+  for (const turn of result.turns ?? []) {
+    lines.push(`     第${turn.turn}轮 发送 -> 等待中     ${ms(turn.toWaitingMs)}   Super Pi   （建会话 + 首个 prompt）`);
+    lines.push(`     第${turn.turn}轮 等待中 -> 出字     ${ms(turn.modelMs)}   模型       （不是 Super Pi）`);
+  }
+  if (result.interrupt) {
+    lines.push("");
+    lines.push("  打断（点「打断并回答」之后）：");
+    lines.push(`     点击 -> 新一轮报等待中     ${ms(result.interrupt.toWaitingMs)}   Super Pi   （等旧轮退完 + 等槽位）`);
+    lines.push(`     点击 -> 出字             ${ms(result.interrupt.toTextMs)}   整条链`);
+    lines.push(`     其中模型                 ${ms(result.interrupt.modelMs)}   模型       （不是 Super Pi）`);
+    lines.push(`     打断后启动的 Pi 进程数： ${result.interrupt.spawned}`);
+  } else {
+    lines.push("");
+    lines.push("  打断：未测（需要一次正在跑工具的轮次）");
+  }
+  lines.push("");
+  lines.push(`  catalog: ${result.catalogSource}，${result.models} 个模型`);
+
+  const spawned = (result.turns ?? []).reduce((sum, t) => sum + t.spawned, 0);
+  const built = (result.turns ?? []).reduce((sum, t) => sum + t.built, 0);
+  const reused = (result.turns ?? []).reduce((sum, t) => sum + t.reused, 0);
+  lines.push("");
+  lines.push("  结构计数 —— 快机器和慢机器上一样的那部分：");
+  lines.push(`    启动的 Pi 进程数：  ${spawned}`);
+  lines.push(`    建立的会话数：      ${built}`);
+  lines.push(`    复用的会话数：      ${reused}`);
+
+  lines.push("");
+  if (!result.nodeOk) {
+    lines.push(`  Node 版本低于 Pi 的要求（>= ${result.required}）。这一条本身就可能解释了前面几段的`);
+    lines.push("  大部分时间：模块加载和 jiti 转译都会更慢。请先升级 Node 再跑一次——否则这份报告");
+    lines.push("  描述的是一台 Pi 本来就不该在上面运行的机器。");
+    lines.push("");
+  }
+  lines.push("  怎么看这份报告：");
+  lines.push("    - 「启动的 Pi 进程数」是最关键的那个数。它是 0，说明 Super Pi 正在用 Pi 的 SDK，");
+  lines.push("      会话被复用了；如果每一轮都很大，说明会话层根本没生效。");
+  lines.push("    - 第 1、2 段是 Super Pi 自己的。如果这两段是秒级，这份报告就是该发出来的东西。");
+  lines.push("    - 第 3 段是模型，会随对话变长。Super Pi 改不了它。");
+  return lines.join("\n");
+}