aws-runtime-bridge 1.9.33 → 1.9.41

package/dist/routes/yml.test.d.ts

@@ -1,5 +0,0 @@
-/**
- * YAML 路由单元测试
- */
-export {};
-//# sourceMappingURL=yml.test.d.ts.map

package/dist/routes/yml.test.d.ts.map

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

package/dist/routes/yml.test.js

@@ -1,58 +0,0 @@
-/**
- * YAML 路由单元测试
- */
-import { describe, it, expect } from 'vitest';
-describe('yml route validation', () => {
-    it('requires workspacePath for read', () => {
-        const validateReadRequest = (body) => {
-            const normalizedWorkspace = body.workspacePath ? String(body.workspacePath).trim() : '';
-            if (!normalizedWorkspace)
-                return { valid: false, error: 'workspacePath is required' };
-            return { valid: true };
-        };
-        expect(validateReadRequest({}).valid).toBe(false);
-        expect(validateReadRequest({ workspacePath: '/valid/path' }).valid).toBe(true);
-    });
-    it('requires workspacePath and content for write', () => {
-        const validateWriteRequest = (body) => {
-            const normalizedWorkspace = body.workspacePath ? String(body.workspacePath).trim() : '';
-            if (!normalizedWorkspace)
-                return { valid: false, error: 'workspacePath is required' };
-            if (!body.content || !String(body.content).trim())
-                return { valid: false, error: 'content is required' };
-            return { valid: true };
-        };
-        expect(validateWriteRequest({}).valid).toBe(false);
-        expect(validateWriteRequest({ workspacePath: '/path', content: 'test' }).valid).toBe(true);
-    });
-    it('uses default ymlPath when not provided', () => {
-        const resolveYmlPath = (ymlPath) => {
-            return ymlPath ? String(ymlPath).trim() || '.agentswork/my.yml' : '.agentswork/my.yml';
-        };
-        expect(resolveYmlPath()).toBe('.agentswork/my.yml');
-        expect(resolveYmlPath('custom/path.yml')).toBe('custom/path.yml');
-    });
-});
-describe('response building', () => {
-    it('builds correct response for existing file', () => {
-        const response = {
-            ok: true,
-            workspacePath: '/project/workspace',
-            filePath: '/project/.agentswork/my.yml',
-            exists: true,
-            content: 'agent:\n  - name: test',
-        };
-        expect(response.ok).toBe(true);
-        expect(response.exists).toBe(true);
-    });
-    it('builds correct response for non-existing file', () => {
-        const response = {
-            ok: true,
-            exists: false,
-            fullContent: null,
-            isTemplate: true,
-        };
-        expect(response.exists).toBe(false);
-        expect(response.isTemplate).toBe(true);
-    });
-});

package/dist/services/ai-source-apply.test.d.ts

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

package/dist/services/ai-source-apply.test.d.ts.map

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

package/dist/services/ai-source-apply.test.js

@@ -1,138 +0,0 @@
-import { describe, expect, it, vi } from 'vitest';
-function status(tool, installed) {
-    return {
-        tool,
-        installed,
-        executable: installed ? tool : null,
-        version: installed ? '1.0.0' : null,
-        installing: false,
-        error: installed ? null : 'not installed',
-    };
-}
-describe('applyCurrentAiConfigToInstalledTools', () => {
-    it('forces current unified AI config and skips uninstalled tools', async () => {
-        const applyClaudeCodeConfig = vi.fn(async (config) => config);
-        const applyCodexConfig = vi.fn(async (config) => config);
-        const applyOpenCodeConfig = vi.fn(async (config) => config);
-        const applyAcodeConfig = vi.fn(async (config) => config);
-        const { applyCurrentAiConfigToInstalledTools } = await import('./ai-source-apply.js');
-        const result = await applyCurrentAiConfigToInstalledTools({
-            template: {
-                baseUrl: 'https://current.example.com',
-                apiKey: 'sk-current',
-                model: 'gpt-current',
-            },
-            requestedSources: {
-                claudecode: { env: { ANTHROPIC_BASE_URL: 'https://stale.example.com' } },
-                codex: { model: 'stale-codex' },
-                opencode: { provider: { default: { options: { baseURL: 'https://stale.example.com/v1' } } } },
-            },
-            toolStatus: {
-                acode: status('acode', true),
-                claude: status('claude', true),
-                codex: status('codex', false),
-                opencode: status('opencode', true),
-            },
-            aiConfigService: {
-                applyAcodeConfig,
-                applyClaudeCodeConfig,
-                applyCodexConfig,
-                applyOpenCodeConfig,
-            },
-        });
-        expect(applyClaudeCodeConfig).toHaveBeenCalledWith({
-            env: {
-                ANTHROPIC_BASE_URL: 'https://current.example.com',
-                ANTHROPIC_AUTH_TOKEN: 'sk-current',
-                ANTHROPIC_MODEL: 'gpt-current',
-            },
-        });
-        expect(applyCodexConfig).not.toHaveBeenCalled();
-        expect(applyOpenCodeConfig).toHaveBeenCalledWith(expect.objectContaining({
-            provider: expect.objectContaining({
-                default: expect.objectContaining({
-                    model: 'gpt-current',
-                    options: expect.objectContaining({
-                        baseURL: 'https://current.example.com/v1',
-                        apiKey: 'sk-current',
-                    }),
-                }),
-            }),
-        }));
-        expect(applyAcodeConfig).toHaveBeenCalledOnce();
-        expect(result.applied.codex).toEqual([]);
-        expect(result.skippedTools).toEqual(['codex']);
-    }, 15_000);
-    it('applies Claude Code config when the installed tool status uses the claudecode alias', async () => {
-        const applyClaudeCodeConfig = vi.fn(async (config) => config);
-        const { applyCurrentAiConfigToInstalledTools } = await import('./ai-source-apply.js');
-        await applyCurrentAiConfigToInstalledTools({
-            template: {
-                baseUrl: 'https://current.example.com',
-                apiKey: 'sk-current',
-                model: 'gpt-current',
-            },
-            toolStatus: {
-                claudecode: status('claudecode', true),
-            },
-            aiConfigService: {
-                applyAcodeConfig: vi.fn(async (config) => config),
-                applyClaudeCodeConfig,
-                applyCodexConfig: vi.fn(async (config) => config),
-                applyOpenCodeConfig: vi.fn(async (config) => config),
-            },
-        });
-        expect(applyClaudeCodeConfig).toHaveBeenCalledOnce();
-    });
-    it('applies explicit per-tool AI sources when no unified template is present', async () => {
-        const applyClaudeCodeConfig = vi.fn(async (config) => config);
-        const applyCodexConfig = vi.fn(async (config) => config);
-        const applyOpenCodeConfig = vi.fn(async (config) => config);
-        const applyAcodeConfig = vi.fn(async (config) => config);
-        const { applyCurrentAiConfigToInstalledTools } = await import('./ai-source-apply.js');
-        const result = await applyCurrentAiConfigToInstalledTools({
-            template: null,
-            requestedSources: {
-                claudecode: {
-                    env: {
-                        ANTHROPIC_BASE_URL: 'https://explicit.example.com',
-                        ANTHROPIC_AUTH_TOKEN: 'sk-explicit',
-                        ANTHROPIC_MODEL: 'claude-explicit',
-                    },
-                },
-                codex: { model: 'gpt-explicit' },
-                opencode: {
-                    provider: {
-                        default: {
-                            options: { baseURL: 'https://explicit.example.com/v1', apiKey: 'sk-explicit' },
-                        },
-                    },
-                },
-            },
-            toolStatus: {
-                claude: status('claude', true),
-                codex: status('codex', true),
-                opencode: status('opencode', true),
-            },
-            aiConfigService: {
-                applyAcodeConfig,
-                applyClaudeCodeConfig,
-                applyCodexConfig,
-                applyOpenCodeConfig,
-            },
-        });
-        expect(applyClaudeCodeConfig).toHaveBeenCalledWith({
-            env: {
-                ANTHROPIC_BASE_URL: 'https://explicit.example.com',
-                ANTHROPIC_AUTH_TOKEN: 'sk-explicit',
-                ANTHROPIC_MODEL: 'claude-explicit',
-            },
-        });
-        expect(applyCodexConfig).toHaveBeenCalledWith({ model: 'gpt-explicit' });
-        expect(applyOpenCodeConfig).toHaveBeenCalledOnce();
-        expect(result.generatedFromUnifiedTemplate).toBe(false);
-        expect(result.applied.claudecode).toEqual(['env']);
-        expect(result.applied.codex).toEqual(['model']);
-        expect(result.applied.opencode).toEqual(['provider']);
-    });
-});

package/dist/services/auto-register.test.d.ts

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

package/dist/services/auto-register.test.d.ts.map

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

package/dist/services/auto-register.test.js

@@ -1,184 +0,0 @@
-import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
-import os from "node:os";
-import path from "node:path";
-import { afterEach, describe, expect, it, vi } from "vitest";
-vi.mock("node:os", async () => {
-    const actual = await vi.importActual("node:os");
-    const mocked = {
-        ...actual,
-        homedir: () => process.env.AWS_TEST_HOME || actual.homedir(),
-    };
-    return {
-        ...mocked,
-        default: mocked,
-    };
-});
-vi.mock("axios", () => ({
-    default: {
-        post: vi.fn(),
-    },
-}));
-const originalEnv = { ...process.env };
-const tempRoots = [];
-function createRuntimeHome() {
-    const root = mkdtempSync(path.join(os.tmpdir(), "aws-auto-register-"));
-    tempRoots.push(root);
-    return root;
-}
-function writeAutoRegisterConfig(homeDir, targets) {
-    const configPath = path.join(homeDir, ".aws-bridge", "config.json");
-    const autoRegisterTargets = (typeof targets === "string"
-        ? [{ serverUrl: targets }]
-        : targets).map((target, index) => {
-        const normalizedTarget = {
-            serverUrl: target.serverUrl,
-            instanceName: target.instanceName || `test-bridge-${index + 1}`,
-            userKey: target.userKey || `aws_live_test_key_${index + 1}`,
-        };
-        if (!target.omitRegisterIp) {
-            normalizedTarget.registerIp = target.registerIp || "127.0.0.1";
-        }
-        return normalizedTarget;
-    });
-    mkdirSync(path.dirname(configPath), { recursive: true });
-    writeFileSync(configPath, `${JSON.stringify({
-        connectionKey: "bridge-key",
-        autoRegisterTargets,
-    }, null, 2)}\n`, "utf-8");
-}
-function useRuntimeHome(runtimeHome) {
-    process.env.AWS_TEST_HOME = runtimeHome;
-    process.env.HOME = runtimeHome;
-    process.env.USERPROFILE = runtimeHome;
-    process.env.AWS_RUNTIME_HOME_DIR = runtimeHome;
-    process.env.AWS_RUNTIME_SCHEDULER_BASE_URL = "";
-}
-async function mockSuccessfulPost(response) {
-    const { default: axios } = await import("axios");
-    vi.mocked(axios.post).mockResolvedValue({ data: response });
-    return vi.mocked(axios.post);
-}
-afterEach(() => {
-    process.env = { ...originalEnv };
-    vi.resetModules();
-    vi.clearAllMocks();
-    vi.restoreAllMocks();
-    for (const root of tempRoots.splice(0)) {
-        rmSync(root, { recursive: true, force: true });
-    }
-});
-describe("auto-register scheduler URL selection", () => {
-    it("uses loopback scheduler URLs without warning when registerIp is omitted", async () => {
-        const runtimeHome = createRuntimeHome();
-        useRuntimeHome(runtimeHome);
-        writeAutoRegisterConfig(runtimeHome, [
-            { serverUrl: "http://127.0.0.1:7380", omitRegisterIp: true },
-        ]);
-        const warnSpy = vi.spyOn(console, "warn").mockImplementation(() => undefined);
-        const post = await mockSuccessfulPost({
-            success: true,
-            instanceId: "bridge-loopback",
-            userId: "user-loopback",
-            message: "ok",
-            runtimeAccessToken: "runtime-token-loopback-123456",
-        });
-        const { autoRegister } = await import("./auto-register.js");
-        await expect(autoRegister()).resolves.toBe(true);
-        expect(warnSpy).not.toHaveBeenCalledWith(expect.stringContaining("未找到与调度中心 (127.0.0.1) 同子网的本机 IP"));
-        expect(post.mock.calls[0]?.[1]).toMatchObject({
-            runtimeBridgeBaseUrl: "http://127.0.0.1:18081",
-        });
-    });
-    it("uses configured serverUrl for lifecycle callbacks when env scheduler URL is absent", async () => {
-        const runtimeHome = createRuntimeHome();
-        useRuntimeHome(runtimeHome);
-        writeAutoRegisterConfig(runtimeHome, "http://127.0.0.1:7380");
-        const post = await mockSuccessfulPost({
-            success: true,
-            instanceId: "bridge-instance-1",
-            userId: "user-1",
-            message: "ok",
-            runtimeAccessToken: "runtime-token-123456",
-        });
-        const { autoRegister, bridgeRestartCleanup, requestRuntimeAccessTokenRefresh, unregister } = await import("./auto-register.js");
-        await expect(autoRegister()).resolves.toBe(true);
-        await expect(bridgeRestartCleanup()).resolves.toMatchObject({ success: true });
-        post.mockResolvedValueOnce({
-            data: {
-                success: true,
-                runtimeAccessToken: "refreshed-token-123456",
-                userId: "user-1",
-            },
-        });
-        await expect(requestRuntimeAccessTokenRefresh()).resolves.toMatchObject({
-            success: true,
-            runtimeAccessToken: "refreshed-token-123456",
-        });
-        post.mockResolvedValueOnce({ data: { success: true, message: "unregistered" } });
-        await expect(unregister()).resolves.toBe(true);
-        expect(post.mock.calls[0]?.[0]).toBe("http://127.0.0.1:7380/api/instances/register");
-        expect(post.mock.calls[1]?.[0]).toBe("http://127.0.0.1:7380/api/instances/bridge-restart-cleanup");
-        expect(post.mock.calls[2]?.[0]).toBe("http://127.0.0.1:7380/api/instances/runtime-tokens/refresh");
-        expect(post.mock.calls[3]?.[0]).toBe("http://127.0.0.1:7380/api/instances/unregister");
-        expect(post.mock.calls[3]?.[2]?.headers?.["X-Runtime-Token"]).toBe("refreshed-token-123456");
-        const { getRuntimeAccessToken, loadRuntimeBinding } = await import("./runtime-binding.js");
-        expect(getRuntimeAccessToken("user-1", "http://127.0.0.1:7380")).toBeUndefined();
-        expect(loadRuntimeBinding().status).toBe("unpaired");
-    });
-    it("uses the registered target URL instead of the first configured target", async () => {
-        const runtimeHome = createRuntimeHome();
-        useRuntimeHome(runtimeHome);
-        writeAutoRegisterConfig(runtimeHome, [
-            { serverUrl: "http://scheduler-a.local:7380", userKey: "aws_live_key_a" },
-            { serverUrl: "http://scheduler-b.local:7380", userKey: "aws_live_key_b" },
-        ]);
-        const post = await mockSuccessfulPost({ success: false, message: "unexpected" });
-        post.mockResolvedValueOnce({
-            data: {
-                success: true,
-                instanceId: "bridge-a",
-                userId: "user-a",
-                runtimeAccessToken: "runtime-token-a-123456",
-            },
-        });
-        post.mockResolvedValueOnce({
-            data: {
-                success: true,
-                instanceId: "bridge-b",
-                userId: "user-b",
-                runtimeAccessToken: "runtime-token-b-123456",
-            },
-        });
-        post.mockResolvedValueOnce({ data: { success: true, message: "cleanup ok" } });
-        const { autoRegister, bridgeRestartCleanup } = await import("./auto-register.js");
-        await expect(autoRegister()).resolves.toBe(true);
-        await expect(bridgeRestartCleanup()).resolves.toMatchObject({ success: true });
-        expect(post.mock.calls[0]?.[0]).toBe("http://scheduler-a.local:7380/api/instances/register");
-        expect(post.mock.calls[1]?.[0]).toBe("http://scheduler-b.local:7380/api/instances/register");
-        expect(post.mock.calls[2]?.[0]).toBe("http://scheduler-b.local:7380/api/instances/bridge-restart-cleanup");
-    });
-    it("falls back to paired runtime binding scheduler URL when config has no serverUrl", async () => {
-        const runtimeHome = createRuntimeHome();
-        useRuntimeHome(runtimeHome);
-        const post = await mockSuccessfulPost({
-            success: true,
-            runtimeAccessToken: "binding-refresh-token-123456",
-            userId: "user-from-binding",
-        });
-        const { saveRuntimeBinding } = await import("./runtime-binding.js");
-        const { requestRuntimeAccessTokenRefresh } = await import("./auto-register.js");
-        saveRuntimeBinding({
-            accessToken: "existing-binding-token-123456",
-            instanceId: "bridge-from-binding",
-            userId: "user-from-binding",
-            schedulerBaseUrl: "http://paired-scheduler.local:7380",
-        });
-        process.env.AWS_AUTO_REGISTER = "true";
-        process.env.AWS_USER_KEY = "aws_live_env_key";
-        await expect(requestRuntimeAccessTokenRefresh()).resolves.toMatchObject({
-            success: true,
-            runtimeAccessToken: "binding-refresh-token-123456",
-        });
-        expect(post.mock.calls[0]?.[0]).toBe("http://paired-scheduler.local:7380/api/instances/runtime-tokens/refresh");
-    });
-});

package/dist/services/aws-client-agent-mcp.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=aws-client-agent-mcp.test.d.ts.map

package/dist/services/aws-client-agent-mcp.test.d.ts.map

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

package/dist/services/aws-client-agent-mcp.test.js

@@ -1,242 +0,0 @@
-import { spawnSync } from 'node:child_process';
-import { existsSync, lstatSync, mkdirSync, mkdtempSync, readFileSync, readlinkSync, realpathSync, rmSync, writeFileSync, } from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import { afterEach, describe, expect, it, vi } from 'vitest';
-const originalEnv = { ...process.env };
-afterEach(() => {
-    process.env = { ...originalEnv };
-    vi.resetModules();
-    vi.restoreAllMocks();
-});
-function createBundledMcpPackage(version = '1.0.0') {
-    const packageRoot = mkdtempSync(path.join(os.tmpdir(), 'aws-mcp-package-'));
-    const bundledDist = path.join(packageRoot, 'package', 'aws-client-agent-mcp', 'dist');
-    mkdirSync(bundledDist, { recursive: true });
-    writeFileSync(path.join(packageRoot, 'package.json'), JSON.stringify({ name: 'aws-runtime-bridge', version: '9.9.9' }), 'utf-8');
-    writeFileSync(path.join(packageRoot, 'package', 'aws-client-agent-mcp', 'package.json'), JSON.stringify({
-        name: 'aws-client-agent-mcp',
-        version,
-        type: 'module',
-        main: 'dist/index.js',
-        dependencies: {
-            '@modelcontextprotocol/sdk': '^1.27.1',
-            ws: '^8.14.2',
-            yaml: '^2.3.4',
-        },
-    }), 'utf-8');
-    writeFileSync(path.join(packageRoot, 'package', 'aws-client-agent-mcp', 'README.md'), '# aws-client-agent-mcp\n', 'utf-8');
-    mkdirSync(path.join(packageRoot, 'node_modules', '@modelcontextprotocol', 'sdk'), {
-        recursive: true,
-    });
-    writeFileSync(path.join(packageRoot, 'node_modules', '@modelcontextprotocol', 'sdk', 'package.json'), JSON.stringify({
-        name: '@modelcontextprotocol/sdk',
-        version: '1.27.1',
-        type: 'module',
-        main: 'index.js',
-        exports: './index.js',
-    }), 'utf-8');
-    writeFileSync(path.join(packageRoot, 'node_modules', '@modelcontextprotocol', 'sdk', 'index.js'), 'export const sdkMarker = "resolved-sdk";\n', 'utf-8');
-    mkdirSync(path.join(packageRoot, 'node_modules', 'ws'), { recursive: true });
-    mkdirSync(path.join(packageRoot, 'node_modules', 'yaml'), { recursive: true });
-    writeFileSync(path.join(bundledDist, 'index.js'), 'console.log("mcp v1");\n', 'utf-8');
-    return packageRoot;
-}
-describe('aws-client-agent-mcp service', () => {
-    it('prefers explicit command override from env', async () => {
-        process.env.AWS_CLIENT_AGENT_MCP_COMMAND = 'custom-aws-client-agent-mcp';
-        process.env.AWS_CLIENT_AGENT_MCP_ARGS = JSON.stringify(['--stdio', '--trace']);
-        const mod = await import('./aws-client-agent-mcp.js');
-        expect(mod.resolveAwsClientAgentMcpCommand()).toEqual({
-            source: 'override',
-            command: 'custom-aws-client-agent-mcp',
-            args: ['--stdio', '--trace'],
-        });
-    });
-    it('uses bundled dist entry after release check', async () => {
-        process.env.AWS_CLIENT_AGENT_MCP_COMMAND = '';
-        const mod = await import('./aws-client-agent-mcp.js');
-        const releasedEntry = path.join(os.homedir(), '.aws-bridge', 'mcp', 'dist', 'index.js');
-        const exists = vi.fn((filePath) => filePath === releasedEntry);
-        const release = vi.fn(() => releasedEntry);
-        const resolved = mod.resolveAwsClientAgentMcpCommand({ exists, release });
-        expect(resolved).toEqual({
-            source: 'bundled',
-            command: process.execPath,
-            args: [releasedEntry],
-        });
-        expect(exists).toHaveBeenCalled();
-        expect(release).toHaveBeenCalledOnce();
-    });
-    it('writes release manifest and skips copy when bundled mcp is unchanged', async () => {
-        process.env.AWS_CLIENT_AGENT_MCP_COMMAND = '';
-        const packageRoot = createBundledMcpPackage('1.0.0');
-        const releasedRoot = mkdtempSync(path.join(os.tmpdir(), 'aws-mcp-release-'));
-        try {
-            const mod = await import('./aws-client-agent-mcp.js');
-            const firstRelease = mod.releaseBundledAwsClientAgentMcp({
-                packageRoot,
-                releasedRoot,
-                now: () => '2026-05-04T00:00:00.000Z',
-            });
-            const releasedIndex = path.join(releasedRoot, 'dist', 'index.js');
-            const manifestPath = path.join(releasedRoot, '.release.json');
-            const releasedPackageJson = path.join(releasedRoot, 'package.json');
-            const releasedNodeModules = path.join(releasedRoot, 'node_modules');
-            expect(firstRelease).toBe(releasedIndex);
-            expect(existsSync(releasedIndex)).toBe(true);
-            expect(JSON.parse(readFileSync(releasedPackageJson, 'utf-8'))).toMatchObject({
-                name: 'aws-client-agent-mcp',
-                version: '1.0.0',
-                dependencies: {
-                    '@modelcontextprotocol/sdk': '^1.27.1',
-                },
-            });
-            expect(readFileSync(path.join(releasedRoot, 'README.md'), 'utf-8')).toBe('# aws-client-agent-mcp\n');
-            expect(lstatSync(releasedNodeModules).isSymbolicLink()).toBe(true);
-            expect(realpathSync(releasedNodeModules)).toBe(realpathSync(path.join(packageRoot, 'node_modules')));
-            expect(path.resolve(readlinkSync(releasedNodeModules))).toBe(path.join(packageRoot, 'node_modules'));
-            const firstManifest = JSON.parse(readFileSync(manifestPath, 'utf-8'));
-            expect(firstManifest).toMatchObject({
-                bridgeVersion: '9.9.9',
-                mcpVersion: '1.0.0',
-                releasedAt: '2026-05-04T00:00:00.000Z',
-            });
-            expect(firstManifest.distHash).toMatch(/^sha256:/);
-            writeFileSync(releasedIndex, 'console.log("local marker");\n', 'utf-8');
-            rmSync(releasedNodeModules, { recursive: true, force: true });
-            mkdirSync(releasedNodeModules, { recursive: true });
-            mod.releaseBundledAwsClientAgentMcp({
-                packageRoot,
-                releasedRoot,
-                now: () => '2026-05-05T00:00:00.000Z',
-            });
-            expect(readFileSync(releasedIndex, 'utf-8')).toBe('console.log("local marker");\n');
-            expect(realpathSync(releasedNodeModules)).toBe(realpathSync(path.join(packageRoot, 'node_modules')));
-            expect(JSON.parse(readFileSync(manifestPath, 'utf-8')).releasedAt).toBe('2026-05-04T00:00:00.000Z');
-        }
-        finally {
-            rmSync(packageRoot, { recursive: true, force: true });
-            rmSync(releasedRoot, { recursive: true, force: true });
-        }
-    });
-    it('refreshes released mcp when bundled dist changes', async () => {
-        process.env.AWS_CLIENT_AGENT_MCP_COMMAND = '';
-        const packageRoot = createBundledMcpPackage('1.0.0');
-        const releasedRoot = mkdtempSync(path.join(os.tmpdir(), 'aws-mcp-release-'));
-        try {
-            const mod = await import('./aws-client-agent-mcp.js');
-            const bundledIndex = path.join(packageRoot, 'package', 'aws-client-agent-mcp', 'dist', 'index.js');
-            const releasedIndex = path.join(releasedRoot, 'dist', 'index.js');
-            mod.releaseBundledAwsClientAgentMcp({ packageRoot, releasedRoot });
-            writeFileSync(bundledIndex, 'console.log("mcp v2");\n', 'utf-8');
-            mod.releaseBundledAwsClientAgentMcp({
-                packageRoot,
-                releasedRoot,
-                now: () => '2026-05-05T00:00:00.000Z',
-            });
-            expect(readFileSync(releasedIndex, 'utf-8')).toBe('console.log("mcp v2");\n');
-            expect(JSON.parse(readFileSync(path.join(releasedRoot, '.release.json'), 'utf-8')).releasedAt).toBe('2026-05-05T00:00:00.000Z');
-        }
-        finally {
-            rmSync(packageRoot, { recursive: true, force: true });
-            rmSync(releasedRoot, { recursive: true, force: true });
-        }
-    });
-    it('releases a runnable package root that resolves bundled mcp runtime dependencies', async () => {
-        process.env.AWS_CLIENT_AGENT_MCP_COMMAND = '';
-        const packageRoot = createBundledMcpPackage('1.0.0');
-        const releasedRoot = mkdtempSync(path.join(os.tmpdir(), 'aws-mcp-release-'));
-        try {
-            const bundledIndex = path.join(packageRoot, 'package', 'aws-client-agent-mcp', 'dist', 'index.js');
-            writeFileSync(bundledIndex, 'import { sdkMarker } from "@modelcontextprotocol/sdk";\nconsole.log(sdkMarker);\n', 'utf-8');
-            const mod = await import('./aws-client-agent-mcp.js');
-            const releasedEntry = mod.releaseBundledAwsClientAgentMcp({ packageRoot, releasedRoot });
-            expect(releasedEntry).toBe(path.join(releasedRoot, 'dist', 'index.js'));
-            if (!releasedEntry) {
-                throw new Error('Expected bundled MCP release entry to exist');
-            }
-            const result = spawnSync(process.execPath, [releasedEntry], {
-                cwd: releasedRoot,
-                encoding: 'utf-8',
-            });
-            expect(result.stderr).toBe('');
-            expect(result.status).toBe(0);
-            expect(result.stdout.trim()).toBe('resolved-sdk');
-        }
-        finally {
-            rmSync(packageRoot, { recursive: true, force: true });
-            rmSync(releasedRoot, { recursive: true, force: true });
-        }
-    });
-    it('releases bundled mcp into home directory when runtime dist is missing', async () => {
-        process.env.AWS_CLIENT_AGENT_MCP_COMMAND = '';
-        const mod = await import('./aws-client-agent-mcp.js');
-        const releasedEntry = path.join(os.homedir(), '.aws-bridge', 'mcp', 'dist', 'index.js');
-        let released = false;
-        const exists = vi.fn((filePath) => released && filePath === releasedEntry);
-        const release = vi.fn(() => {
-            released = true;
-            return releasedEntry;
-        });
-        expect(mod.resolveAwsClientAgentMcpCommand({ exists, release })).toEqual({
-            source: 'bundled',
-            command: process.execPath,
-            args: [releasedEntry],
-        });
-        expect(release).toHaveBeenCalledOnce();
-    });
-    it('falls back to global aws-client-agent-mcp command when bundle is missing', async () => {
-        process.env.AWS_CLIENT_AGENT_MCP_COMMAND = '';
-        const mod = await import('./aws-client-agent-mcp.js');
-        expect(mod.resolveAwsClientAgentMcpCommand({ exists: () => false, release: () => null })).toEqual({
-            source: 'global',
-            command: 'aws-client-agent-mcp',
-            args: [],
-        });
-    });
-    it('builds aws-mcp server config with inferred scheduler urls', async () => {
-        process.env.AWS_CLIENT_AGENT_MCP_COMMAND = 'aws-client-agent-mcp';
-        process.env.CUSTOM_SECRET = 'should-not-leak';
-        process.env.AWS_RUNTIME_HOME_DIR = mkdtempSync(path.join(os.tmpdir(), 'aws-mcp-config-'));
-        process.env.AWS_TEST_HOME = process.env.AWS_RUNTIME_HOME_DIR;
-        process.env.AWS_RUNTIME_SCHEDULER_BASE_URL = '';
-        process.env.AWS_SERVER_URL = '';
-        process.env.AWS_MCP_HTTP_URL = '';
-        const mod = await import('./aws-client-agent-mcp.js');
-        const config = mod.buildAwsMcpServerConfig({
-            agentId: 'agent-1',
-            workspacePath: '/workspace/demo',
-        });
-        expect(config.command).toBe('aws-client-agent-mcp');
-        expect(config.env.AWS_AGENT_ID).toBe('agent-1');
-        expect(config.env.AWS_WORKSPACE_PATH).toBe('/workspace/demo');
-        expect(config.env.AWS_SERVER_URL).toBe('ws://localhost:8080/ws/agent');
-        expect(config.env.AWS_MCP_HTTP_URL).toBe('http://localhost:8080/mcp/call');
-        expect(config.env.CUSTOM_SECRET).toBeUndefined();
-    });
-    it('repairs duplicated scheduler ports when building MCP URLs', async () => {
-        process.env.AWS_CLIENT_AGENT_MCP_COMMAND = 'aws-client-agent-mcp';
-        process.env.AWS_RUNTIME_HOME_DIR = mkdtempSync(path.join(os.tmpdir(), 'aws-mcp-config-'));
-        process.env.AWS_RUNTIME_SCHEDULER_BASE_URL = 'http://127.0.0.1:8080:8080';
-        process.env.AWS_SERVER_URL = '';
-        process.env.AWS_MCP_HTTP_URL = '';
-        const mod = await import('./aws-client-agent-mcp.js');
-        const config = mod.buildAwsMcpServerConfig({
-            agentId: 'agent-1',
-            workspacePath: '/workspace/demo',
-        });
-        expect(config.env.AWS_SERVER_URL).toBe('ws://127.0.0.1:8080/ws/agent');
-        expect(config.env.AWS_MCP_HTTP_URL).toBe('http://127.0.0.1:8080/mcp/call');
-    });
-    it('ignores malformed AWS_CLIENT_AGENT_MCP_ARGS JSON', async () => {
-        process.env.AWS_CLIENT_AGENT_MCP_COMMAND = 'custom-aws-client-agent-mcp';
-        process.env.AWS_CLIENT_AGENT_MCP_ARGS = '{bad json';
-        const mod = await import('./aws-client-agent-mcp.js');
-        expect(mod.resolveAwsClientAgentMcpCommand()).toEqual({
-            source: 'override',
-            command: 'custom-aws-client-agent-mcp',
-            args: [],
-        });
-    });
-});

package/dist/services/bridge-package-publish-hooks.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=bridge-package-publish-hooks.test.d.ts.map

package/dist/services/bridge-package-publish-hooks.test.d.ts.map

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