@evandu/super-pi 0.1.21 → 0.1.23

package/dist/server/files.js

@@ -28,8 +28,8 @@
  * directory a 404 that names itself instead of a containment failure about a symlink that does not exist.
  */
 import { createHash } from "node:crypto";
-import { readFile, readdir, realpath, rename, stat, unlink, writeFile } from "node:fs/promises";
-import { basename, dirname, isAbsolute, relative, resolve, sep } from "node:path";
+import { mkdtemp, readFile, readdir, realpath, rename, stat, unlink, writeFile } from "node:fs/promises";
+import { basename, dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
 /**
  * Above this a read is refused rather than served. 5MB is roughly a large source file or a long document,
  * and it is deliberately far below the point where an editor tab stops being useful: this panel is for
@@ -395,13 +395,13 @@ export async function listDirectory(root, requested) {
         let outside = false;
         if (isLink) {
             try {
-                await guard(absolute);
+                await guard(toRelative(root, absolute));
             }
             catch {
                 outside = true;
             }
         }
-        const isDir = dirent.isDirectory();
+        const isDir = dirent.isDirectory() || (isLink && !outside && await stat(absolute).then((item) => item.isDirectory()).catch(() => false));
         entries.push({
             path: toRelative(root, absolute),
             name: dirent.name,
@@ -474,7 +474,14 @@ export async function searchByName(root, query) {
             }
             throw error;
         }
-        for (const entry of listing.entries) {
+        // listDirectory intentionally caps UI listings; search must inspect the complete directory.
+        const fullEntries = listing.truncated
+            ? (await readdir(await guard(directory), { withFileTypes: true })).map((dirent) => {
+                const absolute = resolve(root, directory, dirent.name);
+                return { path: toRelative(root, absolute), name: dirent.name, kind: dirent.isDirectory() ? "directory" : dirent.isSymbolicLink() ? "symlink" : "file", text: null };
+            })
+            : listing.entries;
+        for (const entry of fullEntries) {
             if (truncated)
                 return;
             if (entry.kind === "file") {
@@ -534,6 +541,7 @@ export async function readWorkspaceFile(root, requested) {
         throw new FilesError(415, `不支持的文件类型（二进制内容）：${requested}`, "binary");
     // `fatal: true` so a truncated multi-byte sequence - a file written by something that cut a UTF-8
     // character in half - throws here instead of decoding to U+FFFD and being written back on save.
+    const bom = raw.length >= 3 && raw[0] === 0xef && raw[1] === 0xbb && raw[2] === 0xbf;
     let content;
     try {
         content = new TextDecoder("utf-8", { fatal: true }).decode(raw);
@@ -541,8 +549,9 @@ export async function readWorkspaceFile(root, requested) {
     catch {
         throw new FilesError(415, `不是有效的 UTF-8 文本，不支持编辑：${requested}`, "binary");
     }
-    return { path: toRelative(root, target), content, meta, eol: content.includes("\r\n") ? "\r\n" : "\n" };
+    return { path: toRelative(root, target), content, meta, bom, eol: content.includes("\r\n") ? "\r\n" : "\n" };
 }
+const writeLocks = new Map();
 /**
  * Write one EXISTING text file. No creation, no deletion, no rename, no directories.
  *
@@ -569,51 +578,73 @@ export async function readWorkspaceFile(root, requested) {
  */
 export async function writeWorkspaceFile(root, requested, content, baseEtag) {
     const target = await resolveInsideRoot(root, requested);
-    const info = await stat(target).catch((error) => {
-        const code = error?.code;
-        if (code === "ENOENT" || code === "ENOTDIR")
-            throw new FilesError(428, `文件不存在，本面板只允许写入已存在的文件：${requested}`, "missing_target");
-        if (code === "EACCES" || code === "EPERM")
-            throw new FilesError(403, `权限不足：${requested}`, "denied");
-        throw error;
-    });
-    if (info.isDirectory())
-        throw new FilesError(400, `这是一个目录，不能写入：${requested}`, "not_a_file");
-    if (hasBinaryExtension(target))
-        throw new FilesError(415, `拒绝写入二进制文件：${requested}`, "binary");
-    const current = await fileMeta(target);
-    if (!baseEtag)
-        throw new FilesError(428, "缺少 baseEtag：保存必须带上打开时读到的版本标识，否则无法判断文件是否被改动过", "etag_required");
-    if (baseEtag !== current.etag) {
-        // The CURRENT etag travels with the refusal, and that is what makes an informed overwrite possible:
-        // the UI can offer "仍然覆盖" which re-sends THIS etag, rather than a blind write that would succeed
-        // only because the check was skipped once. The refusal is not a dead end - it is a question.
-        throw new FilesError(409, `文件在磁盘上已被其他程序修改，未保存：${requested}`, "stale", {
-            path: toRelative(root, target),
-            current,
-            yourEtag: baseEtag,
-        });
-    }
-    const bytes = Buffer.byteLength(content, "utf8");
-    if (bytes > MAX_FILE_BYTES)
-        throw new FilesError(413, `写入内容过大（${(bytes / 1024 / 1024).toFixed(1)}MB），上限 ${MAX_FILE_BYTES / 1024 / 1024}MB`, "too_large");
-    // A save must not turn a text file into a binary one, so the sniff that guards the read guards the
-    // write: a NUL arriving through a paste would otherwise be written to disk and make the file unreadable
-    // to this panel ever after.
-    if (looksBinary(Buffer.from(content, "utf8")))
-        throw new FilesError(415, "拒绝写入：内容包含二进制字节（\\0）", "binary");
-    const temporary = `${target}.super-pi-${process.pid}-${Date.now().toString(36)}.tmp`;
+    const previous = writeLocks.get(target) ?? Promise.resolve();
+    let release;
+    const currentLock = new Promise((resolve) => { release = resolve; });
+    const queued = previous.then(() => currentLock);
+    writeLocks.set(target, queued);
+    await previous;
     try {
-        await writeFile(temporary, content, "utf8");
-        await rename(temporary, target);
+        const info = await stat(target).catch((error) => {
+            const code = error?.code;
+            if (code === "ENOENT" || code === "ENOTDIR")
+                throw new FilesError(428, `文件不存在，本面板只允许写入已存在的文件：${requested}`, "missing_target");
+            if (code === "EACCES" || code === "EPERM")
+                throw new FilesError(403, `权限不足：${requested}`, "denied");
+            throw error;
+        });
+        if (info.isDirectory())
+            throw new FilesError(400, `这是一个目录，不能写入：${requested}`, "not_a_file");
+        if (hasBinaryExtension(target))
+            throw new FilesError(415, `拒绝写入二进制文件：${requested}`, "binary");
+        const current = await fileMeta(target);
+        if (!baseEtag)
+            throw new FilesError(428, "缺少 baseEtag：保存必须带上打开时读到的版本标识，否则无法判断文件是否被改动过", "etag_required");
+        if (baseEtag !== current.etag) {
+            // The CURRENT etag travels with the refusal, and that is what makes an informed overwrite possible:
+            // the UI can offer "仍然覆盖" which re-sends THIS etag, rather than a blind write that would succeed
+            // only because the check was skipped once. The refusal is not a dead end - it is a question.
+            throw new FilesError(409, `文件在磁盘上已被其他程序修改，未保存：${requested}`, "stale", {
+                path: toRelative(root, target),
+                current,
+                yourEtag: baseEtag,
+            });
+        }
+        const bytes = Buffer.byteLength(content, "utf8");
+        if (bytes > MAX_FILE_BYTES)
+            throw new FilesError(413, `写入内容过大（${(bytes / 1024 / 1024).toFixed(1)}MB），上限 ${MAX_FILE_BYTES / 1024 / 1024}MB`, "too_large");
+        // A save must not turn a text file into a binary one, so the sniff that guards the read guards the
+        // write: a NUL arriving through a paste would otherwise be written to disk and make the file unreadable
+        // to this panel ever after.
+        if (looksBinary(Buffer.from(content, "utf8")))
+            throw new FilesError(415, "拒绝写入：内容包含二进制字节（\\0）", "binary");
+        const original = await readFile(target);
+        const hadBom = original.length >= 3 && original[0] === 0xef && original[1] === 0xbb && original[2] === 0xbf;
+        const output = hadBom ? `\uFEFF${content}` : content;
+        const temporary = await mkdtemp(`${target}.super-pi-${process.pid}-`);
+        const temporaryFile = join(temporary, basename(target));
+        try {
+            await writeFile(temporaryFile, output, "utf8");
+            await rename(temporaryFile, target);
+        }
+        catch (error) {
+            // The temporary file is the ONLY thing this function can leave behind, and it is the one thing that
+            // must never survive a failed save.
+            await unlink(temporaryFile).catch(() => { });
+            throw error;
+        }
+        finally {
+            await import("node:fs/promises").then(({ rm }) => rm(temporary, { recursive: true, force: true })).catch(() => { });
+            release();
+            if (writeLocks.get(target) === queued)
+                writeLocks.delete(target);
+        }
+        return { path: toRelative(root, target), meta: await fileMeta(target), created: false };
     }
     catch (error) {
-        // The temporary file is the ONLY thing this function can leave behind, and it is the one thing that
-        // must never survive a failed save.
-        await unlink(temporary).catch(() => { });
+        release();
         throw error;
     }
-    return { path: toRelative(root, target), meta: await fileMeta(target), created: false };
 }
 /** Every `FilesError` carries the status it should be rendered with; anything else is a real fault and
  *  becomes a 500 rather than being dressed up as a refusal the user is asked to understand. */

package/dist/server/http-server.d.ts

@@ -4,6 +4,22 @@ import type { ServerContext } from "./server-context.js";
  * Checks if the remote address is a local loopback interface.
  */
 export declare function isLoopbackAddress(remoteAddress: string | undefined): boolean;
+/**
+ * Checks if the remote address is a local loopback interface, host network interface,
+ * or a private network address (RFC 1918 / IPv6 ULA / link-local).
+ */
+export declare function isLocalOrPrivateAddress(remoteAddress: string | undefined): boolean;
+/**
+ * Returns a list of non-internal IPv4 addresses available on local network interfaces.
+ */
+export declare function getLanIps(): string[];
+/**
+ * Parses CLI arguments (--host, -H, --port, -p) for server configuration.
+ */
+export declare function parseServerArgs(argv: string[]): {
+    host?: string;
+    port?: number;
+};
 /**
  * Checks whether an incoming HTTP request satisfies access token authorization.
  */
@@ -12,7 +28,7 @@ export declare function isAuthorized(request: {
 }, accessToken?: string): boolean;
 export interface HttpServerOptions {
     context: ServerContext;
-    onShutdown: (reason: string) => void;
+    onShutdown: (reason: string) => Promise<void>;
 }
 /**
  * Creates the HTTP server providing static client assets and all `/api/*` endpoints.

package/dist/server/http-server.js

@@ -1,7 +1,7 @@
 import { createReadStream, existsSync } from "node:fs";
 import { readdir, stat } from "node:fs/promises";
 import { createServer } from "node:http";
-import { homedir } from "node:os";
+import { homedir, networkInterfaces } from "node:os";
 import { basename, dirname, extname, join, relative, resolve } from "node:path";
 import { describe as describeFilesError, fileMeta, listDirectory, MAX_FILE_BYTES, readWorkspaceFile, resolveInsideRoot, searchByName, toRelative, writeWorkspaceFile, } from "./files.js";
 import { findUploadFile, MAX_UPLOAD_BODY_BYTES, saveUpload } from "./upload.js";
@@ -13,6 +13,7 @@ const MIME_TYPES = {
     ".svg": "image/svg+xml",
     ".json": "application/json; charset=utf-8",
     ".ico": "image/x-icon",
+    ".png": "image/png",
 };
 /**
  * Checks if the remote address is a local loopback interface.
@@ -20,7 +21,103 @@ const MIME_TYPES = {
 export function isLoopbackAddress(remoteAddress) {
     if (!remoteAddress)
         return false;
-    return ["127.0.0.1", "::1", "::ffff:127.0.0.1"].includes(remoteAddress);
+    const normalized = remoteAddress.replace(/^::ffff:/, "");
+    return (normalized === "127.0.0.1" ||
+        normalized === "::1" ||
+        normalized === "localhost" ||
+        normalized.startsWith("127."));
+}
+/**
+ * Checks if the remote address is a local loopback interface, host network interface,
+ * or a private network address (RFC 1918 / IPv6 ULA / link-local).
+ */
+export function isLocalOrPrivateAddress(remoteAddress) {
+    if (!remoteAddress)
+        return false;
+    if (isLoopbackAddress(remoteAddress))
+        return true;
+    const ip = remoteAddress.replace(/^::ffff:/, "");
+    // RFC 1918 IPv4 Private Networks:
+    // 10.0.0.0/8
+    if (ip.startsWith("10."))
+        return true;
+    // 172.16.0.0/12 (172.16.0.0 - 172.31.255.255)
+    if (/^172\.(1[6-9]|2[0-9]|3[0-1])\./.test(ip))
+        return true;
+    // 192.168.0.0/16
+    if (ip.startsWith("192.168."))
+        return true;
+    // IPv4 Link-Local (169.254.0.0/16)
+    if (ip.startsWith("169.254."))
+        return true;
+    // IPv6 Link-Local (fe80::/10)
+    if (/^fe[89ab][0-9a-f]/i.test(ip))
+        return true;
+    // IPv6 Unique Local Address (fc00::/7 -> fc00:: or fd00::)
+    if (/^f[cd][0-9a-f]{2}:/i.test(ip))
+        return true;
+    try {
+        const ifaces = networkInterfaces();
+        for (const dev of Object.values(ifaces)) {
+            if (!dev)
+                continue;
+            for (const details of dev) {
+                if (details.address === ip)
+                    return true;
+            }
+        }
+    }
+    catch { }
+    return false;
+}
+/**
+ * Returns a list of non-internal IPv4 addresses available on local network interfaces.
+ */
+export function getLanIps() {
+    const ips = [];
+    try {
+        const ifaces = networkInterfaces();
+        for (const dev of Object.values(ifaces)) {
+            if (!dev)
+                continue;
+            for (const details of dev) {
+                if (details.family === "IPv4" && !details.internal) {
+                    ips.push(details.address);
+                }
+            }
+        }
+    }
+    catch { }
+    return ips;
+}
+/**
+ * Parses CLI arguments (--host, -H, --port, -p) for server configuration.
+ */
+export function parseServerArgs(argv) {
+    let host;
+    let port;
+    for (let i = 2; i < argv.length; i++) {
+        const arg = argv[i];
+        if (arg === "--host" || arg === "-H") {
+            const next = argv[++i];
+            if (next && !next.startsWith("-"))
+                host = next;
+        }
+        else if (arg.startsWith("--host=")) {
+            host = arg.slice("--host=".length);
+        }
+        else if (arg === "--port" || arg === "-p") {
+            const p = Number.parseInt(argv[++i], 10);
+            if (!Number.isNaN(p))
+                port = p;
+        }
+        else if (arg.startsWith("--port=")) {
+            const p = Number.parseInt(arg.slice("--port=".length), 10);
+            if (!Number.isNaN(p))
+                port = p;
+        }
+    }
+    return { host, port };
 }
 /**
  * Checks whether an incoming HTTP request satisfies access token authorization.
@@ -36,20 +133,62 @@ export function createHttpServer(options) {
     const { store, paths, accessToken, broadcaster, runService, catalogService } = context;
     const { uploadsDir, clientDir, rootDir } = paths;
     return createServer(async (request, response) => {
-        if (!isAuthorized(request, accessToken)) {
+        // Internal tools use a narrow per-run capability, never the global management token.
+        if (request.url?.split("?")[0] !== "/api/memory/tool" && !isAuthorized(request, accessToken)) {
             response.writeHead(401, { "www-authenticate": "Bearer" }).end("Authentication required");
             return;
         }
         const url = new URL(request.url ?? "/", `http://${request.headers.host ?? "localhost"}`);
         const remote = request.socket.remoteAddress ?? "";
+        /**
+         * THE TERMINAL IS NOT AN API ENDPOINT, and the routing above deliberately cannot reach one.
+         *
+         * Every command family in `CommandHandler` is answerable over plain HTTP except the terminal, which
+         * is WebSocket-only (`terminal.*` messages). `serverContext` therefore carries only the two
+         * predicates `/api/terminal` needs - is it on, and if not why - and NOT a handle on `TerminalService`.
+         * There is consequently no code path from an HTTP request to a spawned shell, which is the property
+         * worth having: the browser's own origin could not reach it even with a forged request.
+         */
+        if (url.pathname === "/api/memory/tool" || url.pathname === "/api/memory") {
+            if (!context.memory) {
+                response.writeHead(503).end();
+                return;
+            }
+            if ((url.pathname.endsWith("/tool") && request.method !== "POST") || !["GET", "POST"].includes(request.method ?? "")) {
+                response.writeHead(405).end();
+                return;
+            }
+            const origin = request.headers.origin;
+            if (origin && origin !== url.origin) {
+                response.writeHead(403).end("Origin not allowed");
+                return;
+            }
+            try {
+                let raw = "";
+                for await (const chunk of request) {
+                    raw += chunk;
+                    if (raw.length > 512000)
+                        throw new Error("记忆请求过大");
+                }
+                const body = raw ? JSON.parse(raw) : {};
+                const result = url.pathname.endsWith("/tool")
+                    ? await context.memory.tool(String(request.headers["x-memory-capability"] ?? ""), body)
+                    : await context.memory.manage(url.searchParams.get("workspaceId") ?? "", body);
+                response.writeHead(200, { "content-type": "application/json; charset=utf-8" }).end(JSON.stringify(result));
+            }
+            catch (error) {
+                response.writeHead(400, { "content-type": "application/json; charset=utf-8" }).end(JSON.stringify({ error: error instanceof Error ? error.message : String(error) }));
+            }
+            return;
+        }
         if (url.pathname === "/api/shutdown") {
-            if (request.method !== "POST" || !isLoopbackAddress(remote)) {
-                response.writeHead(403, { "content-type": "text/plain; charset=utf-8" }).end("Shutdown requires a loopback POST");
+            if (request.method !== "POST" || !isLocalOrPrivateAddress(remote)) {
+                response.writeHead(403, { "content-type": "text/plain; charset=utf-8" }).end("Shutdown requires a loopback or private network POST");
                 return;
             }
             response.writeHead(202, { "content-type": "application/json; charset=utf-8" })
                 .end(JSON.stringify({ status: "shutting_down", message: "Server is stopping" }));
-            setTimeout(() => onShutdown("api-shutdown"), 50);
+            setTimeout(() => { void onShutdown("api-shutdown"); }, 50);
             return;
         }
         if (url.pathname === "/api/health") {
@@ -58,9 +197,27 @@ export function createHttpServer(options) {
                 .end(JSON.stringify({ status: "ok", service: "super-pi", ...version }));
             return;
         }
+        /**
+         * WHETHER THE TERMINAL EXISTS, as a plain GET rather than part of the `state` snapshot.
+         *
+         * It is deployment configuration, not application state: it does not change while the server runs,
+         * it is identical for every workspace, and putting it on `state` would drag it into the persistence
+         * layer and into every existing snapshot schema for no benefit. A `GET` also means the right rail
+         * can decide whether to RENDER the tab at all - and not rendering it is the point, because a tab
+         * that is present and refuses is a tab that invites a user to keep clicking a closed door.
+         *
+         * No address check: this leaks nothing beyond "is this build configured for a shell", which is
+         * already printed in the server's own startup banner to whoever can see the console.
+         */
+        if (url.pathname === "/api/terminal") {
+            const enabled = context.terminalEnabled?.() ?? false;
+            response.writeHead(200, { "content-type": "application/json; charset=utf-8" })
+                .end(JSON.stringify({ enabled, reason: enabled ? "" : (context.terminalDisabledReason?.() ?? "终端未启用。") }));
+            return;
+        }
         if (url.pathname === "/api/subagent/dispatch") {
-            if (request.method !== "POST" || !isLoopbackAddress(remote)) {
-                response.writeHead(403, { "content-type": "text/plain; charset=utf-8" }).end("Sub-agent dispatch requires a loopback POST");
+            if (request.method !== "POST" || !isLocalOrPrivateAddress(remote)) {
+                response.writeHead(403, { "content-type": "text/plain; charset=utf-8" }).end("Sub-agent dispatch requires a loopback or private network POST");
                 return;
             }
             let raw = "";
@@ -80,8 +237,8 @@ export function createHttpServer(options) {
             return;
         }
         if (url.pathname === "/api/workflow/run") {
-            if (request.method !== "POST" || !isLoopbackAddress(remote)) {
-                response.writeHead(403, { "content-type": "text/plain; charset=utf-8" }).end("Workflow dispatch requires a loopback POST");
+            if (request.method !== "POST" || !isLocalOrPrivateAddress(remote)) {
+                response.writeHead(403, { "content-type": "text/plain; charset=utf-8" }).end("Workflow dispatch requires a loopback or private network POST");
                 return;
             }
             let raw = "";
@@ -100,8 +257,8 @@ export function createHttpServer(options) {
             return;
         }
         if (url.pathname === "/api/todos") {
-            if (request.method !== "POST" || !isLoopbackAddress(remote)) {
-                response.writeHead(403, { "content-type": "text/plain; charset=utf-8" }).end("Todo writes require a loopback POST");
+            if (request.method !== "POST" || !isLocalOrPrivateAddress(remote)) {
+                response.writeHead(403, { "content-type": "text/plain; charset=utf-8" }).end("Todo writes require a loopback or private network POST");
                 return;
             }
             let raw = "";
@@ -159,13 +316,13 @@ export function createHttpServer(options) {
                         return;
                     }
                     const file = await readWorkspaceFile(root, rel);
-                    json(200, { path: file.path, content: file.content, eol: file.eol, meta: file.meta, maxBytes: MAX_FILE_BYTES });
+                    json(200, { path: file.path, content: file.content, eol: file.eol, bom: file.bom, meta: file.meta, maxBytes: MAX_FILE_BYTES });
                     return;
                 }
                 if (request.method === "PUT") {
                     const remoteAddr = request.socket.remoteAddress ?? "";
-                    if (!isLoopbackAddress(remoteAddr)) {
-                        json(403, { error: "File writes require a loopback connection", code: "not_loopback" });
+                    if (!isLocalOrPrivateAddress(remoteAddr)) {
+                        json(403, { error: "File writes require a loopback or private network connection", code: "not_loopback" });
                         return;
                     }
                     let raw = "";
@@ -263,8 +420,8 @@ export function createHttpServer(options) {
             return;
         }
         if (url.pathname === "/api/upload") {
-            if (request.method !== "POST" || !isLoopbackAddress(remote)) {
-                response.writeHead(403, { "content-type": "application/json; charset=utf-8" }).end(JSON.stringify({ error: "Upload requires a loopback POST" }));
+            if (request.method !== "POST" || !isLocalOrPrivateAddress(remote)) {
+                response.writeHead(403, { "content-type": "application/json; charset=utf-8" }).end(JSON.stringify({ error: "Upload requires a loopback or private network POST" }));
                 return;
             }
             const json = (status, body) => {
@@ -318,8 +475,8 @@ export function createHttpServer(options) {
             return;
         }
         if (url.pathname.startsWith("/api/upload/")) {
-            if (request.method !== "GET" || !isLoopbackAddress(remote)) {
-                response.writeHead(403, { "content-type": "application/json; charset=utf-8" }).end(JSON.stringify({ error: "Upload access requires a loopback GET" }));
+            if (request.method !== "GET" || !isLocalOrPrivateAddress(remote)) {
+                response.writeHead(403, { "content-type": "application/json; charset=utf-8" }).end(JSON.stringify({ error: "Upload access requires a loopback or private network GET" }));
                 return;
             }
             const pathParts = url.pathname.slice("/api/upload/".length).split("/").filter(Boolean);
@@ -356,7 +513,15 @@ export function createHttpServer(options) {
             response.writeHead(503, { "content-type": "text/plain; charset=utf-8" }).end("Super Pi client has not been built. Run npm run build.");
             return;
         }
+        const candidateInfo = await stat(candidate).catch(() => undefined);
+        if (!candidateInfo?.isFile()) {
+            response.writeHead(404, { "content-type": "text/plain; charset=utf-8" }).end("Not found");
+            return;
+        }
         response.writeHead(200, { "content-type": MIME_TYPES[extname(candidate)] ?? "application/octet-stream" });
-        createReadStream(candidate).pipe(response);
+        const stream = createReadStream(candidate);
+        stream.on("error", () => { if (!response.headersSent)
+            response.writeHead(404); response.end(); });
+        stream.pipe(response);
     });
 }