aws-runtime-bridge 1.0.0

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

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

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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,148 @@
+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`];
+}
+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');
+    });
+});

package/dist/routes/aws-mcp.d.ts

@@ -0,0 +1,10 @@
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+export declare const awsMcpRouter: import("express-serve-static-core").Router;
+declare function hasMatchingSdkSession(agentId: string, workspacePath?: string): boolean;
+declare function createAwsMcpServer(agentId: string, workspacePath?: string): Server;
+export declare const __test__: {
+    createAwsMcpServer: typeof createAwsMcpServer;
+    hasMatchingSdkSession: typeof hasMatchingSdkSession;
+};
+export {};
+//# sourceMappingURL=aws-mcp.d.ts.map

package/dist/routes/aws-mcp.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"aws-mcp.d.ts","sourceRoot":"","sources":["../../src/routes/aws-mcp.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,MAAM,EAAE,MAAM,2CAA2C,CAAC;AAYnE,eAAO,MAAM,YAAY,4CAAW,CAAC;AAErC,iBAAS,qBAAqB,CAAC,OAAO,EAAE,MAAM,EAAE,aAAa,CAAC,EAAE,MAAM,GAAG,OAAO,CAW/E;AAED,iBAAS,kBAAkB,CAAC,OAAO,EAAE,MAAM,EAAE,aAAa,CAAC,EAAE,MAAM,GAAG,MAAM,CAkC3E;AA0BD,eAAO,MAAM,QAAQ;;;CAGpB,CAAC"}

package/dist/routes/aws-mcp.js

@@ -0,0 +1,74 @@
+import { Router } from 'express';
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
+import { CallToolRequestSchema, ListToolsRequestSchema, } from '@modelcontextprotocol/sdk/types.js';
+import { validateToken } from '../middleware/auth.js';
+import { AWS_MCP_TOOLS, callAwsMcpTool } from '../services/aws-mcp-http.js';
+import { sdkSessions } from './terminal.js';
+export const awsMcpRouter = Router();
+function hasMatchingSdkSession(agentId, workspacePath) {
+    for (const entry of sdkSessions.values()) {
+        if (entry.agentId !== agentId) {
+            continue;
+        }
+        if (workspacePath && entry.workspacePath !== workspacePath) {
+            continue;
+        }
+        return true;
+    }
+    return false;
+}
+function createAwsMcpServer(agentId, workspacePath) {
+    const server = new Server({ name: 'aws-runtime-bridge-mcp', version: '1.0.0' }, { capabilities: { tools: {} } });
+    server.setRequestHandler(ListToolsRequestSchema, async () => ({ tools: AWS_MCP_TOOLS }));
+    server.setRequestHandler(CallToolRequestSchema, async (request) => {
+        const { name, arguments: args } = request.params;
+        try {
+            const result = await callAwsMcpTool(name, args, { agentId, workspacePath });
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify(result, null, 2),
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify({ error: errorMessage }, null, 2),
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+    return server;
+}
+awsMcpRouter.all('/aws-mcp', validateToken, async (req, res) => {
+    const agentId = String(req.query.agentId || '').trim();
+    const workspacePath = String(req.query.workspacePath || '').trim() || undefined;
+    if (!agentId) {
+        res.status(400).json({ error: 'agentId is required' });
+        return;
+    }
+    if (!hasMatchingSdkSession(agentId, workspacePath)) {
+        res.status(403).json({ error: 'agentId is not bound to an active SDK session on this runtime bridge' });
+        return;
+    }
+    const server = createAwsMcpServer(agentId, workspacePath);
+    const transport = new StreamableHTTPServerTransport({ sessionIdGenerator: undefined });
+    await server.connect(transport);
+    res.on('close', () => {
+        void transport.close();
+    });
+    await transport.handleRequest(req, res, req.body);
+});
+export const __test__ = {
+    createAwsMcpServer,
+    hasMatchingSdkSession,
+};

package/dist/routes/aws-mcp.test.d.ts

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

package/dist/routes/aws-mcp.test.d.ts.map

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

package/dist/routes/aws-mcp.test.js

@@ -0,0 +1,42 @@
+import { describe, expect, it } from 'vitest';
+import { __test__ } from './aws-mcp.js';
+import { sdkSessions } from './terminal.js';
+describe('aws mcp route validation', () => {
+    it('requires agentId query param', () => {
+        const validateQuery = (query) => {
+            const agentId = String(query.agentId || '').trim();
+            return agentId.length > 0;
+        };
+        expect(validateQuery({})).toBe(false);
+        expect(validateQuery({ agentId: 'agent-1' })).toBe(true);
+    });
+    it('keeps workspacePath optional in bridge-bound mcp url', () => {
+        const buildQueryState = (query) => ({
+            agentId: String(query.agentId || '').trim(),
+            workspacePath: String(query.workspacePath || '').trim() || undefined,
+        });
+        expect(buildQueryState({ agentId: 'agent-1' })).toEqual({
+            agentId: 'agent-1',
+            workspacePath: undefined,
+        });
+        expect(buildQueryState({ agentId: 'agent-1', workspacePath: '/workspace/demo' })).toEqual({
+            agentId: 'agent-1',
+            workspacePath: '/workspace/demo',
+        });
+    });
+    it('authorizes only agent ids bound to active sdk sessions', () => {
+        sdkSessions.clear();
+        sdkSessions.set('session-1', {
+            agentId: 'agent-1',
+            workspacePath: '/workspace/demo',
+            sessionId: 'session-1',
+            config: { command: 'claude', workingDirectory: '/workspace/demo', autoAccept: true },
+            providerId: 'claude-code',
+        });
+        expect(__test__.hasMatchingSdkSession('agent-1', '/workspace/demo')).toBe(true);
+        expect(__test__.hasMatchingSdkSession('agent-1')).toBe(true);
+        expect(__test__.hasMatchingSdkSession('agent-2', '/workspace/demo')).toBe(false);
+        expect(__test__.hasMatchingSdkSession('agent-1', '/workspace/other')).toBe(false);
+        sdkSessions.clear();
+    });
+});

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

@@ -0,0 +1,7 @@
+/**
+ * 文件浏览器 API 路由
+ *
+ * 提供文件系统浏览功能
+ */
+export declare const fileBrowserRouter: import("express-serve-static-core").Router;
+//# sourceMappingURL=file-browser.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"file-browser.d.ts","sourceRoot":"","sources":["../../src/routes/file-browser.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAmBH,eAAO,MAAM,iBAAiB,4CAAW,CAAC"}

package/dist/routes/file-browser.js

@@ -0,0 +1,227 @@
+/**
+ * 文件浏览器 API 路由
+ *
+ * 提供文件系统浏览功能
+ */
+import { Router } from 'express';
+import path from 'node:path';
+import { promises as fs } from 'node:fs';
+import { validateToken } from '../middleware/auth.js';
+import { allowHostFileBrowser } from '../config.js';
+import { createLogger } from '../utils/logger.js';
+import { createWorkspaceEntry, deleteWorkspaceEntry, listWorkspaceDirectory, readWorkspaceFile, renameWorkspaceEntry, writeWorkspaceFile, } from '../services/workspace-files.js';
+const log = createLogger('file-browser');
+export const fileBrowserRouter = Router();
+/**
+ * 列出目录内容
+ * POST /api/file-browser/list
+ */
+fileBrowserRouter.post('/list', validateToken, async (req, res) => {
+    try {
+        if (!allowHostFileBrowser) {
+            return res.status(403).json({
+                error: 'Host filesystem browsing is disabled. Use /api/file-browser/workspace/list with a registered workspace, or set AWS_ALLOW_HOST_FILE_BROWSER=true for isolated local debugging.'
+            });
+        }
+        const { path: requestPath = '' } = req.body || {};
+        const platform = process.platform;
+        const isWindows = platform === 'win32';
+        // 如果路径为空，返回根目录
+        if (!requestPath || requestPath === '') {
+            if (isWindows) {
+                // Windows: 返回驱动器列表
+                const drives = [];
+                for (let i = 67; i <= 90; i++) { // C to Z
+                    const drive = String.fromCharCode(i) + ':\\';
+                    try {
+                        await fs.access(drive);
+                        drives.push({
+                            name: drive,
+                            path: drive,
+                            isDirectory: true
+                        });
+                    }
+                    catch {
+                        // Drive not accessible, skip
+                    }
+                }
+                return res.json({
+                    isWindows: true,
+                    currentPath: '',
+                    items: drives
+                });
+            }
+            else {
+                // Unix: 返回根目录
+                const entries = await fs.readdir('/', { withFileTypes: true });
+                const items = entries
+                    .filter(entry => entry.isDirectory())
+                    .map(entry => ({
+                    name: entry.name,
+                    path: '/' + entry.name,
+                    isDirectory: true
+                }));
+                return res.json({
+                    isWindows: false,
+                    currentPath: '/',
+                    items
+                });
+            }
+        }
+        // 标准化路径
+        const normalizedPath = path.normalize(requestPath);
+        // 检查路径是否存在且为目录
+        let stat;
+        try {
+            stat = await fs.stat(normalizedPath);
+        }
+        catch (err) {
+            return res.status(404).json({ error: 'Path not found: ' + normalizedPath });
+        }
+        if (!stat.isDirectory()) {
+            return res.status(400).json({ error: 'Path is not a directory: ' + normalizedPath });
+        }
+        // 读取目录内容
+        const entries = await fs.readdir(normalizedPath, { withFileTypes: true });
+        const items = entries.map(entry => {
+            const itemPath = path.join(normalizedPath, entry.name);
+            return {
+                name: entry.name,
+                path: itemPath,
+                isDirectory: entry.isDirectory()
+            };
+        });
+        res.json({
+            isWindows,
+            currentPath: normalizedPath,
+            items
+        });
+    }
+    catch (error) {
+        const err = error;
+        res.status(500).json({ error: err.message });
+    }
+});
+/**
+ * 列出工作区目录内容
+ * POST /api/file-browser/workspace/list
+ */
+fileBrowserRouter.post('/workspace/list', validateToken, async (req, res) => {
+    try {
+        const { workspacePath, path: requestPath = '' } = req.body || {};
+        const result = await listWorkspaceDirectory({
+            workspacePath: String(workspacePath || ''),
+            targetPath: String(requestPath || '')
+        });
+        res.json({
+            isWindows: process.platform === 'win32',
+            currentPath: result.currentPath,
+            workspacePath: result.workspacePath,
+            items: result.items
+        });
+    }
+    catch (error) {
+        const err = error;
+        console.error('[file-browser] failed to list workspace directory:', err);
+        res.status(400).json({ error: err.message });
+    }
+});
+/**
+ * 读取工作区文件内容
+ * POST /api/file-browser/workspace/read
+ */
+fileBrowserRouter.post('/workspace/read', validateToken, async (req, res) => {
+    try {
+        const { workspacePath, filePath } = req.body || {};
+        const result = await readWorkspaceFile({
+            workspacePath: String(workspacePath || ''),
+            filePath: String(filePath || '')
+        });
+        res.json(result);
+    }
+    catch (error) {
+        const err = error;
+        console.error('[file-browser] failed to read workspace file:', err);
+        res.status(400).json({ error: err.message });
+    }
+});
+/**
+ * 保存工作区文件内容
+ * POST /api/file-browser/workspace/write
+ */
+fileBrowserRouter.post('/workspace/write', validateToken, async (req, res) => {
+    try {
+        const { workspacePath, filePath, content } = req.body || {};
+        const result = await writeWorkspaceFile({
+            workspacePath: String(workspacePath || ''),
+            filePath: String(filePath || ''),
+            content: String(content ?? '')
+        });
+        res.json(result);
+    }
+    catch (error) {
+        const err = error;
+        console.error('[file-browser] failed to write workspace file:', err);
+        res.status(400).json({ error: err.message });
+    }
+});
+/**
+ * 在工作区目录下创建文件或目录
+ * POST /api/file-browser/workspace/create
+ */
+fileBrowserRouter.post('/workspace/create', validateToken, async (req, res) => {
+    try {
+        const { workspacePath, path: requestPath = '', entryName, isDirectory } = req.body || {};
+        const result = await createWorkspaceEntry({
+            workspacePath: String(workspacePath || ''),
+            targetPath: String(requestPath || ''),
+            entryName: String(entryName || ''),
+            isDirectory: Boolean(isDirectory)
+        });
+        res.json(result);
+    }
+    catch (error) {
+        const err = error;
+        log.error('failed to create workspace entry:', err);
+        res.status(400).json({ error: err.message });
+    }
+});
+/**
+ * 重命名工作区中的文件或目录
+ * POST /api/file-browser/workspace/rename
+ */
+fileBrowserRouter.post('/workspace/rename', validateToken, async (req, res) => {
+    try {
+        const { workspacePath, targetPath, newName } = req.body || {};
+        const result = await renameWorkspaceEntry({
+            workspacePath: String(workspacePath || ''),
+            targetPath: String(targetPath || ''),
+            newName: String(newName || '')
+        });
+        res.json(result);
+    }
+    catch (error) {
+        const err = error;
+        log.error('failed to rename workspace entry:', err);
+        res.status(400).json({ error: err.message });
+    }
+});
+/**
+ * 删除工作区中的文件或目录
+ * POST /api/file-browser/workspace/delete
+ */
+fileBrowserRouter.post('/workspace/delete', validateToken, async (req, res) => {
+    try {
+        const { workspacePath, targetPath } = req.body || {};
+        const result = await deleteWorkspaceEntry({
+            workspacePath: String(workspacePath || ''),
+            targetPath: String(targetPath || '')
+        });
+        res.json(result);
+    }
+    catch (error) {
+        const err = error;
+        log.error('failed to delete workspace entry:', err);
+        res.status(400).json({ error: err.message });
+    }
+});

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

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

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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,88 @@
+/**
+ * File Browser 路由单元测试
+ */
+import { describe, it, expect } from 'vitest';
+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);
+    });
+});
+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']);
+    });
+});

package/dist/routes/git.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Git 快照 API 路由
+ *
+ * 提供 Git Stash 快照的创建、列表、恢复和删除功能
+ */
+export declare const gitRouter: import("express-serve-static-core").Router;
+//# sourceMappingURL=git.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"git.d.ts","sourceRoot":"","sources":["../../src/routes/git.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAQH,eAAO,MAAM,SAAS,4CAAW,CAAC"}