aws-runtime-bridge 1.9.33 → 1.9.41

package/dist/services/instance-state.test.js

@@ -1,245 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import { promises as fs } from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import { getInstanceStateFile, loadInstanceState, saveInstanceState, getAgentInitRoot, } from './instance-state.js';
-describe('instance-state service', () => {
-    const testAgentId = 'test-agent-123';
-    const originalRuntimeHomeDir = process.env.AWS_RUNTIME_HOME_DIR;
-    const testRuntimeHomeDir = path.join(os.tmpdir(), `aws-instance-state-home-${Date.now()}`);
-    function getCurrentStateFilePath() {
-        return getInstanceStateFile(testAgentId);
-    }
-    beforeEach(async () => {
-        process.env.AWS_RUNTIME_HOME_DIR = testRuntimeHomeDir;
-        // 清理测试文件
-        try {
-            await fs.rm(testRuntimeHomeDir, { recursive: true, force: true });
-            await fs.rm(path.join(os.tmpdir(), 'agentswork-runtime-init', testAgentId), { recursive: true, force: true });
-        }
-        catch {
-            // 目录不存在，忽略
-        }
-    });
-    afterEach(async () => {
-        if (originalRuntimeHomeDir === undefined) {
-            delete process.env.AWS_RUNTIME_HOME_DIR;
-        }
-        else {
-            process.env.AWS_RUNTIME_HOME_DIR = originalRuntimeHomeDir;
-        }
-        // 清理测试文件
-        try {
-            await fs.rm(testRuntimeHomeDir, { recursive: true, force: true });
-            await fs.rm(path.join(os.tmpdir(), 'agentswork-runtime-init', testAgentId), { recursive: true, force: true });
-        }
-        catch {
-            // 目录不存在，忽略
-        }
-    });
-    describe('getInstanceStateFile', () => {
-        it('should return correct path in runtime home directory', () => {
-            const result = getInstanceStateFile(testAgentId);
-            const expected = path.join(testRuntimeHomeDir, '.aws-bridge', 'instances', testAgentId, 'state.json');
-            expect(result).toBe(expected);
-        });
-        it('should handle agentId with special characters', () => {
-            const specialAgentId = 'agent-with-dashes_and_underscores';
-            const result = getInstanceStateFile(specialAgentId);
-            expect(result).toContain(specialAgentId);
-            expect(result).toContain('state.json');
-        });
-        it('should convert numeric agentId to string', () => {
-            const numericId = 12345;
-            const result = getInstanceStateFile(numericId);
-            expect(result).toContain('12345');
-        });
-    });
-    describe('getAgentInitRoot', () => {
-        it('should return correct init root directory', () => {
-            const result = getAgentInitRoot(testAgentId);
-            const expected = path.join(testRuntimeHomeDir, '.aws-bridge', 'instances', testAgentId);
-            expect(result).toBe(expected);
-        });
-    });
-    describe('loadInstanceState', () => {
-        it('should return default state when file does not exist', async () => {
-            const state = await loadInstanceState('non-existent-agent-id');
-            expect(state.initialized).toBe(false);
-            expect(state.skills).toEqual([]);
-            expect(state.mcpServers).toEqual([]);
-            expect(state.enabledTools).toEqual(['acode', 'claude', 'opencode', 'codex']);
-            expect(state.toolStatus).toEqual({});
-            expect(state.skillEnabled).toBe(true);
-            expect(state.mcpEnabled).toBe(true);
-            expect(state.updatedAt).toBeNull();
-        });
-        it('should load existing state from file', async () => {
-            // 先保存一个状态
-            const savedState = {
-                initialized: true,
-                skills: [
-                    {
-                        id: 'skill-1',
-                        name: 'test-skill',
-                        fileName: 'test.zip',
-                        filePath: '/path/to/test.zip',
-                        bytes: 1024,
-                        installedAt: '2024-01-01T00:00:00Z',
-                    },
-                ],
-                enabledTools: ['claude', 'gemini'],
-                skillEnabled: false,
-                mcpEnabled: true,
-            };
-            await saveInstanceState(testAgentId, savedState);
-            // 然后加载
-            const loadedState = await loadInstanceState(testAgentId);
-            expect(loadedState.initialized).toBe(true);
-            expect(loadedState.skills).toHaveLength(1);
-            expect(loadedState.skills[0].name).toBe('test-skill');
-            expect(loadedState.enabledTools).toEqual(['claude', 'gemini']);
-            expect(loadedState.skillEnabled).toBe(false);
-            expect(loadedState.mcpEnabled).toBe(true);
-            expect(loadedState.updatedAt).not.toBeNull();
-        });
-        it('should handle corrupted JSON file gracefully', async () => {
-            // 创建损坏的 JSON 文件
-            const stateFilePath = getCurrentStateFilePath();
-            await fs.mkdir(path.dirname(stateFilePath), { recursive: true });
-            await fs.writeFile(stateFilePath, '{ invalid json }', 'utf-8');
-            const state = await loadInstanceState(testAgentId);
-            // 应该返回默认状态
-            expect(state.initialized).toBe(false);
-            expect(state.skills).toEqual([]);
-        });
-        it('should migrate readable legacy temp state into runtime home', async () => {
-            const legacyFilePath = path.join(os.tmpdir(), 'agentswork-runtime-init', testAgentId, 'state.json');
-            const legacyState = {
-                initialized: true,
-                skills: [],
-                mcpServers: [],
-                enabledTools: ['claude'],
-                toolStatus: {},
-                skillEnabled: true,
-                mcpEnabled: false,
-                updatedAt: '2026-01-01T00:00:00.000Z',
-            };
-            await fs.mkdir(path.dirname(legacyFilePath), { recursive: true });
-            await fs.writeFile(legacyFilePath, JSON.stringify(legacyState), 'utf-8');
-            const state = await loadInstanceState(testAgentId);
-            expect(state).toEqual(legacyState);
-            expect(JSON.parse(await fs.readFile(getInstanceStateFile(testAgentId), 'utf-8'))).toEqual(legacyState);
-        });
-    });
-    describe('saveInstanceState', () => {
-        it('should save complete state with all fields', async () => {
-            const partialState = {
-                initialized: true,
-                skills: [],
-                mcpServers: [],
-                enabledTools: ['opencode'],
-                toolStatus: {
-                    claude: {
-                        tool: 'claude',
-                        installed: true,
-                        executable: '/usr/local/bin/claude',
-                        version: '1.0.0',
-                        installing: false,
-                        error: null,
-                    },
-                },
-                skillEnabled: false,
-                mcpEnabled: true,
-            };
-            const result = await saveInstanceState(testAgentId, partialState);
-            expect(result.initialized).toBe(true);
-            expect(result.enabledTools).toEqual(['opencode']);
-            expect(result.toolStatus.claude.installed).toBe(true);
-            expect(result.skillEnabled).toBe(false);
-            expect(result.mcpEnabled).toBe(true);
-            expect(result.updatedAt).not.toBeNull();
-            // 验证文件已创建
-            const fileContent = await fs.readFile(getCurrentStateFilePath(), 'utf-8');
-            const parsed = JSON.parse(fileContent);
-            expect(parsed.initialized).toBe(true);
-        });
-        it('should use default values for missing arrays', async () => {
-            const partialState = {
-                initialized: true,
-            };
-            const result = await saveInstanceState(testAgentId, partialState);
-            expect(result.skills).toEqual([]);
-            expect(result.mcpServers).toEqual([]);
-            expect(result.enabledTools).toEqual(['acode', 'claude', 'opencode', 'codex']);
-        });
-        it('should handle empty state object', async () => {
-            const result = await saveInstanceState(testAgentId, {});
-            expect(result.initialized).toBe(false);
-            expect(result.skills).toEqual([]);
-            expect(result.mcpServers).toEqual([]);
-            expect(result.enabledTools).toEqual(['acode', 'claude', 'opencode', 'codex']);
-            expect(result.toolStatus).toEqual({});
-            expect(result.skillEnabled).toBe(true);
-            expect(result.mcpEnabled).toBe(true);
-        });
-        it('should handle null/undefined values', async () => {
-            const partialState = {
-                initialized: undefined,
-                skills: null,
-                mcpServers: undefined,
-                enabledTools: null,
-                toolStatus: null,
-                skillEnabled: undefined,
-                mcpEnabled: null,
-            };
-            const result = await saveInstanceState(testAgentId, partialState);
-            expect(result.initialized).toBe(false);
-            expect(result.skills).toEqual([]);
-            expect(result.mcpServers).toEqual([]);
-            expect(result.enabledTools).toEqual(['acode', 'claude', 'opencode', 'codex']);
-            expect(result.toolStatus).toEqual({});
-            expect(result.skillEnabled).toBe(true);
-            expect(result.mcpEnabled).toBe(true);
-        });
-        it('should handle invalid toolStatus type', async () => {
-            const partialState = {
-                toolStatus: 'invalid',
-            };
-            const result = await saveInstanceState(testAgentId, partialState);
-            expect(result.toolStatus).toEqual({});
-        });
-        it('should handle array as toolStatus', async () => {
-            const partialState = {
-                toolStatus: [],
-            };
-            const result = await saveInstanceState(testAgentId, partialState);
-            expect(result.toolStatus).toEqual({});
-        });
-        it('should deduplicate and normalize enabledTools', async () => {
-            const partialState = {
-                enabledTools: ['CLAUDE', 'claude', 'OpenCode', '  gemini  ', ''],
-            };
-            const result = await saveInstanceState(testAgentId, partialState);
-            expect(result.enabledTools).toEqual(['claude', 'opencode', 'gemini']);
-        });
-        it('should overwrite existing state', async () => {
-            // 第一次保存
-            await saveInstanceState(testAgentId, { initialized: true });
-            // 第二次保存
-            const result = await saveInstanceState(testAgentId, { initialized: false });
-            expect(result.initialized).toBe(false);
-            // 验证文件内容
-            const fileContent = await fs.readFile(getCurrentStateFilePath(), 'utf-8');
-            const parsed = JSON.parse(fileContent);
-            expect(parsed.initialized).toBe(false);
-        });
-        it('should update updatedAt timestamp on each save', async () => {
-            const first = await saveInstanceState(testAgentId, { initialized: true });
-            // 等待一小段时间确保时间戳不同
-            await new Promise((resolve) => setTimeout(resolve, 10));
-            const second = await saveInstanceState(testAgentId, { initialized: false });
-            expect(second.updatedAt).not.toBe(first.updatedAt);
-        });
-    });
-});

package/dist/services/mcp-launch-binding-queue.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=mcp-launch-binding-queue.test.d.ts.map

package/dist/services/mcp-launch-binding-queue.test.d.ts.map

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

package/dist/services/mcp-launch-binding-queue.test.js

@@ -1,181 +0,0 @@
-import { afterEach, describe, expect, it } from 'vitest';
-import { claimMcpLaunchBinding, clearMcpLaunchBindingQueues, enqueueMcpLaunchBinding, getMcpLaunchQueueSize, removeMcpLaunchBinding, } from './mcp-launch-binding-queue.js';
-describe('mcp launch binding queue', () => {
-    afterEach(() => {
-        clearMcpLaunchBindingQueues();
-    });
-    it('claims same-workspace same-server bindings by agent id', () => {
-        const firstBinding = enqueueMcpLaunchBinding({
-            agentId: 'agent-a',
-            workspacePath: 'C:/repo/demo',
-            serverUrl: 'ws://server-a:7380/ws/agent',
-            runtimeAccessToken: 'token-a',
-            userId: 'user-a',
-            schedulerBaseUrl: 'http://server-a:7380',
-        });
-        const secondBinding = enqueueMcpLaunchBinding({
-            agentId: 'agent-b',
-            workspacePath: 'C:/repo/demo',
-            serverUrl: 'ws://server-a:7380/ws/agent',
-            runtimeAccessToken: 'token-b',
-            userId: 'user-b',
-            schedulerBaseUrl: 'http://server-a:7380',
-        });
-        expect(getMcpLaunchQueueSize('C:/repo/demo')).toBe(2);
-        const first = claimMcpLaunchBinding({
-            agentId: 'agent-a',
-            workspacePath: 'C:/repo/demo',
-            serverUrl: 'ws://server-a:7380/ws/agent',
-        });
-        const second = claimMcpLaunchBinding({
-            agentId: 'agent-b',
-            workspacePath: 'C:/repo/demo',
-            serverUrl: 'ws://server-a:7380/ws/agent',
-        });
-        expect(first?.agentId).toBe('agent-a');
-        expect(first?.runtimeAccessToken).toBe('token-a');
-        expect(second?.agentId).toBe('agent-b');
-        expect(second?.runtimeAccessToken).toBe('token-b');
-        expect(getMcpLaunchQueueSize('C:/repo/demo')).toBe(0);
-    });
-    it('does not claim another agent token from the same workspace and server', () => {
-        const binding = enqueueMcpLaunchBinding({
-            agentId: 'agent-a',
-            workspacePath: 'C:/repo/demo',
-            serverUrl: 'ws://server:7380/ws/agent',
-        });
-        expect(claimMcpLaunchBinding({
-            agentId: 'agent-b',
-            workspacePath: 'C:/repo/demo',
-            serverUrl: 'ws://server:7380/ws/agent',
-        })).toBeNull();
-        expect(binding?.agentId).toBe('agent-a');
-        expect(getMcpLaunchQueueSize('C:/repo/demo')).toBe(1);
-    });
-    it('skips older same-workspace bindings when claiming a later agent token', () => {
-        enqueueMcpLaunchBinding({
-            agentId: 'agent-a',
-            workspacePath: 'C:/repo/demo',
-            serverUrl: 'ws://server:7380/ws/agent',
-            runtimeAccessToken: 'token-a',
-        });
-        enqueueMcpLaunchBinding({
-            agentId: 'agent-b',
-            workspacePath: 'C:/repo/demo',
-            serverUrl: 'ws://server:7380/ws/agent',
-            runtimeAccessToken: 'token-b',
-        });
-        const claimed = claimMcpLaunchBinding({
-            agentId: 'agent-b',
-            workspacePath: 'C:/repo/demo',
-            serverUrl: 'ws://server:7380/ws/agent',
-        });
-        expect(claimed?.agentId).toBe('agent-b');
-        expect(claimed?.runtimeAccessToken).toBe('token-b');
-        expect(getMcpLaunchQueueSize('C:/repo/demo')).toBe(1);
-    });
-    it('allows legacy claim without agent id only when one binding matches', () => {
-        const binding = enqueueMcpLaunchBinding({
-            agentId: 'agent-a',
-            workspacePath: 'C:/repo/demo',
-            serverUrl: 'ws://server:7380/ws/agent',
-        });
-        expect(claimMcpLaunchBinding({
-            workspacePath: 'C:/repo/demo',
-            serverUrl: 'ws://server:7380/ws/agent',
-        })?.agentId).toBe('agent-a');
-        expect(binding?.id).toBeTruthy();
-    });
-    it('rejects legacy claim without agent id when same-workspace same-server bindings are ambiguous', () => {
-        enqueueMcpLaunchBinding({
-            agentId: 'agent-a',
-            workspacePath: 'C:/repo/demo',
-            serverUrl: 'ws://server:7380/ws/agent',
-        });
-        enqueueMcpLaunchBinding({
-            agentId: 'agent-b',
-            workspacePath: 'C:/repo/demo',
-            serverUrl: 'ws://server:7380/ws/agent',
-        });
-        expect(claimMcpLaunchBinding({
-            workspacePath: 'C:/repo/demo',
-            serverUrl: 'ws://server:7380/ws/agent',
-        })).toBeNull();
-        expect(getMcpLaunchQueueSize('C:/repo/demo')).toBe(2);
-    });
-    it('matches by server URL as well as workspace path', () => {
-        const firstBinding = enqueueMcpLaunchBinding({ agentId: 'agent-a', workspacePath: 'C:/repo/demo', serverUrl: 'ws://server-a:7380/ws/agent' });
-        const secondBinding = enqueueMcpLaunchBinding({ agentId: 'agent-b', workspacePath: 'C:/repo/demo', serverUrl: 'ws://server-b:7380/ws/agent' });
-        expect(claimMcpLaunchBinding({ workspacePath: 'C:/repo/demo', serverUrl: 'ws://server-b:7380/ws/agent' })?.agentId).toBe('agent-b');
-        expect(claimMcpLaunchBinding({ workspacePath: 'C:/repo/demo', serverUrl: 'ws://server-a:7380/ws/agent' })?.agentId).toBe('agent-a');
-    });
-    it('matches http scheduler URLs and websocket agent URLs by scheduler origin', () => {
-        enqueueMcpLaunchBinding({ agentId: 'agent-a', workspacePath: 'C:/repo/demo', schedulerBaseUrl: 'http://server-a:7380' });
-        expect(claimMcpLaunchBinding({
-            workspacePath: 'C:/repo/demo',
-            serverUrl: 'ws://server-a:7380/ws/agent',
-        })?.agentId).toBe('agent-a');
-    });
-    it('repairs duplicated scheduler ports when enqueuing launch bindings', () => {
-        const binding = enqueueMcpLaunchBinding({
-            agentId: 'agent-a',
-            workspacePath: 'C:/repo/demo',
-            schedulerBaseUrl: 'http://127.0.0.1:8080:8080',
-        });
-        expect(binding?.serverUrl).toBe('http://127.0.0.1:8080');
-        expect(binding?.schedulerBaseUrl).toBe('http://127.0.0.1:8080');
-        expect(claimMcpLaunchBinding({
-            workspacePath: 'C:/repo/demo',
-            serverUrl: 'ws://127.0.0.1:8080/ws/agent',
-        })?.schedulerBaseUrl).toBe('http://127.0.0.1:8080');
-    });
-    it('matches localhost and 127.0.0.1 launch binding scheduler aliases', () => {
-        enqueueMcpLaunchBinding({
-            agentId: 'agent-a',
-            workspacePath: 'C:/repo/demo',
-            serverUrl: 'ws://localhost:8080/ws/agent',
-        });
-        expect(claimMcpLaunchBinding({
-            workspacePath: 'C:/repo/demo',
-            serverUrl: 'ws://127.0.0.1:8080/ws/agent',
-        })?.agentId).toBe('agent-a');
-    });
-    it('falls back to the only same-workspace binding when scheduler URLs differ', () => {
-        enqueueMcpLaunchBinding({
-            agentId: 'agent-a',
-            workspacePath: 'C:/repo/demo',
-            serverUrl: 'ws://127.0.0.1:7380/ws/agent',
-        });
-        expect(claimMcpLaunchBinding({
-            workspacePath: 'C:/repo/demo',
-            serverUrl: 'ws://101.42.200.84:7380/ws/agent',
-        })?.agentId).toBe('agent-a');
-    });
-    it('does not mix different workspace paths', () => {
-        const firstBinding = enqueueMcpLaunchBinding({ agentId: 'agent-a', workspacePath: 'C:/repo/a', serverUrl: 'ws://server:7380/ws/agent' });
-        const secondBinding = enqueueMcpLaunchBinding({ agentId: 'agent-b', workspacePath: 'C:/repo/b', serverUrl: 'ws://server:7380/ws/agent' });
-        expect(claimMcpLaunchBinding({ workspacePath: 'C:/repo/b', serverUrl: 'ws://server:7380/ws/agent' })?.agentId).toBe('agent-b');
-        expect(claimMcpLaunchBinding({ workspacePath: 'C:/repo/a', serverUrl: 'ws://server:7380/ws/agent' })?.agentId).toBe('agent-a');
-    });
-    it('removes a stale launch binding by id after a failed start', () => {
-        const binding = enqueueMcpLaunchBinding({
-            agentId: 'agent-a',
-            workspacePath: 'C:/repo/demo',
-            serverUrl: 'ws://server:7380/ws/agent',
-        });
-        expect(binding).not.toBeNull();
-        expect(removeMcpLaunchBinding(binding?.id || '')).toBe(true);
-        expect(claimMcpLaunchBinding({
-            agentId: 'agent-a',
-            workspacePath: 'C:/repo/demo',
-            serverUrl: 'ws://server:7380/ws/agent',
-        })).toBeNull();
-        expect(getMcpLaunchQueueSize('C:/repo/demo')).toBe(0);
-    });
-    it('returns null for missing or invalid workspaces', () => {
-        expect(enqueueMcpLaunchBinding({ agentId: '', workspacePath: 'C:/repo/demo' })).toBeNull();
-        expect(enqueueMcpLaunchBinding({ agentId: 'agent-a', workspacePath: '' })).toBeNull();
-        expect(claimMcpLaunchBinding({ workspacePath: 'C:/repo/missing', serverUrl: 'ws://server:7380/ws/agent' })).toBeNull();
-        expect(claimMcpLaunchBinding({ workspacePath: 'C:/repo/demo' })).toBeNull();
-    });
-});

package/dist/services/runtime-binding.test.d.ts

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

package/dist/services/runtime-binding.test.d.ts.map

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

package/dist/services/runtime-binding.test.js

@@ -1,78 +0,0 @@
-import { mkdirSync, mkdtempSync, rmSync } from "node:fs";
-import os from "node:os";
-import path from "node:path";
-import { afterEach, describe, expect, it } from "vitest";
-import { buildRuntimeTokenKey, clearScopedRuntimeAccessToken, getRuntimeAccessToken, getScopedRuntimeAccessToken, normalizeSchedulerBaseUrl, saveScopedRuntimeAccessToken, } from "./runtime-binding.js";
-const originalEnv = { ...process.env };
-const tempRoots = [];
-function useRuntimeHome() {
-    const runtimeHome = mkdtempSync(path.join(os.tmpdir(), "aws-runtime-binding-"));
-    tempRoots.push(runtimeHome);
-    mkdirSync(runtimeHome, { recursive: true });
-    process.env.AWS_RUNTIME_HOME_DIR = runtimeHome;
-    process.env.HOME = runtimeHome;
-    process.env.USERPROFILE = runtimeHome;
-    return runtimeHome;
-}
-afterEach(() => {
-    process.env = { ...originalEnv };
-    for (const root of tempRoots.splice(0)) {
-        rmSync(root, { recursive: true, force: true });
-    }
-});
-describe('runtime binding scheduler URL normalization', () => {
-    it('repairs duplicated scheduler ports', () => {
-        expect(normalizeSchedulerBaseUrl('http://127.0.0.1:8080:8080')).toBe('http://127.0.0.1:8080');
-    });
-    it('normalizes websocket agent URLs to scheduler HTTP origins', () => {
-        expect(normalizeSchedulerBaseUrl('ws://127.0.0.1:8080/ws/agent')).toBe('http://127.0.0.1:8080');
-        expect(normalizeSchedulerBaseUrl('wss://example.com/ws/agent')).toBe('https://example.com');
-    });
-    it('canonicalizes loopback scheduler aliases to one origin', () => {
-        expect(normalizeSchedulerBaseUrl('ws://localhost:8080/ws/agent')).toBe('http://127.0.0.1:8080');
-        expect(normalizeSchedulerBaseUrl('http://localhost:8080')).toBe('http://127.0.0.1:8080');
-    });
-    it("returns paired binding token only when requested scheduler URL matches", async () => {
-        useRuntimeHome();
-        const { saveRuntimeBinding } = await import("./runtime-binding.js");
-        saveRuntimeBinding({
-            accessToken: "paired-runtime-token-123456",
-            instanceId: "bridge-1",
-            userId: "user-a",
-            schedulerBaseUrl: "http://scheduler.local:7380",
-        });
-        expect(getRuntimeAccessToken(undefined, "http://scheduler.local:7380/api")).toBe("paired-runtime-token-123456");
-        expect(getRuntimeAccessToken(undefined, "http://scheduler.local:8080")).toBeUndefined();
-    });
-    it("scopes runtime tokens by user and full scheduler origin", () => {
-        useRuntimeHome();
-        const key7380 = saveScopedRuntimeAccessToken({
-            userId: "user-a",
-            serverBaseUrl: "http://scheduler.local:7380",
-            accessToken: "runtime-token-7380-123456",
-        });
-        const key8080 = saveScopedRuntimeAccessToken({
-            userId: "user-a",
-            serverBaseUrl: "http://scheduler.local:8080",
-            accessToken: "runtime-token-8080-123456",
-        });
-        expect(key7380).not.toBe(key8080);
-        expect(buildRuntimeTokenKey("user-a", "http://scheduler.local:7380/api")).toBe(key7380);
-        expect(getScopedRuntimeAccessToken("user-a", "http://scheduler.local:7380")).toBe("runtime-token-7380-123456");
-        expect(getScopedRuntimeAccessToken("user-a", "http://scheduler.local:8080")).toBe("runtime-token-8080-123456");
-        expect(clearScopedRuntimeAccessToken("user-a", "http://scheduler.local:7380")).toBe(true);
-        expect(getScopedRuntimeAccessToken("user-a", "http://scheduler.local:7380")).toBeUndefined();
-        expect(getScopedRuntimeAccessToken("user-a", "http://scheduler.local:8080")).toBe("runtime-token-8080-123456");
-    });
-    it("uses the same scoped runtime token for localhost and 127.0.0.1", () => {
-        useRuntimeHome();
-        const key = saveScopedRuntimeAccessToken({
-            userId: "user-a",
-            serverBaseUrl: "http://localhost:8080",
-            accessToken: "runtime-token-loopback-123456",
-        });
-        expect(buildRuntimeTokenKey("user-a", "ws://127.0.0.1:8080/ws/agent")).toBe(key);
-        expect(getScopedRuntimeAccessToken("user-a", "http://127.0.0.1:8080")).toBe("runtime-token-loopback-123456");
-        expect(getRuntimeAccessToken("user-a", "ws://localhost:8080/ws/agent")).toBe("runtime-token-loopback-123456");
-    });
-});

package/dist/services/runtime-lifecycle-policy.test.d.ts

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

package/dist/services/runtime-lifecycle-policy.test.d.ts.map

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

package/dist/services/runtime-lifecycle-policy.test.js

@@ -1,41 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { buildGracefulShutdownPlan, shouldAutoCleanOrphanProcesses, shouldCleanupPersistedSessionsOnStartup, } from "./runtime-lifecycle-policy.js";
-describe("runtime lifecycle policy", () => {
-    it("keeps agent processes and persisted state during scheduler restart preservation", () => {
-        expect(buildGracefulShutdownPlan(true)).toEqual({
-            terminateSdkSessions: false,
-            closePtySessions: false,
-            terminateResidualProcesses: false,
-            unregisterInstance: false,
-            clearPersistedSessions: false,
-        });
-    });
-    it("cleans runtime state for explicit bridge shutdown", () => {
-        expect(buildGracefulShutdownPlan(false)).toEqual({
-            terminateSdkSessions: true,
-            closePtySessions: true,
-            terminateResidualProcesses: true,
-            unregisterInstance: true,
-            clearPersistedSessions: true,
-        });
-    });
-    it("does not destructively clean persisted sessions on startup unless explicitly enabled", () => {
-        expect(shouldCleanupPersistedSessionsOnStartup(false, {})).toBe(false);
-        expect(shouldCleanupPersistedSessionsOnStartup(false, {
-            AWS_BRIDGE_CLEAN_ORPHANS_ON_STARTUP: "true",
-        })).toBe(true);
-        expect(shouldCleanupPersistedSessionsOnStartup(true, {
-            AWS_BRIDGE_CLEAN_ORPHANS_ON_STARTUP: "true",
-        })).toBe(false);
-    });
-    it("does not let orphan monitor terminate preserved sessions unless cleanup is explicit", () => {
-        expect(shouldAutoCleanOrphanProcesses({})).toBe(false);
-        expect(shouldAutoCleanOrphanProcesses({
-            AWS_ORPHAN_AUTO_CLEAN_MODE: "auto",
-        })).toBe(false);
-        expect(shouldAutoCleanOrphanProcesses({
-            AWS_ORPHAN_AUTO_CLEAN_MODE: "auto",
-            AWS_BRIDGE_CLEAN_ORPHANS_ON_STARTUP: "true",
-        })).toBe(true);
-    });
-});

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

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

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

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