@evandu/super-pi 0.1.138 → 0.1.139

package/dist/server/application/scheduled-task-service.js

@@ -219,7 +219,14 @@ export class ScheduledTaskService {
         if (this.stopped)
             return;
         const now = Date.now();
-        const due = (this.store.snapshot().scheduledTasks ?? []).filter((task) => task.enabled && task.nextRunAt !== undefined && task.nextRunAt <= now);
+        // READ THROUGH THE NARROW READER, NOT THROUGH A CLONE OF THE WHOLE APPLICATION.
+        //
+        // This sweep runs every fifteen seconds for the whole life of the server. It used to read its
+        // tasks through `store.snapshot()` - a deep clone of every workspace, every conversation and every
+        // message of every conversation - to find the zero-to-three tasks that are due. On a server
+        // holding a long transcript that is a full copy of the app four times a minute, for a list that is
+        // usually empty. The narrow reader returns the tasks themselves and nothing else.
+        const due = this.store.scheduledTasks().filter((task) => task.enabled && task.nextRunAt !== undefined && task.nextRunAt <= now);
         for (const task of due) {
             if (this.inFlight.has(task.id))
                 continue;

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

@@ -108,7 +108,22 @@ export class WorkspaceService {
                 agentToStore = agent.id;
             }
         }
-        assertModelAllowed(this.store.snapshot().modelFilterRules, workspace, selection ?? (await this.runtime.catalog()).defaultModel);
+        // THE MODEL RULES HOLD THE MODEL THE USER JUST SET. The check is on `selection` ALONE, and
+        // `selection` is undefined when the update did not touch the model at all - which is a
+        // DIFFERENT thing from 「the model is Pi's default」.
+        //
+        // It used to read `selection ?? (await this.runtime.catalog()).defaultModel`, so changing the
+        // THINKING LEVEL - a setting that has nothing to do with models - was checked against Pi's own
+        // default model, and a workspace whose rules allow only its own default could not change its
+        // thinking level at all. The refusal even named a model the user had never chosen: 「当前模型
+        // 「Pi 默认 (prov/model-zzz)」不匹配允许的模型正则」.
+        //
+        // What the rules have to hold is the model this workspace's conversations will RUN ON, and the
+        // only model the user could have set here is `selection`. When the update does not name a model,
+        // the workspace's existing default (or the absence of one) is what stands, and that is checked
+        // where it is stamped onto a conversation - at birth, in `conversation-service.ts`.
+        if (selection)
+            assertModelAllowed(this.store.modelFilterRules(), workspace, selection);
         await this.store.setWorkspaceDefaults(workspaceId, {
             model: selection,
             thinkingLevel: settings.thinkingLevel ?? undefined,

package/dist/server/feishu-cli.js

@@ -60,8 +60,15 @@ const defaultSpawn = (command, args, options) => new Promise((resolve, reject) =
     });
     let stdout = "";
     let stderr = "";
-    child.stdout?.on("data", (chunk) => { stdout += String(chunk); });
-    child.stderr?.on("data", (chunk) => { stderr += String(chunk); });
+    // A PIPE CARRIES BYTES, AND A READ BOUNDARY CAN LAND INSIDE A CHARACTER. A Chinese character is
+    // three bytes, so decoding one chunk at a time turns every character that straddles a boundary
+    // into U+FFFD - which for this CLI means a JSON envelope whose text is damaged, and an envelope
+    // that may not parse at all. The stream decodes instead, and Node keeps an incomplete
+    // character until the rest of its bytes arrive.
+    child.stdout?.setEncoding("utf8");
+    child.stderr?.setEncoding("utf8");
+    child.stdout?.on("data", (chunk) => { stdout += chunk; });
+    child.stderr?.on("data", (chunk) => { stderr += chunk; });
     const timer = setTimeout(() => { child.kill(); }, options.timeoutMs);
     child.once("error", (error) => {
         clearTimeout(timer);
@@ -91,8 +98,12 @@ const defaultBackgroundSpawn = (command, args, options) => {
     });
     return {
         onOutput: (listener) => {
-            child.stdout?.on("data", (chunk) => listener(String(chunk)));
-            child.stderr?.on("data", (chunk) => listener(String(chunk)));
+            // The same rule as the one-shot spawn: the stream decodes, so a character that straddles a
+            // read boundary stays whole.
+            child.stdout?.setEncoding("utf8");
+            child.stderr?.setEncoding("utf8");
+            child.stdout?.on("data", (chunk) => listener(chunk));
+            child.stderr?.on("data", (chunk) => listener(chunk));
         },
         done: new Promise((resolve) => {
             child.once("close", () => resolve());

package/dist/server/file-index.d.ts

@@ -46,6 +46,19 @@ export declare class FileIndex {
     start(root: string): void;
     stop(): void;
     snapshot(since?: number): FileIndexSnapshot;
+    /**
+     * ONE FILE, REFRESHED.
+     *
+     * The path arrives from a MODEL - from the arguments of the `write`/`edit` tool - so it may be
+     * absolute, and an absolute path inside the workspace is the same file as its relative spelling.
+     * `toWorkspaceRelative` translates that spelling; the guard then decides containment, exactly as it
+     * does for every other path in this module.
+     *
+     * A FILE THAT IS GONE IS NOT A FAILURE. `ENOENT` means the agent deleted it, and the index says so
+     * by removing it. Anything else is a real problem and is thrown to the caller - which is why the
+     * callers must handle it (see `refreshWorkspaceIndex` in `run-service.ts`): a background index
+     * refresh must never take a turn down with it.
+     */
     refresh(path: string): Promise<void>;
     /** Record metadata already obtained by opening, saving, or polling an open file. No second stat: the
      * caller's file API operation has already passed the sole containment guard and read this metadata. */
@@ -54,3 +67,20 @@ export declare class FileIndex {
     private scan;
     private publish;
 }
+/**
+ * REFRESH THE WORKSPACE'S FILE INDEX AFTER THE AGENT WROTE SOMETHING - AND NEVER AT THE COST OF THE
+ * TURN.
+ *
+ * WHY THIS IS A FUNCTION AND NOT A `void` CALL. `FileIndex.refresh` refuses a path it cannot contain,
+ * and a refusal is a REJECTED PROMISE. Calling it with `void` and nothing else leaves that rejection
+ * without a handler, and Node reports an unhandled rejection - which this server used to log as a
+ * `fatal` line. That is exactly what happened in the field: one absolute-path write per agent edit
+ * produced one `[fatal] unhandledRejection: FilesError` in the server log - a log that reads like a
+ * crash report and is not one - while the Files panel went on showing the file the agent had just
+ * written as if it had never been touched.
+ *
+ * A REFUSED PATH IS A FACT ABOUT THE PATH, NOT A FAULT OF THE TURN. So the refusal is caught here,
+ * said out loud, and the turn carries on. The index is a convenience; it must never be able to end a
+ * conversation.
+ */
+export declare function refreshWorkspaceIndex(indexes: Map<string, FileIndex> | undefined, workspaceId: string, path: string): void;

package/dist/server/file-index.js

@@ -1,5 +1,5 @@
 import { readdir, stat } from "node:fs/promises";
-import { SEARCH_SKIP_DIRS, createRootGuard, fileMeta, isTextName, toRelative } from "./files.js";
+import { SEARCH_SKIP_DIRS, createRootGuard, fileMeta, isTextName, toRelative, toWorkspaceRelative } from "./files.js";
 const MAX_DIRECTORIES = 4000;
 const MAX_FILES = 30000;
 const MAX_MS = 4000;
@@ -41,14 +41,35 @@ export class FileIndex {
             changed: valid ? deltas.flatMap((item) => item.changed) : [...this.entries.values()],
             removed: valid ? deltas.flatMap((item) => item.removed) : [] };
     }
+    /**
+     * ONE FILE, REFRESHED.
+     *
+     * The path arrives from a MODEL - from the arguments of the `write`/`edit` tool - so it may be
+     * absolute, and an absolute path inside the workspace is the same file as its relative spelling.
+     * `toWorkspaceRelative` translates that spelling; the guard then decides containment, exactly as it
+     * does for every other path in this module.
+     *
+     * A FILE THAT IS GONE IS NOT A FAILURE. `ENOENT` means the agent deleted it, and the index says so
+     * by removing it. Anything else is a real problem and is thrown to the caller - which is why the
+     * callers must handle it (see `refreshWorkspaceIndex` in `run-service.ts`): a background index
+     * refresh must never take a turn down with it.
+     */
     async refresh(path) {
         if (!this.root)
             return;
         const guard = createRootGuard(this.root);
+        const requested = toWorkspaceRelative(this.root, path);
+        // The key the index stores paths under. It starts as the translated path and is replaced by the
+        // canonical relative form once the guard has resolved it, so a removed file is removed under the
+        // name the index actually knows it by.
+        let key = requested;
         try {
-            const absolute = await guard(path);
-            const info = await stat(absolute);
+            const absolute = await guard(requested);
+            // The canonical relative name is settled BEFORE the stat, so a file that is already gone is
+            // still removed under the name the index knows it by (`src/a.ts`, not `src\a.ts`).
             const rel = toRelative(this.root, absolute);
+            key = rel;
+            const info = await stat(absolute);
             if (info.isDirectory())
                 this.publish([{ path: rel, kind: "directory", size: null, mtimeMs: null, etag: null, text: null }], []);
             else {
@@ -59,7 +80,7 @@ export class FileIndex {
         catch (error) {
             const code = error.code;
             if (code === "ENOENT" || code === "ENOTDIR")
-                this.remove(path);
+                this.remove(key);
             else
                 throw error;
         }
@@ -148,3 +169,27 @@ export class FileIndex {
         this.broadcast(event);
     }
 }
+/**
+ * REFRESH THE WORKSPACE'S FILE INDEX AFTER THE AGENT WROTE SOMETHING - AND NEVER AT THE COST OF THE
+ * TURN.
+ *
+ * WHY THIS IS A FUNCTION AND NOT A `void` CALL. `FileIndex.refresh` refuses a path it cannot contain,
+ * and a refusal is a REJECTED PROMISE. Calling it with `void` and nothing else leaves that rejection
+ * without a handler, and Node reports an unhandled rejection - which this server used to log as a
+ * `fatal` line. That is exactly what happened in the field: one absolute-path write per agent edit
+ * produced one `[fatal] unhandledRejection: FilesError` in the server log - a log that reads like a
+ * crash report and is not one - while the Files panel went on showing the file the agent had just
+ * written as if it had never been touched.
+ *
+ * A REFUSED PATH IS A FACT ABOUT THE PATH, NOT A FAULT OF THE TURN. So the refusal is caught here,
+ * said out loud, and the turn carries on. The index is a convenience; it must never be able to end a
+ * conversation.
+ */
+export function refreshWorkspaceIndex(indexes, workspaceId, path) {
+    const index = indexes?.get(workspaceId);
+    if (!index)
+        return;
+    void index.refresh(path).catch((error) => {
+        console.warn(`Super Pi: the file index did not refresh ${path}: ${error instanceof Error ? error.message : "unknown error"}`);
+    });
+}

package/dist/server/files.d.ts

@@ -158,6 +158,27 @@ export type DirListing = {
 };
 /** The `/`-separated relative form used on the wire and in every comparison. */
 export declare function toRelative(root: string, absolute: string): string;
+/**
+ * A PATH A MODEL WROTE, AS THE WORKSPACE SPELLS IT.
+ *
+ * WHO SPELLS PATHS THIS WAY. Pi's `write`/`edit` tools carry whatever path the MODEL produced, and a
+ * model that has been told where the workspace is writes an absolute path: `/home/me/project/src/a.ts`
+ * is the same file as `src/a.ts`. The model is not trying to escape anything - it is repeating the
+ * workspace root it was given.
+ *
+ * WHY THIS IS HERE AND NOT IN THE CALLER. Two layers need the same translation and neither may own
+ * it: the file-change tracker (which records what the agent wrote) and the file index (which refreshes
+ * what the agent wrote). Before this function existed, the index refused an absolute path outright -
+ * and because the refusal was thrown out of a promise nobody was awaiting, one absolute-path write
+ * produced one `[fatal] unhandledRejection` in the server log and left the Files panel showing a file
+ * the agent had just written as if it had never been touched.
+ *
+ * AN ABSOLUTE PATH OUTSIDE THE WORKSPACE IS REFUSED, EXACTLY AS `../` IS REFUSED. The containment rule
+ * belongs to this module and has exactly one owner; this function does not get a second, weaker copy of
+ * it. It translates a spelling and then hands the result to the guard, which is what actually decides
+ * containment - including the symlink case, which a string comparison can never see.
+ */
+export declare function toWorkspaceRelative(root: string, requested: string): string;
 /** One directory's contents. Directories sort before files, then case-insensitively by name with numeric
  *  ordering, so `src2` lands between `src` and `src10` rather than after every `srcN`. */
 export declare function listDirectory(root: string, requested: string | null | undefined): Promise<DirListing>;

package/dist/server/files.js

@@ -396,6 +396,44 @@ export function isDocumentName(name) {
 export function toRelative(root, absolute) {
     return relative(root, absolute).split(sep).join("/");
 }
+/**
+ * A PATH A MODEL WROTE, AS THE WORKSPACE SPELLS IT.
+ *
+ * WHO SPELLS PATHS THIS WAY. Pi's `write`/`edit` tools carry whatever path the MODEL produced, and a
+ * model that has been told where the workspace is writes an absolute path: `/home/me/project/src/a.ts`
+ * is the same file as `src/a.ts`. The model is not trying to escape anything - it is repeating the
+ * workspace root it was given.
+ *
+ * WHY THIS IS HERE AND NOT IN THE CALLER. Two layers need the same translation and neither may own
+ * it: the file-change tracker (which records what the agent wrote) and the file index (which refreshes
+ * what the agent wrote). Before this function existed, the index refused an absolute path outright -
+ * and because the refusal was thrown out of a promise nobody was awaiting, one absolute-path write
+ * produced one `[fatal] unhandledRejection` in the server log and left the Files panel showing a file
+ * the agent had just written as if it had never been touched.
+ *
+ * AN ABSOLUTE PATH OUTSIDE THE WORKSPACE IS REFUSED, EXACTLY AS `../` IS REFUSED. The containment rule
+ * belongs to this module and has exactly one owner; this function does not get a second, weaker copy of
+ * it. It translates a spelling and then hands the result to the guard, which is what actually decides
+ * containment - including the symlink case, which a string comparison can never see.
+ */
+export function toWorkspaceRelative(root, requested) {
+    const raw = requested.trim();
+    // A RELATIVE PATH IS ALREADY THE WORKSPACE'S SPELLING. It is passed through untouched so that the
+    // guard sees exactly what the caller asked for - including `../`, which the guard is there to refuse.
+    if (!isAbsolute(raw))
+        return raw;
+    const base = resolve(root);
+    const rel = relative(base, resolve(raw));
+    if (rel === "")
+        return "";
+    // `relative` answers "what is left to walk from base to target". When the target is on another drive
+    // (Windows) or outside the root (anywhere), the answer is an absolute path or a chain of `..`, and
+    // both mean the same thing: this path is not inside the workspace.
+    if (isAbsolute(rel) || rel === ".." || rel.startsWith(`..${sep}`) || rel.startsWith("../")) {
+        throw new FilesError(403, "拒绝绝对路径：请给出相对于工作区根目录的路径", "outside_workspace");
+    }
+    return rel.split(sep).join("/");
+}
 /** One directory's contents. Directories sort before files, then case-insensitively by name with numeric
  *  ordering, so `src2` lands between `src` and `src10` rather than after every `srcN`. */
 export async function listDirectory(root, requested) {