@keyou007/agent-bot 0.1.18-alpha.3 → 0.1.19-alpha.0

package/dist/proxy/ProxySessionController.js

@@ -3,6 +3,7 @@ import { promises as fs } from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import { createProjectlessWorkspace, detectProjectlessWorkspace } from "../codex/ProjectlessWorkspace.js";
+import { SystemThreadWriterProcessController, } from "../codex/ThreadWriterProcess.js";
 import { resolveUserPath } from "../config/paths.js";
 import { DEFAULT_GROUP_NAME_FORMAT, } from "../config/schema.js";
 import { CommandRouter } from "../commands/CommandRouter.js";
@@ -14,12 +15,21 @@ import { formatGroupNameDate, formatNewGroupName, parseTaskNameFromGroupName, }
 import { normalizeFeishuPostText } from "../feishu/InboundText.js";
 import { allowsFeishuUser } from "../feishu/ownerAccess.js";
 import { classifyFileContent } from "../local-files/LocalFileViewerServer.js";
+import { errorLogValue } from "../logging/errorLogValue.js";
 import { buildTurnGraphRows } from "../presentation/turnGraph.js";
 import { isActiveShellCommandJob, ShellCommandJobManager, } from "../shell/ShellCommandJobManager.js";
 import { createId } from "../utils/id.js";
 import { truncateMiddle, truncateText } from "../utils/markdown.js";
 import { normalizeTaskTitle } from "../utils/taskTitle.js";
 import { executeShellCommand, } from "../utils/executeShellCommand.js";
+class PresentedRequestError extends Error {
+    originalError;
+    constructor(originalError) {
+        super(originalError instanceof Error ? originalError.message : String(originalError), { cause: originalError });
+        this.originalError = originalError;
+        this.name = "PresentedRequestError";
+    }
+}
 const MESSAGE_RECEIVED_REACTION = "OnIt";
 const MESSAGE_COMPLETED_REACTION = "DONE";
 const MESSAGE_FAILED_REACTION = "ERROR";
@@ -178,6 +188,7 @@ export class ProxySessionController {
     shellCommandExecutor;
     windowsDriveLister;
     shellCommandJobs;
+    threadWriterProcesses;
     router = new CommandRouter();
     cardRenderer = new CardRenderer();
     messageQueues = new Map();
@@ -201,7 +212,7 @@ export class ProxySessionController {
     recoveryActivityHeartbeat;
     startupRecovery;
     queuedPromptsRestored = false;
-    constructor(config, store, runtimes, outbound, logger, lifecycle, shellCommandExecutor = executeShellCommand, windowsDriveLister = listWindowsDriveRoots, shellCommandJobs = new ShellCommandJobManager(path.join(path.dirname(config.storage.sqlitePath), "command-jobs"))) {
+    constructor(config, store, runtimes, outbound, logger, lifecycle, shellCommandExecutor = executeShellCommand, windowsDriveLister = listWindowsDriveRoots, shellCommandJobs = new ShellCommandJobManager(path.join(path.dirname(config.storage.sqlitePath), "command-jobs")), threadWriterProcesses = new SystemThreadWriterProcessController()) {
         this.config = config;
         this.store = store;
         this.runtimes = runtimes;
@@ -211,6 +222,7 @@ export class ProxySessionController {
         this.shellCommandExecutor = shellCommandExecutor;
         this.windowsDriveLister = windowsDriveLister;
         this.shellCommandJobs = shellCommandJobs;
+        this.threadWriterProcesses = threadWriterProcesses;
         for (const [, runtime] of this.runtimes.entries()) {
             this.unsubscribe.push(runtime.onEvent((event) => {
                 void this.handleRuntimeEvent(event).catch((error) => {
@@ -328,7 +340,11 @@ export class ProxySessionController {
                     : undefined;
                 await this.finalizeStandaloneMessageReaction(message.messageId, "failed");
                 const detail = result.error instanceof Error ? result.error.message : String(result.error);
-                await this.outbound.withReplyTarget(message.contextKey, replyTarget, () => this.sendError(message.contextKey, new Error(`无法读取合并转发消息：${detail}`)));
+                await this.outbound.withReplyTarget(message.contextKey, replyTarget, () => this.sendError(message.contextKey, new Error(`无法读取合并转发消息：${detail}`), {
+                    requestId: message.messageId,
+                    messageId: message.messageId,
+                    phase: "merged_forward_read",
+                }));
                 return;
             }
             const instruction = message.displayText ?? DEFAULT_MERGED_FORWARD_INSTRUCTION;
@@ -360,7 +376,11 @@ export class ProxySessionController {
                     : undefined;
                 await this.finalizeStandaloneMessageReaction(message.messageId, "failed");
                 const detail = error instanceof Error ? error.message : String(error);
-                await this.outbound.withReplyTarget(message.contextKey, replyTarget, () => this.sendError(message.contextKey, new Error(`无法读取引用消息：${detail}`)));
+                await this.outbound.withReplyTarget(message.contextKey, replyTarget, () => this.sendError(message.contextKey, new Error(`无法读取引用消息：${detail}`), {
+                    requestId: message.messageId,
+                    messageId: message.messageId,
+                    phase: "referenced_message_read",
+                }));
                 return;
             }
         }
@@ -394,7 +414,11 @@ export class ProxySessionController {
             }
             catch (error) {
                 await this.finalizeStandaloneMessageReaction(message.messageId, "failed");
-                await this.outbound.withReplyTarget(message.contextKey, replyTarget, () => this.sendError(message.contextKey, error));
+                await this.outbound.withReplyTarget(message.contextKey, replyTarget, () => this.sendError(message.contextKey, error, {
+                    requestId: message.messageId,
+                    messageId: message.messageId,
+                    phase: "image_download",
+                }));
                 return;
             }
         }
@@ -413,7 +437,11 @@ export class ProxySessionController {
             }
             catch (error) {
                 await this.finalizeStandaloneMessageReaction(message.messageId, "failed");
-                await this.outbound.withReplyTarget(message.contextKey, replyTarget, () => this.sendError(message.contextKey, error));
+                await this.outbound.withReplyTarget(message.contextKey, replyTarget, () => this.sendError(message.contextKey, error, {
+                    requestId: message.messageId,
+                    messageId: message.messageId,
+                    phase: "file_download",
+                }));
                 return;
             }
         }
@@ -426,9 +454,21 @@ export class ProxySessionController {
         }
         catch (error) {
             await this.finalizeStandaloneMessageReaction(message.messageId, "failed");
-            await this.outbound.withReplyTarget(message.contextKey, replyTarget, () => this.sendError(message.contextKey, error));
+            await this.outbound.withReplyTarget(message.contextKey, replyTarget, () => this.sendError(message.contextKey, error, {
+                requestId: message.messageId,
+                messageId: message.messageId,
+                phase: "command_parse",
+            }));
             return;
         }
+        if (command.type !== "prompt") {
+            this.logger.info({
+                requestId: message.messageId,
+                messageId: message.messageId,
+                contextKey: message.contextKey,
+                command: command.type,
+            }, "Processing Agent Bot command.");
+        }
         // Operational and read-only commands must remain available even if a prompt operation is slow.
         if (isQueueIndependentCommand(command)) {
             await this.outbound.withReplyTarget(message.contextKey, replyTarget, async () => {
@@ -442,7 +482,12 @@ export class ProxySessionController {
                 }
                 catch (error) {
                     await this.finalizeStandaloneMessageReaction(message.messageId, "failed");
-                    await this.sendError(message.contextKey, error);
+                    await this.sendError(message.contextKey, error, {
+                        requestId: message.messageId,
+                        messageId: message.messageId,
+                        command: command.type,
+                        phase: "command_execute",
+                    });
                 }
             });
             return;
@@ -459,7 +504,12 @@ export class ProxySessionController {
             }
             catch (error) {
                 await this.finalizeStandaloneMessageReaction(message.messageId, "failed");
-                await this.sendError(message.contextKey, error);
+                await this.sendError(message.contextKey, error, {
+                    requestId: message.messageId,
+                    messageId: message.messageId,
+                    command: command.type,
+                    phase: "command_execute",
+                });
             }
         }));
         this.messageQueues.set(message.contextKey, next);
@@ -479,7 +529,11 @@ export class ProxySessionController {
             resolvedAction = this.resolveCardActionBinding(action);
         }
         catch (error) {
-            await this.sendError(action.contextKey, error);
+            await this.sendError(action.contextKey, error, {
+                requestId: action.actionId,
+                actionId: action.actionId,
+                phase: "card_action_resolve",
+            });
             return;
         }
         const contextKey = this.cardActionContextKey(resolvedAction);
@@ -510,6 +564,18 @@ export class ProxySessionController {
                 else if (kind === "shell_command_cancel") {
                     await this.cancelShellCommandJob(contextKey, String(scopedAction.value.jobId ?? ""));
                 }
+                else if (kind === "thread_writer_close") {
+                    await this.closeThreadWriter(scopedAction, contextKey);
+                }
+                else if (kind === "thread_writer_fork") {
+                    const sessionId = String(scopedAction.value.sessionId ?? "");
+                    const threadId = String(scopedAction.value.threadId ?? "");
+                    const record = this.requireSession(contextKey, sessionId);
+                    if (!threadId || record.remoteSessionId !== threadId) {
+                        throw new Error("任务占用卡片已经失效，请重新发送消息获取最新状态。");
+                    }
+                    await this.forkSessionReference(contextKey, sessionId);
+                }
                 else if (kind === "turn_reset") {
                     const sessionId = String(scopedAction.value.sessionId ?? "");
                     const turnId = String(scopedAction.value.turnId ?? "");
@@ -734,7 +800,12 @@ export class ProxySessionController {
                 }
             }
             catch (error) {
-                await this.sendError(contextKey, error);
+                await this.sendError(contextKey, error, {
+                    requestId: scopedAction.actionId,
+                    actionId: scopedAction.actionId,
+                    command: String(scopedAction.value.action ?? "unknown"),
+                    phase: "card_action_execute",
+                });
             }
         });
     }
@@ -1809,6 +1880,9 @@ export class ProxySessionController {
             loaded = await this.loadSession(record);
         }
         catch (error) {
+            if (await this.presentThreadWriterConflict(record, contextKey, error, true)) {
+                throw new PresentedRequestError(error);
+            }
             await this.outbound.failPendingTurn(record.localSessionId, error instanceof Error ? error.message : String(error));
             throw error;
         }
@@ -2900,6 +2974,8 @@ export class ProxySessionController {
                     });
                 }
                 catch (error) {
+                    if (activeWriterThreadId(error))
+                        throw error;
                     if (!(agent.kind === "app-server" && !record.lastTurnId && isMissingRolloutError(error)))
                         throw error;
                     this.logger.warn({ error, sessionId: record.localSessionId }, "App Server task has no rollout; creating a replacement task.");
@@ -5262,14 +5338,26 @@ export class ProxySessionController {
                 description: command.description,
             })),
         }));
-        await this.outbound.sendInteractiveCard(contextKey, this.cardRenderer.renderHelpCard("Agent Bot 使用帮助", [
+        const introLines = [
             "直接发送消息即可继续当前任务；执行中发送的新消息会追加到本次任务。",
             "点击命令按钮可执行默认形式；有必填参数的命令需要手动发送。",
             "> 命令前缀示例：/sess 等同于 /sessions。",
             "> 命令缩写示例：/fg 等同于 /forkgroup。",
             "前缀或缩写匹配多个命令时，需要输入更长的形式。",
             "**[参数]** 可选　**<参数>** 必填",
-        ], sections));
+        ];
+        try {
+            await this.outbound.sendInteractiveCard(contextKey, this.cardRenderer.renderHelpCard("Agent Bot 使用帮助", introLines, sections));
+        }
+        catch (cardError) {
+            this.logger.warn({ error: cardError, contextKey, command: "help", phase: "help_card_send" }, "Failed to send the help card; falling back to plain text.");
+            try {
+                await this.outbound.sendText(contextKey, renderPlainHelp(introLines, sections));
+            }
+            catch (textError) {
+                throw new AggregateError([cardError, textError], "帮助卡片和纯文本帮助均发送失败。");
+            }
+        }
     }
     async setGroupMute(contextKey, enabled) {
         const chatContextKey = baseChatContextKey(contextKey);
@@ -5375,10 +5463,236 @@ export class ProxySessionController {
             throw new Error(`找不到任务：${sessionId}`);
         return record;
     }
-    async sendError(contextKey, error) {
-        this.logger.warn({ error, contextKey }, "Request failed.");
-        await this.outbound.sendText(contextKey, error instanceof Error ? error.message : String(error));
+    async presentThreadWriterConflict(record, contextKey, error, replacePendingTurn) {
+        if (contextKey.startsWith("console:"))
+            return false;
+        const threadId = activeWriterThreadId(error);
+        if (!threadId || record.remoteSessionId !== threadId)
+            return false;
+        const runtime = this.runtimes.forAgent(record.agentName);
+        const lockPath = runtime.getThreadWriterLockPath?.(threadId);
+        let owners = [];
+        if (lockPath) {
+            try {
+                owners = await this.threadWriterProcesses.inspect(lockPath);
+            }
+            catch (inspectionError) {
+                this.logger.warn({ error: inspectionError, threadId, lockPath }, "Failed to inspect the process holding a thread writer lock.");
+            }
+        }
+        const owner = owners.length === 1 ? owners[0] : undefined;
+        const applicationIdle = owner && lockPath
+            ? await this.inspectThreadWriterApplicationIdle(runtime, lockPath, threadId, owner)
+            : undefined;
+        const card = this.cardRenderer.renderThreadWriterConflict(this.threadWriterConflictView(record, contextKey, threadId, owners, "occupied", lockPath
+            ? undefined
+            : "无法识别占用进程。", applicationIdle));
+        if (replacePendingTurn) {
+            const replaced = await this.outbound.failPendingTurn(record.localSessionId, "任务被占用。", card);
+            if (!replaced)
+                await this.outbound.sendInteractiveCard(contextKey, card);
+        }
+        else {
+            await this.outbound.sendInteractiveCard(contextKey, card);
+        }
+        return true;
+    }
+    threadWriterConflictView(record, contextKey, threadId, owners, status, notice, applicationIdle) {
+        const owner = owners.length === 1 ? owners[0] : undefined;
+        return {
+            status,
+            contextKey,
+            sessionId: record.localSessionId,
+            threadId,
+            taskTitle: record.title,
+            notice: notice ?? (owners.length > 1
+                ? `检测到 ${owners.length} 个相关进程，无法安全地自动关闭。`
+                : undefined),
+            applicationIdle,
+            ...(owner ? {
+                owner: {
+                    displayName: owner.displayName,
+                    writerPid: owner.writerPid,
+                    writerProcessName: owner.writerProcessName,
+                    writerStartedAt: owner.writerStartedAt,
+                    applicationPid: owner.applicationPid,
+                    applicationProcessName: owner.applicationProcessName,
+                    applicationStartedAt: owner.applicationStartedAt,
+                    canClose: owner.canClose,
+                },
+            } : {}),
+        };
+    }
+    async closeThreadWriter(action, contextKey) {
+        const messageId = requiredCardMessageId(action.messageId);
+        const sessionId = String(action.value.sessionId ?? "");
+        const threadId = String(action.value.threadId ?? "");
+        const expectedWriterPid = positiveActionPid(action.value.writerPid);
+        const expectedApplicationPid = positiveActionPid(action.value.applicationPid);
+        const expectedWriterStartedAt = String(action.value.writerStartedAt ?? "");
+        const expectedApplicationStartedAt = String(action.value.applicationStartedAt ?? "");
+        const force = action.value.force === true || action.value.force === "true";
+        const record = this.requireSession(contextKey, sessionId);
+        if (!threadId || record.remoteSessionId !== threadId) {
+            throw new Error("任务占用卡片已经失效，请重新发送消息获取最新状态。");
+        }
+        const runtime = this.runtimes.forAgent(record.agentName);
+        const lockPath = runtime.getThreadWriterLockPath?.(threadId);
+        if (!lockPath)
+            throw new Error("当前 Agent 不支持自动关闭占用程序。");
+        let owners = await this.threadWriterProcesses.inspect(lockPath);
+        const expectedOwner = owners.length === 1 && threadWriterMatches(owners[0], expectedWriterPid, expectedWriterStartedAt, expectedApplicationPid, expectedApplicationStartedAt) ? owners[0] : undefined;
+        if (!expectedOwner) {
+            const currentOwner = owners.length === 1 ? owners[0] : undefined;
+            const applicationIdle = currentOwner
+                ? await this.inspectThreadWriterApplicationIdle(runtime, lockPath, threadId, currentOwner)
+                : undefined;
+            await this.outbound.updateInteractiveCard(contextKey, messageId, this.cardRenderer.renderThreadWriterConflict(this.threadWriterConflictView(record, contextKey, threadId, owners, owners.length === 0 ? "released" : "occupied", owners.length === 0
+                ? "请重新发送消息。"
+                : "占用进程已变化，请重试。", applicationIdle)));
+            return;
+        }
+        if (!expectedOwner.canClose)
+            throw new Error("无法确认占用者是 Agent 程序，已拒绝关闭。");
+        try {
+            await this.threadWriterProcesses.close(expectedOwner, force);
+        }
+        catch (error) {
+            owners = await this.threadWriterProcesses.inspect(lockPath);
+            if (owners.some((owner) => threadWriterMatches(owner, expectedWriterPid, expectedWriterStartedAt, expectedApplicationPid, expectedApplicationStartedAt)))
+                throw error;
+        }
+        owners = await this.waitForThreadWriterChange(lockPath, expectedOwner);
+        const sameOwnerRemains = owners.some((owner) => threadWriterMatches(owner, expectedOwner.writerPid, expectedOwner.writerStartedAt ?? "", expectedOwner.applicationPid, expectedOwner.applicationStartedAt ?? ""));
+        if (sameOwnerRemains && force) {
+            throw new Error(`无法关闭 ${expectedOwner.displayName}（PID ${expectedOwner.applicationPid}）。`);
+        }
+        const status = owners.length === 0
+            ? "released"
+            : sameOwnerRemains ? "force_required" : "occupied";
+        const notice = owners.length === 0
+            ? "请重新发送消息。"
+            : sameOwnerRemains
+                ? "普通关闭失败，可强制关闭。"
+                : "占用进程已变化，请重试。";
+        const currentOwner = owners.length === 1 ? owners[0] : undefined;
+        const applicationIdle = currentOwner
+            ? await this.inspectThreadWriterApplicationIdle(runtime, lockPath, threadId, currentOwner)
+            : undefined;
+        await this.outbound.updateInteractiveCard(contextKey, messageId, this.cardRenderer.renderThreadWriterConflict(this.threadWriterConflictView(record, contextKey, threadId, owners, status, notice, applicationIdle)));
+    }
+    async inspectThreadWriterApplicationIdle(runtime, lockPath, threadId, owner) {
+        if (!owner.applicationStartedAt
+            || !this.threadWriterProcesses.inspectApplicationThreadIds
+            || !runtime.inspectRemoteSessionActivity)
+            return undefined;
+        try {
+            const ownedThreadIds = await this.threadWriterProcesses.inspectApplicationThreadIds(lockPath, owner);
+            if (!ownedThreadIds.includes(threadId))
+                return undefined;
+            const activities = await Promise.all(ownedThreadIds.map((ownedThreadId) => runtime.inspectRemoteSessionActivity(ownedThreadId)));
+            return activities.every((activity) => !activity.active);
+        }
+        catch (error) {
+            this.logger.warn({ error, threadId, applicationPid: owner.applicationPid }, "Failed to inspect thread-writer application activity.");
+            return undefined;
+        }
+    }
+    async waitForThreadWriterChange(lockPath, expectedOwner) {
+        const deadline = Date.now() + 5_000;
+        let owners = [];
+        do {
+            owners = await this.threadWriterProcesses.inspect(lockPath);
+            if (!owners.some((owner) => threadWriterMatches(owner, expectedOwner.writerPid, expectedOwner.writerStartedAt ?? "", expectedOwner.applicationPid, expectedOwner.applicationStartedAt ?? "")))
+                return owners;
+            await delay(250);
+        } while (Date.now() < deadline);
+        return owners;
+    }
+    async sendError(contextKey, error, details = {}) {
+        if (error instanceof PresentedRequestError) {
+            this.logger.warn({ error: errorLogValue(error.originalError), contextKey, ...details }, "Request failed after a dedicated error card was presented.");
+            return;
+        }
+        const record = this.currentSession(contextKey);
+        if (record) {
+            try {
+                if (await this.presentThreadWriterConflict(record, contextKey, error, false))
+                    return;
+            }
+            catch (presentationError) {
+                this.logger.warn({ error: presentationError, originalError: errorLogValue(error), contextKey, ...details }, "Failed to present the thread writer conflict card.");
+            }
+        }
+        this.logger.warn({ error, contextKey, ...details }, "Request failed.");
+        try {
+            await this.outbound.sendText(contextKey, error instanceof Error ? error.message : String(error));
+        }
+        catch (deliveryError) {
+            this.logger.error({
+                error: deliveryError,
+                originalError: errorLogValue(error),
+                contextKey,
+                ...details,
+                phase: "error_response_send",
+            }, "Failed to deliver the request failure to the user.");
+        }
+    }
+}
+function activeWriterThreadId(error) {
+    const visited = new Set();
+    let current = error;
+    while (current !== undefined && current !== null && !visited.has(current)) {
+        visited.add(current);
+        const message = current instanceof Error
+            ? current.message
+            : typeof current === "string" ? current : undefined;
+        const match = message?.match(/thread(?:\/resume failed:\s*thread)?\s+([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})\s+already has an active writer/iu);
+        if (match?.[1])
+            return match[1];
+        current = current instanceof Error ? current.cause : undefined;
+    }
+    return undefined;
+}
+function positiveActionPid(value) {
+    const pid = typeof value === "number" ? value : Number(value);
+    if (!Number.isSafeInteger(pid) || pid <= 4) {
+        throw new Error("任务占用卡片中的进程信息无效，请重新发送消息获取最新状态。");
     }
+    return pid;
+}
+function threadWriterMatches(owner, writerPid, writerStartedAt, applicationPid, applicationStartedAt) {
+    return Boolean(writerStartedAt)
+        && Boolean(applicationStartedAt)
+        && owner.writerPid === writerPid
+        && owner.writerStartedAt === writerStartedAt
+        && owner.applicationPid === applicationPid
+        && owner.applicationStartedAt === applicationStartedAt;
+}
+function delay(milliseconds) {
+    return new Promise((resolve) => setTimeout(resolve, milliseconds));
+}
+function renderPlainHelp(introLines, sections) {
+    return [
+        "Agent Bot 使用帮助",
+        "",
+        ...introLines.map((line) => decodeHelpEntities(line.replace(/^>\s*/u, "").replaceAll("**", ""))),
+        ...sections.flatMap((section) => [
+            "",
+            section.title,
+            ...section.commands.map((command) => [
+                command.text,
+                command.usage ? decodeHelpEntities(command.usage) : "",
+                `- ${command.description}`,
+            ].filter(Boolean).join(" ")),
+        ]),
+    ].join("\n");
+}
+function decodeHelpEntities(value) {
+    return value
+        .replaceAll("&#60;", "<")
+        .replaceAll("&#62;", ">")
+        .replaceAll("&amp;", "&");
 }
 function threadForkAnchorMessageIds(message) {
     return [...new Set([message.rootMessageId, message.parentMessageId]