aws-runtime-bridge 1.9.33 → 1.9.41

package/dist/services/bridge-package-publish-hooks.test.js

@@ -1,136 +0,0 @@
-import { createHmac } from "node:crypto";
-import { afterEach, describe, expect, it, vi } from "vitest";
-import { createBridgePackagePublishPayload, createBridgePublishSignature, notifyBridgePackagePublished, readBridgePackageInfo, } from "./bridge-package-publish-hooks.js";
-const originalEnv = { ...process.env };
-function createLoggerMock() {
-    return {
-        info: vi.fn(),
-        warn: vi.fn(),
-        error: vi.fn(),
-    };
-}
-function createPublishEnv(overrides = {}) {
-    return {
-        ...originalEnv,
-        BRIDGE_PACKAGE_ON_PUBLIC_HOOKS_URL: "",
-        BRIDGE_PACKAGE_ON_PUBLIC_HOOKS_SECRET: "",
-        GITHUB_REPOSITORY: "owner/repo",
-        GITHUB_REF: "refs/heads/main",
-        GITHUB_SHA: "abc123",
-        GITHUB_RUN_ID: "456",
-        GITHUB_RUN_NUMBER: "789",
-        ...overrides,
-    };
-}
-const packageInfo = {
-    name: "aws-runtime-bridge",
-    version: "1.7.6",
-};
-afterEach(() => {
-    process.env = { ...originalEnv };
-    vi.clearAllMocks();
-    vi.restoreAllMocks();
-});
-describe("bridge package publish hooks", () => {
-    it("reads the bridge package name and version from package.json", async () => {
-        await expect(readBridgePackageInfo()).resolves.toMatchObject({
-            name: "aws-runtime-bridge",
-            version: expect.stringMatching(/^\d+\.\d+\.\d+/),
-        });
-    });
-    it("creates a publish payload with GitHub Actions metadata", () => {
-        const payload = createBridgePackagePublishPayload(packageInfo, createPublishEnv(), () => new Date("2026-05-23T12:00:00.000Z"));
-        expect(payload).toEqual({
-            package: "aws-runtime-bridge",
-            version: "1.7.6",
-            repository: "owner/repo",
-            ref: "refs/heads/main",
-            sha: "abc123",
-            runId: "456",
-            runNumber: "789",
-            publishedAt: "2026-05-23T12:00:00.000Z",
-        });
-    });
-    it("signs the exact request body with HMAC SHA-256", () => {
-        const body = JSON.stringify({ package: "aws-runtime-bridge", version: "1.7.6" });
-        const secret = "test-secret";
-        const expectedDigest = createHmac("sha256", secret).update(body, "utf-8").digest("hex");
-        expect(createBridgePublishSignature(body, secret)).toBe(`sha256=${expectedDigest}`);
-    });
-    it("skips notification when both hook URL and secret are absent", async () => {
-        const post = vi.fn();
-        const logger = createLoggerMock();
-        await expect(notifyBridgePackagePublished({
-            env: createPublishEnv(),
-            logger,
-            packageInfo,
-            post,
-        })).resolves.toBe(false);
-        expect(post).not.toHaveBeenCalled();
-        expect(logger.info).toHaveBeenCalledWith("Bridge package publish hook is not configured. Skipping notification.");
-        expect(JSON.stringify(logger)).not.toContain("test-secret");
-    });
-    it("skips notification when only one hook setting is configured", async () => {
-        const post = vi.fn();
-        const logger = createLoggerMock();
-        await expect(notifyBridgePackagePublished({
-            env: createPublishEnv({
-                BRIDGE_PACKAGE_ON_PUBLIC_HOOKS_URL: "https://hooks.example.test/bridge",
-                BRIDGE_PACKAGE_ON_PUBLIC_HOOKS_SECRET: "",
-            }),
-            logger,
-            packageInfo,
-            post,
-        })).resolves.toBe(false);
-        expect(post).not.toHaveBeenCalled();
-        expect(logger.warn).toHaveBeenCalledWith("Bridge package publish hook requires both BRIDGE_PACKAGE_ON_PUBLIC_HOOKS_URL and BRIDGE_PACKAGE_ON_PUBLIC_HOOKS_SECRET. Skipping notification.");
-    });
-    it("sends signed publish notification when hook URL and secret are configured", async () => {
-        const post = vi.fn().mockResolvedValue({ data: { success: true } });
-        const logger = createLoggerMock();
-        const secret = "super-secret-value";
-        const env = createPublishEnv({
-            BRIDGE_PACKAGE_ON_PUBLIC_HOOKS_URL: "https://hooks.example.test/bridge?token=url-token",
-            BRIDGE_PACKAGE_ON_PUBLIC_HOOKS_SECRET: secret,
-        });
-        await expect(notifyBridgePackagePublished({
-            env,
-            logger,
-            packageInfo,
-            now: () => new Date("2026-05-23T12:00:00.000Z"),
-            post,
-        })).resolves.toBe(true);
-        expect(post).toHaveBeenCalledTimes(1);
-        const [url, body, config] = post.mock.calls[0] ?? [];
-        expect(url).toBe("https://hooks.example.test/bridge?token=url-token");
-        expect(typeof body).toBe("string");
-        expect(JSON.parse(body)).toMatchObject({
-            package: "aws-runtime-bridge",
-            version: "1.7.6",
-            publishedAt: "2026-05-23T12:00:00.000Z",
-        });
-        expect(config).toMatchObject({
-            headers: {
-                "Content-Type": "application/json",
-                "X-Bridge-Signature": createBridgePublishSignature(body, secret),
-                "X-Bridge-Timestamp": "1779537600",
-            },
-            timeout: 10_000,
-        });
-        expect(logger.info).toHaveBeenCalledWith("Notifying bridge package publish hook for aws-runtime-bridge@1.7.6 (https://hooks.example.test).");
-        expect(JSON.stringify(logger.info.mock.calls)).not.toContain(secret);
-        expect(JSON.stringify(logger.info.mock.calls)).not.toContain("url-token");
-    });
-    it("surfaces notification failures when hook is configured", async () => {
-        const post = vi.fn().mockRejectedValue(new Error("network unavailable"));
-        await expect(notifyBridgePackagePublished({
-            env: createPublishEnv({
-                BRIDGE_PACKAGE_ON_PUBLIC_HOOKS_URL: "https://hooks.example.test/bridge",
-                BRIDGE_PACKAGE_ON_PUBLIC_HOOKS_SECRET: "test-secret",
-            }),
-            logger: createLoggerMock(),
-            packageInfo,
-            post,
-        })).rejects.toThrow("network unavailable");
-    });
-});

package/dist/services/cc-switch-discovery.test.d.ts

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

package/dist/services/cc-switch-discovery.test.d.ts.map

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

package/dist/services/cc-switch-discovery.test.js

@@ -1,56 +0,0 @@
-import { mkdir, mkdtemp, readFile, readdir, rm, writeFile } from 'node:fs/promises';
-import os from 'node:os';
-import path from 'node:path';
-import { afterEach, beforeEach, describe, expect, it } from 'vitest';
-import { discoverCcSwitchConfiguredItems, loadCcSwitchSdk } from './cc-switch-sdk.js';
-import { getAgentInitRoot } from './instance-state.js';
-import { syncLegacyStateFromSdk } from './instance-init-service.js';
-describe('CC Switch discovery flow', () => {
-    const previousRuntimeHome = process.env.AWS_RUNTIME_HOME_DIR;
-    let runtimeHome = '';
-    let agentId = '';
-    beforeEach(async () => {
-        runtimeHome = await mkdtemp(path.join(os.tmpdir(), 'cc-switch-discovery-runtime-'));
-        agentId = `agent-discovery-${Date.now()}-${Math.random().toString(36).slice(2)}`;
-        process.env.AWS_RUNTIME_HOME_DIR = runtimeHome;
-    });
-    afterEach(async () => {
-        if (previousRuntimeHome === undefined) {
-            delete process.env.AWS_RUNTIME_HOME_DIR;
-        }
-        else {
-            process.env.AWS_RUNTIME_HOME_DIR = previousRuntimeHome;
-        }
-        await rm(runtimeHome, { recursive: true, force: true });
-        if (agentId) {
-            await rm(getAgentInitRoot(agentId), { recursive: true, force: true });
-        }
-    });
-    it('discovers configured MCP and Skill items into instance state without rewriting source app files', async () => {
-        const opencodeConfigPath = path.join(runtimeHome, '.config', 'opencode', 'opencode.json');
-        const codexSkillDir = path.join(runtimeHome, '.codex', 'skills', 'codex-review');
-        const opencodeConfig = {
-            theme: 'dark',
-            mcpServers: {
-                'legacy-opencode': {
-                    type: 'remote',
-                    url: 'http://localhost:9999/sse',
-                },
-            },
-        };
-        await mkdir(path.dirname(opencodeConfigPath), { recursive: true });
-        await writeFile(opencodeConfigPath, JSON.stringify(opencodeConfig, null, 2), 'utf-8');
-        await mkdir(codexSkillDir, { recursive: true });
-        await writeFile(path.join(codexSkillDir, 'SKILL.md'), '---\nname: Codex Review\ndescription: Review code with Codex\n---\n# Skill\n', 'utf-8');
-        const beforeOpencodeRaw = await readFile(opencodeConfigPath, 'utf-8');
-        const beforeCodexEntries = await readdir(path.dirname(codexSkillDir));
-        const sdk = await loadCcSwitchSdk(agentId);
-        const imported = await discoverCcSwitchConfiguredItems(sdk);
-        const synced = await syncLegacyStateFromSdk(agentId, sdk);
-        expect(imported).toEqual({ mcpServers: 1, skills: 1 });
-        expect(synced.state.mcpServers.some((item) => item.name === 'legacy-opencode')).toBe(true);
-        expect(synced.state.skills.some((item) => item.name === 'Codex Review')).toBe(true);
-        expect(await readFile(opencodeConfigPath, 'utf-8')).toBe(beforeOpencodeRaw);
-        expect(await readdir(path.dirname(codexSkillDir))).toEqual(beforeCodexEntries);
-    });
-});

package/dist/services/cli-commands.test.d.ts

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

package/dist/services/cli-commands.test.d.ts.map

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

package/dist/services/cli-commands.test.js

@@ -1,230 +0,0 @@
-import { existsSync, 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 { createSystemdUnitContent, handleCliCommand, readPackageVersion, } from "./cli-commands.js";
-const tempRoots = [];
-function createPackageRoot(version = "9.8.7") {
-    const root = mkdtempSync(path.join(os.tmpdir(), "aws-bridge-cli-"));
-    tempRoots.push(root);
-    mkdirSync(root, { recursive: true });
-    writeFileSync(path.join(root, "package.json"), JSON.stringify({ name: "aws-runtime-bridge", version }), "utf-8");
-    return root;
-}
-function createServiceUnitPath() {
-    const root = mkdtempSync(path.join(os.tmpdir(), "aws-bridge-service-"));
-    tempRoots.push(root);
-    return path.join(root, "systemd", "awsb.service");
-}
-function quotedSystemdArg(value) {
-    return `"${value.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
-}
-afterEach(() => {
-    for (const root of tempRoots.splice(0)) {
-        rmSync(root, { recursive: true, force: true });
-    }
-});
-describe("cli commands", () => {
-    it("reads package version from package root", () => {
-        const packageRoot = createPackageRoot("1.2.3");
-        expect(readPackageVersion(packageRoot)).toBe("1.2.3");
-    });
-    it("prints version for -v", async () => {
-        const packageRoot = createPackageRoot("1.2.3");
-        const output = [];
-        const result = await handleCliCommand({
-            argv: ["-v"],
-            packageRoot,
-            stdout: (message) => output.push(message),
-        });
-        expect(result).toEqual({ handled: true, exitCode: 0 });
-        expect(output).toEqual(["aws-runtime-bridge 1.2.3"]);
-    });
-    it("prints version for version command", async () => {
-        const packageRoot = createPackageRoot("2.0.0");
-        const output = [];
-        const result = await handleCliCommand({
-            argv: ["version"],
-            packageRoot,
-            stdout: (message) => output.push(message),
-        });
-        expect(result).toEqual({ handled: true, exitCode: 0 });
-        expect(output).toEqual(["aws-runtime-bridge 2.0.0"]);
-    });
-    it("runs npm global update for update command", async () => {
-        const output = [];
-        const commands = [];
-        const result = await handleCliCommand({
-            argv: ["update"],
-            stdout: (message) => output.push(message),
-            runCommand: (command, args) => {
-                commands.push({ command, args });
-                return { status: 0 };
-            },
-        });
-        expect(result).toEqual({ handled: true, exitCode: 0 });
-        expect(commands).toEqual([
-            { command: "npm", args: ["install", "-g", "aws-runtime-bridge@latest"] },
-        ]);
-        expect(output.at(-1)).toBe("[runtime-bridge] 更新完成。请重新运行 awsb -v 查看当前版本。");
-    });
-    it("returns npm exit code when update fails", async () => {
-        const errors = [];
-        const result = await handleCliCommand({
-            argv: ["update"],
-            stdout: () => undefined,
-            stderr: (message) => errors.push(message),
-            runCommand: () => ({ status: 7 }),
-        });
-        expect(result).toEqual({ handled: true, exitCode: 7 });
-        expect(errors).toEqual(["[runtime-bridge] 更新失败，npm 退出码: 7"]);
-    });
-    it("runs interactive config command", async () => {
-        const result = await handleCliCommand({
-            argv: ["config"],
-            configure: async () => "configured",
-        });
-        expect(result).toEqual({ handled: true, exitCode: 0 });
-    });
-    it("returns non-zero when config command fails", async () => {
-        const result = await handleCliCommand({
-            argv: ["config"],
-            configure: async () => "failed",
-        });
-        expect(result).toEqual({ handled: true, exitCode: 1 });
-    });
-    it("creates a systemd unit that starts the current executable with setup skipped", () => {
-        const executablePath = "/opt/aws-runtime-bridge/dist/index.js";
-        const unit = createSystemdUnitContent(executablePath);
-        expect(unit).toContain("Description=AgentsWorkStudio Runtime Bridge");
-        expect(unit).toContain("Environment=AWS_BRIDGE_SKIP_SETUP=true");
-        expect(unit).toContain(`ExecStart=${quotedSystemdArg(process.execPath)} ${quotedSystemdArg(executablePath)}`);
-        expect(unit).toContain("Restart=on-failure");
-        expect(unit).toContain("WantedBy=multi-user.target");
-    });
-    it("installs service, enables autostart, and starts when inactive", async () => {
-        const output = [];
-        const commands = [];
-        const serviceUnitPath = createServiceUnitPath();
-        const executablePath = "/usr/local/bin/awsb";
-        const result = await handleCliCommand({
-            argv: ["service", "install"],
-            platform: "linux",
-            serviceUnitPath,
-            executablePath,
-            stdout: (message) => output.push(message),
-            runCommand: (command, args) => {
-                commands.push({ command, args });
-                if (args[0] === "is-active") {
-                    return { status: 3 };
-                }
-                return { status: 0 };
-            },
-        });
-        expect(result).toEqual({ handled: true, exitCode: 0 });
-        expect(readFileSync(serviceUnitPath, "utf-8")).toContain(`ExecStart=${quotedSystemdArg(process.execPath)} ${quotedSystemdArg(executablePath)}`);
-        expect(commands).toEqual([
-            { command: "systemctl", args: ["daemon-reload"] },
-            { command: "systemctl", args: ["enable", "awsb.service"] },
-            { command: "systemctl", args: ["is-active", "--quiet", "awsb.service"] },
-            { command: "systemctl", args: ["start", "awsb.service"] },
-        ]);
-        expect(output.at(-1)).toBe("[runtime-bridge] awsb systemd 服务已安装、已启用开机自启并已启动。");
-    });
-    it("does not start service during install when it is already active", async () => {
-        const commands = [];
-        const serviceUnitPath = createServiceUnitPath();
-        const result = await handleCliCommand({
-            argv: ["service", "install"],
-            platform: "linux",
-            serviceUnitPath,
-            executablePath: "/usr/local/bin/awsb",
-            runCommand: (command, args) => {
-                commands.push({ command, args });
-                return { status: 0 };
-            },
-        });
-        expect(result).toEqual({ handled: true, exitCode: 0 });
-        expect(commands).toEqual([
-            { command: "systemctl", args: ["daemon-reload"] },
-            { command: "systemctl", args: ["enable", "awsb.service"] },
-            { command: "systemctl", args: ["is-active", "--quiet", "awsb.service"] },
-        ]);
-    });
-    it("uninstalls service by stopping, disabling, removing unit, and reloading systemd", async () => {
-        const output = [];
-        const commands = [];
-        const serviceUnitPath = createServiceUnitPath();
-        mkdirSync(path.dirname(serviceUnitPath), { recursive: true });
-        writeFileSync(serviceUnitPath, "unit", "utf-8");
-        const result = await handleCliCommand({
-            argv: ["service", "uninstall"],
-            platform: "linux",
-            serviceUnitPath,
-            stdout: (message) => output.push(message),
-            runCommand: (command, args) => {
-                commands.push({ command, args });
-                return { status: 0 };
-            },
-        });
-        expect(result).toEqual({ handled: true, exitCode: 0 });
-        expect(existsSync(serviceUnitPath)).toBe(false);
-        expect(commands).toEqual([
-            { command: "systemctl", args: ["is-active", "--quiet", "awsb.service"] },
-            { command: "systemctl", args: ["stop", "awsb.service"] },
-            { command: "systemctl", args: ["disable", "awsb.service"] },
-            { command: "systemctl", args: ["daemon-reload"] },
-        ]);
-        expect(output.at(-1)).toBe("[runtime-bridge] awsb systemd 服务已卸载。");
-    });
-    it("tolerates uninstall when service is inactive and unit is absent", async () => {
-        const output = [];
-        const commands = [];
-        const serviceUnitPath = createServiceUnitPath();
-        const result = await handleCliCommand({
-            argv: ["service", "uninstall"],
-            platform: "linux",
-            serviceUnitPath,
-            stdout: (message) => output.push(message),
-            runCommand: (command, args) => {
-                commands.push({ command, args });
-                if (args[0] === "is-active" || args[0] === "disable") {
-                    return { status: 1 };
-                }
-                return { status: 0 };
-            },
-        });
-        expect(result).toEqual({ handled: true, exitCode: 0 });
-        expect(commands).toEqual([
-            { command: "systemctl", args: ["is-active", "--quiet", "awsb.service"] },
-            { command: "systemctl", args: ["disable", "awsb.service"] },
-            { command: "systemctl", args: ["daemon-reload"] },
-        ]);
-        expect(output).toContain("[runtime-bridge] awsb systemd unit 不存在，跳过删除。");
-    });
-    it("fails service commands clearly on non-linux platforms", async () => {
-        const errors = [];
-        const result = await handleCliCommand({
-            argv: ["service", "install"],
-            platform: "win32",
-            stderr: (message) => errors.push(message),
-        });
-        expect(result).toEqual({ handled: true, exitCode: 1 });
-        expect(errors).toEqual([
-            "[runtime-bridge] service 命令仅支持 Linux systemd 环境。",
-        ]);
-    });
-    it("prints service help for missing subcommand", async () => {
-        const output = [];
-        const result = await handleCliCommand({
-            argv: ["service"],
-            stdout: (message) => output.push(message),
-        });
-        expect(result).toEqual({ handled: true, exitCode: 1 });
-        expect(output).toEqual(["Usage: awsb service <install|uninstall>"]);
-    });
-    it("does not handle normal startup arguments", async () => {
-        const result = await handleCliCommand({ argv: [] });
-        expect(result).toEqual({ handled: false, exitCode: 0 });
-    });
-});

package/dist/services/instance-init-service.test.d.ts

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

package/dist/services/instance-init-service.test.d.ts.map

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

package/dist/services/instance-init-service.test.js

@@ -1,140 +0,0 @@
-import { promises as fs } from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-const detectToolStatusesMock = vi.fn();
-const ensureToolsInstalledMock = vi.fn();
-const installSkillPackageToSdkMock = vi.fn();
-const runCcSwitchAdapterMock = vi.fn();
-vi.mock('./tool-installer.js', () => ({
-    detectToolStatuses: detectToolStatusesMock,
-    ensureToolsInstalled: ensureToolsInstalledMock,
-}));
-vi.mock('./cc-switch-sdk.js', () => ({
-    loadCcSwitchSdk: vi.fn(async () => activeSdk),
-    runCcSwitchAdapter: runCcSwitchAdapterMock,
-    toSdkAppsFromEnabledTools: (enabledTools) => {
-        const tools = Array.isArray(enabledTools) ? enabledTools : [];
-        return {
-            claude: false,
-            acode: false,
-            claudecode: tools.includes('claude') || tools.includes('claudecode'),
-            codex: tools.includes('codex'),
-            gemini: tools.includes('gemini'),
-            opencode: tools.includes('opencode'),
-            openclaw: tools.includes('openclaw'),
-        };
-    },
-}));
-vi.mock('../utils/file-utils.js', async (importOriginal) => {
-    const original = await importOriginal();
-    return {
-        ...original,
-        installSkillPackageToSdk: installSkillPackageToSdkMock,
-    };
-});
-class MockSdk {
-    constructor() {
-        this.createdMcpInputs = [];
-        this.installedSkills = [];
-        this.mcpServers = [];
-    }
-    getAllSkills() {
-        return this.installedSkills;
-    }
-    getAllMcpServers() {
-        return this.mcpServers;
-    }
-    async createMcpServer(input) {
-        this.createdMcpInputs.push({ name: input.name, apps: input.apps });
-        const server = {
-            id: `mcp-${this.mcpServers.length + 1}`,
-            name: input.name,
-            server: input.server,
-            apps: input.apps,
-        };
-        this.mcpServers.push(server);
-        return server;
-    }
-    async updateMcpServer(id, input) {
-        const existing = this.mcpServers.find((server) => server.id === id);
-        if (!existing) {
-            throw new Error(`missing mcp ${id}`);
-        }
-        if (input.apps) {
-            existing.apps = input.apps;
-        }
-        if (input.server) {
-            existing.server = input.server;
-        }
-        return existing;
-    }
-}
-let activeSdk;
-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('initInstance enabled tool initialization', () => {
-    const originalRuntimeHomeDir = process.env.AWS_RUNTIME_HOME_DIR;
-    let runtimeHomeDir;
-    beforeEach(async () => {
-        runtimeHomeDir = path.join(os.tmpdir(), `aws-init-enabled-tools-${Date.now()}`);
-        process.env.AWS_RUNTIME_HOME_DIR = runtimeHomeDir;
-        activeSdk = new MockSdk();
-        vi.clearAllMocks();
-        runCcSwitchAdapterMock.mockResolvedValue({ ok: true, snapshot: { skills: 0, mcpServers: 0 } });
-        installSkillPackageToSdkMock.mockImplementation(async (_sdk, skillPackage, _skillDir, apps) => {
-            const installed = {
-                id: 'skill-1',
-                name: String(skillPackage.skillName || 'demo-skill'),
-                directory: '/demo-skill',
-                apps,
-                installedAt: Date.now(),
-            };
-            activeSdk.installedSkills.push(installed);
-            return installed;
-        });
-    });
-    afterEach(async () => {
-        if (originalRuntimeHomeDir === undefined) {
-            delete process.env.AWS_RUNTIME_HOME_DIR;
-        }
-        else {
-            process.env.AWS_RUNTIME_HOME_DIR = originalRuntimeHomeDir;
-        }
-        await fs.rm(runtimeHomeDir, { recursive: true, force: true });
-    });
-    it('persists requested tools but configures MCP and skills only for installed tools', async () => {
-        detectToolStatusesMock.mockResolvedValue({
-            claude: status('claude', true),
-            opencode: status('opencode', false),
-            codex: status('codex', false),
-        });
-        const { initInstance } = await import('./instance-init-service.js');
-        const result = await initInstance('agent-installed-only', runtimeHomeDir, {
-            ccSwitchEnabledTools: ['claude', 'opencode', 'codex'],
-            skillPackages: [{ skillName: 'demo-skill', downloadUrl: 'https://example.com/skill.zip' }],
-            mcpServers: [{ name: 'aws-mcp', command: 'node', args: ['server.js'] }],
-        });
-        expect(ensureToolsInstalledMock).not.toHaveBeenCalled();
-        expect(result.enabledTools).toEqual(['claude', 'opencode', 'codex']);
-        expect(result.ok).toBe(true);
-        expect(installSkillPackageToSdkMock).toHaveBeenCalledWith(activeSdk, expect.objectContaining({ skillName: 'demo-skill' }), expect.any(String), expect.objectContaining({ claudecode: true, opencode: false, codex: false }));
-        expect(activeSdk.createdMcpInputs).toEqual([
-            {
-                name: 'aws-mcp',
-                apps: expect.objectContaining({ claudecode: true, opencode: false, codex: false }),
-            },
-        ]);
-        const statePath = path.join(runtimeHomeDir, '.aws-bridge', 'instances', 'agent-installed-only', 'state.json');
-        const state = JSON.parse(await fs.readFile(statePath, 'utf-8'));
-        expect(state.enabledTools).toEqual(['claude', 'opencode', 'codex']);
-    });
-});

package/dist/services/instance-state.test.d.ts

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

package/dist/services/instance-state.test.d.ts.map

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