aws-runtime-bridge 1.9.32 → 1.9.40

package/dist/config.test.js

@@ -1,107 +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,
-    };
-});
-const originalEnv = { ...process.env };
-const tempRoots = [];
-function createRuntimeHome() {
-    const root = mkdtempSync(path.join(os.tmpdir(), "aws-config-"));
-    tempRoots.push(root);
-    return root;
-}
-function useRuntimeHome(runtimeHome) {
-    process.env.AWS_TEST_HOME = runtimeHome;
-    process.env.HOME = runtimeHome;
-    process.env.USERPROFILE = runtimeHome;
-    process.env.AWS_RUNTIME_HOME_DIR = runtimeHome;
-    delete process.env.AWS_RUNTIME_SCHEDULER_BASE_URL;
-}
-function writeBridgeConfig(runtimeHome, autoRegisterTargets) {
-    const configPath = path.join(runtimeHome, ".aws-bridge", "config.json");
-    mkdirSync(path.dirname(configPath), { recursive: true });
-    writeFileSync(configPath, `${JSON.stringify({ connectionKey: "bridge-key", autoRegisterTargets }, null, 2)}\n`, "utf-8");
-}
-afterEach(() => {
-    process.env = { ...originalEnv };
-    vi.resetModules();
-    vi.clearAllMocks();
-    vi.restoreAllMocks();
-    for (const root of tempRoots.splice(0)) {
-        rmSync(root, { recursive: true, force: true });
-    }
-});
-describe("scheduler base URL resolution", () => {
-    it("keeps scheduler URL supplied by the server request as the highest priority", async () => {
-        const runtimeHome = createRuntimeHome();
-        useRuntimeHome(runtimeHome);
-        process.env.AWS_RUNTIME_SCHEDULER_BASE_URL = "http://env.local:7380";
-        writeBridgeConfig(runtimeHome, [{ serverUrl: "http://target.local:7380" }]);
-        const { resolveSchedulerBaseUrlFrom } = await import("./config.js");
-        expect(resolveSchedulerBaseUrlFrom("http://server.local:7380/api")).toEqual({
-            url: "http://server.local:7380",
-            source: "request",
-            ambiguousTargetUrls: [],
-        });
-    });
-    it("keeps explicit AWS_RUNTIME_SCHEDULER_BASE_URL as the highest priority", async () => {
-        const runtimeHome = createRuntimeHome();
-        useRuntimeHome(runtimeHome);
-        process.env.AWS_RUNTIME_SCHEDULER_BASE_URL = "http://explicit.local:7380/path";
-        writeBridgeConfig(runtimeHome, [{ serverUrl: "http://target.local:7380" }]);
-        const { resolveSchedulerBaseUrl } = await import("./config.js");
-        expect(resolveSchedulerBaseUrl()).toEqual({
-            url: "http://explicit.local:7380",
-            source: "env",
-            ambiguousTargetUrls: [],
-        });
-    });
-    it("uses a single auto-register target serverUrl when scheduler env is absent", async () => {
-        const runtimeHome = createRuntimeHome();
-        useRuntimeHome(runtimeHome);
-        writeBridgeConfig(runtimeHome, [{ serverUrl: "http://127.0.0.1:7380" }]);
-        const { resolveSchedulerBaseUrl } = await import("./config.js");
-        expect(resolveSchedulerBaseUrl()).toEqual({
-            url: "http://127.0.0.1:7380",
-            source: "single-auto-register-target",
-            ambiguousTargetUrls: [],
-        });
-    });
-    it("does not silently select the first auto-register target when multiple URLs exist", async () => {
-        const runtimeHome = createRuntimeHome();
-        useRuntimeHome(runtimeHome);
-        writeBridgeConfig(runtimeHome, [
-            { serverUrl: "http://scheduler-a.local:7380" },
-            { serverUrl: "http://scheduler-b.local:7380" },
-        ]);
-        const { DEFAULT_SCHEDULER_BASE_URL, resolveSchedulerBaseUrl } = await import("./config.js");
-        expect(resolveSchedulerBaseUrl()).toEqual({
-            url: DEFAULT_SCHEDULER_BASE_URL,
-            source: "ambiguous-auto-register-targets",
-            ambiguousTargetUrls: [
-                "http://scheduler-a.local:7380",
-                "http://scheduler-b.local:7380",
-            ],
-        });
-    });
-    it("falls back to the legacy localhost default when no scheduler source exists", async () => {
-        const runtimeHome = createRuntimeHome();
-        useRuntimeHome(runtimeHome);
-        const { DEFAULT_SCHEDULER_BASE_URL, resolveSchedulerBaseUrl } = await import("./config.js");
-        expect(resolveSchedulerBaseUrl()).toEqual({
-            url: DEFAULT_SCHEDULER_BASE_URL,
-            source: "default",
-            ambiguousTargetUrls: [],
-        });
-    });
-});

package/dist/routes/ai-sources.test.d.ts

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

package/dist/routes/ai-sources.test.d.ts.map

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

package/dist/routes/ai-sources.test.js

@@ -1,169 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import assert from 'node:assert/strict';
-function buildUnifiedToolConfig(template) {
-    const normalizedBaseUrl = String(template.baseUrl || '').trim();
-    const normalizedApiKey = String(template.apiKey || '').trim();
-    const normalizedModels = [
-        ...(Array.isArray(template.models) ? template.models : []),
-        template.model,
-    ]
-        .map((item) => String(item || '').trim())
-        .filter((item, index, list) => item && list.indexOf(item) === index);
-    const normalizedModel = normalizedModels[0] || String(template.model || '').trim();
-    const normalizedOpenCodeBaseUrl = normalizedBaseUrl.endsWith('/v1')
-        ? normalizedBaseUrl
-        : `${normalizedBaseUrl.replace(/\/+$/, '')}/v1`;
-    const opencodeModels = Object.fromEntries(normalizedModels.map((model) => [model, {
-            name: model,
-            modalities: {
-                input: ['text', 'image'],
-                output: ['text'],
-            },
-        }]));
-    return {
-        claudecode: {
-            env: {
-                ANTHROPIC_BASE_URL: normalizedBaseUrl,
-                ANTHROPIC_AUTH_TOKEN: normalizedApiKey,
-                ANTHROPIC_MODEL: normalizedModel,
-            },
-        },
-        opencode: {
-            provider: {
-                default: {
-                    npm: '@ai-sdk/openai-compatible',
-                    options: {
-                        baseURL: normalizedOpenCodeBaseUrl,
-                        apiKey: normalizedApiKey,
-                    },
-                    models: opencodeModels,
-                },
-            },
-        },
-    };
-}
-function normalizeListedModels(payload) {
-    if (!payload || typeof payload !== 'object' || Array.isArray(payload)) {
-        return [];
-    }
-    const records = Array.isArray(payload.data)
-        ? payload.data
-        : [];
-    const ids = new Set();
-    for (const item of records) {
-        if (!item || typeof item !== 'object' || Array.isArray(item)) {
-            continue;
-        }
-        const id = String(item.id || '').trim();
-        if (id) {
-            ids.add(id);
-        }
-    }
-    return [...ids];
-}
-function buildModelListCandidates(baseUrl, protocol) {
-    const normalizedBaseUrl = baseUrl.replace(/\/+$/, '');
-    if (protocol === 'anthropic') {
-        return [`${normalizedBaseUrl}/v1/models`];
-    }
-    if (protocol === 'openai') {
-        return normalizedBaseUrl.endsWith('/v1')
-            ? [`${normalizedBaseUrl}/models`]
-            : [`${normalizedBaseUrl}/models`, `${normalizedBaseUrl}/v1/models`];
-    }
-    const openAiCandidates = normalizedBaseUrl.endsWith('/v1')
-        ? [`${normalizedBaseUrl}/models`]
-        : [`${normalizedBaseUrl}/models`, `${normalizedBaseUrl}/v1/models`];
-    return [...openAiCandidates, `${normalizedBaseUrl}/v1/models`];
-}
-function buildApplyAiSourcesResponse(body) {
-    return {
-        acodeModelEffort: String(body.acodeModelEffort || ''),
-        claudecodeModelEffort: String(body.claudecodeModelEffort || ''),
-        codexModelEffort: String(body.codexModelEffort || ''),
-        opencodeModelEffort: String(body.opencodeModelEffort || ''),
-    };
-}
-describe('ai source unified config generation', () => {
-    it('builds tool-specific configs from unified template fields', () => {
-        assert.deepEqual(buildUnifiedToolConfig({
-            baseUrl: 'https://example.com',
-            apiKey: 'sk-demo',
-            model: 'claude-sonnet-4-5',
-            models: ['claude-sonnet-4-5', 'claude-haiku-4-5'],
-        }), {
-            claudecode: {
-                env: {
-                    ANTHROPIC_BASE_URL: 'https://example.com',
-                    ANTHROPIC_AUTH_TOKEN: 'sk-demo',
-                    ANTHROPIC_MODEL: 'claude-sonnet-4-5',
-                },
-            },
-            opencode: {
-                provider: {
-                    default: {
-                        npm: '@ai-sdk/openai-compatible',
-                        options: {
-                            baseURL: 'https://example.com/v1',
-                            apiKey: 'sk-demo',
-                        },
-                        models: {
-                            'claude-sonnet-4-5': {
-                                name: 'claude-sonnet-4-5',
-                                modalities: {
-                                    input: ['text', 'image'],
-                                    output: ['text'],
-                                },
-                            },
-                            'claude-haiku-4-5': {
-                                name: 'claude-haiku-4-5',
-                                modalities: {
-                                    input: ['text', 'image'],
-                                    output: ['text'],
-                                },
-                            },
-                        },
-                    },
-                },
-            },
-        });
-    });
-    it('extracts model ids from an OpenAI-compatible models payload', () => {
-        expect(normalizeListedModels({
-            data: [
-                { id: 'claude-sonnet-4-5' },
-                { id: 'claude-haiku-4-5' },
-                { id: 'claude-sonnet-4-5' },
-            ],
-        })).toEqual(['claude-sonnet-4-5', 'claude-haiku-4-5']);
-    });
-    it('builds fallback candidates for openai-compatible and anthropic model listing', () => {
-        expect(buildModelListCandidates('https://octopus.721579.xyz', 'openai')).toEqual([
-            'https://octopus.721579.xyz/models',
-            'https://octopus.721579.xyz/v1/models',
-        ]);
-        expect(buildModelListCandidates('https://api.anthropic.com', 'anthropic')).toEqual([
-            'https://api.anthropic.com/v1/models',
-        ]);
-    });
-    it('keeps openai-compatible baseURL unchanged when template already includes /v1', () => {
-        expect(buildUnifiedToolConfig({
-            baseUrl: 'https://octopus.721579.xyz/v1',
-            apiKey: 'sk-demo',
-            model: 'gpt-test',
-        }).opencode.provider.default.options.baseURL).toBe('https://octopus.721579.xyz/v1');
-    });
-    it('echoes selected model effort metadata in apply-ai-sources responses', () => {
-        expect(buildApplyAiSourcesResponse({
-            acodeModelEffort: 'xhigh',
-            claudecodeModelEffort: 'high',
-            codexModelEffort: 'max',
-            opencodeModelEffort: 'high',
-        })).toEqual({
-            acodeModelEffort: 'xhigh',
-            claudecodeModelEffort: 'high',
-            codexModelEffort: 'max',
-            opencodeModelEffort: 'high',
-        });
-    });
-});

package/dist/routes/file-browser.test.d.ts

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

package/dist/routes/file-browser.test.d.ts.map

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

package/dist/routes/file-browser.test.js

@@ -1,155 +0,0 @@
-/**
- * File Browser 路由单元测试
- */
-import { describe, it, expect } from 'vitest';
-import { mkdtemp, mkdir, rm, writeFile } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import path from 'node:path';
-import multer from 'multer';
-import { createWorkspaceUploadLimitResponse, isIgnoredByGitIgnore, listHostDirectoryTree, parseGitIgnoreRules, parseWorkspaceUploadRelativePaths, WORKSPACE_UPLOAD_FILE_LIMIT } from './file-browser.js';
-describe('file-browser route validation', () => {
-    it('returns root drives on Windows when path is empty', () => {
-        const getRootForWindows = () => {
-            const drives = [];
-            for (let i = 67; i <= 90; i++)
-                drives.push(String.fromCharCode(i) + ':\\');
-            return drives;
-        };
-        const drives = getRootForWindows();
-        expect(drives.length).toBe(24);
-        expect(drives.includes('C:\\')).toBe(true);
-    });
-    it('validates workspacePath for workspace/list', () => {
-        const validateWorkspaceListRequest = (body) => {
-            if (!body.workspacePath)
-                return { valid: false, error: 'workspacePath is required' };
-            return { valid: true };
-        };
-        expect(validateWorkspaceListRequest({}).valid).toBe(false);
-        expect(validateWorkspaceListRequest({ workspacePath: '/project' }).valid).toBe(true);
-    });
-    it('validates filePath for workspace/read', () => {
-        const validateReadRequest = (body) => {
-            if (!body.workspacePath || !body.filePath)
-                return { valid: false, error: 'workspacePath and filePath are required' };
-            return { valid: true };
-        };
-        expect(validateReadRequest({}).valid).toBe(false);
-        expect(validateReadRequest({ workspacePath: '/project', filePath: 'file.txt' }).valid).toBe(true);
-    });
-    it('validates create request', () => {
-        const validateCreateRequest = (body) => {
-            if (!body.workspacePath)
-                return { valid: false, error: 'workspacePath is required' };
-            if (!body.entryName)
-                return { valid: false, error: 'entryName is required' };
-            return { valid: true };
-        };
-        expect(validateCreateRequest({}).valid).toBe(false);
-        expect(validateCreateRequest({ workspacePath: '/p', entryName: 'new-file' }).valid).toBe(true);
-    });
-    it('validates rename request', () => {
-        const validateRenameRequest = (body) => {
-            if (!body.workspacePath || !body.targetPath || !body.newName)
-                return { valid: false, error: 'workspacePath, targetPath, and newName are required' };
-            return { valid: true };
-        };
-        expect(validateRenameRequest({}).valid).toBe(false);
-        expect(validateRenameRequest({ workspacePath: '/p', targetPath: '/p/old', newName: 'new' }).valid).toBe(true);
-    });
-    it('validates delete request', () => {
-        const validateDeleteRequest = (body) => {
-            if (!body.workspacePath || !body.targetPath)
-                return { valid: false, error: 'workspacePath and targetPath are required' };
-            return { valid: true };
-        };
-        expect(validateDeleteRequest({}).valid).toBe(false);
-        expect(validateDeleteRequest({ workspacePath: '/p', targetPath: '/p/file' }).valid).toBe(true);
-    });
-    it('validates move request', () => {
-        const validateMoveRequest = (body) => {
-            if (!body.workspacePath || !body.targetPath || !body.destinationPath)
-                return { valid: false, error: 'workspacePath, targetPath, and destinationPath are required' };
-            return { valid: true };
-        };
-        expect(validateMoveRequest({}).valid).toBe(false);
-        expect(validateMoveRequest({ workspacePath: '/p', targetPath: '/p/file', destinationPath: '/p/dest' }).valid).toBe(true);
-    });
-});
-describe('file-browser response building', () => {
-    it('builds correct list response', () => {
-        const response = {
-            isWindows: true,
-            currentPath: 'C:\\Users',
-            items: [
-                { name: 'Documents', path: 'C:\\Users\\Documents', isDirectory: true },
-                { name: 'Downloads', path: 'C:\\Users\\Downloads', isDirectory: true },
-            ],
-        };
-        expect(response.isWindows).toBe(true);
-        expect(response.items.length).toBe(2);
-    });
-    it('categorizes entries by type', () => {
-        const entries = [
-            { name: 'src', isDir: true },
-            { name: 'package.json', isDir: false },
-        ];
-        const directories = entries.filter(e => e.isDir).map(e => e.name);
-        const files = entries.filter(e => !e.isDir).map(e => e.name);
-        expect(directories).toEqual(['src']);
-        expect(files).toEqual(['package.json']);
-    });
-    it('returns JSON guidance when folder upload exceeds file count limit', () => {
-        const response = createWorkspaceUploadLimitResponse(new multer.MulterError('LIMIT_FILE_COUNT'));
-        expect(response.status).toBe(400);
-        expect(response.body).toEqual({
-            error: `一次最多上传 ${WORKSPACE_UPLOAD_FILE_LIMIT} 个文件，请拆分文件夹后重试。`,
-            code: 'LIMIT_FILE_COUNT'
-        });
-    });
-    it('parses relative paths from a JSON manifest to preserve folder hierarchy', () => {
-        const relativePaths = parseWorkspaceUploadRelativePaths({
-            relativePathsJson: JSON.stringify(['a/b/c.txt', 'a/d/e.txt'])
-        });
-        expect(relativePaths).toEqual(['a/b/c.txt', 'a/d/e.txt']);
-    });
-    it('keeps backward compatibility with repeated relativePaths fields', () => {
-        const relativePaths = parseWorkspaceUploadRelativePaths({
-            relativePaths: ['a/b/c.txt', 'a/d/e.txt']
-        });
-        expect(relativePaths).toEqual(['a/b/c.txt', 'a/d/e.txt']);
-    });
-});
-describe('directory tree gitignore filtering', () => {
-    it('matches ignored directories from .gitignore rules', () => {
-        const rules = parseGitIgnoreRules(`
-node_modules/
-/dist/
-logs*
-!logs-keep/
-`);
-        expect(isIgnoredByGitIgnore('node_modules', true, rules)).toBe(true);
-        expect(isIgnoredByGitIgnore('packages/app/node_modules', true, rules)).toBe(true);
-        expect(isIgnoredByGitIgnore('dist', true, rules)).toBe(true);
-        expect(isIgnoredByGitIgnore('packages/app/dist', true, rules)).toBe(false);
-        expect(isIgnoredByGitIgnore('logs-temp', true, rules)).toBe(true);
-        expect(isIgnoredByGitIgnore('logs-keep', true, rules)).toBe(false);
-    });
-    it('filters actual directory tree entries using root .gitignore', async () => {
-        const root = await mkdtemp(path.join(tmpdir(), 'aws-tree-ignore-'));
-        try {
-            await mkdir(path.join(root, 'src'));
-            await mkdir(path.join(root, 'node_modules'));
-            await mkdir(path.join(root, 'dist'));
-            await writeFile(path.join(root, '.gitignore'), 'node_modules/\n/dist/\n');
-            const result = await listHostDirectoryTree(root);
-            const names = result.tree.map((item) => item.name);
-            expect(names).toContain('src');
-            expect(names).not.toContain('node_modules');
-            expect(names).not.toContain('dist');
-        }
-        finally {
-            await rm(root, { recursive: true, force: true });
-        }
-    });
-});

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

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

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

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