@keyou007/agent-bot 0.1.15-alpha.4 → 0.1.15-alpha.5

package/dist/proxy/ProxySessionController.js

@@ -12,6 +12,7 @@ import { generateGroupAvatarPng, resolveGroupAvatarProjectName } from "../feishu
 import { normalizeFeishuPostText } from "../feishu/InboundText.js";
 import { allowsFeishuUser } from "../feishu/ownerAccess.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";
@@ -27,7 +28,8 @@ const RESET_HISTORY_PAGE_SIZE = 10;
 const MAX_LLM_TURN_RETRIES = 3;
 const RECOVERY_ACTIVITY_WINDOW_MS = 5 * 60 * 1_000;
 const RECOVERY_HEARTBEAT_INTERVAL_MS = 60 * 1_000;
-const SHELL_COMMAND_ELAPSED_UPDATE_INTERVAL_MS = 3_000;
+const SHELL_COMMAND_JOB_POLL_INTERVAL_MS = 1_000;
+const SHELL_COMMAND_JOB_RELAUNCH_DELAY_MS = 5_000;
 const FORWARD_ATTACHMENT_WINDOW_MS = 800;
 const DEFAULT_MERGED_FORWARD_INSTRUCTION = "请参考以下内容回复用户";
 const DEFAULT_REFERENCED_MESSAGE_INSTRUCTION = "请参考引用消息回复用户";
@@ -61,6 +63,12 @@ const HELP_COMMAND_SECTIONS = [
                 usage: "[目录]",
                 description: "浏览、发送文件，并从选定目录创建任务或群",
             },
+            {
+                command: "/file",
+                usage: "<文件路径>",
+                description: "将指定文件发送到当前飞书会话",
+                requiresArgument: true,
+            },
             {
                 command: "/forkgroup",
                 usage: "[title]",
@@ -170,6 +178,7 @@ export class ProxySessionController {
     lifecycle;
     shellCommandExecutor;
     windowsDriveLister;
+    shellCommandJobs;
     router = new CommandRouter();
     cardRenderer = new CardRenderer();
     messageQueues = new Map();
@@ -186,11 +195,12 @@ export class ProxySessionController {
     pendingMergedForwards = new Map();
     pendingResourceForwards = new Map();
     relatedReactionMessageIds = new Map();
+    shellCommandJobMonitors = new Map();
     unsubscribe = [];
     recoveryActivityHeartbeat;
     startupRecovery;
     queuedPromptsRestored = false;
-    constructor(config, store, runtimes, outbound, logger, lifecycle, shellCommandExecutor = executeShellCommand, windowsDriveLister = listWindowsDriveRoots) {
+    constructor(config, store, runtimes, outbound, logger, lifecycle, shellCommandExecutor = executeShellCommand, windowsDriveLister = listWindowsDriveRoots, shellCommandJobs = new ShellCommandJobManager(path.join(path.dirname(config.storage.sqlitePath), "command-jobs"))) {
         this.config = config;
         this.store = store;
         this.runtimes = runtimes;
@@ -199,6 +209,7 @@ export class ProxySessionController {
         this.lifecycle = lifecycle;
         this.shellCommandExecutor = shellCommandExecutor;
         this.windowsDriveLister = windowsDriveLister;
+        this.shellCommandJobs = shellCommandJobs;
         for (const [, runtime] of this.runtimes.entries()) {
             this.unsubscribe.push(runtime.onEvent((event) => {
                 void this.handleRuntimeEvent(event).catch((error) => {
@@ -424,8 +435,9 @@ export class ProxySessionController {
                     if (command.type === "prompt")
                         await this.ensureThreadFork(message);
                     await this.execute(message.contextKey, command, message.messageId, replyTarget, localImagePaths, message.userId, message);
-                    if (!isPromptCommand(command))
+                    if (!commandDefersReactionFinalization(command)) {
                         await this.finalizeStandaloneMessageReaction(message.messageId, "completed");
+                    }
                 }
                 catch (error) {
                     await this.finalizeStandaloneMessageReaction(message.messageId, "failed");
@@ -440,8 +452,9 @@ export class ProxySessionController {
                 if (command.type === "prompt")
                     await this.ensureThreadFork(message);
                 await this.execute(message.contextKey, command, message.messageId, replyTarget, localImagePaths, message.userId, message);
-                if (!isPromptCommand(command))
+                if (!commandDefersReactionFinalization(command)) {
                     await this.finalizeStandaloneMessageReaction(message.messageId, "completed");
+                }
             }
             catch (error) {
                 await this.finalizeStandaloneMessageReaction(message.messageId, "failed");
@@ -493,6 +506,9 @@ export class ProxySessionController {
                     const sessionId = String(scopedAction.value.sessionId ?? "");
                     await this.cancelSession(this.requireSession(contextKey, sessionId));
                 }
+                else if (kind === "shell_command_cancel") {
+                    await this.cancelShellCommandJob(contextKey, String(scopedAction.value.jobId ?? ""));
+                }
                 else if (kind === "turn_reset") {
                     const sessionId = String(scopedAction.value.sessionId ?? "");
                     await this.resetCurrentSessionToTurn(contextKey, sessionId, String(scopedAction.value.turnId ?? ""));
@@ -753,6 +769,8 @@ export class ProxySessionController {
         for (const timer of this.recoveryRetryTimers.values())
             clearTimeout(timer);
         this.recoveryRetryTimers.clear();
+        for (const [jobId] of this.shellCommandJobMonitors)
+            this.stopShellCommandJobMonitor(jobId);
         clearInterval(this.recoveryActivityHeartbeat);
     }
     async controlStopTask(localSessionId) {
@@ -1269,11 +1287,14 @@ export class ProxySessionController {
         }
         switch (command.type) {
             case "shell":
-                await this.runShellCommand(contextKey, command.command);
+                await this.runShellCommand(contextKey, command.command, messageId);
                 return;
             case "dir":
                 await this.openDirectoryBrowser(contextKey, command.directory);
                 return;
+            case "file":
+                await this.sendCurrentTaskFile(contextKey, command.filePath);
+                return;
             case "new":
                 if (command.projectless && this.ensureAgent(context.defaultAgent).kind !== "app-server") {
                     throw new Error("/new --nodir 仅支持 App Server Agent。");
@@ -1416,6 +1437,7 @@ export class ProxySessionController {
         return recovery;
     }
     async runStartupRecovery() {
+        await this.recoverShellCommandJobs();
         this.backfillTurnAttemptsForUpgrade();
         const attempts = this.store.listIncompleteTurnAttempts();
         const recoveryCutoff = Date.now() - RECOVERY_ACTIVITY_WINDOW_MS;
@@ -3510,102 +3532,138 @@ export class ProxySessionController {
             this.logger.warn({ error, localSessionId }, "Failed to read the latest Agent Goal status.");
         }
     }
-    async runShellCommand(contextKey, command) {
+    async runShellCommand(contextKey, command, sourceMessageId) {
         const cwd = this.currentSession(contextKey)?.cwd ?? this.config.defaults.cwd;
-        const startedAt = Date.now();
-        let latestOutput = {
-            stdout: "",
-            stderr: "",
-            outputTruncated: false,
-        };
-        let runningState = {
+        const created = await this.shellCommandJobs.createJob({ contextKey, sourceMessageId, command, cwd });
+        let cardMessageId;
+        const initialState = {
+            jobId: created.id,
+            contextKey,
             command,
             cwd,
-            ...latestOutput,
+            output: "",
+            outputTruncated: false,
             status: "running",
             elapsedMs: 0,
         };
-        const cardMessageId = await this.outbound.sendInteractiveCard(contextKey, this.cardRenderer.renderShellCommandCard(runningState));
-        const scheduler = cardMessageId
-            ? new CardUpdateScheduler({
-                render: (state) => this.cardRenderer.renderShellCommandCard(state),
-                write: (card) => this.outbound.updateInteractiveCard(contextKey, cardMessageId, card),
-                onError: (error) => this.logger.warn({ error, contextKey, messageId: cardMessageId }, "Failed to update a shell command card."),
-            })
-            : undefined;
-        scheduler?.seed(runningState);
-        const elapsedTimer = scheduler ? setInterval(() => {
-            runningState = { ...runningState, elapsedMs: Date.now() - startedAt };
-            scheduler.update(runningState);
-        }, SHELL_COMMAND_ELAPSED_UPDATE_INTERVAL_MS) : undefined;
-        elapsedTimer?.unref?.();
-        const updateRunningOutput = (snapshot) => {
-            latestOutput = snapshot;
-            runningState = {
-                ...runningState,
-                ...snapshot,
-                elapsedMs: Date.now() - startedAt,
-            };
-            scheduler?.update(runningState);
-        };
-        let result;
         try {
-            result = await this.shellCommandExecutor(command, cwd, { onOutput: updateRunningOutput });
+            cardMessageId = await this.outbound.sendInteractiveCard(contextKey, this.cardRenderer.renderShellCommandCard(initialState));
+            if (!cardMessageId)
+                throw new Error("Failed to create the shell command card.");
+            const bound = await this.shellCommandJobs.bindCard(created.id, cardMessageId);
+            await this.shellCommandJobs.startJob(created.id);
+            this.monitorShellCommandJob(bound, initialState);
         }
         catch (error) {
-            if (elapsedTimer)
-                clearInterval(elapsedTimer);
-            const failedCard = this.cardRenderer.renderShellCommandCard({
-                command,
-                cwd,
-                ...latestOutput,
-                stderr: [latestOutput.stderr.trimEnd(), runtimeErrorMessage(error)].filter(Boolean).join("\n"),
-                status: "failed",
-                elapsedMs: Date.now() - startedAt,
-            });
-            if (scheduler) {
+            await this.shellCommandJobs.failJob(created.id, runtimeErrorMessage(error)).catch(() => undefined);
+            if (cardMessageId) {
                 try {
-                    await scheduler.flush({
-                        ...runningState,
-                        stderr: [latestOutput.stderr.trimEnd(), runtimeErrorMessage(error)].filter(Boolean).join("\n"),
-                        status: "failed",
-                        elapsedMs: Date.now() - startedAt,
-                    });
+                    const failed = await this.shellCommandJobs.readJob(created.id);
+                    await this.outbound.updateInteractiveCard(contextKey, cardMessageId, this.cardRenderer.renderShellCommandCard(shellCommandJobCardView(failed)));
+                    await this.shellCommandJobs.markPresented(created.id);
                 }
                 catch (cardError) {
-                    this.logger.warn({ error: cardError, contextKey, messageId: cardMessageId }, "Failed to finalize a shell command card.");
-                }
-                finally {
-                    scheduler.dispose();
+                    this.logger.warn({ error: cardError, jobId: created.id, contextKey, messageId: cardMessageId }, "Failed to finalize a shell command card after the runner failed to start.");
                 }
             }
             else {
-                await this.outbound.sendInteractiveCard(contextKey, failedCard);
+                await this.shellCommandJobs.markPresented(created.id).catch(() => undefined);
             }
             throw error;
         }
-        if (elapsedTimer)
-            clearInterval(elapsedTimer);
-        const finalState = {
-            command,
-            cwd,
-            stdout: result.stdout,
-            stderr: result.stderr,
-            status: result.timedOut ? "timed_out" : result.exitCode === 0 ? "completed" : "failed",
-            exitCode: result.exitCode,
-            elapsedMs: Date.now() - startedAt,
-            outputTruncated: result.outputTruncated,
+    }
+    monitorShellCommandJob(job, seededState) {
+        if (!job.cardMessageId || this.shellCommandJobMonitors.has(job.id))
+            return;
+        const scheduler = new CardUpdateScheduler({
+            render: (state) => this.cardRenderer.renderShellCommandCard(state),
+            write: (card) => this.outbound.updateInteractiveCard(job.contextKey, job.cardMessageId, card),
+            onError: (error) => this.logger.warn({ error, jobId: job.id, contextKey: job.contextKey, messageId: job.cardMessageId }, "Failed to update a background shell command card."),
+        });
+        if (seededState)
+            scheduler.seed(seededState);
+        const monitor = {
+            scheduler,
+            refreshing: false,
+            timer: setInterval(() => {
+                void this.refreshShellCommandJob(job.id);
+            }, SHELL_COMMAND_JOB_POLL_INTERVAL_MS),
         };
-        if (scheduler) {
-            try {
-                await scheduler.flush(finalState);
+        monitor.timer.unref?.();
+        this.shellCommandJobMonitors.set(job.id, monitor);
+        void this.refreshShellCommandJob(job.id, seededState === undefined);
+    }
+    async refreshShellCommandJob(jobId, critical = false) {
+        const monitor = this.shellCommandJobMonitors.get(jobId);
+        if (!monitor || monitor.refreshing)
+            return;
+        monitor.refreshing = true;
+        try {
+            const job = await this.shellCommandJobs.readJob(jobId);
+            const view = shellCommandJobCardView(job);
+            if (isActiveShellCommandJob(job.status)) {
+                monitor.scheduler.update(view, critical ? "critical" : "normal");
+                return;
             }
-            finally {
-                scheduler.dispose();
+            await monitor.scheduler.flush(view);
+            if (job.sourceMessageId) {
+                await this.finalizeStandaloneMessageReaction(job.sourceMessageId, job.status === "completed" ? "completed" : job.status === "cancelled" ? "cancelled" : "failed");
             }
+            await this.shellCommandJobs.markPresented(jobId);
+            this.stopShellCommandJobMonitor(jobId);
         }
-        else {
-            await this.outbound.sendInteractiveCard(contextKey, this.cardRenderer.renderShellCommandCard(finalState));
+        catch (error) {
+            this.logger.warn({ error, jobId }, "Failed to refresh a background shell command job.");
+        }
+        finally {
+            const current = this.shellCommandJobMonitors.get(jobId);
+            if (current)
+                current.refreshing = false;
+        }
+    }
+    stopShellCommandJobMonitor(jobId) {
+        const monitor = this.shellCommandJobMonitors.get(jobId);
+        if (!monitor)
+            return;
+        clearInterval(monitor.timer);
+        monitor.scheduler.dispose();
+        this.shellCommandJobMonitors.delete(jobId);
+    }
+    async cancelShellCommandJob(contextKey, jobId) {
+        if (!jobId)
+            throw new Error("命令任务无效，请使用最新的命令卡片。");
+        const job = await this.shellCommandJobs.readJob(jobId);
+        if (job.contextKey !== contextKey)
+            throw new Error("该命令不属于当前会话。");
+        const requested = await this.shellCommandJobs.requestCancellation(jobId);
+        if (!requested) {
+            await this.outbound.sendText(contextKey, "该命令已经结束。");
+            return;
+        }
+        if (!this.shellCommandJobMonitors.has(jobId))
+            this.monitorShellCommandJob(job);
+        await this.refreshShellCommandJob(jobId, true);
+    }
+    async recoverShellCommandJobs() {
+        const jobs = await this.shellCommandJobs.listRecoverableJobs();
+        if (jobs.length > 0) {
+            this.logger.warn({ jobIds: jobs.map((job) => job.id) }, "Recovering background shell command jobs after startup.");
+        }
+        for (const job of jobs) {
+            if (!job.cardMessageId || !this.outbound.canRoute(job.contextKey))
+                continue;
+            if (job.status === "starting"
+                && job.runnerPid === undefined
+                && Date.now() - job.updatedAt >= SHELL_COMMAND_JOB_RELAUNCH_DELAY_MS) {
+                try {
+                    await this.shellCommandJobs.startJob(job.id);
+                }
+                catch (error) {
+                    await this.shellCommandJobs.failJob(job.id, runtimeErrorMessage(error)).catch(() => undefined);
+                }
+            }
+            const refreshed = await this.shellCommandJobs.readJob(job.id);
+            this.monitorShellCommandJob(refreshed);
         }
     }
     async setTitle(contextKey, title) {
@@ -3969,6 +4027,12 @@ export class ProxySessionController {
         if (!stats.isFile())
             throw new Error(`这不是普通文件：${filePath}`);
     }
+    async sendCurrentTaskFile(contextKey, requestedFilePath) {
+        const record = this.requireCurrentSession(contextKey);
+        const filePath = resolveUserPath(requestedFilePath, record.cwd);
+        await this.assertSendableFile(filePath);
+        await this.outbound.sendFile(contextKey, filePath);
+    }
     async listSessions(contextKey, searchTerm, options = {}) {
         const context = this.store.getOrCreateUserContext(contextKey, this.config.defaults.agent);
         const normalizedSearch = searchTerm?.trim().toLowerCase();
@@ -5304,7 +5368,7 @@ function isBotOwnedActiveTurn(record, remote) {
         && record.lastTurnId === remote.lastTurnId;
 }
 function isQueueIndependentCommand(command) {
-    if (["archive", "dismiss", "stop", "status", "restart", "mute", "help", "sessions", "dir", "goal", "nosteer"].includes(command.type))
+    if (["archive", "dismiss", "stop", "status", "restart", "mute", "help", "sessions", "dir", "file", "goal", "nosteer", "shell"].includes(command.type))
         return true;
     if (command.type === "agent")
         return command.agent === undefined;
@@ -5312,8 +5376,22 @@ function isQueueIndependentCommand(command) {
         return true;
     return false;
 }
+function shellCommandJobCardView(job) {
+    const status = job.status === "starting" ? "running" : job.status;
+    return {
+        jobId: job.id,
+        contextKey: job.contextKey,
+        command: job.command,
+        cwd: job.cwd,
+        output: [job.output.trimEnd(), job.error].filter(Boolean).join("\n"),
+        status,
+        exitCode: job.exitCode,
+        elapsedMs: Math.max(0, (job.completedAt ?? Date.now()) - job.startedAt),
+        outputTruncated: job.outputTruncated,
+    };
+}
 function commandRequiresCurrentSession(command) {
-    if (["dismiss", "stop", "title", "turns", "model", "provider", "thinking", "permissions", "nosteer"].includes(command.type)) {
+    if (["dismiss", "stop", "title", "turns", "file", "model", "provider", "thinking", "permissions", "nosteer"].includes(command.type)) {
         return true;
     }
     if (command.type === "archive" || command.type === "fork")
@@ -5485,8 +5563,8 @@ async function listWindowsDriveRoots() {
         throw new Error("没有检测到可用的 Windows 磁盘。");
     return drives;
 }
-function isPromptCommand(command) {
-    return command.type === "prompt" || command.type === "nosteer";
+function commandDefersReactionFinalization(command) {
+    return command.type === "prompt" || command.type === "nosteer" || command.type === "shell";
 }
 function runtimePrompt(text, localImagePaths) {
     return localImagePaths?.length ? { text, localImagePaths } : text;