@evandu/super-pi 0.1.132 → 0.1.135

package/dist/client/index.html

@@ -8,8 +8,8 @@
     <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-ChyemF2I.js"></script>
-    <link rel="stylesheet" crossorigin href="/assets/index-D3MEG8uH.css">
+    <script type="module" crossorigin src="/assets/index-Dyta-HkQ.js"></script>
+    <link rel="stylesheet" crossorigin href="/assets/index-V93Kzott.css">
   </head>
   <body>
     <div id="root"></div>

package/dist/server/active-memory.d.ts

@@ -61,6 +61,7 @@ export declare class ActiveMemory {
     }): string;
     release(token: string): void;
     private identity;
+    private hasWorkspace;
     search(workspaceId: string, query: string, sessionId?: string): {
         conversationId: string;
         title: string;

package/dist/server/active-memory.js

@@ -109,10 +109,14 @@ export class ActiveMemory {
     release(token) { this.capabilities.delete(token); }
     identity(token) {
         const identity = this.capabilities.get(token);
-        if (!identity || !this.store.snapshot().workspaces.some(w => w.id === identity.workspaceId))
+        if (!identity || !this.hasWorkspace(identity.workspaceId))
             throw new Error("记忆授权已失效");
         return identity;
     }
+    hasWorkspace(workspaceId) {
+        const store = this.store;
+        return store.hasWorkspace ? store.hasWorkspace(workspaceId) : store.snapshot().workspaces.some(w => w.id === workspaceId);
+    }
     search(workspaceId, query, sessionId) {
         const words = query.toLocaleLowerCase().match(/[\p{L}\p{N}_-]{2,}/gu)?.slice(0, 12) ?? [];
         if (!words.length)
@@ -232,7 +236,7 @@ export class ActiveMemory {
         return alreadyLocked ? work() : this.locked(work);
     }
     async manage(workspaceId, body) {
-        if (!this.store.snapshot().workspaces.some(w => w.id === workspaceId))
+        if (!this.hasWorkspace(workspaceId))
             throw new Error("工作区不存在");
         if (body.action === "configure") {
             await this.configure(body.settings);

package/dist/server/agents.js

@@ -447,7 +447,27 @@ export async function readAgents(directory, options = {}) {
             throw error;
         }
         for (const file of entries.filter((name) => name.toLowerCase().endsWith(".md")).sort()) {
-            const source = await readFile(join(dir, file), "utf8");
+            // A FILE THAT CANNOT BE READ IS THE SAME KIND OF PROBLEM AS ONE THAT CANNOT BE PARSED.
+            //
+            // The function's own reason for existing says it plainly: "one typo in one agent must not take
+            // down the picker and hide every other agent with it". A file that cannot be READ is at least as
+            // ordinary as that - on Windows "another program has this file open" is a Tuesday, not an
+            // emergency - and it used to be the one unguarded step in this loop: the parse failure below is
+            // collected as a problem, while the read failure was thrown, so a single locked file emptied the
+            // whole directory. Four callers ate that: the main agent's own definition (the turn could not
+            // start), the roster handed to sub-agents on every turn, the roster used when dispatching one,
+            // and the picker (which came back with an empty agent list).
+            let source;
+            try {
+                source = await readFile(join(dir, file), "utf8");
+            }
+            catch (error) {
+                const fileId = file.replace(/\.md$/i, "");
+                if (!seenIds.has(fileId)) {
+                    problems.push({ file, message: `读取失败：${error instanceof Error ? error.message : String(error)}` });
+                }
+                continue;
+            }
             const parsed = parseDefinition(file, source);
             if ("message" in parsed) {
                 const fileId = file.replace(/\.md$/i, "");

package/dist/server/application/feishu-service.d.ts

@@ -23,8 +23,31 @@ export type FeishuStatus = {
     identity?: "user" | "bot";
     /** Whether the agent can read and write documents right now. */
     connected: boolean;
+    /**
+     * WHICH STEP OF THE GUIDE THE PERSON IS ON.
+     *
+     * 1 = install the CLI, 2 = connect the account, 3 = ready. The panel draws the three steps and
+     * marks this one, so "what do I do now" is answered by where the cursor is rather than by a
+     * sentence the person has to interpret.
+     */
+    step: 1 | 2 | 3;
     /** What to do next, in one sentence. */
     message: string;
+    /** The CLI's own words, when it had something to say about the situation. */
+    detail?: string;
+    /** The CLI's own hint, which usually names the exact command to run. */
+    hint?: string;
+    /** Whether the check actually reached Feishu. */
+    verified?: boolean;
+    /**
+     * WHETHER THE APPLICATION ITSELF HAS TO BE REBUILT.
+     *
+     * Distinct from "step 2": a person whose application is fine but who has not logged in still
+     * needs step 2, while a person whose credential was refused needs a NEW application. Telling
+     * those two apart is what keeps a transient network failure from being answered by "let me
+     * create you another application".
+     */
+    rebuild?: boolean;
 };
 /** The outcome of starting the connect flow. */
 export type FeishuConnectResult = {
@@ -50,35 +73,59 @@ export declare class FeishuService {
     private readonly cli;
     /** The device code of a login that is waiting for the person to authorize it. */
     private pendingDeviceCode?;
+    /** Whether an application registration is running and waiting for the browser confirmation. */
+    private pendingAppCreation;
     constructor(cli?: FeishuCli);
     /**
      * WHAT THE CLI CAN DO RIGHT NOW.
      *
-     * The three states a person can be in, and what each one means for the agent:
+     * The states a person can be in, and what each one means for the agent:
      *
      * - The CLI is not installed: nothing works, and the fix is one command.
      * - The CLI has no application: `config init --new` creates one through a browser confirmation,
      *   so the developer console is never visited.
-     * - The CLI has an application but no person logged in: the agent can still act as the
-     *   application, but it cannot reach that person's own documents until they authorize it.
+     * - The application exists but its credential is no longer accepted: the CLI says
+     *   `verify_failed` and names the reason, and the fix is a new application - which is the same
+     *   browser confirmation, so it stays one button.
+     * - The application works but no person is logged in: the agent can act as the application, but
+     *   it cannot reach that person's own documents until they authorize it.
      */
     status(): Promise<FeishuStatus>;
+    /**
+     * CHECKS THE CONNECTION, and says whether it actually works.
+     *
+     * The status already verifies; this is the same answer shaped for a button, so that a person can
+     * ask "it still doesn't work, why?" and get the CLI's own verdict rather than a guess.
+     */
+    verify(): Promise<{
+        ok: boolean;
+        message: string;
+        detail?: string;
+        hint?: string;
+    }>;
     /**
      * STARTS THE CONNECT FLOW.
      *
      * Two steps, and which one runs is decided by what the CLI already has:
      *
-     * - No application: `config init --new` registers one through a browser confirmation. It BLOCKS
-     *   until the person confirms, so it runs in the background and the URL is taken from its output.
-     * - An application but no person: `auth login --no-wait --json` asks for a device code and hands
-     *   back the URL to open. The code is kept here until the person says they are done.
+     * - No application, or one whose credential no longer works: `config init --new` registers a
+     *   fresh application through a browser confirmation. It BLOCKS until the person confirms, so it
+     *   runs in the background and the URL is taken from its output. The broken case goes here too,
+     *   because a new application is the one repair that needs no secret to be typed into a form.
+     * - A working application but no person: `auth login --no-wait --json` asks for a device code
+     *   and hands back the URL to open. The code is kept here until the person says they are done.
      */
     connect(): Promise<FeishuConnectResult>;
     /**
-     * FINISHES THE LOGIN, once the person says they authorized it.
+     * FINISHES THE FLOW, once the person says they are done.
+     *
+     * TWO KINDS OF "DONE", and the difference is what the CLI is waiting for:
      *
-     * The device code is handed back to the CLI, which completes the exchange and stores the token
-     * in the keychain. Super Pi never sees the token itself.
+     * - An application is being registered: `config init --new` finishes by itself once the person
+     *   confirms in the browser, so there is nothing to hand back. The status is re-read and the
+     *   answer is whether the application showed up.
+     * - A login is being authorized: the device code is handed back to the CLI, which completes the
+     *   exchange and stores the token in the keychain. Super Pi never sees the token itself.
      */
     completeConnect(): Promise<FeishuConnectResult>;
     /**

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

@@ -17,19 +17,24 @@ export class FeishuService {
     cli;
     /** The device code of a login that is waiting for the person to authorize it. */
     pendingDeviceCode;
+    /** Whether an application registration is running and waiting for the browser confirmation. */
+    pendingAppCreation = false;
     constructor(cli = new FeishuCli()) {
         this.cli = cli;
     }
     /**
      * WHAT THE CLI CAN DO RIGHT NOW.
      *
-     * The three states a person can be in, and what each one means for the agent:
+     * The states a person can be in, and what each one means for the agent:
      *
      * - The CLI is not installed: nothing works, and the fix is one command.
      * - The CLI has no application: `config init --new` creates one through a browser confirmation,
      *   so the developer console is never visited.
-     * - The CLI has an application but no person logged in: the agent can still act as the
-     *   application, but it cannot reach that person's own documents until they authorize it.
+     * - The application exists but its credential is no longer accepted: the CLI says
+     *   `verify_failed` and names the reason, and the fix is a new application - which is the same
+     *   browser confirmation, so it stays one button.
+     * - The application works but no person is logged in: the agent can act as the application, but
+     *   it cannot reach that person's own documents until they authorize it.
      */
     async status() {
         const status = await this.cli.status();
@@ -39,59 +44,121 @@ export class FeishuService {
                 userReady: false,
                 botReady: false,
                 connected: false,
-                message: "没有检测到官方飞书 CLI（lark-cli）。请先在终端运行 npm i -g @larksuite/cli 装上它，再回到这里点「连接飞书账号」。如果已经装了但 Super Pi 找不到（两边的 PATH 不一样），用环境变量 SUPER_PI_FEISHU_CLI 指向它的完整路径再重启 Super Pi。",
+                step: 1,
+                message: "还没有安装官方飞书 CLI。在终端里跑一次 npm i -g @larksuite/cli 就行，装完回到这里点「连接飞书账号」。",
+                ...(status.hint ? { hint: status.hint } : {}),
             };
         }
+        const common = {
+            installed: true,
+            ...(status.version ? { version: status.version } : {}),
+            ...(status.appId ? { appId: status.appId } : {}),
+            ...(status.verified !== undefined ? { verified: status.verified } : {}),
+            ...(status.note ? { detail: status.note } : {}),
+        };
         if (!status.appId) {
             return {
-                installed: true,
-                ...(status.version ? { version: status.version } : {}),
+                ...common,
+                userReady: false,
+                botReady: false,
+                connected: false,
+                step: 2,
+                message: "CLI 已就绪，还差一个应用。点「连接飞书账号」，浏览器里确认一下就有了——不用去开发者后台注册。",
+            };
+        }
+        // A CREDENTIAL THE CLI KNOWS IS BROKEN is the case a plain status would have hidden: the local
+        // file still holds an app, so the panel would have said "已配置", and every document call
+        // would have failed. The CLI's own verdict is the one that can be acted on.
+        const broken = status.botStatus === "verify_failed" || (status.verified === true && !status.botReady && !status.userReady);
+        if (broken) {
+            return {
+                ...common,
                 userReady: false,
                 botReady: false,
                 connected: false,
-                message: "飞书 CLI 已就绪，但还没有应用。点「连接飞书账号」，它会给你一个浏览器链接，确认之后应用就建好了——不用去开发者后台注册。",
+                step: 2,
+                rebuild: true,
+                message: `应用的凭据已经失效：${trimSentence(status.botMessage ?? "飞书拒绝了这次验证")}。点「连接飞书账号」会重新走一遍确认流程、建一个可用的应用。`,
+                ...(status.hint ? { hint: status.hint } : {}),
+            };
+        }
+        if (status.verified === false) {
+            return {
+                ...common,
+                userReady: false,
+                botReady: false,
+                connected: false,
+                step: 2,
+                message: "没能连上飞书（本地配置读到了，但验证请求没出去）。检查一下网络，然后点「测试连接」重试。",
+                ...(status.hint ? { hint: status.hint } : {}),
             };
         }
         if (!status.userReady) {
             return {
-                installed: true,
-                ...(status.version ? { version: status.version } : {}),
-                appId: status.appId,
+                ...common,
                 userReady: false,
                 botReady: status.botReady,
                 connected: false,
+                step: 2,
                 ...(status.identity ? { identity: status.identity } : {}),
-                message: "应用已配置，但还没有登录你的账号。点「连接飞书账号」用浏览器授权，授权之后 Agent 就能以你的身份读写你自己的文档，不用逐篇加协作者。",
+                message: "应用已经能用，但还没登录你的账号。点「连接飞书账号」在浏览器里授权一下，授权之后 Agent 就能以你的身份读写你自己的文档，不用逐篇加协作者。",
+                ...(status.hint ? { hint: status.hint } : {}),
             };
         }
         return {
-            installed: true,
-            ...(status.version ? { version: status.version } : {}),
-            appId: status.appId,
+            ...common,
             userReady: true,
             botReady: status.botReady,
             connected: true,
             identity: status.identity ?? "user",
+            step: 3,
             message: "已连接：Agent 会以你的身份读写飞书云文档。",
         };
     }
+    /**
+     * CHECKS THE CONNECTION, and says whether it actually works.
+     *
+     * The status already verifies; this is the same answer shaped for a button, so that a person can
+     * ask "it still doesn't work, why?" and get the CLI's own verdict rather than a guess.
+     */
+    async verify() {
+        const status = await this.status();
+        if (status.connected) {
+            return {
+                ok: true,
+                message: status.message,
+                ...(status.detail ? { detail: status.detail } : {}),
+            };
+        }
+        return {
+            ok: false,
+            message: status.message,
+            ...(status.detail ? { detail: status.detail } : {}),
+            ...(status.hint ? { hint: status.hint } : {}),
+        };
+    }
     /**
      * STARTS THE CONNECT FLOW.
      *
      * Two steps, and which one runs is decided by what the CLI already has:
      *
-     * - No application: `config init --new` registers one through a browser confirmation. It BLOCKS
-     *   until the person confirms, so it runs in the background and the URL is taken from its output.
-     * - An application but no person: `auth login --no-wait --json` asks for a device code and hands
-     *   back the URL to open. The code is kept here until the person says they are done.
+     * - No application, or one whose credential no longer works: `config init --new` registers a
+     *   fresh application through a browser confirmation. It BLOCKS until the person confirms, so it
+     *   runs in the background and the URL is taken from its output. The broken case goes here too,
+     *   because a new application is the one repair that needs no secret to be typed into a form.
+     * - A working application but no person: `auth login --no-wait --json` asks for a device code
+     *   and hands back the URL to open. The code is kept here until the person says they are done.
      */
     async connect() {
         const status = await this.status();
         if (!status.installed) {
             return { ok: false, message: status.message };
         }
-        if (!status.appId) {
+        // Step 2 is "connect the account"; the application part of it is missing or broken when the
+        // person has no application OR when the one they have was refused by Feishu.
+        if (!status.appId || status.rebuild) {
             const verificationUri = await this.cli.startAppCreation();
+            this.pendingAppCreation = true;
             return {
                 ok: true,
                 step: "app",
@@ -119,12 +186,31 @@ export class FeishuService {
         }
     }
     /**
-     * FINISHES THE LOGIN, once the person says they authorized it.
+     * FINISHES THE FLOW, once the person says they are done.
      *
-     * The device code is handed back to the CLI, which completes the exchange and stores the token
-     * in the keychain. Super Pi never sees the token itself.
+     * TWO KINDS OF "DONE", and the difference is what the CLI is waiting for:
+     *
+     * - An application is being registered: `config init --new` finishes by itself once the person
+     *   confirms in the browser, so there is nothing to hand back. The status is re-read and the
+     *   answer is whether the application showed up.
+     * - A login is being authorized: the device code is handed back to the CLI, which completes the
+     *   exchange and stores the token in the keychain. Super Pi never sees the token itself.
      */
     async completeConnect() {
+        if (this.pendingAppCreation) {
+            this.pendingAppCreation = false;
+            const status = await this.status();
+            if (status.appId) {
+                return {
+                    ok: true,
+                    message: "应用建好了。接下来点「连接飞书账号」授权你的账号，Agent 就能以你的身份读写文档了。",
+                };
+            }
+            return {
+                ok: false,
+                message: "还没看到应用建好。请确认浏览器里的确认已经提交（有时要等 CLI 写完钥匙串），然后再点一次「我已完成」。",
+            };
+        }
         if (!this.pendingDeviceCode) {
             return { ok: false, message: "没有待完成的登录。点「连接飞书账号」重新开始。" };
         }
@@ -235,8 +321,16 @@ export class FeishuService {
         throw new Error(`未知的飞书工具操作：${action}`);
     }
 }
-/** The message of a failure, whatever shape the failure has. */
-function messageOf(error) {
+/**
+ * A SENTENCE WITHOUT ITS OWN FULL STOP.
+ *
+ * The CLI writes English sentences that end in a period, and this service writes Chinese ones that
+ * end in 。 — so a message pasted in verbatim reads "invalid.。点「重新连接」".
+ */
+function trimSentence(text) {
+    return text.trim().replace(/[.\s]+$/, "");
+}
+/** The message of a failure, whatever shape the failure has. */ function messageOf(error) {
     if (error instanceof FeishuCliError)
         return error.message;
     if (error instanceof Error)

package/dist/server/application/run-service.d.ts

@@ -61,6 +61,7 @@ export declare class RunService {
     private readonly extensionUiService;
     private agentsDir;
     private readonly workflows;
+    private readonly questionWaiters;
     private memory?;
     setMemory(memory: import("../active-memory.js").ActiveMemory): void;
     /**
@@ -178,6 +179,9 @@ export declare class RunService {
         answers?: QuestionAnswer[];
         cancelled?: boolean;
     }): Promise<void>;
+    private questionKey;
+    private answerPayload;
+    private settleQuestion;
     /**
      * THE `question` TOOL BLOCKS HERE, ON THE CALL THAT ASKED IT.
      *