aws-runtime-bridge 1.9.33 → 1.9.40

package/dist/services/workspace-watch.test.js

@@ -1,38 +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 } from 'vitest';
-import { getWorkspaceWatchCountForTests, unwatchWorkspaceFile, watchWorkspaceFile, } from './workspace-watch.js';
-describe('workspace file watch service', () => {
-    let tempRoot = '';
-    let workspacePath = '';
-    let filePath = '';
-    beforeEach(async () => {
-        tempRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'aws-workspace-watch-'));
-        workspacePath = path.join(tempRoot, 'workspace');
-        filePath = path.join(workspacePath, 'demo.docx');
-        await fs.mkdir(workspacePath, { recursive: true });
-        await fs.writeFile(filePath, 'watch me', 'utf-8');
-    });
-    afterEach(async () => {
-        await unwatchWorkspaceFile({ workspacePath, filePath }).catch(() => undefined);
-        await unwatchWorkspaceFile({ workspacePath, filePath }).catch(() => undefined);
-        await fs.rm(tempRoot, { recursive: true, force: true, maxRetries: 3, retryDelay: 50 });
-    });
-    it('unwatches a deleted file by its original workspace path key', async () => {
-        await watchWorkspaceFile({ workspacePath, filePath });
-        expect(getWorkspaceWatchCountForTests()).toBe(1);
-        await fs.rm(filePath);
-        await unwatchWorkspaceFile({ workspacePath, filePath });
-        expect(getWorkspaceWatchCountForTests()).toBe(0);
-    });
-    it('keeps shared watchers until all references unwatch', async () => {
-        await watchWorkspaceFile({ workspacePath, filePath });
-        await watchWorkspaceFile({ workspacePath, filePath });
-        expect(getWorkspaceWatchCountForTests()).toBe(1);
-        await unwatchWorkspaceFile({ workspacePath, filePath });
-        expect(getWorkspaceWatchCountForTests()).toBe(1);
-        await unwatchWorkspaceFile({ workspacePath, filePath });
-        expect(getWorkspaceWatchCountForTests()).toBe(0);
-    });
-});

package/dist/utils/file-utils.test.d.ts

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

package/dist/utils/file-utils.test.d.ts.map

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

package/dist/utils/file-utils.test.js

@@ -1,244 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import { promises as fs } from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import { atomicWriteJsonFile, ensureDir, escapePowerShellLiteral, resolveSkillSourceDirFromExtractRoot, stringifyStableJson, toSdkAppsFromEnabledTools, resolveSkillSourceDir, } from './file-utils.js';
-// Mock axios for download tests
-vi.mock('axios', () => ({
-    default: {
-        get: vi.fn(),
-        post: vi.fn(),
-    },
-}));
-// Mock config
-vi.mock('../config.js', () => ({
-    schedulerBaseUrl: 'http://localhost:8080',
-}));
-vi.mock('../services/runtime-binding.js', () => ({
-    getRuntimeAccessToken: vi.fn(() => 'test-token'),
-}));
-describe('file-utils', () => {
-    describe('ensureDir', () => {
-        const tempDir = path.join(os.tmpdir(), `aws-file-utils-test-${Date.now()}`);
-        afterEach(async () => {
-            try {
-                await fs.rm(tempDir, { recursive: true, force: true });
-            }
-            catch {
-                // ignore
-            }
-        });
-        it('should create directory if not exists', async () => {
-            const result = await ensureDir(tempDir);
-            expect(result).toBe(tempDir);
-            const stat = await fs.stat(tempDir);
-            expect(stat.isDirectory()).toBe(true);
-        });
-        it('should create nested directories', async () => {
-            const nestedDir = path.join(tempDir, 'level1', 'level2', 'level3');
-            const result = await ensureDir(nestedDir);
-            expect(result).toBe(nestedDir);
-            const stat = await fs.stat(nestedDir);
-            expect(stat.isDirectory()).toBe(true);
-        });
-        it('should return path if directory already exists', async () => {
-            await fs.mkdir(tempDir, { recursive: true });
-            const result = await ensureDir(tempDir);
-            expect(result).toBe(tempDir);
-        });
-    });
-    describe('atomicWriteJsonFile', () => {
-        const tempDir = path.join(os.tmpdir(), `aws-file-utils-json-test-${Date.now()}`);
-        afterEach(async () => {
-            await fs.rm(tempDir, { recursive: true, force: true }).catch(() => undefined);
-        });
-        it('should write stable sorted json for deterministic config files', async () => {
-            const filePath = path.join(tempDir, 'config.json');
-            await atomicWriteJsonFile(filePath, {
-                z: 1,
-                nested: { b: true, a: false },
-                array: [{ d: 4, c: 3 }],
-            });
-            expect(await fs.readFile(filePath, 'utf-8')).toBe('{\n' +
-                '  "array": [\n' +
-                '    {\n' +
-                '      "c": 3,\n' +
-                '      "d": 4\n' +
-                '    }\n' +
-                '  ],\n' +
-                '  "nested": {\n' +
-                '    "a": false,\n' +
-                '    "b": true\n' +
-                '  },\n' +
-                '  "z": 1\n' +
-                '}\n');
-        });
-    });
-    describe('stringifyStableJson', () => {
-        it('should preserve array order while sorting object keys', () => {
-            expect(stringifyStableJson([{ b: 2, a: 1 }, { d: 4, c: 3 }])).toBe('[\n' +
-                '  {\n' +
-                '    "a": 1,\n' +
-                '    "b": 2\n' +
-                '  },\n' +
-                '  {\n' +
-                '    "c": 3,\n' +
-                '    "d": 4\n' +
-                '  }\n' +
-                ']\n');
-        });
-    });
-    describe('escapePowerShellLiteral', () => {
-        it('should escape single quotes by doubling them', () => {
-            expect(escapePowerShellLiteral("test'value")).toBe("test''value");
-        });
-        it('should handle multiple single quotes', () => {
-            expect(escapePowerShellLiteral("a'b'c")).toBe("a''b''c");
-        });
-        it('should return empty string for empty input', () => {
-            expect(escapePowerShellLiteral('')).toBe('');
-        });
-        it('should handle null/undefined gracefully', () => {
-            expect(escapePowerShellLiteral(null)).toBe('');
-            expect(escapePowerShellLiteral(undefined)).toBe('');
-        });
-        it('should not modify strings without quotes', () => {
-            expect(escapePowerShellLiteral('normal path')).toBe('normal path');
-        });
-        it('should handle path with special characters', () => {
-            expect(escapePowerShellLiteral("C:\\Users\\Test's Folder")).toBe("C:\\Users\\Test''s Folder");
-        });
-    });
-    describe('resolveSkillSourceDirFromExtractRoot', () => {
-        const tempRoot = path.join(os.tmpdir(), `aws-skill-extract-test-${Date.now()}`);
-        beforeEach(async () => {
-            await fs.mkdir(tempRoot, { recursive: true });
-        });
-        afterEach(async () => {
-            try {
-                await fs.rm(tempRoot, { recursive: true, force: true });
-            }
-            catch {
-                // ignore
-            }
-        });
-        it('should return subdirectory when single visible directory exists', async () => {
-            const subDir = path.join(tempRoot, 'skill-package');
-            await fs.mkdir(subDir, { recursive: true });
-            await fs.writeFile(path.join(subDir, 'skill.md'), 'test', 'utf-8');
-            const result = await resolveSkillSourceDirFromExtractRoot(tempRoot);
-            expect(result).toBe(subDir);
-        });
-        it('should return root when multiple visible directories exist', async () => {
-            const subDir1 = path.join(tempRoot, 'dir1');
-            const subDir2 = path.join(tempRoot, 'dir2');
-            await fs.mkdir(subDir1, { recursive: true });
-            await fs.mkdir(subDir2, { recursive: true });
-            const result = await resolveSkillSourceDirFromExtractRoot(tempRoot);
-            expect(result).toBe(tempRoot);
-        });
-        it('should return root when files exist at root level', async () => {
-            await fs.writeFile(path.join(tempRoot, 'skill.md'), 'test', 'utf-8');
-            await fs.writeFile(path.join(tempRoot, 'README.md'), 'readme', 'utf-8');
-            const result = await resolveSkillSourceDirFromExtractRoot(tempRoot);
-            expect(result).toBe(tempRoot);
-        });
-        it('should ignore hidden directories (starting with dot)', async () => {
-            const visibleDir = path.join(tempRoot, 'visible');
-            const hiddenDir = path.join(tempRoot, '.hidden');
-            await fs.mkdir(visibleDir, { recursive: true });
-            await fs.mkdir(hiddenDir, { recursive: true });
-            const result = await resolveSkillSourceDirFromExtractRoot(tempRoot);
-            expect(result).toBe(visibleDir);
-        });
-        it('should return root when no visible entries exist', async () => {
-            const hiddenDir = path.join(tempRoot, '.hidden');
-            await fs.mkdir(hiddenDir, { recursive: true });
-            const result = await resolveSkillSourceDirFromExtractRoot(tempRoot);
-            expect(result).toBe(tempRoot);
-        });
-    });
-    describe('toSdkAppsFromEnabledTools', () => {
-        it('should map enabled tools to app flags', () => {
-            const result = toSdkAppsFromEnabledTools(['claude', 'opencode']);
-            expect(result.claude).toBe(true);
-            expect(result.opencode).toBe(true);
-            expect(result.codex).toBe(false);
-            expect(result.gemini).toBe(false);
-        });
-        it('should handle all known tools', () => {
-            const result = toSdkAppsFromEnabledTools([
-                'claude',
-                'claudecode',
-                'codex',
-                'gemini',
-                'opencode',
-                'openclaw',
-            ]);
-            expect(result.claude).toBe(true);
-            expect(result.codex).toBe(true);
-            expect(result.gemini).toBe(true);
-            expect(result.opencode).toBe(true);
-            expect(result.openclaw).toBe(true);
-        });
-        it('should return all false for empty array', () => {
-            const result = toSdkAppsFromEnabledTools([]);
-            expect(result.claude).toBe(false);
-            expect(result.codex).toBe(false);
-            expect(result.gemini).toBe(false);
-            expect(result.opencode).toBe(false);
-            expect(result.openclaw).toBe(false);
-        });
-        it('should handle null/undefined input', () => {
-            const resultNull = toSdkAppsFromEnabledTools(null);
-            const resultUndefined = toSdkAppsFromEnabledTools(undefined);
-            expect(resultNull.claude).toBe(false);
-            expect(resultUndefined.claude).toBe(false);
-        });
-        it('should ignore unknown tools', () => {
-            const result = toSdkAppsFromEnabledTools(['unknown-tool', 'claude']);
-            expect(result.claude).toBe(true);
-        });
-    });
-    describe('resolveSkillSourceDir', () => {
-        it('should return sourceDir when available', () => {
-            const skill = { sourceDir: '/path/to/source' };
-            expect(resolveSkillSourceDir(skill)).toBe(path.resolve('/path/to/source'));
-        });
-        it('should fallback to directory when sourceDir not available', () => {
-            const skill = { directory: '/path/to/directory' };
-            expect(resolveSkillSourceDir(skill)).toBe(path.resolve('/path/to/directory'));
-        });
-        it('should fallback to filePath when sourceDir and directory not available', () => {
-            const skill = { filePath: '/path/to/file.yaml' };
-            expect(resolveSkillSourceDir(skill)).toBe(path.resolve('/path/to/file.yaml'));
-        });
-        it('should prioritize sourceDir over directory and filePath', () => {
-            const skill = {
-                sourceDir: '/source',
-                directory: '/directory',
-                filePath: '/file',
-            };
-            expect(resolveSkillSourceDir(skill)).toBe(path.resolve('/source'));
-        });
-        it('should throw error when no path is available', () => {
-            const skill = {};
-            expect(() => resolveSkillSourceDir(skill)).toThrow('skill.sourceDir is required');
-        });
-        it('should throw error when skill is null', () => {
-            expect(() => resolveSkillSourceDir(null)).toThrow('skill.sourceDir is required');
-        });
-        it('should throw error when path is empty string', () => {
-            const skill = { sourceDir: '' };
-            expect(() => resolveSkillSourceDir(skill)).toThrow('skill.sourceDir is required');
-        });
-        it('should throw error when path is whitespace only', () => {
-            const skill = { sourceDir: '   ' };
-            expect(() => resolveSkillSourceDir(skill)).toThrow('skill.sourceDir is required');
-        });
-        it('should trim whitespace from path', () => {
-            const skill = { sourceDir: '  /path/to/source  ' };
-            expect(resolveSkillSourceDir(skill)).toBe(path.resolve('/path/to/source'));
-        });
-    });
-});

package/dist/utils/logger.test.d.ts

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

package/dist/utils/logger.test.d.ts.map

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

package/dist/utils/logger.test.js

@@ -1,93 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import { Logger, createLogger, logger } from './logger';
-describe('Logger', () => {
-    let consoleSpy;
-    beforeEach(() => {
-        consoleSpy = {
-            debug: vi.spyOn(console, 'debug').mockImplementation(() => { }),
-            info: vi.spyOn(console, 'info').mockImplementation(() => { }),
-            warn: vi.spyOn(console, 'warn').mockImplementation(() => { }),
-            error: vi.spyOn(console, 'error').mockImplementation(() => { }),
-        };
-    });
-    afterEach(() => {
-        vi.restoreAllMocks();
-    });
-    describe('log levels', () => {
-        it('should not log debug when level is info', () => {
-            const log = new Logger({ level: 'info' });
-            log.debug('test message');
-            expect(consoleSpy.debug).not.toHaveBeenCalled();
-        });
-        it('should log info when level is info', () => {
-            const log = new Logger({ level: 'info' });
-            log.info('test message');
-            expect(consoleSpy.info).toHaveBeenCalled();
-        });
-        it('should log warn when level is info', () => {
-            const log = new Logger({ level: 'info' });
-            log.warn('test message');
-            expect(consoleSpy.warn).toHaveBeenCalled();
-        });
-        it('should log error when level is info', () => {
-            const log = new Logger({ level: 'info' });
-            log.error('test message');
-            expect(consoleSpy.error).toHaveBeenCalled();
-        });
-        it('should log all levels when level is debug', () => {
-            const log = new Logger({ level: 'debug' });
-            log.debug('debug message');
-            log.info('info message');
-            log.warn('warn message');
-            log.error('error message');
-            expect(consoleSpy.debug).toHaveBeenCalled();
-            expect(consoleSpy.info).toHaveBeenCalled();
-            expect(consoleSpy.warn).toHaveBeenCalled();
-            expect(consoleSpy.error).toHaveBeenCalled();
-        });
-    });
-    describe('prefix', () => {
-        it('should include prefix in log message', () => {
-            const log = new Logger({ level: 'info', prefix: 'test-module' });
-            log.info('test message');
-            expect(consoleSpy.info).toHaveBeenCalledWith(expect.stringContaining('[test-module]'));
-        });
-    });
-    describe('timestamp', () => {
-        it('should include timestamp by default', () => {
-            const log = new Logger({ level: 'info' });
-            log.info('test message');
-            expect(consoleSpy.info).toHaveBeenCalledWith(expect.stringMatching(/\[\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}/));
-        });
-    });
-    describe('child logger', () => {
-        it('should create child logger with combined prefix', () => {
-            const parentLog = new Logger({ level: 'info', prefix: 'parent' });
-            const childLog = parentLog.child('child');
-            childLog.info('test message');
-            expect(consoleSpy.info).toHaveBeenCalledWith(expect.stringContaining('[parent:child]'));
-        });
-    });
-    describe('object formatting', () => {
-        it('should format objects in log message', () => {
-            const log = new Logger({ level: 'info' });
-            log.info('test', { key: 'value' });
-            expect(consoleSpy.info).toHaveBeenCalledWith(expect.stringContaining('"key"'));
-        });
-    });
-});
-describe('createLogger', () => {
-    it('should create logger with prefix', () => {
-        const log = createLogger('test-prefix');
-        expect(log).toBeInstanceOf(Logger);
-    });
-});
-describe('default logger', () => {
-    it('should export logger methods', () => {
-        expect(typeof logger.debug).toBe('function');
-        expect(typeof logger.info).toBe('function');
-        expect(typeof logger.warn).toBe('function');
-        expect(typeof logger.error).toBe('function');
-        expect(typeof logger.child).toBe('function');
-    });
-});

package/dist/utils/sdk-package-loader.test.d.ts

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

package/dist/utils/sdk-package-loader.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"sdk-package-loader.test.d.ts","sourceRoot":"","sources":["../../src/utils/sdk-package-loader.test.ts"],"names":[],"mappings":""}

package/dist/utils/sdk-package-loader.test.js

@@ -1,84 +0,0 @@
-import { mkdir, mkdtemp, rm, writeFile } from 'node:fs/promises';
-import os from 'node:os';
-import path from 'node:path';
-import { afterEach, describe, expect, it } from 'vitest';
-import { resolveBridgePackageEntryPath } from './sdk-package-loader.js';
-const tempRoots = [];
-afterEach(async () => {
-    await Promise.all(tempRoots.splice(0).map((root) => rm(root, { recursive: true, force: true })));
-});
-async function createTempPackageRoot() {
-    const root = await mkdtemp(path.join(os.tmpdir(), 'aws-sdk-package-loader-'));
-    tempRoots.push(root);
-    return root;
-}
-describe('sdk package loader', () => {
-    it('resolves package exports instead of assuming a root index.js file', async () => {
-        const packageRoot = await createTempPackageRoot();
-        const packageDirectory = path.join(packageRoot, 'node_modules', '@opencode-ai', 'sdk');
-        await mkdir(path.join(packageDirectory, 'dist'), { recursive: true });
-        await writeFile(path.join(packageDirectory, 'package.json'), JSON.stringify({
-            name: '@opencode-ai/sdk',
-            type: 'module',
-            exports: {
-                '.': {
-                    import: './dist/index.js',
-                    types: './dist/index.d.ts',
-                },
-            },
-        }));
-        await writeFile(path.join(packageDirectory, 'dist', 'index.js'), 'export const ok = true;');
-        await expect(resolveBridgePackageEntryPath('@opencode-ai/sdk', packageRoot)).resolves.toBe(path.join(packageDirectory, 'dist', 'index.js'));
-    });
-    it('resolves default conditional exports', async () => {
-        const packageRoot = await createTempPackageRoot();
-        const packageDirectory = path.join(packageRoot, 'node_modules', 'default-only-sdk');
-        await mkdir(path.join(packageDirectory, 'dist'), { recursive: true });
-        await writeFile(path.join(packageDirectory, 'package.json'), JSON.stringify({ exports: { '.': { default: './dist/default.js' } } }));
-        await writeFile(path.join(packageDirectory, 'dist', 'default.js'), 'export const ok = true;');
-        await expect(resolveBridgePackageEntryPath('default-only-sdk', packageRoot)).resolves.toBe(path.join(packageDirectory, 'dist', 'default.js'));
-    });
-    it('resolves Claude Agent SDK default export to sdk.mjs', async () => {
-        const packageRoot = await createTempPackageRoot();
-        const packageDirectory = path.join(packageRoot, 'node_modules', '@anthropic-ai', 'claude-agent-sdk');
-        await mkdir(packageDirectory, { recursive: true });
-        await writeFile(path.join(packageDirectory, 'package.json'), JSON.stringify({
-            name: '@anthropic-ai/claude-agent-sdk',
-            type: 'module',
-            main: 'sdk.mjs',
-            exports: {
-                '.': {
-                    types: './sdk.d.ts',
-                    default: './sdk.mjs',
-                },
-            },
-        }));
-        await writeFile(path.join(packageDirectory, 'sdk.mjs'), 'export const query = () => {};');
-        await expect(resolveBridgePackageEntryPath('@anthropic-ai/claude-agent-sdk', packageRoot)).resolves.toBe(path.join(packageDirectory, 'sdk.mjs'));
-    });
-    it('falls back to module when exports is absent', async () => {
-        const packageRoot = await createTempPackageRoot();
-        const packageDirectory = path.join(packageRoot, 'node_modules', 'module-sdk');
-        await mkdir(path.join(packageDirectory, 'esm'), { recursive: true });
-        await writeFile(path.join(packageDirectory, 'package.json'), JSON.stringify({ module: './esm/index.js' }));
-        await writeFile(path.join(packageDirectory, 'esm', 'index.js'), 'export const ok = true;');
-        await expect(resolveBridgePackageEntryPath('module-sdk', packageRoot)).resolves.toBe(path.join(packageDirectory, 'esm', 'index.js'));
-    });
-    it('falls back to main when exports and module are absent', async () => {
-        const packageRoot = await createTempPackageRoot();
-        const packageDirectory = path.join(packageRoot, 'node_modules', 'main-sdk');
-        await mkdir(path.join(packageDirectory, 'lib'), { recursive: true });
-        await writeFile(path.join(packageDirectory, 'package.json'), JSON.stringify({ main: './lib/main.js' }));
-        await writeFile(path.join(packageDirectory, 'lib', 'main.js'), 'export const ok = true;');
-        await expect(resolveBridgePackageEntryPath('main-sdk', packageRoot)).resolves.toBe(path.join(packageDirectory, 'lib', 'main.js'));
-    });
-    it('rejects when the resolved package entry is missing', async () => {
-        const packageRoot = await createTempPackageRoot();
-        const packageDirectory = path.join(packageRoot, 'node_modules', 'broken-sdk');
-        await mkdir(packageDirectory, { recursive: true });
-        await writeFile(path.join(packageDirectory, 'package.json'), JSON.stringify({ exports: './dist/missing.js' }));
-        await expect(resolveBridgePackageEntryPath('broken-sdk', packageRoot)).rejects.toMatchObject({
-            code: 'ENOENT',
-        });
-    });
-});

package/dist/utils/validation.test.d.ts

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

package/dist/utils/validation.test.d.ts.map

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

package/dist/utils/validation.test.js

@@ -1,88 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { parseBoolean, ensureEnabledTools } from './validation';
-describe('parseBoolean', () => {
-    describe('true values', () => {
-        it('should return true for "true"', () => {
-            expect(parseBoolean('true')).toBe(true);
-        });
-        it('should return true for "TRUE"', () => {
-            expect(parseBoolean('TRUE')).toBe(true);
-        });
-        it('should return true for "1"', () => {
-            expect(parseBoolean('1')).toBe(true);
-        });
-        it('should return true for "yes"', () => {
-            expect(parseBoolean('yes')).toBe(true);
-        });
-        it('should return true for boolean true', () => {
-            expect(parseBoolean(true)).toBe(true);
-        });
-    });
-    describe('empty/null/undefined values', () => {
-        it('should return default value (true) for empty string', () => {
-            expect(parseBoolean('')).toBe(true); // 默认值是 true
-        });
-        it('should return default value (true) for null', () => {
-            expect(parseBoolean(null)).toBe(true); // 默认值是 true
-        });
-        it('should return default value (true) for undefined', () => {
-            expect(parseBoolean(undefined)).toBe(true); // 默认值是 true
-        });
-        it('should return false when defaultValue is false for empty string', () => {
-            expect(parseBoolean('', false)).toBe(false);
-        });
-        it('should return false when defaultValue is false for null', () => {
-            expect(parseBoolean(null, false)).toBe(false);
-        });
-        it('should return false when defaultValue is false for undefined', () => {
-            expect(parseBoolean(undefined, false)).toBe(false);
-        });
-    });
-    describe('default value', () => {
-        it('should return default when value is null', () => {
-            expect(parseBoolean(null, true)).toBe(true);
-        });
-        it('should return default when value is undefined', () => {
-            expect(parseBoolean(undefined, true)).toBe(true);
-        });
-        it('should ignore default for valid values', () => {
-            expect(parseBoolean('false', true)).toBe(false);
-        });
-    });
-});
-describe('ensureEnabledTools', () => {
-    it('should return default tools for empty array', () => {
-        const result = ensureEnabledTools([]);
-        expect(result).toContain('claude');
-        expect(result).toContain('opencode');
-        expect(result).toContain('codex');
-    });
-    it('should return default tools for null', () => {
-        const result = ensureEnabledTools(null);
-        expect(result).toContain('claude');
-        expect(result).toContain('opencode');
-        expect(result).toContain('codex');
-    });
-    it('should return default tools for undefined', () => {
-        const result = ensureEnabledTools(undefined);
-        expect(result).toContain('claude');
-        expect(result).toContain('opencode');
-        expect(result).toContain('codex');
-    });
-    it('should return input array when not empty', () => {
-        const result = ensureEnabledTools(['claude', 'gemini']);
-        expect(result).toEqual(['claude', 'gemini']);
-    });
-    it('should handle single tool', () => {
-        const result = ensureEnabledTools(['opencode']);
-        expect(result).toEqual(['opencode']);
-    });
-    it('should deduplicate tools', () => {
-        const result = ensureEnabledTools(['claude', 'claude', 'opencode']);
-        expect(result).toEqual(['claude', 'opencode']);
-    });
-    it('should normalize tools to lowercase', () => {
-        const result = ensureEnabledTools(['CLAUDE', 'OpenCode']);
-        expect(result).toEqual(['claude', 'opencode']);
-    });
-});

package/dist/utils/yaml-utils.test.d.ts

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

package/dist/utils/yaml-utils.test.d.ts.map

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