@evandu/super-pi 0.1.152 → 0.1.153

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-CgRiEaG2.js"></script>
+    <script type="module" crossorigin src="/assets/index-Ce896Hh9.js"></script>
     <link rel="stylesheet" crossorigin href="/assets/index-DCLaWQin.css">
   </head>
   <body>

package/dist/server/terminal.d.ts

@@ -29,8 +29,8 @@
  *      nothing else; this file resolves the id against the store and spawns in that workspace's path.
  *      A browser that asked for `C:\` or `/etc` gets its own workspace's directory instead, because
  *      there is no code path on which a client-supplied path reaches `spawn`.
- *   4. BOUNDED SESSIONS. `MAX_SESSIONS` shells, one per client tab, capped so a loop of reconnects
- *      cannot accumulate processes.
+ *   4. BOUNDED SESSIONS. `MAX_SESSIONS` live shells, capped so a loop of reconnects cannot accumulate
+ *      processes.
  *
  * What is NOT here is a per-command allowlist. A terminal that refuses `rm` or `curl` is not a terminal,
  * and pretending otherwise would be worse than the honest version: with (1) and (2) the operator has
@@ -89,8 +89,33 @@ export declare function terminalShellCandidates(env?: NodeJS.ProcessEnv): {
     args: string[];
     label: string;
 }[];
-/** One shell per browser tab, and a hard ceiling so reconnects cannot accumulate processes. */
-export declare const MAX_SESSIONS = 8;
+/**
+ * THE CEILING ON LIVE SHELLS.
+ *
+ * WHAT THIS COUNTS. Only the browser's terminal panel: `terminal.open` is the ONE place a shell is
+ * spawned, and it is a command the browser sends over its own WebSocket. An agent session, a
+ * sub-agent run, and the `exec` tool do NOT consume this budget - the exec tool spawns its own
+ * short-lived `shell -c` process through a different service.
+ *
+ * WHY THE COUNT ACCUMULATES. The client opens up to five terminals per session (`MAX_SLOTS` in
+ * TerminalPanel), and a shell is deliberately KEPT ALIVE across a session switch: the panel unmounts
+ * without closing it, so the work in that shell survives the switch. Every session in the tree is a
+ * conversation with its own panel - including a CHILD session the user can click into - and each of
+ * them can hold five shells, and all of them land in this one map. A tree multiplies: eight parents
+ * with four children each are forty sessions, and forty sessions at four terminals is a hundred and
+ * sixty shells.
+ *
+ * WHY 256. Every shell in this map was opened by the user on purpose, and what runs inside it is the
+ * user's own business - so this constant is NOT a memory governor and does not pretend to be one. Its
+ * whole job is to be generous enough never to stand in the way of real work, and loud enough that a
+ * client looping on `terminal.open` is stopped with a message instead of quietly filling the machine.
+ * (For the record, the platform's own overhead per shell is the shell: an idle Windows PowerShell is
+ * ~90MB and an idle bash ~8MB, so the cost of "many terminals" is the cost of the shells themselves.)
+ * Reconnect storms do not need this constant to be low: the socket-close cleanup already kills a
+ * connection's shells, and the 30-second heartbeat reaps the half-open connections that would
+ * otherwise leave them behind.
+ */
+export declare const MAX_SESSIONS = 256;
 /**
  * The terminal's wire protocol, as members of the EXISTING `ClientCommand` / `ServerEvent` unions rather
  * than a second transport.

package/dist/server/terminal.js

@@ -29,8 +29,8 @@
  *      nothing else; this file resolves the id against the store and spawns in that workspace's path.
  *      A browser that asked for `C:\` or `/etc` gets its own workspace's directory instead, because
  *      there is no code path on which a client-supplied path reaches `spawn`.
- *   4. BOUNDED SESSIONS. `MAX_SESSIONS` shells, one per client tab, capped so a loop of reconnects
- *      cannot accumulate processes.
+ *   4. BOUNDED SESSIONS. `MAX_SESSIONS` live shells, capped so a loop of reconnects cannot accumulate
+ *      processes.
  *
  * What is NOT here is a per-command allowlist. A terminal that refuses `rm` or `curl` is not a terminal,
  * and pretending otherwise would be worse than the honest version: with (1) and (2) the operator has
@@ -190,8 +190,33 @@ export function terminalShellCandidates(env = process.env) {
 // ---------------------------------------------------------------------------------------------
 // Bounds
 // ---------------------------------------------------------------------------------------------
-/** One shell per browser tab, and a hard ceiling so reconnects cannot accumulate processes. */
-export const MAX_SESSIONS = 8;
+/**
+ * THE CEILING ON LIVE SHELLS.
+ *
+ * WHAT THIS COUNTS. Only the browser's terminal panel: `terminal.open` is the ONE place a shell is
+ * spawned, and it is a command the browser sends over its own WebSocket. An agent session, a
+ * sub-agent run, and the `exec` tool do NOT consume this budget - the exec tool spawns its own
+ * short-lived `shell -c` process through a different service.
+ *
+ * WHY THE COUNT ACCUMULATES. The client opens up to five terminals per session (`MAX_SLOTS` in
+ * TerminalPanel), and a shell is deliberately KEPT ALIVE across a session switch: the panel unmounts
+ * without closing it, so the work in that shell survives the switch. Every session in the tree is a
+ * conversation with its own panel - including a CHILD session the user can click into - and each of
+ * them can hold five shells, and all of them land in this one map. A tree multiplies: eight parents
+ * with four children each are forty sessions, and forty sessions at four terminals is a hundred and
+ * sixty shells.
+ *
+ * WHY 256. Every shell in this map was opened by the user on purpose, and what runs inside it is the
+ * user's own business - so this constant is NOT a memory governor and does not pretend to be one. Its
+ * whole job is to be generous enough never to stand in the way of real work, and loud enough that a
+ * client looping on `terminal.open` is stopped with a message instead of quietly filling the machine.
+ * (For the record, the platform's own overhead per shell is the shell: an idle Windows PowerShell is
+ * ~90MB and an idle bash ~8MB, so the cost of "many terminals" is the cost of the shells themselves.)
+ * Reconnect storms do not need this constant to be low: the socket-close cleanup already kills a
+ * connection's shells, and the 30-second heartbeat reaps the half-open connections that would
+ * otherwise leave them behind.
+ */
+export const MAX_SESSIONS = 256;
 /** Below the client panel's own minimum, and small enough that a `ls` cannot stall the socket. */
 const MIN_COLS = 20;
 const MIN_ROWS = 5;
@@ -296,7 +321,15 @@ export class TerminalService {
             if (this.sessions.has(command.sessionId))
                 return;
             if (this.sessions.size >= MAX_SESSIONS) {
-                send({ type: "terminal.error", sessionId: command.sessionId, message: `终端会话已达上限（${MAX_SESSIONS} 个），请先关闭一个。` });
+                // The count is in the message because the shells eating the budget are usually the BACKGROUND
+                // ones of other sessions - a parent session's children included, each of which has its own
+                // panel with its own terminals. The user sees three terminals in this panel and a refusal,
+                // and has no way to guess that the sessions they left open still hold shells.
+                send({
+                    type: "terminal.error",
+                    sessionId: command.sessionId,
+                    message: `终端会话已达上限（服务器最多 ${MAX_SESSIONS} 个，当前已有 ${this.sessions.size} 个在运行）。切换会话后仍在后台运行的终端也计入其中（包括 session 树里的子会话），请到对应的会话里关闭一个再试。`,
+                });
                 return;
             }
             // The workspace id is the ONLY thing the browser supplies, and it is resolved here. A client that

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@evandu/super-pi",
-  "version": "0.1.152",
+  "version": "0.1.153",
   "description": "Web control plane and companion for Pi",
   "license": "MIT",
   "type": "module",
@@ -29,8 +29,8 @@
     "node": ">=22.19.0"
   },
   "scripts": {
-    "prepack": "npm run build",
-    "prepublishOnly": "npm run build && cross-env SUPER_PI_REQUIRE_REAL_PI=1 node scripts/extension-load.test.mjs",
+    "prepack": "node scripts/clean-build.mjs",
+    "prepublishOnly": "node scripts/clean-build.mjs && cross-env SUPER_PI_REQUIRE_REAL_PI=1 node scripts/extension-load.test.mjs",
     "dev": "concurrently --kill-others-on-fail \"npm:dev:server\" \"npm:dev:client\"",
     "dev:client": "vite --host 0.0.0.0",
     "dev:server": "cross-env SUPER_PI_PORT=3081 tsx watch src/server/index.ts",
@@ -53,6 +53,7 @@
     "scripts/pi-session.test.mjs",
     "scripts/length-continuation.test.mjs",
     "scripts/pi-session-isolation.test.mjs",
+    "scripts/build-state.test.mjs",
     "scripts/installed-layout.test.mjs",
     "scripts/pi-model-switch.test.mjs",
     "scripts/pi-thinking-levels.test.mjs",
@@ -277,6 +278,7 @@
     "scripts/narrow-layout.test.mjs",
     "scripts/scrollbar-style.test.mjs",
     "scripts/stream-tail-browser.test.mjs",
+    "scripts/scroll-restore-browser.test.mjs",
     "scripts/theme-contrast.test.mjs",
     "scripts/theme-switch-state.test.mjs",
     "scripts/settings-window-structure.test.mjs",

package/dist/.super-pi-check-inputs.json

@@ -1,4 +0,0 @@
-{
-  "hash": "1219863c6dde78b6d52bf17deb4231e37ea1e686894543611a5c328017e6ac18",
-  "recordedAt": "2026-11-01T17:52:28.907Z"
-}

package/dist/server/feishu-config.d.ts

@@ -1,68 +0,0 @@
-import type { FeishuDomain } from "./feishu.js";
-/**
- * THE FEISHU CREDENTIALS, and where they live.
- *
- * WHY A FILE IN THE DATA DIRECTORY AND NOT A FIELD IN THE APP STATE. The App State is broadcast to
- * every browser that connects, and it is written to disk in a form that is meant to be readable.
- * A secret does not belong there - the same rule the provider registry follows, where the API key
- * lives in `<dataDir>/providers.json` with restrictive permissions and the browser is told only
- * that a key exists.
- *
- * WHY THE ENVIRONMENT OVERRIDES THE FILE. A deployment that provisions the credential through the
- * environment should not have to write a file as well, and the environment is the harder thing to
- * override accidentally. The file is the fallback, not the other way round.
- *
- * WHY THERE IS ONE SET OF CREDENTIALS FOR THE WHOLE SERVER. Feishu credentials belong to an
- * application inside one enterprise, and Super Pi runs on one person's machine. A per-workspace
- * credential would be a second enterprise's application, and the user of that workspace would have
- * to be handed a secret they never asked for.
- */
-export type FeishuConfig = {
-    /** The application's App ID. */
-    appId?: string;
-    /** The application's App Secret. Never leaves the server. */
-    appSecret?: string;
-    /** Which Feishu the calls go to. */
-    domain?: FeishuDomain;
-};
-/** Where the credentials come from, for the panel to show. */
-export type FeishuConfigSource = "environment" | "file" | "none";
-export declare class FeishuConfigStore {
-    private readonly file;
-    constructor(file: string);
-    /**
-     * The credentials in force, and where they came from.
-     *
-     * The environment wins over the file, and the file is read only when the environment has not
-     * said anything - so a machine that provisions the credential through the environment never
-     * touches the file at all.
-     */
-    read(): Promise<{
-        config: FeishuConfig;
-        source: FeishuConfigSource;
-    }>;
-    /**
-     * The file's own contents, and only its own contents.
-     *
-     * A file that cannot be read is a file that is not there, and a file that cannot be parsed is a
-     * file this server did not write. Both are reported rather than thrown: a broken credential
-     * file must not stop the server from starting.
-     */
-    private readFile;
-    /**
-     * Writes the credentials.
-     *
-     * The write is atomic (a temporary file and a rename) so a crash cannot leave half a JSON file
-     * behind, and the file's mode is 0600 so that a secret is not readable by every account on the
-     * machine. On Windows the mode is not enforced the same way, and there is nothing this code can
-     * do about that.
-     */
-    write(config: FeishuConfig): Promise<void>;
-}
-/**
- * The domain a name means, defaulting to Feishu.
- *
- * A name this does not recognise is Feishu rather than an error: the domain is a convenience for
- * Lark users, and refusing to start over a typo in it would be worse than trying Feishu.
- */
-export declare function domainOf(value: string | undefined): FeishuDomain;

package/dist/server/feishu-config.js

@@ -1,84 +0,0 @@
-import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
-import { randomUUID } from "node:crypto";
-import { dirname } from "node:path";
-export class FeishuConfigStore {
-    file;
-    constructor(file) {
-        this.file = file;
-    }
-    /**
-     * The credentials in force, and where they came from.
-     *
-     * The environment wins over the file, and the file is read only when the environment has not
-     * said anything - so a machine that provisions the credential through the environment never
-     * touches the file at all.
-     */
-    async read() {
-        const fromEnv = {
-            ...(process.env.SUPER_PI_FEISHU_APP_ID ? { appId: process.env.SUPER_PI_FEISHU_APP_ID.trim() } : {}),
-            ...(process.env.SUPER_PI_FEISHU_APP_SECRET ? { appSecret: process.env.SUPER_PI_FEISHU_APP_SECRET.trim() } : {}),
-            ...(process.env.SUPER_PI_FEISHU_DOMAIN ? { domain: domainOf(process.env.SUPER_PI_FEISHU_DOMAIN) } : {}),
-        };
-        if (fromEnv.appId && fromEnv.appSecret)
-            return { config: fromEnv, source: "environment" };
-        const stored = await this.readFile();
-        if (fromEnv.appId || fromEnv.appSecret)
-            return { config: { ...stored, ...fromEnv }, source: "environment" };
-        return { config: stored, source: stored.appId && stored.appSecret ? "file" : "none" };
-    }
-    /**
-     * The file's own contents, and only its own contents.
-     *
-     * A file that cannot be read is a file that is not there, and a file that cannot be parsed is a
-     * file this server did not write. Both are reported rather than thrown: a broken credential
-     * file must not stop the server from starting.
-     */
-    async readFile() {
-        try {
-            const raw = await readFile(this.file, "utf8");
-            const parsed = JSON.parse(raw);
-            return {
-                ...(typeof parsed.appId === "string" ? { appId: parsed.appId } : {}),
-                ...(typeof parsed.appSecret === "string" ? { appSecret: parsed.appSecret } : {}),
-                ...(parsed.domain ? { domain: domainOf(parsed.domain) } : {}),
-            };
-        }
-        catch {
-            return {};
-        }
-    }
-    /**
-     * Writes the credentials.
-     *
-     * The write is atomic (a temporary file and a rename) so a crash cannot leave half a JSON file
-     * behind, and the file's mode is 0600 so that a secret is not readable by every account on the
-     * machine. On Windows the mode is not enforced the same way, and there is nothing this code can
-     * do about that.
-     */
-    async write(config) {
-        await mkdir(dirname(this.file), { recursive: true });
-        const temporary = `${this.file}.${randomUUID()}.tmp`;
-        const value = {
-            ...(config.appId ? { appId: config.appId } : {}),
-            ...(config.appSecret ? { appSecret: config.appSecret } : {}),
-            ...(config.domain ? { domain: config.domain } : {}),
-        };
-        try {
-            await writeFile(temporary, `${JSON.stringify(value, null, 2)}\n`, { mode: 0o600 });
-            await rename(temporary, this.file);
-        }
-        catch (error) {
-            await writeFile(temporary, "{}", { mode: 0o600 }).catch(() => undefined);
-            throw error;
-        }
-    }
-}
-/**
- * The domain a name means, defaulting to Feishu.
- *
- * A name this does not recognise is Feishu rather than an error: the domain is a convenience for
- * Lark users, and refusing to start over a typo in it would be worse than trying Feishu.
- */
-export function domainOf(value) {
-    return String(value ?? "").trim().toLowerCase() === "lark" ? "lark" : "feishu";
-}

package/dist/server/feishu.d.ts

@@ -1,187 +0,0 @@
-/**
- * THE FEISHU CLIENT: everything Super Pi knows how to do with a cloud document on Feishu.
- *
- * WHY THIS LAYER EXISTS AT ALL. Feishu's document API is not "read a file" and "write a file". A
- * document is a TREE OF BLOCKS, the API refuses to create a document with content in it, and the
- * official way to put Markdown into a document is a three-step dance (convert to blocks, then
- * insert them as nested blocks under the page block). An agent that had to know that would be
- * writing protocol details into every prompt. So the protocol lives here, once, and what is left
- * above it is "read this document" and "write this document".
- *
- * WHY AN HTTP CLIENT AND NOT THE OFFICIAL SDK. The official SDK (`@larksuiteoapi/node-sdk`) is a
- * good library, but it is a dependency of the PACKAGE, and this package's whole point is that it
- * installs and runs. Every call it makes is a plain HTTP call with a bearer token, so the four
- * endpoints this feature needs are four functions - and the credential handling (a token that
- * expires, a token that has to be refreshed, a rate limit that has to be waited out) is the part
- * that is worth writing carefully and testing on its own.
- *
- * WHAT THE IDENTITY IS. Everything here runs as the APPLICATION (`tenant_access_token`), never as
- * a person. That is the identity that needs no OAuth dance and no browser, and it is also the
- * identity that can only touch the documents the application has been made a collaborator on.
- * See `docs/FEISHU.md` for the setup that implies, because it is the one thing a user must do
- * before any of this works.
- */
-/** The tool that reads a Feishu document. */
-export declare const FEISHU_READ_TOOL_NAME = "feishu_doc_read";
-/** The tool that writes a Feishu document. */
-export declare const FEISHU_WRITE_TOOL_NAME = "feishu_doc_write";
-/** Which flavour of Feishu we talk to. The API paths differ, the shapes do not. */
-export type FeishuDomain = "feishu" | "lark";
-/** A block in a Feishu document. Only the fields this code reads are named. */
-export type FeishuBlock = {
-    block_id: string;
-    parent_id?: string;
-    children?: string[];
-    block_type: number;
-    [key: string]: unknown;
-};
-/**
- * A REFUSAL FROM FEISHU, with the code kept alongside the message.
- *
- * The code is kept because the message Feishu sends is written for a developer reading a log,
- * and the part a person needs - "add this application as a collaborator", "open this permission
- * point" - is not in it.
- */
-export declare class FeishuError extends Error {
-    readonly code: number;
-    readonly hint?: string | undefined;
-    constructor(code: number, message: string, hint?: string | undefined);
-}
-/**
- * The message a refusal is shown with: what Feishu said, and what to do about it.
- */
-export declare function describeFeishuError(code: number, message: string): string;
-/**
- * WHAT A URL OR A TOKEN NAMES.
- *
- * `kind` is "docx" for a document and "wiki" for a knowledge-base node. The distinction is not
- * cosmetic: a wiki URL's token is NOT the document id, and passing it as one produces a document
- * that does not exist. A wiki link has to be resolved through the wiki API first.
- */
-export type FeishuTarget = {
-    kind: "docx" | "wiki";
-    token: string;
-    /** The tenant host the link came from, when it came from a link. Used to build a URL for a new document. */
-    host?: string;
-};
-/**
- * Reads a document reference: a full URL, or a bare token.
- *
- * WHY BARE TOKENS ARE ACCEPTED. A person reading a document's URL sees the token in it, and an
- * agent that has been handed `doxcn...` should not have to be told to wrap it in a URL first.
- */
-export declare function parseFeishuTarget(input: string): FeishuTarget;
-/**
- * Renders a document's blocks as Markdown.
- *
- * WHY MARKDOWN AND NOT THE RAW TEXT. `raw_content` gives the words without the shape: a heading
- * arrives as a heading's text, a list arrives as separate lines, and a reader cannot tell them
- * apart. The block tree is the document, and Markdown is the closest plain-text shape this side of
- * the product already understands.
- */
-export declare function blocksToMarkdown(blocks: FeishuBlock[]): string;
-/** The client the service drives. Every call goes through here. */
-export type FeishuClientOptions = {
-    appId: string;
-    appSecret: string;
-    domain?: FeishuDomain;
-    /** Injected in tests, so the suite never touches the network. */
-    fetchImpl?: typeof fetch;
-};
-export declare class FeishuClient {
-    private readonly options;
-    private token?;
-    /** Whether the newer OAuth token endpoint works for this application. */
-    private useLegacyAuth;
-    /** The write queue. One write at a time, spaced by the interval the API allows. */
-    private writeChain;
-    private lastWriteAt;
-    constructor(options: FeishuClientOptions);
-    private get apiBase();
-    private get accountsBase();
-    private get fetchImpl();
-    /**
-     * THE ACCESS TOKEN, fetched once and reused.
-     *
-     * The lifetime is two hours and the API says to believe the number it returns rather than a
-     * hardcoded one, so the expiry comes from the response and the token is renewed a couple of
-     * minutes before it runs out.
-     */
-    accessToken(force?: boolean): Promise<string>;
-    /**
-     * The current OAuth endpoint: `POST https://accounts.feishu.cn/oauth/v3/token`.
-     *
-     * It is the one the documentation recommends. If it refuses - an older application, a tenant
-     * that has not been migrated - the legacy endpoint is tried instead, and the client remembers
-     * so the failing call is not made again on every token refresh.
-     */
-    private fetchOAuthToken;
-    /**
-     * The historical endpoint: `POST /open-apis/auth/v3/tenant_access_token/internal`.
-     *
-     * It is documented as superseded, but it is the endpoint every 自建应用 has worked with for
-     * years, and a fallback that costs one request is cheaper than a feature that does not run.
-     */
-    private fetchLegacyToken;
-    /**
-     * ONE CALL, with the bearer token attached.
-     *
-     * A 429 is waited out rather than reported: the API tells us how many seconds until the window
-     * resets, and a write that gives up because it was 200ms early is a write that did not happen.
-     */
-    private request;
-    /**
-     * Runs one write, spaced from the last one.
-     */
-    private withWriteSlot;
-    /** The basic information about a document: its title and its version. */
-    documentMeta(documentId: string): Promise<{
-        documentId: string;
-        title?: string;
-        revisionId?: number;
-    }>;
-    /** Every block of a document, across every page. */
-    documentBlocks(documentId: string): Promise<FeishuBlock[]>;
-    /** The plain text of a document, without any structure. */
-    rawContent(documentId: string): Promise<string>;
-    /** The blocks directly under the page block - the document's top level. */
-    rootChildren(documentId: string): Promise<string[]>;
-    /** Creates an empty document. The content goes in afterwards, because the API has no other way. */
-    createDocument(title: string, folderToken?: string): Promise<{
-        documentId: string;
-        revisionId?: number;
-    }>;
-    /** Resolves a knowledge-base node to the document behind it. */
-    wikiNode(token: string): Promise<{
-        objToken: string;
-        objType: string;
-        title?: string;
-    }>;
-    /**
-     * Turns Markdown into the blocks that represent it.
-     *
-     * The API will not create a document with content in it, and building the blocks by hand would
-     * mean reimplementing the conversion Feishu already does - tables, code fences, todos and all.
-     */
-    convertMarkdown(markdown: string): Promise<{
-        blocks: FeishuBlock[];
-        firstLevelBlockIds: string[];
-    }>;
-    /**
-     * Inserts blocks under the page block.
-     *
-     * THE CHUNKING IS NOT AN OPTIMISATION. The API accepts at most 1000 blocks per call, and the
-     * blocks of one subtree cannot be split across calls - so the top-level blocks are packed into
-     * batches that each fit, and a document of any length goes in.
-     */
-    insertBlocks(documentId: string, blocks: FeishuBlock[], firstLevelBlockIds: string[], index?: number): Promise<number | undefined>;
-    /** Deletes a range of the page block's children. The range is left-closed and right-open. */
-    deleteChildren(documentId: string, startIndex: number, endIndex: number): Promise<number | undefined>;
-}
-/**
- * Removes the read-only merge information from a table block.
- *
- * The API rejects a table block that carries `merge_info`, and the conversion endpoint hands it
- * back with that field on it. The documentation says to strip it, so it is stripped.
- */
-export declare function stripTableMergeInfo(block: FeishuBlock): FeishuBlock;