@evandu/super-pi 0.1.113 → 0.1.115

package/dist/client/index.html

@@ -8,7 +8,7 @@
     <link rel="alternate icon" href="/favicon.ico" />
     <link rel="apple-touch-icon" href="/favicon.svg" />
     <title>Super Pi</title>
-    <script type="module" crossorigin src="/assets/index-BixdV7aQ.js"></script>
+    <script type="module" crossorigin src="/assets/index-CLoO6IHy.js"></script>
     <link rel="stylesheet" crossorigin href="/assets/index-CGXMw9LP.css">
   </head>
   <body>

package/dist/extension.js

@@ -116,7 +116,7 @@ export default function (pi) {
                     }
                 }
                 if (!ready) {
-                    ctx.ui.notify?.(`Warning: Super Pi server on port ${port} did not respond to health check in time`, "warning");
+                    ctx.ui.notify?.(`Warning: Super Pi server on port ${port} did not respond to health check in time. Run "super-pi logs" to see why.`, "warning");
                 }
             }
             openBrowser(url);

package/dist/server/application/conversation-service.js

@@ -100,6 +100,8 @@ export class ConversationService {
         const conversation = state.conversations.find(item => item.id === conversationId);
         if (!conversation)
             throw new Error("会话不存在");
+        if (conversation.archivedAt)
+            throw new Error("已归档的会话无法重命名，请先恢复会话");
         const workspace = state.workspaces.find(item => item.id === conversation.workspaceId);
         if (!workspace)
             throw new Error("会话所属的工作区不存在");
@@ -154,6 +156,9 @@ export class ConversationService {
      * Renames a conversation.
      */
     async renameConversation(conversationId, name) {
+        const conversation = this.store.snapshot().conversations.find((item) => item.id === conversationId);
+        if (conversation?.archivedAt)
+            throw new Error("已归档的会话无法重命名，请先恢复会话");
         await this.store.renameConversation(conversationId, name);
         this.broadcaster.broadcastState();
     }
@@ -368,6 +373,9 @@ export class ConversationService {
         if (!conversation) {
             return { ok: false, message: "会话不存在" };
         }
+        if (conversation.archivedAt) {
+            return { ok: false, message: "已归档的会话无法分叉，请先恢复会话" };
+        }
         const workspace = snapshot.workspaces.find((item) => item.id === conversation.workspaceId);
         if (!workspace) {
             return { ok: false, message: `会话所属的工作区 ${conversation.workspaceId} 已不存在，拒绝分叉` };

package/dist/server/index.js

@@ -28,12 +28,25 @@ import { ExecService } from "./exec-service.js";
 import { createHttpServer, getLanIps, isLocalOrPrivateAddress, parseServerArgs } from "./http-server.js";
 import { WsBroadcaster, WsServer } from "./ws-server.js";
 import { initRunningVersion } from "./version.js";
+import { installServerLogging } from "./logging.js";
 import { ToolRegistry } from "./tool-registry.js";
 import { ToolRunner } from "./tool-runner.js";
 import { ToolLlmService } from "./tool-llm.js";
 // ------------------------------------------------------------- Environment & paths
 const rootDir = resolve(import.meta.dirname, "../..");
 initRunningVersion(rootDir);
+// ------------------------------------------------------------- The log file
+//
+// THE SERVER IS STARTED DETACHED WITH ITS OUTPUT THROWN AWAY, so anything printed to the console
+// is gone. A crash used to take the process down with no word at all, and the browser just sat there
+// saying "connecting". The log file is installed BEFORE anything else can fail, so the first line in
+// it is always "the server started" and the last line is always "the server stopped".
+const defaultDataDir = !rootDir.includes("node_modules") && existsSync(join(rootDir, ".super-pi"))
+    ? join(rootDir, ".super-pi")
+    : join(homedir(), ".super-pi");
+const dataDir = resolve(process.env.SUPER_PI_DATA_DIR ?? defaultDataDir);
+const logging = installServerLogging(dataDir);
+logging.write("info", `server starting: pid ${process.pid}, node ${process.versions.node}, data dir ${dataDir}`);
 // THE SECURITY PATCH, APPLIED WHERE IT CANNOT BREAK AN INSTALL.
 //
 // Pi's package pins a vulnerable `brace-expansion` in its own shrinkwrapped tree, and npm will not let
@@ -84,10 +97,6 @@ const envPort = Number.parseInt(process.env.SUPER_PI_PORT ?? "3080", 10);
 const port = cliArgs.port ?? (Number.isNaN(envPort) ? 3080 : envPort);
 const host = cliArgs.host ?? process.env.SUPER_PI_HOST ?? "0.0.0.0";
 const internalHost = (host === "0.0.0.0" || host === "::" || !host) ? "127.0.0.1" : host;
-const defaultDataDir = !rootDir.includes("node_modules") && existsSync(join(rootDir, ".super-pi"))
-    ? join(rootDir, ".super-pi")
-    : join(homedir(), ".super-pi");
-const dataDir = resolve(process.env.SUPER_PI_DATA_DIR ?? defaultDataDir);
 const agentPromptDir = join(dataDir, "agent-prompts");
 const clientDir = join(rootDir, "dist", "client");
 const accessToken = process.env.SUPER_PI_ACCESS_TOKEN;
@@ -326,6 +335,7 @@ const wsServer = new WsServer({
 httpServer.listen(port, host, () => {
     const displayHost = host === "0.0.0.0" || host === "::" ? "127.0.0.1" : host;
     console.log(`Super Pi is running at http://${displayHost}:${port}`);
+    logging.write("info", `listening on ${host}:${port} (pid ${process.pid})`);
     if (host === "0.0.0.0" || host === "::") {
         const lanIps = getLanIps();
         for (const ip of lanIps) {

package/dist/server/logging.d.ts

@@ -0,0 +1,32 @@
+/**
+ * THE SERVER'S OWN LOG FILE.
+ *
+ * Super Pi is started DETACHED, with its standard streams thrown away (`stdio: "ignore"`), because
+ * the person who started it is usually gone by the time it matters - the panel runs in a browser tab
+ * and the server lives on behind it. The cost of that decision was that when the server DIED, it
+ * died silently: the browser sat there saying "connecting" and nobody could say why. A log file is
+ * the cheapest possible answer to "how did it die".
+ *
+ * Two properties matter more than volume here:
+ *
+ * - EVERY LINE IS WRITTEN SYNCHRONOUSLY. A buffered stream loses exactly the lines you want - the
+ *   ones written a millisecond before the crash - because the buffer is still in memory when the
+ *   process dies. `appendFileSync` costs a syscall per line, which is nothing at this volume, and
+ *   it costs the line that matters.
+ * - THE CRASH IS LOGGED BEFORE THE PROCESS LEAVES. `uncaughtException` and `unhandledRejection` are
+ *   the two ways a Node process dies without saying anything, and both are turned into a stack trace
+ *   in the log file.
+ */
+export declare const SERVER_LOG_NAME = "server.log";
+export interface ServerLogging {
+    /** Absolute path of the log file this server writes to. */
+    readonly logFile: string;
+    /** Absolute path of the liveness file; its timestamp says when the server was last alive. */
+    readonly heartbeatFile: string;
+    /** Append one line to the log file, independently of the console. */
+    write(level: string, message: string): void;
+}
+/**
+ * Install the file logger. Returns the handle so the caller can write lines the console never sees.
+ */
+export declare function installServerLogging(dataDir: string): ServerLogging;

package/dist/server/logging.js

@@ -0,0 +1,132 @@
+import { appendFileSync, existsSync, mkdirSync, renameSync, statSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+/**
+ * THE SERVER'S OWN LOG FILE.
+ *
+ * Super Pi is started DETACHED, with its standard streams thrown away (`stdio: "ignore"`), because
+ * the person who started it is usually gone by the time it matters - the panel runs in a browser tab
+ * and the server lives on behind it. The cost of that decision was that when the server DIED, it
+ * died silently: the browser sat there saying "connecting" and nobody could say why. A log file is
+ * the cheapest possible answer to "how did it die".
+ *
+ * Two properties matter more than volume here:
+ *
+ * - EVERY LINE IS WRITTEN SYNCHRONOUSLY. A buffered stream loses exactly the lines you want - the
+ *   ones written a millisecond before the crash - because the buffer is still in memory when the
+ *   process dies. `appendFileSync` costs a syscall per line, which is nothing at this volume, and
+ *   it costs the line that matters.
+ * - THE CRASH IS LOGGED BEFORE THE PROCESS LEAVES. `uncaughtException` and `unhandledRejection` are
+ *   the two ways a Node process dies without saying anything, and both are turned into a stack trace
+ *   in the log file.
+ */
+export const SERVER_LOG_NAME = "server.log";
+/** Kept small enough to open by eye; the previous file is kept as `server.log.1`. */
+const MAX_LOG_BYTES = 8 * 1024 * 1024;
+function format(level, message) {
+    const time = new Date().toISOString();
+    // A multi-line message (a stack trace) stays one entry per line, each carrying the same stamp, so
+    // that a `tail` still shows where it started.
+    return message
+        .split("\n")
+        .map((line) => `[${time}] [${level}] ${line}`)
+        .join("\n");
+}
+function rotateIfLarge(logFile) {
+    try {
+        if (!existsSync(logFile))
+            return;
+        if (statSync(logFile).size < MAX_LOG_BYTES)
+            return;
+        const previous = `${logFile}.1`;
+        try {
+            renameSync(previous, `${previous}.old`);
+        }
+        catch { /* no previous file: fine */ }
+        renameSync(logFile, previous);
+    }
+    catch {
+        // Rotation is best-effort: a log file that cannot be rotated must not stop the server from
+        // starting, and must not stop it from logging.
+    }
+}
+/**
+ * Install the file logger. Returns the handle so the caller can write lines the console never sees.
+ */
+export function installServerLogging(dataDir) {
+    const logDir = join(dataDir, "logs");
+    try {
+        mkdirSync(logDir, { recursive: true });
+    }
+    catch { /* the write below will report the real problem */ }
+    const logFile = join(logDir, SERVER_LOG_NAME);
+    rotateIfLarge(logFile);
+    /**
+     * THE LIVENESS FILE.
+     *
+     * A log file says what the server said; it cannot say when the server STOPPED, because the lines
+     * it would have written to say that are exactly the ones a crash takes away. A native crash (the
+     * kind that comes from a terminal being killed) never runs a JavaScript handler at all, so the
+     * server cannot even write "I died". This file answers the other half of the question: it is
+     * touched every minute while the server lives, so its timestamp says "the server was alive until
+     * this moment" - which is how a silent death gets a time on it.
+     */
+    const heartbeatFile = join(logDir, "heartbeat.txt");
+    const touch = () => {
+        try {
+            writeFileSync(heartbeatFile, `${Date.now()}\n`, "utf8");
+        }
+        catch { /* best effort */ }
+    };
+    touch();
+    const heartbeat = setInterval(touch, 60_000);
+    // The heartbeat must not be the reason the process stays alive.
+    heartbeat.unref?.();
+    const write = (level, message) => {
+        try {
+            appendFileSync(logFile, `${format(level, message)}\n`, "utf8");
+        }
+        catch { /* never let logging crash the server */ }
+    };
+    // CONSOLE OUTPUT IS TEED INTO THE FILE, NOT REPLACED BY IT.
+    //
+    // Everything the server already prints (the banner, warnings from the services, the shutdown
+    // notice) is worth keeping, and the cheapest way to keep it is to keep printing it and copy it.
+    // A service that logs through `console.warn` gets into the file for free.
+    const levels = ["log", "info", "warn", "error", "debug"];
+    const originals = new Map();
+    for (const level of levels) {
+        const original = console[level];
+        originals.set(level, original);
+        console[level] = (...args) => {
+            original.apply(console, args);
+            write(level === "log" ? "info" : level, args.map((arg) => (typeof arg === "string" ? arg : safeStringify(arg))).join(" "));
+        };
+    }
+    /**
+     * THE TWO WAYS A NODE PROCESS DIES WITHOUT A WORD.
+     *
+     * `uncaughtException` is a throw nobody caught; `unhandledRejection` is a promise nobody awaited.
+     * Both used to take the server down silently. Both now write the stack and then end the process -
+     * for `uncaughtException` continuing is not safe, because the process state after an uncaught
+     * exception is undefined.
+     */
+    process.on("uncaughtException", (error) => {
+        write("fatal", `uncaughtException: ${error instanceof Error ? (error.stack ?? error.message) : String(error)}`);
+        process.exit(1);
+    });
+    process.on("unhandledRejection", (reason) => {
+        write("fatal", `unhandledRejection: ${reason instanceof Error ? (reason.stack ?? reason.message) : String(reason)}`);
+    });
+    process.on("exit", (code) => {
+        write("info", `server process exiting with code ${code}`);
+    });
+    return { logFile, heartbeatFile, write };
+}
+function safeStringify(value) {
+    try {
+        return JSON.stringify(value);
+    }
+    catch {
+        return String(value);
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@evandu/super-pi",
-  "version": "0.1.113",
+  "version": "0.1.115",
   "description": "Web control plane and companion for Pi",
   "license": "MIT",
   "type": "module",
@@ -46,6 +46,7 @@
     "scripts/pi-model-switch.test.mjs",
     "scripts/pi-thinking-levels.test.mjs",
     "scripts/diagnose-cli.test.mjs",
+    "scripts/cli-logs.test.mjs",
     "scripts/lan-access.test.mjs",
     "scripts/terminal-pty.test.mjs",
     "scripts/persistence-repository.test.mjs",