aws-runtime-bridge 1.7.45 → 1.7.46

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

@@ -1 +1 @@
-{"version":3,"file":"ai-sources.d.ts","sourceRoot":"","sources":["../../src/routes/ai-sources.ts"],"names":[],"mappings":"AAcA,eAAO,MAAM,eAAe,4CAAW,CAAC"}
+{"version":3,"file":"ai-sources.d.ts","sourceRoot":"","sources":["../../src/routes/ai-sources.ts"],"names":[],"mappings":"AAYA,eAAO,MAAM,eAAe,4CAAW,CAAC"}

package/dist/routes/ai-sources.js

@@ -1,9 +1,11 @@
-import { Router } from 'express';
 import axios from 'axios';
+import { Router } from 'express';
 import { validateToken } from '../middleware/auth.js';
+import { applyCurrentAiConfigToInstalledTools } from '../services/ai-source-apply.js';
 import { getAiConfigService } from '../services/cc-switch-sdk.js';
-import { buildToolSpecificAiConfig, } from '@cc-switch/sdk';
+import { detectToolStatuses } from '../services/tool-installer.js';
 import { createLogger } from '../utils/logger.js';
+import { ensureEnabledTools } from '../utils/validation.js';
 const log = createLogger('ai-sources');
 export const aiSourcesRouter = Router();
 function normalizeListedModels(payload) {
@@ -57,48 +59,30 @@ async function fetchRemoteModelList(baseUrl, apiKey) {
     return normalizeListedModels(anthropicResponse.data);
 }
 aiSourcesRouter.post('/cc-switch/apply-ai-sources', validateToken, async (req, res) => {
-    const { agentId, template, claudecodeTemplateId, codexTemplateId, opencodeTemplateId, claudecode, codex, opencode, } = req.body || {};
+    const { agentId, template, ccSwitchEnabledTools, claudecodeTemplateId, codexTemplateId, opencodeTemplateId, claudecode, codex, opencode, } = req.body || {};
     if (!agentId) {
         res.status(400).json({ error: 'agentId is required' });
         return;
     }
     try {
         const aiConfigService = getAiConfigService();
-        const generatedConfig = template ? buildToolSpecificAiConfig({
-            baseUrl: String(template?.baseUrl || ''),
-            apiKey: String(template?.apiKey || ''),
-            model: String(template?.model || ''),
-            models: Array.isArray(template?.models)
-                ? template.models.map((item) => String(item || '').trim()).filter(Boolean)
-                : undefined,
-        }) : null;
-        const claudeSource = generatedConfig?.claudecode || claudecode;
-        const codexSource = generatedConfig?.codex || codex;
-        const opencodeSource = generatedConfig?.opencode || opencode;
-        let mergedClaude = null;
-        let mergedCodex = null;
-        let mergedOpencode = null;
-        if (claudeSource && typeof claudeSource === 'object') {
-            mergedClaude = await aiConfigService.applyClaudeCodeConfig(claudeSource);
-        }
-        if (codexSource && typeof codexSource === 'object') {
-            mergedCodex = await aiConfigService.applyCodexConfig(codexSource);
-        }
-        if (opencodeSource && typeof opencodeSource === 'object') {
-            mergedOpencode = await aiConfigService.applyOpenCodeConfig(opencodeSource);
-        }
+        const tools = ensureEnabledTools(ccSwitchEnabledTools);
+        const toolStatus = await detectToolStatuses(tools);
+        const appliedSummary = await applyCurrentAiConfigToInstalledTools({
+            template: template,
+            requestedSources: { claudecode, codex, opencode },
+            toolStatus,
+            aiConfigService,
+        });
         res.json({
             ok: true,
             agentId: String(agentId),
             claudecodeTemplateId: String(claudecodeTemplateId || ''),
             codexTemplateId: String(codexTemplateId || ''),
             opencodeTemplateId: String(opencodeTemplateId || ''),
-            generatedFromUnifiedTemplate: Boolean(generatedConfig),
-            applied: {
-                claudecode: claudeSource && typeof claudeSource === 'object' ? Object.keys(claudeSource) : [],
-                codex: codexSource && typeof codexSource === 'object' ? Object.keys(codexSource) : [],
-                opencode: opencodeSource && typeof opencodeSource === 'object' ? Object.keys(opencodeSource) : [],
-            },
+            generatedFromUnifiedTemplate: appliedSummary.generatedFromUnifiedTemplate,
+            applied: appliedSummary.applied,
+            skippedTools: appliedSummary.skippedTools,
         });
     }
     catch (error) {

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

@@ -0,0 +1,43 @@
+import { type ClaudeCodeConfig, type CodexConfig, type OpenCodeConfig } from '@cc-switch/sdk';
+import type { ToolInstallStatus } from '../types.js';
+export interface AiSourceTemplateInput {
+    baseUrl?: unknown;
+    apiKey?: unknown;
+    model?: unknown;
+    models?: unknown;
+}
+export interface RequestedAiSources {
+    claudecode?: unknown;
+    codex?: unknown;
+    opencode?: unknown;
+}
+export interface AiConfigApplier {
+    applyClaudeCodeConfig(config: ClaudeCodeConfig): Promise<ClaudeCodeConfig>;
+    applyCodexConfig(config: CodexConfig): Promise<CodexConfig>;
+    applyOpenCodeConfig(config: OpenCodeConfig): Promise<OpenCodeConfig>;
+}
+export interface ApplyCurrentAiConfigOptions {
+    template: AiSourceTemplateInput | null | undefined;
+    requestedSources?: RequestedAiSources;
+    toolStatus: Record<string, ToolInstallStatus>;
+    aiConfigService: AiConfigApplier;
+}
+export interface AppliedAiConfigSummary {
+    generatedFromUnifiedTemplate: boolean;
+    applied: {
+        claudecode: string[];
+        codex: string[];
+        opencode: string[];
+    };
+    skippedTools: string[];
+    merged: {
+        claudecode: ClaudeCodeConfig | null;
+        codex: CodexConfig | null;
+        opencode: OpenCodeConfig | null;
+    };
+}
+/**
+ * 主流程：用当前统一 AI 配置覆盖各 Agent CLI 配置，并跳过未安装 CLI。
+ */
+export declare function applyCurrentAiConfigToInstalledTools(options: ApplyCurrentAiConfigOptions): Promise<AppliedAiConfigSummary>;
+//# sourceMappingURL=ai-source-apply.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ai-source-apply.d.ts","sourceRoot":"","sources":["../../src/services/ai-source-apply.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,gBAAgB,EACrB,KAAK,WAAW,EAChB,KAAK,cAAc,EACpB,MAAM,gBAAgB,CAAC;AAExB,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAErD,MAAM,WAAW,qBAAqB;IACpC,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB;AAED,MAAM,WAAW,kBAAkB;IACjC,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AAED,MAAM,WAAW,eAAe;IAC9B,qBAAqB,CAAC,MAAM,EAAE,gBAAgB,GAAG,OAAO,CAAC,gBAAgB,CAAC,CAAC;IAC3E,gBAAgB,CAAC,MAAM,EAAE,WAAW,GAAG,OAAO,CAAC,WAAW,CAAC,CAAC;IAC5D,mBAAmB,CAAC,MAAM,EAAE,cAAc,GAAG,OAAO,CAAC,cAAc,CAAC,CAAC;CACtE;AAED,MAAM,WAAW,2BAA2B;IAC1C,QAAQ,EAAE,qBAAqB,GAAG,IAAI,GAAG,SAAS,CAAC;IACnD,gBAAgB,CAAC,EAAE,kBAAkB,CAAC;IACtC,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,iBAAiB,CAAC,CAAC;IAC9C,eAAe,EAAE,eAAe,CAAC;CAClC;AAED,MAAM,WAAW,sBAAsB;IACrC,4BAA4B,EAAE,OAAO,CAAC;IACtC,OAAO,EAAE;QACP,UAAU,EAAE,MAAM,EAAE,CAAC;QACrB,KAAK,EAAE,MAAM,EAAE,CAAC;QAChB,QAAQ,EAAE,MAAM,EAAE,CAAC;KACpB,CAAC;IACF,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,MAAM,EAAE;QACN,UAAU,EAAE,gBAAgB,GAAG,IAAI,CAAC;QACpC,KAAK,EAAE,WAAW,GAAG,IAAI,CAAC;QAC1B,QAAQ,EAAE,cAAc,GAAG,IAAI,CAAC;KACjC,CAAC;CACH;AAqBD;;GAEG;AACH,wBAAsB,oCAAoC,CACxD,OAAO,EAAE,2BAA2B,GACnC,OAAO,CAAC,sBAAsB,CAAC,CAsCjC"}

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

@@ -0,0 +1,54 @@
+import { buildToolSpecificAiConfig, } from '@cc-switch/sdk';
+function normalizeTemplate(template) {
+    return {
+        baseUrl: String(template?.baseUrl || ''),
+        apiKey: String(template?.apiKey || ''),
+        model: String(template?.model || ''),
+        models: Array.isArray(template?.models)
+            ? template.models.map((item) => String(item || '').trim()).filter(Boolean)
+            : undefined,
+    };
+}
+function isInstalled(toolStatus, tool) {
+    return Boolean(toolStatus[tool]?.installed);
+}
+function isClaudeCodeInstalled(toolStatus) {
+    return isInstalled(toolStatus, 'claude') || isInstalled(toolStatus, 'claudecode');
+}
+/**
+ * 主流程：用当前统一 AI 配置覆盖各 Agent CLI 配置，并跳过未安装 CLI。
+ */
+export async function applyCurrentAiConfigToInstalledTools(options) {
+    const generatedConfig = options.template
+        ? buildToolSpecificAiConfig(normalizeTemplate(options.template))
+        : null;
+    const skippedTools = Object.values(options.toolStatus)
+        .filter((item) => !item.installed)
+        .map((item) => item.tool);
+    let mergedClaude = null;
+    let mergedCodex = null;
+    let mergedOpencode = null;
+    if (generatedConfig?.claudecode && isClaudeCodeInstalled(options.toolStatus)) {
+        mergedClaude = await options.aiConfigService.applyClaudeCodeConfig(generatedConfig.claudecode);
+    }
+    if (generatedConfig?.codex && isInstalled(options.toolStatus, 'codex')) {
+        mergedCodex = await options.aiConfigService.applyCodexConfig(generatedConfig.codex);
+    }
+    if (generatedConfig?.opencode && isInstalled(options.toolStatus, 'opencode')) {
+        mergedOpencode = await options.aiConfigService.applyOpenCodeConfig(generatedConfig.opencode);
+    }
+    return {
+        generatedFromUnifiedTemplate: Boolean(generatedConfig),
+        applied: {
+            claudecode: generatedConfig?.claudecode && mergedClaude ? Object.keys(generatedConfig.claudecode) : [],
+            codex: generatedConfig?.codex && mergedCodex ? Object.keys(generatedConfig.codex) : [],
+            opencode: generatedConfig?.opencode && mergedOpencode ? Object.keys(generatedConfig.opencode) : [],
+        },
+        skippedTools,
+        merged: {
+            claudecode: mergedClaude,
+            codex: mergedCodex,
+            opencode: mergedOpencode,
+        },
+    };
+}

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

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

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

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

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

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

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

@@ -1,4 +1,4 @@
-import { CcSwitchSdk } from '@cc-switch/sdk';
+import type { CcSwitchSdk } from '@cc-switch/sdk';
 import type { AdapterResult, InitLogEntry, LegacyMcpStateItem, LegacySkillStateItem, McpPayload, SkillPackage, SyncStateResult } from '../types.js';
 export declare function syncLegacyStateFromSdk(agentId: string, sdk: CcSwitchSdk): Promise<SyncStateResult>;
 export declare function initInstance(agentId: string, workspacePath: string, options: {

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

@@ -1 +1 @@
-{"version":3,"file":"instance-init-service.d.ts","sourceRoot":"","sources":["../../src/services/instance-init-service.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAK7C,OAAO,KAAK,EAAE,aAAa,EAAE,YAAY,EAAE,kBAAkB,EAAE,oBAAoB,EAAE,UAAU,EAAS,YAAY,EAAE,eAAe,EAAqB,MAAM,aAAa,CAAC;AAK9K,wBAAsB,sBAAsB,CAC1C,OAAO,EAAE,MAAM,EACf,GAAG,EAAE,WAAW,GACf,OAAO,CAAC,eAAe,CAAC,CAyB1B;AAED,wBAAsB,YAAY,CAChC,OAAO,EAAE,MAAM,EACf,aAAa,EAAE,MAAM,EACrB,OAAO,EAAE;IACP,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,oBAAoB,CAAC,EAAE,MAAM,EAAE,CAAC;IAChC,YAAY,CAAC,EAAE,YAAY,CAAC;IAC5B,aAAa,CAAC,EAAE,YAAY,EAAE,CAAC;IAC/B,UAAU,CAAC,EAAE,UAAU,EAAE,CAAC;CAC3B,GACA,OAAO,CAAC;IACT,EAAE,EAAE,OAAO,CAAC;IACZ,OAAO,EAAE,MAAM,CAAC;IAChB,aAAa,EAAE,MAAM,CAAC;IACtB,QAAQ,EAAE,MAAM,CAAC;IACjB,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,IAAI,CAAC,EAAE,YAAY,EAAE,CAAC;IACtB,KAAK,EAAE;QACL,OAAO,EAAE,OAAO,CAAC;QACjB,cAAc,EAAE,OAAO,CAAC;QACxB,cAAc,CAAC,EAAE,MAAM,CAAC;QACxB,SAAS,CAAC,EAAE,oBAAoB,EAAE,CAAC;KACpC,CAAC;IACF,GAAG,EAAE;QACH,OAAO,EAAE,OAAO,CAAC;QACjB,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;QAC1B,cAAc,CAAC,EAAE,MAAM,CAAC;KACzB,CAAC;IACF,aAAa,CAAC,EAAE,aAAa,CAAC;IAC9B,SAAS,CAAC,EAAE;QACV,MAAM,EAAE,oBAAoB,EAAE,CAAC;QAC/B,UAAU,EAAE,kBAAkB,EAAE,CAAC;KAClC,CAAC;CACH,CAAC,CA+MD"}
+{"version":3,"file":"instance-init-service.d.ts","sourceRoot":"","sources":["../../src/services/instance-init-service.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAElD,OAAO,KAAK,EAAE,aAAa,EAAE,YAAY,EAAE,kBAAkB,EAAE,oBAAoB,EAAE,UAAU,EAAS,YAAY,EAAE,eAAe,EAAqB,MAAM,aAAa,CAAC;AAsB9K,wBAAsB,sBAAsB,CAC1C,OAAO,EAAE,MAAM,EACf,GAAG,EAAE,WAAW,GACf,OAAO,CAAC,eAAe,CAAC,CAyB1B;AAED,wBAAsB,YAAY,CAChC,OAAO,EAAE,MAAM,EACf,aAAa,EAAE,MAAM,EACrB,OAAO,EAAE;IACP,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,oBAAoB,CAAC,EAAE,MAAM,EAAE,CAAC;IAChC,YAAY,CAAC,EAAE,YAAY,CAAC;IAC5B,aAAa,CAAC,EAAE,YAAY,EAAE,CAAC;IAC/B,UAAU,CAAC,EAAE,UAAU,EAAE,CAAC;CAC3B,GACA,OAAO,CAAC;IACT,EAAE,EAAE,OAAO,CAAC;IACZ,OAAO,EAAE,MAAM,CAAC;IAChB,aAAa,EAAE,MAAM,CAAC;IACtB,QAAQ,EAAE,MAAM,CAAC;IACjB,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,IAAI,CAAC,EAAE,YAAY,EAAE,CAAC;IACtB,KAAK,EAAE;QACL,OAAO,EAAE,OAAO,CAAC;QACjB,cAAc,EAAE,OAAO,CAAC;QACxB,cAAc,CAAC,EAAE,MAAM,CAAC;QACxB,SAAS,CAAC,EAAE,oBAAoB,EAAE,CAAC;KACpC,CAAC;IACF,GAAG,EAAE;QACH,OAAO,EAAE,OAAO,CAAC;QACjB,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;QAC1B,cAAc,CAAC,EAAE,MAAM,CAAC;KACzB,CAAC;IACF,aAAa,CAAC,EAAE,aAAa,CAAC;IAC9B,SAAS,CAAC,EAAE;QACV,MAAM,EAAE,oBAAoB,EAAE,CAAC;QAC/B,UAAU,EAAE,kBAAkB,EAAE,CAAC;KAClC,CAAC;CACH,CAAC,CA4MD"}

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

@@ -1,12 +1,18 @@
-import path from 'node:path';
 import { promises as fs } from 'node:fs';
-import { getAgentInitRoot, loadInstanceState, saveInstanceState } from './instance-state.js';
-import { loadCcSwitchSdk, runCcSwitchAdapter, toSdkAppsFromEnabledTools } from './cc-switch-sdk.js';
+import path from 'node:path';
 import { ensureDir, installSkillPackageToSdk } from '../utils/file-utils.js';
 import { buildMcpConfigContent, normalizeSdkMcpServerSpec, toLegacyMcpStateItem, toLegacySkillStateItem } from '../utils/mcp-utils.js';
-import { ensureEnabledTools, parseBoolean } from '../utils/validation.js';
 import { normalizeMcpPayload } from '../utils/mcp-utils.js';
-import { detectToolStatuses, ensureToolsInstalled } from './tool-installer.js';
+import { ensureEnabledTools, parseBoolean } from '../utils/validation.js';
+import { loadCcSwitchSdk, runCcSwitchAdapter, toSdkAppsFromEnabledTools } from './cc-switch-sdk.js';
+import { getAgentInitRoot, loadInstanceState, saveInstanceState } from './instance-state.js';
+import { detectToolStatuses } from './tool-installer.js';
+function pickInstalledTools(requestedTools, toolStatus) {
+    const installed = new Set(Object.values(toolStatus)
+        .filter((item) => item.installed)
+        .map((item) => item.tool));
+    return requestedTools.filter((tool) => installed.has(tool));
+}
 export async function syncLegacyStateFromSdk(agentId, sdk) {
     const state = await loadInstanceState(agentId);
     const mcpServers = sdk.getAllMcpServers().map((item) => toLegacyMcpStateItem(item));
@@ -51,12 +57,14 @@ export async function initInstance(agentId, workspacePath, options) {
         installedTools: Object.values(detectedToolStatus).filter((item) => item.installed).map((item) => item.tool),
         missingTools: Object.values(detectedToolStatus).filter((item) => !item.installed).map((item) => item.tool),
     });
+    const installedTools = pickInstalledTools(tools, detectedToolStatus);
+    const missingTools = Object.values(detectedToolStatus).filter((item) => !item.installed);
     const initResult = {
         ok: true,
         agentId: String(agentId),
         workspacePath: normalizedWorkspace,
         initRoot,
-        enabledTools: tools,
+        enabledTools: installedTools,
         toolStatus: detectedToolStatus,
         logs,
         skill: {
@@ -69,23 +77,17 @@ export async function initInstance(agentId, workspacePath, options) {
         },
     };
     const state = await loadInstanceState(agentId);
-    pushLog('install-tools', 'running', '开始自动安装缺失工具', { tools });
-    const ensuredToolStatus = await ensureToolsInstalled(tools);
-    initResult.toolStatus = ensuredToolStatus;
-    const failedTools = Object.values(ensuredToolStatus).filter((item) => !item.installed);
-    if (failedTools.length > 0) {
-        pushLog('install-tools', 'error', '部分工具自动安装失败', {
-            failedTools: failedTools.map((item) => ({ tool: item.tool, error: item.error })),
-        });
-    }
-    else {
-        pushLog('install-tools', 'success', '工具安装步骤完成', {
-            installedTools: Object.values(ensuredToolStatus).map((item) => ({ tool: item.tool, version: item.version })),
+    if (missingTools.length > 0) {
+        pushLog('skip-uninstalled-tools', 'skipped', '已跳过未安装工具', {
+            skippedTools: missingTools.map((item) => ({ tool: item.tool, error: item.error })),
         });
     }
+    pushLog('select-installed-tools', 'success', '已选择可初始化工具', {
+        installedTools,
+    });
     pushLog('load-sdk', 'running', '开始加载 CC Switch SDK');
     const sdk = await loadCcSwitchSdk(agentId);
-    const sdkApps = toSdkAppsFromEnabledTools(tools);
+    const sdkApps = toSdkAppsFromEnabledTools(installedTools);
     pushLog('load-sdk', 'success', 'CC Switch SDK 加载完成', { sdkApps });
     if (initResult.skill.enabled) {
         pushLog('install-skills', 'running', '开始安装技能包', {
@@ -125,7 +127,7 @@ export async function initInstance(agentId, workspacePath, options) {
         });
         const normalizedMcpServers = (Array.isArray(options.mcpServers) ? options.mcpServers : [])
             .map((item) => normalizeMcpPayload(item))
-            .filter((item) => item != null);
+            .filter((item) => item !== null);
         const appliedMcp = [];
         for (const item of normalizedMcpServers) {
             const allMcps = sdk.getAllMcpServers();
@@ -152,8 +154,8 @@ export async function initInstance(agentId, workspacePath, options) {
     }
     pushLog('persist-state', 'running', '开始保存实例状态');
     state.initialized = true;
-    state.enabledTools = tools;
-    state.toolStatus = ensuredToolStatus;
+    state.enabledTools = installedTools;
+    state.toolStatus = detectedToolStatus;
     state.skillEnabled = initResult.skill.enabled;
     state.mcpEnabled = initResult.mcp.enabled;
     await saveInstanceState(agentId, state);
@@ -178,7 +180,7 @@ export async function initInstance(agentId, workspacePath, options) {
     pushLog('adapter', 'success', '适配器回写完成', {
         snapshot: adapterResult.snapshot,
     });
-    pushLog('complete', failedTools.length > 0 ? 'error' : 'success', failedTools.length > 0 ? '实例初始化完成，但存在工具安装失败项' : '实例初始化完成');
+    pushLog('complete', 'success', missingTools.length > 0 ? '实例初始化完成，未安装工具已跳过' : '实例初始化完成');
     return {
         ...initResult,
         adapterResult,

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

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

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

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

@@ -0,0 +1,139 @@
+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,
+            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 installed-only tool initialization', () => {
+    const originalRuntimeHomeDir = process.env.AWS_RUNTIME_HOME_DIR;
+    let runtimeHomeDir;
+    beforeEach(async () => {
+        runtimeHomeDir = path.join(os.tmpdir(), `aws-init-installed-only-${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('skips uninstalled tools and 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']);
+        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']);
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "aws-runtime-bridge",
-  "version": "1.7.45",
+  "version": "1.7.46",
   "description": "AgentsWorkStudio runtime bridge service for machine-level agent runtime integration",
   "type": "module",
   "main": "dist/index.js",