aws-runtime-bridge 1.0.0

package/dist/services/session-output.js

@@ -0,0 +1,122 @@
+/**
+ * 会话输出缓冲服务
+ *
+ * 管理终端会话的输出缓冲和刷新机制
+ */
+import axios from 'axios';
+import { schedulerBaseUrl, runtimeToken } from '../config.js';
+/** 活跃会话存储 */
+export const sessions = new Map();
+/**
+ * 发送状态更新到调度器
+ *
+ * @param agentId - Agent ID
+ * @param sessionId - 会话 ID
+ * @param status - 状态
+ * @param actionInfo - 可选的动作详情
+ */
+export async function sendStatus(agentId, sessionId, status, actionInfo, usage) {
+    const payload = { agentId, sessionId, status };
+    // 添加细粒度动作信息
+    if (actionInfo) {
+        if (actionInfo.actionType)
+            payload.actionType = actionInfo.actionType;
+        if (actionInfo.actionLabel)
+            payload.actionLabel = actionInfo.actionLabel;
+        if (actionInfo.actionDetail)
+            payload.actionDetail = actionInfo.actionDetail;
+    }
+    // 添加 token 用量信息
+    if (usage) {
+        payload.inputTokens = usage.inputTokens;
+        payload.outputTokens = usage.outputTokens;
+    }
+    return axios.post(`${schedulerBaseUrl}/api/runtime/callback/status`, payload, { headers: { 'X-Runtime-Token': runtimeToken } }).catch(() => undefined);
+}
+/**
+ * 发送输出到调度器
+ *
+ * @param agentId - Agent ID
+ * @param output - 输出内容
+ * @param sessionId - 会话 ID
+ * @param seq - 序列号
+ */
+export async function sendOutput(agentId, output, sessionId, seq) {
+    try {
+        await axios.post(`${schedulerBaseUrl}/api/runtime/callback/output`, { agentId, output, sessionId, seq }, { headers: { 'X-Runtime-Token': runtimeToken } });
+    }
+    catch {
+        // ignore transient callback failures
+    }
+}
+/**
+ * 发送 AskUserQuestion 事件到调度器。
+ *
+ * @param agentId - Agent ID
+ * @param sessionId - SDK 会话 ID
+ * @param questions - 结构化问题列表
+ */
+export async function sendQuestionRequest(agentId, sessionId, questions) {
+    try {
+        await axios.post(`${schedulerBaseUrl}/api/runtime/callback/question`, { agentId, sessionId, questions }, { headers: { 'X-Runtime-Token': runtimeToken } });
+    }
+    catch {
+        // ignore transient callback failures
+    }
+}
+/**
+ * 调度输出刷新
+ *
+ * @param sessionId - 会话 ID
+ */
+export function scheduleOutputFlush(sessionId) {
+    const session = sessions.get(sessionId);
+    if (!session) {
+        return;
+    }
+    if (session.flushTimer) {
+        return;
+    }
+    session.flushTimer = setTimeout(() => {
+        session.flushTimer = null;
+        flushSessionOutput(sessionId).catch(() => undefined);
+    }, 30);
+}
+/**
+ * 刷新会话输出
+ *
+ * @param sessionId - 会话 ID
+ */
+export async function flushSessionOutput(sessionId) {
+    const session = sessions.get(sessionId);
+    if (!session) {
+        return;
+    }
+    if (session.flushInFlight) {
+        return;
+    }
+    if (!session.outputBuffer) {
+        return;
+    }
+    const output = session.outputBuffer;
+    session.outputBuffer = '';
+    const running = (async () => {
+        const seq = session.seq + 1;
+        session.seq = seq;
+        await sendOutput(session.agentId, output, sessionId, seq);
+        const latest = sessions.get(sessionId);
+        if (latest?.outputBuffer) {
+            scheduleOutputFlush(sessionId);
+        }
+    })();
+    session.flushInFlight = running;
+    try {
+        await running;
+    }
+    finally {
+        const latest = sessions.get(sessionId);
+        if (latest) {
+            latest.flushInFlight = null;
+        }
+    }
+}

package/dist/services/session-output.test.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Session Output 服务单元测试
+ */
+export {};
+//# sourceMappingURL=session-output.test.d.ts.map

package/dist/services/session-output.test.d.ts.map

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

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

@@ -0,0 +1,68 @@
+/**
+ * Session Output 服务单元测试
+ */
+import { describe, it, expect } from 'vitest';
+describe('session-output service', () => {
+    it('manages sessions map correctly', () => {
+        const sessions = new Map();
+        sessions.set('session-1', { agentId: 'agent-1', outputBuffer: '' });
+        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', () => {
+        const sessions = new Map([
+            ['session-1', { agentId: 'agent-1' }],
+            ['session-2', { 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', () => {
+        let outputBuffer = '';
+        const appendOutput = (data) => { outputBuffer += data; };
+        appendOutput('line1\n');
+        appendOutput('line2\n');
+        expect(outputBuffer).toBe('line1\nline2\n');
+    });
+    it('clears buffer after flush', () => {
+        let outputBuffer = 'pending output';
+        const flushBuffer = () => {
+            const output = outputBuffer;
+            outputBuffer = '';
+            return output;
+        };
+        const flushed = flushBuffer();
+        expect(flushed).toBe('pending output');
+        expect(outputBuffer).toBe('');
+    });
+    it('increments sequence correctly', () => {
+        let seq = 0;
+        const nextSeq = () => { seq += 1; return seq; };
+        expect(nextSeq()).toBe(1);
+        expect(nextSeq()).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'
+        });
+    });
+});

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

@@ -0,0 +1,51 @@
+/**
+ * 终端会话持久化服务
+ *
+ * 管理终端会话元数据的持久化存储
+ */
+import type { PersistedSession } from '../types.js';
+/**
+ * 获取持久化会话文件路径
+ *
+ * @returns 会话文件路径
+ */
+export declare function getPersistedSessionsFile(): string;
+/**
+ * 加载持久化的终端会话列表
+ *
+ * @returns 持久化会话列表
+ */
+export declare function loadPersistedSessions(): Promise<PersistedSession[]>;
+/**
+ * 保存持久化的终端会话列表
+ *
+ * @param sessions - 会话列表
+ */
+export declare function savePersistedSessions(sessions: PersistedSession[]): Promise<void>;
+/**
+ * 添加或更新持久化会话
+ *
+ * @param session - 会话数据
+ */
+export declare function upsertPersistedSession(session: PersistedSession): Promise<void>;
+/**
+ * 移除持久化会话（从完整文件中删除，包括 stopped 状态的）
+ *
+ * @param sessionId - 会话 ID
+ */
+export declare function removePersistedSession(sessionId: string): Promise<void>;
+/**
+ * 根据 agentId 查找持久化会话
+ *
+ * @param agentId - Agent ID
+ * @returns 持久化会话，未找到返回 undefined
+ */
+export declare function findPersistedSessionByAgentId(agentId: string): Promise<PersistedSession | undefined>;
+/**
+ * 根据 agentId 移除持久化会话
+ * 用于确保停止时能删除正确的持久化会话
+ *
+ * @param agentId - Agent ID
+ */
+export declare function removePersistedSessionByAgentId(agentId: string): Promise<void>;
+//# sourceMappingURL=terminal-persistence.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"terminal-persistence.d.ts","sourceRoot":"","sources":["../../src/services/terminal-persistence.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAMH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAKpD;;;;GAIG;AACH,wBAAgB,wBAAwB,IAAI,MAAM,CAEjD;AAED;;;;GAIG;AACH,wBAAsB,qBAAqB,IAAI,OAAO,CAAC,gBAAgB,EAAE,CAAC,CAUzE;AAED;;;;GAIG;AACH,wBAAsB,qBAAqB,CAAC,QAAQ,EAAE,gBAAgB,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAIvF;AAED;;;;GAIG;AACH,wBAAsB,sBAAsB,CAAC,OAAO,EAAE,gBAAgB,GAAG,OAAO,CAAC,IAAI,CAAC,CASrF;AAED;;;;GAIG;AACH,wBAAsB,sBAAsB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAoB7E;AAED;;;;;GAKG;AACH,wBAAsB,6BAA6B,CACjD,OAAO,EAAE,MAAM,GACd,OAAO,CAAC,gBAAgB,GAAG,SAAS,CAAC,CAGvC;AAED;;;;;GAKG;AACH,wBAAsB,+BAA+B,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAoBpF"}

package/dist/services/terminal-persistence.js

@@ -0,0 +1,125 @@
+/**
+ * 终端会话持久化服务
+ *
+ * 管理终端会话元数据的持久化存储
+ */
+import path from 'node:path';
+import os from 'node:os';
+import { promises as fs } from 'node:fs';
+import { ensureDir } from '../utils/file-utils.js';
+import { createLogger } from '../utils/logger.js';
+const log = createLogger('terminal-persistence');
+/**
+ * 获取持久化会话文件路径
+ *
+ * @returns 会话文件路径
+ */
+export function getPersistedSessionsFile() {
+    return path.join(os.tmpdir(), 'agentswork-runtime-bridge', 'sessions.json');
+}
+/**
+ * 加载持久化的终端会话列表
+ *
+ * @returns 持久化会话列表
+ */
+export async function loadPersistedSessions() {
+    const filePath = getPersistedSessionsFile();
+    try {
+        const raw = await fs.readFile(filePath, 'utf-8');
+        const sessions = JSON.parse(raw);
+        // 只返回状态为 running 的会话
+        return sessions.filter(s => s.status === 'running');
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * 保存持久化的终端会话列表
+ *
+ * @param sessions - 会话列表
+ */
+export async function savePersistedSessions(sessions) {
+    const filePath = getPersistedSessionsFile();
+    await ensureDir(path.dirname(filePath));
+    await fs.writeFile(filePath, JSON.stringify(sessions, null, 2), 'utf-8');
+}
+/**
+ * 添加或更新持久化会话
+ *
+ * @param session - 会话数据
+ */
+export async function upsertPersistedSession(session) {
+    const sessions = await loadPersistedSessions();
+    const index = sessions.findIndex(s => s.sessionId === session.sessionId);
+    if (index >= 0) {
+        sessions[index] = session;
+    }
+    else {
+        sessions.push(session);
+    }
+    await savePersistedSessions(sessions);
+}
+/**
+ * 移除持久化会话（从完整文件中删除，包括 stopped 状态的）
+ *
+ * @param sessionId - 会话 ID
+ */
+export async function removePersistedSession(sessionId) {
+    const filePath = getPersistedSessionsFile();
+    try {
+        const raw = await fs.readFile(filePath, 'utf-8');
+        const allSessions = JSON.parse(raw);
+        const beforeCount = allSessions.length;
+        const filtered = allSessions.filter(s => s.sessionId !== sessionId);
+        const afterCount = filtered.length;
+        if (beforeCount !== afterCount) {
+            log.info(`[removePersistedSession] 删除持久化会话: sessionId=${sessionId}, 删除前=${beforeCount}, 删除后=${afterCount}`);
+        }
+        else {
+            log.warn(`[removePersistedSession] 未找到要删除的会话: sessionId=${sessionId}, 当前会话数=${beforeCount}`);
+        }
+        await savePersistedSessions(filtered);
+    }
+    catch (error) {
+        // 文件不存在，无需删除
+        log.debug(`[removePersistedSession] 文件不存在或读取失败: ${filePath}`);
+    }
+}
+/**
+ * 根据 agentId 查找持久化会话
+ *
+ * @param agentId - Agent ID
+ * @returns 持久化会话，未找到返回 undefined
+ */
+export async function findPersistedSessionByAgentId(agentId) {
+    const sessions = await loadPersistedSessions();
+    return sessions.find(s => s.agentId === agentId);
+}
+/**
+ * 根据 agentId 移除持久化会话
+ * 用于确保停止时能删除正确的持久化会话
+ *
+ * @param agentId - Agent ID
+ */
+export async function removePersistedSessionByAgentId(agentId) {
+    const filePath = getPersistedSessionsFile();
+    try {
+        const raw = await fs.readFile(filePath, 'utf-8');
+        const allSessions = JSON.parse(raw);
+        const beforeCount = allSessions.length;
+        const filtered = allSessions.filter(s => s.agentId !== agentId);
+        const afterCount = filtered.length;
+        if (beforeCount !== afterCount) {
+            log.info(`[removePersistedSessionByAgentId] 删除持久化会话: agentId=${agentId}, 删除前=${beforeCount}, 删除后=${afterCount}`);
+        }
+        else {
+            log.debug(`[removePersistedSessionByAgentId] 未找到要删除的会话: agentId=${agentId}`);
+        }
+        await savePersistedSessions(filtered);
+    }
+    catch (error) {
+        // 文件不存在，无需删除
+        log.debug(`[removePersistedSessionByAgentId] 文件不存在或读取失败: ${filePath}`);
+    }
+}

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

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

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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,88 @@
+/**
+ * Terminal Persistence 服务单元测试
+ */
+import { describe, it, expect } from 'vitest';
+describe('terminal-persistence service', () => {
+    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([]);
+    });
+});

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

@@ -0,0 +1,15 @@
+import type { ToolInstallStatus } from "../types.js";
+export declare const SUPPORTED_INSTALLABLE_TOOLS: readonly string[];
+/**
+ * 检查单个工具的 CLI 可执行状态，供实例状态展示与初始化前判断使用。
+ */
+export declare function detectToolInstallStatus(tool: string): Promise<ToolInstallStatus>;
+/**
+ * 批量检查工具安装状态，统一返回给前端面板和实例状态持久化。
+ */
+export declare function detectToolStatuses(tools: string[]): Promise<Record<string, ToolInstallStatus>>;
+/**
+ * 根据勾选工具自动安装缺失 CLI，安装后重新检测状态并返回。
+ */
+export declare function ensureToolsInstalled(tools: string[]): Promise<Record<string, ToolInstallStatus>>;
+//# sourceMappingURL=tool-installer.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"tool-installer.d.ts","sourceRoot":"","sources":["../../src/services/tool-installer.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAoErD,eAAO,MAAM,2BAA2B,mBAEvC,CAAC;AAmLF;;GAEG;AACH,wBAAsB,uBAAuB,CAC3C,IAAI,EAAE,MAAM,GACX,OAAO,CAAC,iBAAiB,CAAC,CAyB5B;AAED;;GAEG;AACH,wBAAsB,kBAAkB,CACtC,KAAK,EAAE,MAAM,EAAE,GACd,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,iBAAiB,CAAC,CAAC,CAkB5C;AAED;;GAEG;AACH,wBAAsB,oBAAoB,CACxC,KAAK,EAAE,MAAM,EAAE,GACd,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,iBAAiB,CAAC,CAAC,CA+C5C"}