aws-runtime-bridge 1.9.0 → 1.9.2

package/package/acode/dist/builtins/commandArtifacts.js

@@ -0,0 +1,77 @@
+import { randomUUID } from "node:crypto";
+import { promises as fs } from "node:fs";
+import path from "node:path";
+export const COMMAND_OUTPUT_SPILLOVER_LINE_LIMIT = 300;
+export const LONG_COMMAND_LINE_LIMIT = 300;
+export const MAX_COMMAND_OUTPUT_BYTES = 128 * 1024;
+export function toDisplayPath(targetPath) {
+    return targetPath.replace(/\\/g, "/");
+}
+function padDatePart(value) {
+    return String(value).padStart(2, "0");
+}
+export function countOutputLines(output) {
+    if (!output) {
+        return 0;
+    }
+    const normalized = output.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+    const withoutTrailingLineBreak = normalized.endsWith("\n")
+        ? normalized.slice(0, -1)
+        : normalized;
+    return withoutTrailingLineBreak
+        ? withoutTrailingLineBreak.split("\n").length
+        : 1;
+}
+function buildCommandArtifactPath(workspaceRoot, now, suffix, extension) {
+    const year = now.getFullYear();
+    const month = padDatePart(now.getMonth() + 1);
+    const day = padDatePart(now.getDate());
+    const hour = padDatePart(now.getHours());
+    const minute = padDatePart(now.getMinutes());
+    const timestamp = `${year}${month}${day}-${hour}${minute}${padDatePart(now.getSeconds())}-${String(now.getMilliseconds()).padStart(3, "0")}-${process.pid}-${randomUUID().slice(0, 8)}`;
+    return path.join(workspaceRoot, ".agentswork", "acode", "cmd-dist", `${year}-${month}-${day}`, hour, minute, `${timestamp}-${suffix}.${extension}`);
+}
+export async function writeCommandArtifactFile(workspaceRoot, suffix, extension, content, now = new Date()) {
+    const targetPath = buildCommandArtifactPath(workspaceRoot, now, suffix, extension);
+    await fs.mkdir(path.dirname(targetPath), { recursive: true });
+    await fs.writeFile(targetPath, content, "utf-8");
+    return targetPath;
+}
+export function buildCommandOutputSpilloverContent(input) {
+    return [
+        `Command: ${input.commandText}`,
+        `Command file: ${input.commandFilePath ?? "null"}`,
+        `Command line count: ${input.commandLineCount}`,
+        `CWD: ${input.cwd}`,
+        `Started: ${input.startedAt.toISOString()}`,
+        `Ended: ${input.endedAt.toISOString()}`,
+        `Exit code: ${input.exitCode ?? "null"}`,
+        `Signal: ${input.signal ?? "null"}`,
+        `Timed out: ${input.timedOut}`,
+        `Timed out by inactivity: ${input.inactivityTimedOut}`,
+        "",
+        "--- stdout ---",
+        input.stdout,
+        "",
+        "--- stderr ---",
+        input.stderr,
+    ].join("\n");
+}
+export function formatCommandOutputSpilloverStdout(outputFilePath, outputLineCount) {
+    return [
+        `[ACode] 命令输出超过 ${COMMAND_OUTPUT_SPILLOVER_LINE_LIMIT} 行（共 ${outputLineCount} 行），完整输出已写入: ${toDisplayPath(outputFilePath)}`,
+        "[ACode] Agent 可自行读取该文件，或在该文件中搜索需要的内容。",
+        "",
+    ].join("\n");
+}
+export function truncateOutput(value) {
+    const bytes = Buffer.byteLength(value, "utf-8");
+    if (bytes <= MAX_COMMAND_OUTPUT_BYTES) {
+        return { text: value };
+    }
+    const buffer = Buffer.from(value, "utf-8");
+    return {
+        text: buffer.subarray(0, MAX_COMMAND_OUTPUT_BYTES).toString("utf-8") +
+            `\n...[truncated after ${MAX_COMMAND_OUTPUT_BYTES} bytes]`,
+    };
+}

package/package/acode/dist/builtins/commandOutputEvents.d.ts

@@ -0,0 +1,21 @@
+export type CommandOutputStream = "stdout" | "stderr" | "mixed";
+export interface CommandOutputEvent {
+    readonly stream: CommandOutputStream;
+    readonly text: string;
+    readonly sequence: number;
+    readonly cwd: string;
+    readonly commandLineCount: number;
+    readonly commandFilePath?: string;
+}
+export type CommandOutputSink = (event: CommandOutputEvent) => void;
+export interface OutputEventCollector {
+    readonly push: (stream: Exclude<CommandOutputStream, "mixed">, text: string) => void;
+    readonly close: () => void;
+}
+export declare function createOutputEventCollector(input: {
+    readonly cwd: string;
+    readonly commandLineCount: number;
+    readonly commandFilePath?: string;
+    readonly onOutput?: CommandOutputSink;
+}): OutputEventCollector;
+//# sourceMappingURL=commandOutputEvents.d.ts.map

package/package/acode/dist/builtins/commandOutputEvents.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"commandOutputEvents.d.ts","sourceRoot":"","sources":["../../src/builtins/commandOutputEvents.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,mBAAmB,GAAG,QAAQ,GAAG,QAAQ,GAAG,OAAO,CAAC;AAEhE,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,MAAM,EAAE,mBAAmB,CAAC;IACrC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,gBAAgB,EAAE,MAAM,CAAC;IAClC,QAAQ,CAAC,eAAe,CAAC,EAAE,MAAM,CAAC;CACnC;AAED,MAAM,MAAM,iBAAiB,GAAG,CAAC,KAAK,EAAE,kBAAkB,KAAK,IAAI,CAAC;AAOpE,MAAM,WAAW,oBAAoB;IACnC,QAAQ,CAAC,IAAI,EAAE,CACb,MAAM,EAAE,OAAO,CAAC,mBAAmB,EAAE,OAAO,CAAC,EAC7C,IAAI,EAAE,MAAM,KACT,IAAI,CAAC;IACV,QAAQ,CAAC,KAAK,EAAE,MAAM,IAAI,CAAC;CAC5B;AAKD,wBAAgB,0BAA0B,CAAC,KAAK,EAAE;IAChD,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,gBAAgB,EAAE,MAAM,CAAC;IAClC,QAAQ,CAAC,eAAe,CAAC,EAAE,MAAM,CAAC;IAClC,QAAQ,CAAC,QAAQ,CAAC,EAAE,iBAAiB,CAAC;CACvC,GAAG,oBAAoB,CAsDvB"}

package/package/acode/dist/builtins/commandOutputEvents.js

@@ -0,0 +1,56 @@
+const COMMAND_OUTPUT_EVENT_FLUSH_MS = 80;
+const MAX_COMMAND_OUTPUT_EVENT_CHARS = 16 * 1024;
+export function createOutputEventCollector(input) {
+    const onOutput = input.onOutput;
+    const pendingChunks = [];
+    let pendingCharCount = 0;
+    let sequence = 0;
+    let flushTimer;
+    const clearFlushTimer = () => {
+        if (!flushTimer)
+            return;
+        clearTimeout(flushTimer);
+        flushTimer = undefined;
+    };
+    const flush = () => {
+        if (!onOutput || pendingChunks.length === 0)
+            return;
+        clearFlushTimer();
+        sequence += 1;
+        const streams = new Set(pendingChunks.map((chunk) => chunk.stream));
+        const stream = streams.size === 1 ? pendingChunks[0]?.stream ?? "mixed" : "mixed";
+        const text = pendingChunks.map((chunk) => chunk.text).join("");
+        pendingChunks.length = 0;
+        pendingCharCount = 0;
+        onOutput({
+            stream,
+            text,
+            sequence,
+            cwd: input.cwd,
+            commandLineCount: input.commandLineCount,
+            ...(input.commandFilePath
+                ? { commandFilePath: input.commandFilePath }
+                : {}),
+        });
+    };
+    return {
+        push(stream, text) {
+            if (!onOutput || !text)
+                return;
+            pendingChunks.push({ stream, text });
+            pendingCharCount += text.length;
+            if (pendingCharCount >= MAX_COMMAND_OUTPUT_EVENT_CHARS) {
+                flush();
+                return;
+            }
+            if (!flushTimer) {
+                flushTimer = setTimeout(flush, COMMAND_OUTPUT_EVENT_FLUSH_MS);
+                flushTimer.unref?.();
+            }
+        },
+        close() {
+            flush();
+            clearFlushTimer();
+        },
+    };
+}

package/package/acode/dist/builtins/shellCommandPreparation.d.ts

@@ -0,0 +1,15 @@
+export interface ShellExecutable {
+    readonly command: string;
+    readonly argsPrefix: readonly string[];
+    readonly scriptExtension: "cmd" | "sh";
+    readonly scriptInvocation: (scriptPath: string) => string;
+}
+export interface PreparedShellCommand {
+    readonly commandText: string;
+    readonly originalCommandText: string;
+    readonly commandLineCount: number;
+    readonly commandFilePath?: string;
+}
+export declare function shellExecutable(): ShellExecutable;
+export declare function prepareShellCommand(commandText: string, workspaceRoot: string, shell: ShellExecutable): Promise<PreparedShellCommand>;
+//# sourceMappingURL=shellCommandPreparation.d.ts.map

package/package/acode/dist/builtins/shellCommandPreparation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shellCommandPreparation.d.ts","sourceRoot":"","sources":["../../src/builtins/shellCommandPreparation.ts"],"names":[],"mappings":"AAOA,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,UAAU,EAAE,SAAS,MAAM,EAAE,CAAC;IACvC,QAAQ,CAAC,eAAe,EAAE,KAAK,GAAG,IAAI,CAAC;IACvC,QAAQ,CAAC,gBAAgB,EAAE,CAAC,UAAU,EAAE,MAAM,KAAK,MAAM,CAAC;CAC3D;AAED,MAAM,WAAW,oBAAoB;IACnC,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,mBAAmB,EAAE,MAAM,CAAC;IACrC,QAAQ,CAAC,gBAAgB,EAAE,MAAM,CAAC;IAClC,QAAQ,CAAC,eAAe,CAAC,EAAE,MAAM,CAAC;CACnC;AAUD,wBAAgB,eAAe,IAAI,eAAe,CAejD;AAcD,wBAAsB,mBAAmB,CACvC,WAAW,EAAE,MAAM,EACnB,aAAa,EAAE,MAAM,EACrB,KAAK,EAAE,eAAe,GACrB,OAAO,CAAC,oBAAoB,CAAC,CAkB/B"}

package/package/acode/dist/builtins/shellCommandPreparation.js

@@ -0,0 +1,44 @@
+import { countOutputLines, LONG_COMMAND_LINE_LIMIT, toDisplayPath, writeCommandArtifactFile, } from "./commandArtifacts.js";
+function quotePosixShellArg(value) {
+    return `'${value.replace(/'/g, "'\\''")}'`;
+}
+function quoteWindowsCmdPath(value) {
+    return `"${value.replace(/"/g, '""')}"`;
+}
+export function shellExecutable() {
+    if (process.platform === "win32") {
+        return {
+            command: process.env.ComSpec || "cmd.exe",
+            argsPrefix: ["/d", "/c"],
+            scriptExtension: "cmd",
+            scriptInvocation: (scriptPath) => `call ${quoteWindowsCmdPath(scriptPath)}`,
+        };
+    }
+    return {
+        command: process.env.SHELL || "/bin/sh",
+        argsPrefix: ["-lc"],
+        scriptExtension: "sh",
+        scriptInvocation: (scriptPath) => `sh ${quotePosixShellArg(scriptPath)}`,
+    };
+}
+function buildCommandFileContent(commandText, scriptExtension) {
+    const commandWithTrailingLineBreak = commandText.endsWith("\n")
+        ? commandText
+        : `${commandText}\n`;
+    return scriptExtension === "cmd"
+        ? `@echo off\r\n${commandWithTrailingLineBreak}`
+        : commandWithTrailingLineBreak;
+}
+export async function prepareShellCommand(commandText, workspaceRoot, shell) {
+    const commandLineCount = countOutputLines(commandText);
+    if (commandLineCount <= LONG_COMMAND_LINE_LIMIT) {
+        return { commandText, originalCommandText: commandText, commandLineCount };
+    }
+    const commandFilePath = await writeCommandArtifactFile(workspaceRoot, "cmd", shell.scriptExtension, buildCommandFileContent(commandText, shell.scriptExtension));
+    return {
+        commandText: shell.scriptInvocation(commandFilePath),
+        originalCommandText: commandText,
+        commandLineCount,
+        commandFilePath: toDisplayPath(commandFilePath),
+    };
+}

package/package/acode/dist/builtins/shellCommandResult.d.ts

@@ -0,0 +1,30 @@
+import type { PreparedShellCommand } from "./shellCommandPreparation.js";
+export interface ShellCommandResult {
+    readonly exitCode: number | null;
+    readonly signal: NodeJS.Signals | null;
+    readonly stdout: string;
+    readonly stderr: string;
+    readonly durationMs: number;
+    readonly timedOut: boolean;
+    readonly inactivityTimedOut: boolean;
+    readonly outputSpilled: boolean;
+    readonly outputFilePath?: string;
+    readonly outputLineCount: number;
+    readonly commandFilePath?: string;
+    readonly commandLineCount: number;
+}
+interface ClosedShellCommandInput {
+    readonly exitCode: number | null;
+    readonly signal: NodeJS.Signals | null;
+    readonly stdout: string;
+    readonly stderr: string;
+    readonly startedAt: Date;
+    readonly timedOut: boolean;
+    readonly inactivityTimedOut: boolean;
+    readonly prepared: PreparedShellCommand;
+    readonly workspaceRoot: string;
+    readonly cwd: string;
+}
+export declare function resolveClosedShellCommand(input: ClosedShellCommandInput): Promise<ShellCommandResult>;
+export {};
+//# sourceMappingURL=shellCommandResult.d.ts.map

package/package/acode/dist/builtins/shellCommandResult.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shellCommandResult.d.ts","sourceRoot":"","sources":["../../src/builtins/shellCommandResult.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,8BAA8B,CAAC;AAEzE,MAAM,WAAW,kBAAkB;IAClC,QAAQ,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACjC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC,OAAO,GAAG,IAAI,CAAC;IACvC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC;IAC3B,QAAQ,CAAC,kBAAkB,EAAE,OAAO,CAAC;IACrC,QAAQ,CAAC,aAAa,EAAE,OAAO,CAAC;IAChC,QAAQ,CAAC,cAAc,CAAC,EAAE,MAAM,CAAC;IACjC,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC;IACjC,QAAQ,CAAC,eAAe,CAAC,EAAE,MAAM,CAAC;IAClC,QAAQ,CAAC,gBAAgB,EAAE,MAAM,CAAC;CAClC;AAED,UAAU,uBAAuB;IAChC,QAAQ,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACjC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC,OAAO,GAAG,IAAI,CAAC;IACvC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,SAAS,EAAE,IAAI,CAAC;IACzB,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC;IAC3B,QAAQ,CAAC,kBAAkB,EAAE,OAAO,CAAC;IACrC,QAAQ,CAAC,QAAQ,EAAE,oBAAoB,CAAC;IACxC,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;CACrB;AA0CD,wBAAsB,yBAAyB,CAC9C,KAAK,EAAE,uBAAuB,GAC5B,OAAO,CAAC,kBAAkB,CAAC,CAuD7B"}

package/package/acode/dist/builtins/shellCommandResult.js

@@ -0,0 +1,71 @@
+import { buildCommandOutputSpilloverContent, COMMAND_OUTPUT_SPILLOVER_LINE_LIMIT, countOutputLines, formatCommandOutputSpilloverStdout, toDisplayPath, truncateOutput, writeCommandArtifactFile, } from "./commandArtifacts.js";
+async function writeCommandOutputSpilloverFile(workspaceRoot, content) {
+    return writeCommandArtifactFile(workspaceRoot, "cmd", "out", content);
+}
+function buildShellCommandResult(input) {
+    return {
+        exitCode: input.exitCode,
+        signal: input.signal,
+        stdout: input.stdout,
+        stderr: input.stderr,
+        durationMs: input.endedAt.getTime() - input.startedAt.getTime(),
+        timedOut: input.timedOut,
+        inactivityTimedOut: input.inactivityTimedOut,
+        outputSpilled: input.outputSpilled,
+        outputLineCount: input.outputLineCount,
+        ...(input.outputFilePath ? { outputFilePath: input.outputFilePath } : {}),
+        ...(input.commandFilePath
+            ? { commandFilePath: input.commandFilePath }
+            : {}),
+        commandLineCount: input.commandLineCount,
+    };
+}
+export async function resolveClosedShellCommand(input) {
+    const endedAt = new Date();
+    const outputLineCount = countOutputLines(`${input.stdout}${input.stderr}`);
+    if (outputLineCount > COMMAND_OUTPUT_SPILLOVER_LINE_LIMIT) {
+        const outputFilePath = await writeCommandOutputSpilloverFile(input.workspaceRoot, buildCommandOutputSpilloverContent({
+            commandText: input.prepared.originalCommandText,
+            commandFilePath: input.prepared.commandFilePath,
+            commandLineCount: input.prepared.commandLineCount,
+            cwd: input.cwd,
+            startedAt: input.startedAt,
+            endedAt,
+            exitCode: input.exitCode,
+            signal: input.signal,
+            timedOut: input.timedOut,
+            inactivityTimedOut: input.inactivityTimedOut,
+            stdout: input.stdout,
+            stderr: input.stderr,
+        }));
+        return buildShellCommandResult({
+            exitCode: input.exitCode,
+            signal: input.signal,
+            stdout: formatCommandOutputSpilloverStdout(outputFilePath, outputLineCount),
+            stderr: "",
+            startedAt: input.startedAt,
+            endedAt,
+            timedOut: input.timedOut,
+            inactivityTimedOut: input.inactivityTimedOut,
+            outputSpilled: true,
+            outputFilePath: toDisplayPath(outputFilePath),
+            outputLineCount,
+            commandFilePath: input.prepared.commandFilePath,
+            commandLineCount: input.prepared.commandLineCount,
+        });
+    }
+    return buildShellCommandResult({
+        exitCode: input.exitCode,
+        signal: input.signal,
+        stdout: truncateOutput(input.stdout).text,
+        stderr: truncateOutput(input.stderr).text,
+        startedAt: input.startedAt,
+        endedAt,
+        timedOut: input.timedOut,
+        inactivityTimedOut: input.inactivityTimedOut,
+        outputSpilled: false,
+        outputLineCount,
+        commandFilePath: input.prepared.commandFilePath,
+        commandLineCount: input.prepared.commandLineCount,
+    });
+}

package/package/acode/dist/builtins/shellCommandRunner.d.ts

@@ -0,0 +1,14 @@
+import { type CommandOutputEvent, type CommandOutputSink } from "./commandOutputEvents.js";
+import { type ShellCommandResult } from "./shellCommandResult.js";
+export type { CommandOutputEvent, CommandOutputSink };
+export interface RunShellCommandOptions {
+    readonly commandText: string;
+    readonly workspaceRoot: string;
+    readonly cwd: string;
+    readonly timeoutMs: number;
+    readonly inactivityTimeoutMs: number;
+    readonly onOutput?: CommandOutputSink;
+}
+export type { ShellCommandResult };
+export declare function runShellCommand(options: RunShellCommandOptions): Promise<ShellCommandResult>;
+//# sourceMappingURL=shellCommandRunner.d.ts.map

package/package/acode/dist/builtins/shellCommandRunner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shellCommandRunner.d.ts","sourceRoot":"","sources":["../../src/builtins/shellCommandRunner.ts"],"names":[],"mappings":"AAEA,OAAO,EACN,KAAK,kBAAkB,EACvB,KAAK,iBAAiB,EAEtB,MAAM,0BAA0B,CAAC;AAKlC,OAAO,EAEN,KAAK,kBAAkB,EACvB,MAAM,yBAAyB,CAAC;AAMjC,YAAY,EAAE,kBAAkB,EAAE,iBAAiB,EAAE,CAAC;AAEtD,MAAM,WAAW,sBAAsB;IACtC,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,mBAAmB,EAAE,MAAM,CAAC;IACrC,QAAQ,CAAC,QAAQ,CAAC,EAAE,iBAAiB,CAAC;CACtC;AAED,YAAY,EAAE,kBAAkB,EAAE,CAAC;AAInC,wBAAsB,eAAe,CACpC,OAAO,EAAE,sBAAsB,GAC7B,OAAO,CAAC,kBAAkB,CAAC,CAqH7B"}

package/package/acode/dist/builtins/shellCommandRunner.js

@@ -0,0 +1,114 @@
+import { spawn } from "node:child_process";
+import { createOutputEventCollector, } from "./commandOutputEvents.js";
+import { prepareShellCommand, shellExecutable, } from "./shellCommandPreparation.js";
+import { resolveClosedShellCommand, } from "./shellCommandResult.js";
+import { createShellOutputDecoder, decodeShellOutputChunk, } from "./shellOutputDecoder.js";
+const KILL_ESCALATION_DELAY_MS = 1000;
+export async function runShellCommand(options) {
+    const shell = shellExecutable();
+    const prepared = await prepareShellCommand(options.commandText, options.workspaceRoot, shell);
+    return new Promise((resolve, reject) => {
+        const startedAt = new Date();
+        const child = spawn(shell.command, [...shell.argsPrefix, prepared.commandText], {
+            cwd: options.cwd,
+            env: process.env,
+            windowsVerbatimArguments: process.platform === "win32",
+            windowsHide: true,
+        });
+        const outputEvents = createOutputEventCollector({
+            cwd: options.cwd,
+            commandLineCount: prepared.commandLineCount,
+            commandFilePath: prepared.commandFilePath,
+            onOutput: options.onOutput,
+        });
+        let stdout = "";
+        let stderr = "";
+        let timedOut = false;
+        let inactivityTimedOut = false;
+        let killEscalationTimer;
+        let inactivityTimer;
+        const stdoutDecoder = createShellOutputDecoder();
+        const stderrDecoder = createShellOutputDecoder();
+        const clearTimers = () => {
+            if (inactivityTimer)
+                clearTimeout(inactivityTimer);
+            if (killEscalationTimer)
+                clearTimeout(killEscalationTimer);
+            inactivityTimer = undefined;
+            killEscalationTimer = undefined;
+        };
+        const escalateKill = () => {
+            if (killEscalationTimer)
+                return;
+            killEscalationTimer = setTimeout(() => {
+                if (!child.killed) {
+                    child.kill("SIGKILL");
+                }
+            }, KILL_ESCALATION_DELAY_MS);
+            killEscalationTimer.unref?.();
+        };
+        const timer = setTimeout(() => {
+            timedOut = true;
+            child.kill("SIGTERM");
+            escalateKill();
+        }, options.timeoutMs);
+        timer.unref?.();
+        const resetInactivityTimer = () => {
+            if (inactivityTimer)
+                clearTimeout(inactivityTimer);
+            inactivityTimer = setTimeout(() => {
+                inactivityTimedOut = true;
+                timedOut = true;
+                child.kill("SIGTERM");
+                escalateKill();
+            }, options.inactivityTimeoutMs);
+            inactivityTimer.unref?.();
+        };
+        resetInactivityTimer();
+        const appendStdout = (text) => {
+            if (!text)
+                return;
+            stdout += text;
+            outputEvents.push("stdout", text);
+            resetInactivityTimer();
+        };
+        const appendStderr = (text) => {
+            if (!text)
+                return;
+            stderr += text;
+            outputEvents.push("stderr", text);
+            resetInactivityTimer();
+        };
+        child.stdout?.on("data", (chunk) => {
+            appendStdout(decodeShellOutputChunk(stdoutDecoder, chunk));
+        });
+        child.stderr?.on("data", (chunk) => {
+            appendStderr(decodeShellOutputChunk(stderrDecoder, chunk));
+        });
+        child.on("error", (error) => {
+            clearTimeout(timer);
+            clearTimers();
+            outputEvents.close();
+            reject(error);
+        });
+        child.on("close", (exitCode, signal) => {
+            clearTimeout(timer);
+            clearTimers();
+            appendStdout(decodeShellOutputChunk(stdoutDecoder, undefined, true));
+            appendStderr(decodeShellOutputChunk(stderrDecoder, undefined, true));
+            outputEvents.close();
+            void resolveClosedShellCommand({
+                exitCode,
+                signal,
+                stdout,
+                stderr,
+                startedAt,
+                timedOut,
+                inactivityTimedOut,
+                prepared,
+                workspaceRoot: options.workspaceRoot,
+                cwd: options.cwd,
+            }).then(resolve, reject);
+        });
+    });
+}

package/package/acode/dist/builtins/shellOutputDecoder.d.ts

@@ -0,0 +1,5 @@
+import { TextDecoder } from "node:util";
+export declare function resolveShellOutputEncoding(platform?: NodeJS.Platform, env?: NodeJS.ProcessEnv): string;
+export declare function createShellOutputDecoder(encoding?: string): TextDecoder;
+export declare function decodeShellOutputChunk(decoder: TextDecoder, chunk?: Buffer, end?: boolean): string;
+//# sourceMappingURL=shellOutputDecoder.d.ts.map

package/package/acode/dist/builtins/shellOutputDecoder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shellOutputDecoder.d.ts","sourceRoot":"","sources":["../../src/builtins/shellOutputDecoder.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC;AAKxC,wBAAgB,0BAA0B,CACzC,QAAQ,GAAE,MAAM,CAAC,QAA2B,EAC5C,GAAG,GAAE,MAAM,CAAC,UAAwB,GAClC,MAAM,CAUR;AAED,wBAAgB,wBAAwB,CACvC,QAAQ,SAA+B,GACrC,WAAW,CAMb;AAED,wBAAgB,sBAAsB,CACrC,OAAO,EAAE,WAAW,EACpB,KAAK,CAAC,EAAE,MAAM,EACd,GAAG,UAAQ,GACT,MAAM,CAQR"}

package/package/acode/dist/builtins/shellOutputDecoder.js

@@ -0,0 +1,30 @@
+import { TextDecoder } from "node:util";
+const DEFAULT_WINDOWS_SHELL_OUTPUT_ENCODING = "gb18030";
+const DEFAULT_SHELL_OUTPUT_ENCODING = "utf-8";
+export function resolveShellOutputEncoding(platform = process.platform, env = process.env) {
+    const configuredEncoding = env.ACODE_COMMAND_OUTPUT_ENCODING?.trim() ||
+        env.AWS_TERMINAL_OUTPUT_ENCODING?.trim();
+    if (configuredEncoding) {
+        return configuredEncoding;
+    }
+    return platform === "win32"
+        ? DEFAULT_WINDOWS_SHELL_OUTPUT_ENCODING
+        : DEFAULT_SHELL_OUTPUT_ENCODING;
+}
+export function createShellOutputDecoder(encoding = resolveShellOutputEncoding()) {
+    try {
+        return new TextDecoder(encoding, { fatal: false });
+    }
+    catch {
+        return new TextDecoder(DEFAULT_SHELL_OUTPUT_ENCODING, { fatal: false });
+    }
+}
+export function decodeShellOutputChunk(decoder, chunk, end = false) {
+    if (end) {
+        return decoder.decode();
+    }
+    if (!chunk || chunk.length === 0) {
+        return "";
+    }
+    return decoder.decode(chunk, { stream: true });
+}

package/package/acode/dist/mcpToolNames.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Main flow: normalize common MCP separators, then use the final segment as
+ * the semantic tool name that controls timeout policy.
+ */
+export declare function getSemanticToolName(toolName: string): string;
+/**
+ * Main flow: classify only exact polling tool names so similarly named tools
+ * keep the regular MCP timeout.
+ */
+export declare function isMcpPollingToolName(toolName: string): boolean;
+//# sourceMappingURL=mcpToolNames.d.ts.map

package/package/acode/dist/mcpToolNames.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mcpToolNames.d.ts","sourceRoot":"","sources":["../src/mcpToolNames.ts"],"names":[],"mappings":"AAEA;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAI5D;AAED;;;GAGG;AACH,wBAAgB,oBAAoB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAE9D"}

package/package/acode/dist/mcpToolNames.js

@@ -0,0 +1,17 @@
+const POLLING_TOOL_NAMES = new Set(["poll_message", "get_message"]);
+/**
+ * Main flow: normalize common MCP separators, then use the final segment as
+ * the semantic tool name that controls timeout policy.
+ */
+export function getSemanticToolName(toolName) {
+    const normalized = toolName.trim().toLowerCase();
+    const segments = normalized.split(/__|[./]/).filter(Boolean);
+    return segments.at(-1) ?? normalized;
+}
+/**
+ * Main flow: classify only exact polling tool names so similarly named tools
+ * keep the regular MCP timeout.
+ */
+export function isMcpPollingToolName(toolName) {
+    return POLLING_TOOL_NAMES.has(getSemanticToolName(toolName));
+}

package/package/acode/dist/runtime.d.ts

@@ -3,12 +3,15 @@ import type { ACodeRuntimeConfig } from "./types.js";
 export declare class ACodeRuntime extends EventEmitter {
     private readonly config;
     private readonly hookBus;
+    private initialConversation;
     private state;
     private abortController;
     private submitQueue;
     private activeTurn;
     private abortRequested;
     private sessionCompleteEmitted;
+    private contextVersion;
+    private readonly stopWaiters;
     constructor(config: ACodeRuntimeConfig);
     private emitAcodeEvent;
     /**
@@ -23,6 +26,12 @@ export declare class ACodeRuntime extends EventEmitter {
      * MCP tool call 则执行工具并继续同一轮，最后输出 assistant 文本与 usage。
      */
     submit(message: string): Promise<void>;
+    /**
+     * Reset only the conversation context while keeping the live ACode session,
+     * MCP connections, exposed tools, commands, and hooks available.
+     */
+    resetContext(): Promise<void>;
+    private isTurnSuperseded;
     private executeSubmit;
     /** 中止当前轮次；由执行轮次统一发出一个终态事件，避免 aborted/failed 双终态。 */
     abort(): Promise<void>;
@@ -34,6 +43,16 @@ export declare class ACodeRuntime extends EventEmitter {
     private readChatCompletionStream;
     private handleToolCalls;
     private callMcpToolWithTimeout;
+    /**
+     * Build a one-shot waiter that rejects long-running MCP calls when the runtime stops.
+     * Main flow: register a stop callback -> race it with the SDK call -> remove it after either side settles.
+     */
+    private createRuntimeStopWaiter;
+    /**
+     * Notify and clear every pending runtime-stop waiter.
+     * Main flow: snapshot callbacks -> clear the set -> reject each pending MCP race exactly once.
+     */
+    private notifyRuntimeStop;
     private appendSyntheticMultimodalUserMessage;
     private appendToolFailureResult;
     private connectMcpServers;

package/package/acode/dist/runtime.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"runtime.d.ts","sourceRoot":"","sources":["../src/runtime.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAiB3C,OAAO,KAAK,EAOV,kBAAkB,EAEnB,MAAM,YAAY,CAAC;AAuoCpB,qBAAa,YAAa,SAAQ,YAAY;IAmChC,OAAO,CAAC,QAAQ,CAAC,MAAM;IAlCnC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAe;IAEvC,OAAO,CAAC,KAAK,CAoBX;IAEF,OAAO,CAAC,eAAe,CAAgC;IAEvD,OAAO,CAAC,WAAW,CAAoC;IAEvD,OAAO,CAAC,UAAU,CAAS;IAE3B,OAAO,CAAC,cAAc,CAAS;IAE/B,OAAO,CAAC,sBAAsB,CAAS;gBAEV,MAAM,EAAE,kBAAkB;IAevD,OAAO,CAAC,cAAc;IAatB;;;;OAIG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAyF5B;;;;OAIG;IACG,MAAM,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;YAM9B,aAAa;IA2E3B,oDAAoD;IAC9C,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAM5B,uCAAuC;IACjC,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IA8B3B,OAAO,CAAC,kBAAkB;YAaZ,YAAY;YAoEZ,qBAAqB;YA4JrB,wBAAwB;YA6ExB,eAAe;YAoJf,sBAAsB;YAqCtB,oCAAoC;IAkBlD,OAAO,CAAC,uBAAuB;YAuBjB,iBAAiB;IA2C/B,OAAO,CAAC,kBAAkB;YA2BZ,oBAAoB;CAiBnC"}
+{"version":3,"file":"runtime.d.ts","sourceRoot":"","sources":["../src/runtime.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAkB3C,OAAO,KAAK,EAOV,kBAAkB,EAEnB,MAAM,YAAY,CAAC;AAksCpB,qBAAa,YAAa,SAAQ,YAAY;IAsChC,OAAO,CAAC,QAAQ,CAAC,MAAM;IArCnC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAe;IACvC,OAAO,CAAC,mBAAmB,CAAqB;IAEhD,OAAO,CAAC,KAAK,CAoBX;IAEF,OAAO,CAAC,eAAe,CAAgC;IAEvD,OAAO,CAAC,WAAW,CAAoC;IAEvD,OAAO,CAAC,UAAU,CAAS;IAE3B,OAAO,CAAC,cAAc,CAAS;IAE/B,OAAO,CAAC,sBAAsB,CAAS;IACvC,OAAO,CAAC,cAAc,CAAK;IAC3B,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAyB;gBAExB,MAAM,EAAE,kBAAkB;IAevD,OAAO,CAAC,cAAc;IAatB;;;;OAIG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IA2F5B;;;;OAIG;IACG,MAAM,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAS5C;;;OAGG;IACG,YAAY,IAAI,OAAO,CAAC,IAAI,CAAC;IAWnC,OAAO,CAAC,gBAAgB;YAIV,aAAa;IA6F3B,oDAAoD;IAC9C,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAM5B,uCAAuC;IACjC,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IA+B3B,OAAO,CAAC,kBAAkB;YAaZ,YAAY;YAoFZ,qBAAqB;YAuKrB,wBAAwB;YA8ExB,eAAe;YAuMf,sBAAsB;IA6CpC;;;OAGG;IACH,OAAO,CAAC,uBAAuB;IAiC/B;;;OAGG;IACH,OAAO,CAAC,iBAAiB;YAQX,oCAAoC;IAsBlD,OAAO,CAAC,uBAAuB;YAuBjB,iBAAiB;IA2C/B,OAAO,CAAC,kBAAkB;YA2BZ,oBAAoB;CAiBnC"}