aws-runtime-bridge 1.9.32 → 1.9.40

package/dist/services/session-output.test.js

@@ -1,177 +0,0 @@
-/**
- * Session Output 服务单元测试
- */
-import axios from "axios";
-import { afterEach, describe, expect, it, vi } from "vitest";
-import { logger } from "../utils/logger.js";
-import { appendSessionOutput, sendOutput, sendStatus, sessions, } from "./session-output.js";
-import { getRuntimeAccessToken } from "./runtime-binding.js";
-vi.mock("axios", () => ({
-    default: {
-        post: vi.fn(),
-    },
-}));
-vi.mock("./runtime-binding.js", () => ({
-    getRuntimeAccessToken: vi.fn(() => "runtime-token"),
-}));
-vi.mock("../utils/logger.js", () => ({
-    logger: {
-        warn: vi.fn(),
-    },
-}));
-const mockedAxiosPost = axios.post;
-const mockedLogger = vi.mocked(logger);
-const mockedGetRuntimeAccessToken = vi.mocked(getRuntimeAccessToken);
-const createSession = (overrides = {}) => ({
-    agentId: "agent-1",
-    workspacePath: "D:/workspace",
-    outputBuffer: "",
-    flushTimer: null,
-    flushInFlight: null,
-    seq: 0,
-    ...overrides,
-});
-afterEach(() => {
-    sessions.clear();
-    vi.clearAllMocks();
-});
-describe("session-output service", () => {
-    it("manages sessions map correctly", () => {
-        sessions.set("session-1", createSession());
-        expect(sessions.size).toBe(1);
-        expect(sessions.has("session-1")).toBe(true);
-        const session = sessions.get("session-1");
-        if (session)
-            session.outputBuffer = "test output";
-        expect(sessions.get("session-1")?.outputBuffer).toBe("test output");
-        sessions.delete("session-1");
-        expect(sessions.size).toBe(0);
-    });
-    it("finds session by agentId", () => {
-        sessions.set("session-1", createSession({ agentId: "agent-1" }));
-        sessions.set("session-2", createSession({ agentId: "agent-2" }));
-        const findByAgentId = (agentId) => {
-            for (const [id, session] of sessions) {
-                if (session.agentId === agentId)
-                    return id;
-            }
-            return null;
-        };
-        expect(findByAgentId("agent-1")).toBe("session-1");
-        expect(findByAgentId("agent-3")).toBe(null);
-    });
-    it("accumulates output correctly", () => {
-        sessions.set("session-1", createSession());
-        appendSessionOutput("session-1", "line1\n");
-        appendSessionOutput("session-1", "line2\n");
-        expect(sessions.get("session-1")?.outputBuffer).toBe("line1\nline2\n");
-    });
-    it("bounds pending SDK output so callback failures cannot grow memory without limit", () => {
-        sessions.set("session-bounded", createSession());
-        appendSessionOutput("session-bounded", "a".repeat(70 * 1024));
-        const output = sessions.get("session-bounded")?.outputBuffer ?? "";
-        expect(output.length).toBeLessThanOrEqual(64 * 1024);
-        expect(output).toContain("AgentsWorkStudio: omitted");
-        expect(output.endsWith("a")).toBe(true);
-    });
-    it("increments sequence correctly", () => {
-        const session = createSession();
-        sessions.set("session-1", session);
-        session.seq += 1;
-        expect(session.seq).toBe(1);
-        session.seq += 1;
-        expect(session.seq).toBe(2);
-    });
-    it("builds correct status payload", () => {
-        const buildStatusPayload = (agentId, sessionId, status) => ({
-            agentId,
-            sessionId,
-            status,
-        });
-        expect(buildStatusPayload("agent-1", "session-1", "running")).toEqual({
-            agentId: "agent-1",
-            sessionId: "session-1",
-            status: "running",
-        });
-        expect(buildStatusPayload("agent-1", null, "stopped")).toEqual({
-            agentId: "agent-1",
-            sessionId: null,
-            status: "stopped",
-        });
-    });
-    it("does not throw when runtime status callback fails", async () => {
-        mockedAxiosPost.mockRejectedValueOnce(new Error("scheduler unavailable"));
-        await expect(sendStatus("agent-1", "session-1", "waiting_input")).resolves.toBeUndefined();
-        expect(mockedAxiosPost).toHaveBeenCalledWith(expect.stringContaining("/api/runtime/callback/status"), {
-            agentId: "agent-1",
-            sessionId: "session-1",
-            status: "waiting_input",
-        }, { headers: { "X-Runtime-Token": "runtime-token" } });
-        expect(mockedLogger.warn).toHaveBeenCalledWith("Runtime status callback failed", expect.objectContaining({
-            agentId: "agent-1",
-            sessionId: "session-1",
-            status: "waiting_input",
-        }));
-    });
-    it("uses explicit runtime callback token before persisted binding token", async () => {
-        mockedAxiosPost.mockResolvedValueOnce({ data: { ok: true } });
-        await sendStatus("agent-1", "session-1", "waiting_input", undefined, undefined, {
-            runtimeAccessToken: "session-runtime-token",
-        });
-        expect(mockedAxiosPost).toHaveBeenCalledWith(expect.stringContaining("/api/runtime/callback/status"), {
-            agentId: "agent-1",
-            sessionId: "session-1",
-            status: "waiting_input",
-        }, { headers: { "X-Runtime-Token": "session-runtime-token" } });
-    });
-    it("sends structured source event metadata with SDK output chunks", async () => {
-        mockedAxiosPost.mockResolvedValueOnce({ data: { ok: true } });
-        await sendOutput("agent-1", "answer chunk", "session-1", 7, { sourceEventType: "text_delta" }, { runtimeAccessToken: "session-runtime-token" });
-        expect(mockedAxiosPost).toHaveBeenCalledWith(expect.stringContaining("/api/runtime/callback/output"), {
-            agentId: "agent-1",
-            output: "answer chunk",
-            sessionId: "session-1",
-            seq: 7,
-            sourceEventType: "text_delta",
-        }, { headers: { "X-Runtime-Token": "session-runtime-token" } });
-    });
-    it("uses launch scheduler URL for Docker-deployed scheduler callbacks", async () => {
-        mockedAxiosPost.mockResolvedValue({ data: { ok: true } });
-        await sendStatus("agent-1", "session-1", "thinking", undefined, undefined, {
-            runtimeAccessToken: "session-runtime-token",
-            schedulerBaseUrl: "http://127.0.0.1:7380",
-        });
-        await sendOutput("agent-1", "[ACode] 正在请求模型 gpt-test：hello", "session-1", 8, { sourceEventType: "ai_request", logCategory: "acode" }, {
-            runtimeAccessToken: "session-runtime-token",
-            schedulerBaseUrl: "http://127.0.0.1:7380",
-        });
-        expect(mockedAxiosPost).toHaveBeenNthCalledWith(1, "http://127.0.0.1:7380/api/runtime/callback/status", {
-            agentId: "agent-1",
-            sessionId: "session-1",
-            status: "thinking",
-        }, { headers: { "X-Runtime-Token": "session-runtime-token" } });
-        expect(mockedAxiosPost).toHaveBeenNthCalledWith(2, "http://127.0.0.1:7380/api/runtime/callback/output", {
-            agentId: "agent-1",
-            output: "[ACode] 正在请求模型 gpt-test：hello",
-            sessionId: "session-1",
-            seq: 8,
-            sourceEventType: "ai_request",
-            logCategory: "acode",
-        }, { headers: { "X-Runtime-Token": "session-runtime-token" } });
-    });
-    it("looks up persisted runtime token by launch scheduler URL when explicit token is missing", async () => {
-        mockedAxiosPost.mockResolvedValueOnce({ data: { ok: true } });
-        mockedGetRuntimeAccessToken.mockImplementationOnce((_, serverBaseUrl) => serverBaseUrl === "http://127.0.0.1:7380"
-            ? "scoped-7380-token"
-            : undefined);
-        await sendStatus("agent-1", "session-1", "thinking", undefined, undefined, {
-            schedulerBaseUrl: "http://127.0.0.1:7380",
-        });
-        expect(mockedGetRuntimeAccessToken).toHaveBeenNthCalledWith(1, undefined, "http://127.0.0.1:7380");
-        expect(mockedAxiosPost).toHaveBeenCalledWith("http://127.0.0.1:7380/api/runtime/callback/status", {
-            agentId: "agent-1",
-            sessionId: "session-1",
-            status: "thinking",
-        }, { headers: { "X-Runtime-Token": "scoped-7380-token" } });
-    });
-});

package/dist/services/startup-config-wizard.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=startup-config-wizard.test.d.ts.map

package/dist/services/startup-config-wizard.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"startup-config-wizard.test.d.ts","sourceRoot":"","sources":["../../src/services/startup-config-wizard.test.ts"],"names":[],"mappings":""}

package/dist/services/startup-config-wizard.test.js

@@ -1,184 +0,0 @@
-import { mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
-import os from "node:os";
-import path from "node:path";
-import { afterEach, describe, expect, it } from "vitest";
-import { configureStartupConfig, ensureStartupConfig, } from "./startup-config-wizard.js";
-class FakePrompt {
-    constructor(answers) {
-        this.answers = answers;
-        this.index = 0;
-        this.closed = false;
-        this.prompts = [];
-    }
-    async question(prompt) {
-        this.prompts.push(prompt);
-        return this.answers[this.index++] ?? "";
-    }
-    close() {
-        this.closed = true;
-    }
-}
-const tempRoots = [];
-function createConfigPath() {
-    const root = mkdtempSync(path.join(os.tmpdir(), "aws-bridge-wizard-"));
-    tempRoots.push(root);
-    return path.join(root, ".aws-bridge", "config.json");
-}
-afterEach(() => {
-    for (const root of tempRoots.splice(0)) {
-        rmSync(root, { recursive: true, force: true });
-    }
-});
-describe("startup config wizard", () => {
-    it("does not prompt when config file already exists", async () => {
-        const configPath = createConfigPath();
-        mkdirSync(path.dirname(configPath), { recursive: true });
-        writeFileSync(configPath, "{}", "utf-8");
-        const prompt = new FakePrompt([]);
-        const result = await ensureStartupConfig({ configPath, interactive: true, prompt });
-        expect(result).toBe("exists");
-        expect(prompt.closed).toBe(false);
-    });
-    it("writes generated connection key when user chooses no", async () => {
-        const configPath = createConfigPath();
-        const prompt = new FakePrompt(["n"]);
-        const result = await ensureStartupConfig({
-            configPath,
-            interactive: true,
-            prompt,
-            generateConnectionKey: () => "awsb_test_generated_key",
-        });
-        expect(result).toBe("skipped");
-        expect(JSON.parse(readFileSync(configPath, "utf-8"))).toEqual({
-            connectionKey: "awsb_test_generated_key",
-        });
-    });
-    it("writes connection key and auto register target from interactive answers", async () => {
-        const configPath = createConfigPath();
-        const prompt = new FakePrompt([
-            "y",
-            "gkmzjaznX55..",
-            "http://127.0.0.1:8080",
-            "至强主机",
-            "aws_live_crh_g0GGrg5IntODg1sFwnas7qf4yGrcwoisDWPBtd8",
-            "127.0.0.1",
-        ]);
-        const result = await ensureStartupConfig({ configPath, interactive: true, prompt });
-        expect(result).toBe("created");
-        expect(JSON.parse(readFileSync(configPath, "utf-8"))).toEqual({
-            connectionKey: "gkmzjaznX55..",
-            autoRegisterTargets: [
-                {
-                    serverUrl: "http://127.0.0.1:8080",
-                    instanceName: "至强主机",
-                    userKey: "aws_live_crh_g0GGrg5IntODg1sFwnas7qf4yGrcwoisDWPBtd8",
-                    registerIp: "127.0.0.1",
-                },
-            ],
-        });
-    });
-    it("writes generated connection key and does not block startup in non-interactive environments", async () => {
-        const configPath = createConfigPath();
-        const result = await ensureStartupConfig({
-            configPath,
-            interactive: false,
-            generateConnectionKey: () => "awsb_non_interactive_key",
-        });
-        expect(result).toBe("non-interactive");
-        expect(JSON.parse(readFileSync(configPath, "utf-8"))).toEqual({
-            connectionKey: "awsb_non_interactive_key",
-        });
-    });
-    it("supports environment opt-out for unattended startup", async () => {
-        const configPath = createConfigPath();
-        const result = await ensureStartupConfig({
-            configPath,
-            interactive: true,
-            env: { AWS_BRIDGE_SKIP_SETUP: "true" },
-            generateConnectionKey: () => "awsb_env_skip_key",
-        });
-        expect(result).toBe("skipped");
-        expect(JSON.parse(readFileSync(configPath, "utf-8"))).toEqual({
-            connectionKey: "awsb_env_skip_key",
-        });
-    });
-    it("reconfigures existing config and keeps current values on empty input", async () => {
-        const configPath = createConfigPath();
-        mkdirSync(path.dirname(configPath), { recursive: true });
-        writeFileSync(configPath, JSON.stringify({
-            connectionKey: "old-connection-key",
-            autoRegisterTargets: [
-                {
-                    serverUrl: "http://old-server:7380",
-                    instanceName: "old-instance",
-                    userKey: "old-user-key",
-                    registerIp: "10.0.0.8",
-                },
-            ],
-        }, null, 2), "utf-8");
-        const prompt = new FakePrompt(["", "", "", "", ""]);
-        const result = await configureStartupConfig({
-            configPath,
-            interactive: true,
-            prompt,
-        });
-        expect(result).toBe("configured");
-        expect(JSON.parse(readFileSync(configPath, "utf-8"))).toEqual({
-            connectionKey: "old-connection-key",
-            autoRegisterTargets: [
-                {
-                    serverUrl: "http://old-server:7380",
-                    instanceName: "old-instance",
-                    userKey: "old-user-key",
-                    registerIp: "10.0.0.8",
-                },
-            ],
-        });
-        expect(prompt.prompts).toEqual([
-            "connectionKey（面板连接 Bridge 的密钥）（默认使用当前值 old-connection-key，直接回车保留）: ",
-            "serverUrl（调度中心地址）（默认使用当前值 http://old-server:7380，直接回车保留）: ",
-            "instanceName（实例名称）（默认使用当前值 old-instance，直接回车保留）: ",
-            "userKey（用户 API Key）（默认使用当前值 old-user-key，直接回车保留）: ",
-            "registerIp（Bridge 对外访问 IP）（默认使用当前值 10.0.0.8，直接回车保留）: ",
-        ]);
-    });
-    it("reconfigures existing config with changed values", async () => {
-        const configPath = createConfigPath();
-        mkdirSync(path.dirname(configPath), { recursive: true });
-        writeFileSync(configPath, JSON.stringify({
-            connectionKey: "old-connection-key",
-            autoRegisterTargets: [
-                {
-                    serverUrl: "http://old-server:7380",
-                    instanceName: "old-instance",
-                    userKey: "old-user-key",
-                    registerIp: "10.0.0.8",
-                },
-            ],
-        }), "utf-8");
-        const prompt = new FakePrompt([
-            "new-connection-key",
-            "http://new-server:7380",
-            "new-instance",
-            "new-user-key",
-            "10.0.0.9",
-        ]);
-        const result = await configureStartupConfig({
-            configPath,
-            interactive: true,
-            prompt,
-        });
-        expect(result).toBe("configured");
-        expect(JSON.parse(readFileSync(configPath, "utf-8"))).toEqual({
-            connectionKey: "new-connection-key",
-            autoRegisterTargets: [
-                {
-                    serverUrl: "http://new-server:7380",
-                    instanceName: "new-instance",
-                    userKey: "new-user-key",
-                    registerIp: "10.0.0.9",
-                },
-            ],
-        });
-    });
-});

package/dist/services/terminal-persistence.test.d.ts

@@ -1,5 +0,0 @@
-/**
- * Terminal Persistence 服务单元测试
- */
-export {};
-//# sourceMappingURL=terminal-persistence.test.d.ts.map

package/dist/services/terminal-persistence.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"terminal-persistence.test.d.ts","sourceRoot":"","sources":["../../src/services/terminal-persistence.test.ts"],"names":[],"mappings":"AAAA;;GAEG"}

package/dist/services/terminal-persistence.test.js

@@ -1,159 +0,0 @@
-/**
- * Terminal Persistence 服务单元测试
- */
-import { promises as fs } from 'node:fs';
-import path from 'node:path';
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-const tmpRoot = path.join(process.cwd(), '.tmp-vitest-terminal-persistence');
-vi.mock('node:os', () => ({
-    default: {
-        tmpdir: () => tmpRoot,
-    },
-}));
-const persistence = await import('./terminal-persistence.js');
-function makeSession(sessionId, agentId) {
-    return {
-        sessionId,
-        agentId,
-        workspacePath: `/workspace/${agentId}`,
-        command: 'claude',
-        startedAt: new Date(0).toISOString(),
-        status: 'running',
-    };
-}
-describe('terminal-persistence service', () => {
-    beforeEach(async () => {
-        await fs.rm(tmpRoot, { recursive: true, force: true });
-    });
-    afterEach(async () => {
-        await fs.rm(tmpRoot, { recursive: true, force: true });
-    });
-    it('generates correct file path', () => {
-        const getPersistedSessionsFile = (tmpdir) => {
-            return `${tmpdir}/agentswork-runtime-bridge/sessions.json`;
-        };
-        const path = getPersistedSessionsFile('/tmp');
-        expect(path.includes('agentswork-runtime-bridge')).toBe(true);
-        expect(path.endsWith('sessions.json')).toBe(true);
-    });
-    it('serializes sessions to JSON correctly', () => {
-        const sessions = [{ sessionId: 'session-1', agentId: 'agent-1', status: 'running' }];
-        const json = JSON.stringify(sessions);
-        const parsed = JSON.parse(json);
-        expect(parsed.length).toBe(1);
-        expect(parsed[0].sessionId).toBe('session-1');
-    });
-    it('filters running sessions on load', () => {
-        const sessions = [
-            { sessionId: 's1', status: 'running' },
-            { sessionId: 's2', status: 'stopped' },
-            { sessionId: 's3', status: 'running' },
-        ];
-        const runningSessions = sessions.filter(s => s.status === 'running');
-        expect(runningSessions.length).toBe(2);
-    });
-    it('adds new session', () => {
-        const sessions = [];
-        const upsertSession = (newSession) => {
-            const index = sessions.findIndex(s => s.sessionId === newSession.sessionId);
-            if (index >= 0)
-                sessions[index] = newSession;
-            else
-                sessions.push(newSession);
-        };
-        upsertSession({ sessionId: 'session-1', agentId: 'agent-1' });
-        expect(sessions.length).toBe(1);
-    });
-    it('updates existing session', () => {
-        const sessions = [{ sessionId: 'session-1', status: 'running' }];
-        const index = sessions.findIndex(s => s.sessionId === 'session-1');
-        if (index >= 0)
-            sessions[index] = { sessionId: 'session-1', status: 'stopped' };
-        expect(sessions[0].status).toBe('stopped');
-    });
-    it('removes session by id', () => {
-        const sessions = [{ sessionId: 's1' }, { sessionId: 's2' }];
-        const index = sessions.findIndex(s => s.sessionId === 's2');
-        if (index >= 0)
-            sessions.splice(index, 1);
-        expect(sessions.length).toBe(1);
-        expect(sessions.find(s => s.sessionId === 's2')).toBeUndefined();
-    });
-    it('prefers removing persisted session after stop to prevent later recovery', () => {
-        const sessions = [
-            { sessionId: 's1', agentId: 'a1', status: 'running' },
-            { sessionId: 's2', agentId: 'a2', status: 'running' },
-        ];
-        const stoppedSessionId = 's1';
-        const afterRemove = sessions.filter(s => s.sessionId !== stoppedSessionId);
-        expect(afterRemove).toEqual([
-            { sessionId: 's2', agentId: 'a2', status: 'running' },
-        ]);
-        expect(afterRemove.find(s => s.sessionId === stoppedSessionId)).toBeUndefined();
-    });
-    it('finds session by agentId', () => {
-        const sessions = [
-            { sessionId: 's1', agentId: 'a1' },
-            { sessionId: 's2', agentId: 'a2' },
-        ];
-        const found = sessions.find(s => s.agentId === 'a2');
-        expect(found?.sessionId).toBe('s2');
-    });
-    it('handles invalid JSON on load', () => {
-        const parseSessions = (raw) => {
-            try {
-                return JSON.parse(raw);
-            }
-            catch {
-                return [];
-            }
-        };
-        expect(parseSessions('invalid json')).toEqual([]);
-    });
-    it('keeps a single running session per agent when upserting', async () => {
-        await persistence.upsertPersistedSession(makeSession('session-old', 'agent-1'));
-        await persistence.upsertPersistedSession(makeSession('session-new', 'agent-1'));
-        const sessions = await persistence.loadPersistedSessions();
-        expect(sessions).toHaveLength(1);
-        expect(sessions[0].sessionId).toBe('session-new');
-    });
-    it('persists latest runtime action state for restart recovery', async () => {
-        await persistence.upsertPersistedSession(makeSession('session-1', 'agent-1'));
-        const updated = await persistence.updatePersistedSessionRuntimeState('session-1', {
-            runtimeStatus: 'tool_using',
-            runtimeActionType: 'mcp',
-            runtimeActionLabel: 'poll_message',
-            runtimeActionDetail: '等待群聊消息',
-        });
-        const sessions = await persistence.loadPersistedSessions();
-        expect(updated).toBe(true);
-        expect(sessions[0]).toMatchObject({
-            sessionId: 'session-1',
-            runtimeStatus: 'tool_using',
-            runtimeActionType: 'mcp',
-            runtimeActionLabel: 'poll_message',
-            runtimeActionDetail: '等待群聊消息',
-        });
-    });
-    it('serializes concurrent upserts without losing sessions', async () => {
-        await Promise.all([
-            persistence.upsertPersistedSession(makeSession('session-1', 'agent-1')),
-            persistence.upsertPersistedSession(makeSession('session-2', 'agent-2')),
-            persistence.upsertPersistedSession(makeSession('session-3', 'agent-3')),
-        ]);
-        const sessions = await persistence.loadPersistedSessions();
-        expect(sessions.map(session => session.sessionId).sort()).toEqual(['session-1', 'session-2', 'session-3']);
-    });
-    it('does not revive a removed session during concurrent writes', async () => {
-        await persistence.savePersistedSessions([
-            makeSession('session-1', 'agent-1'),
-            makeSession('session-2', 'agent-2'),
-        ]);
-        await Promise.all([
-            persistence.removePersistedSession('session-1'),
-            persistence.upsertPersistedSession(makeSession('session-3', 'agent-3')),
-        ]);
-        const sessions = await persistence.loadPersistedSessions();
-        expect(sessions.map(session => session.sessionId).sort()).toEqual(['session-2', 'session-3']);
-    });
-});

package/dist/services/tool-installer.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=tool-installer.test.d.ts.map

package/dist/services/tool-installer.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"tool-installer.test.d.ts","sourceRoot":"","sources":["../../src/services/tool-installer.test.ts"],"names":[],"mappings":""}