@iaforged/context-code 1.2.8 → 1.2.10

package/dist/src/core/agents/swarmTools.js

@@ -0,0 +1,38 @@
+export const coreSendMessageTool = {
+    name: 'send_message',
+    description: 'Send a message to another specialist agent in parallel. Use this when you need multiple specialists to work on independent parts of a task.',
+    execute: async (input) => {
+        const { targetAgentId, instructions } = input;
+        if (typeof targetAgentId !== 'string' || typeof instructions !== 'string') {
+            return { success: false, error: 'targetAgentId and instructions are required strings.' };
+        }
+        return {
+            success: true,
+            data: {
+                mode: 'parallel',
+                targetAgentId,
+                instructions
+            },
+            output: `Message sent to ${targetAgentId}. Waiting for results...`
+        };
+    }
+};
+export const coreHandoffTool = {
+    name: 'handoff',
+    description: 'Transfer control of the conversation to another specialist. Use this when a single specialist is better suited to handle the entire user request from now on.',
+    execute: async (input) => {
+        const { targetAgentId, instructions } = input;
+        if (typeof targetAgentId !== 'string' || typeof instructions !== 'string') {
+            return { success: false, error: 'targetAgentId and instructions are required strings.' };
+        }
+        return {
+            success: true,
+            data: {
+                mode: 'handoff',
+                targetAgentId,
+                instructions
+            },
+            output: `Handing off control to ${targetAgentId}.`
+        };
+    }
+};

package/dist/src/core/auth/index.js

@@ -0,0 +1,2 @@
+export * from './loginCore.js';
+export * from './logoutCore.js';

package/dist/src/core/auth/loginCliAdapter.js

@@ -0,0 +1,24 @@
+import { resetCostState } from '../../bootstrap/state.js';
+import { clearTrustedDeviceToken, enrollTrustedDevice } from '../../bridge/trustedDevice.js';
+import { refreshGrowthBookAfterAuthChange } from '../../services/analytics/growthbook.js';
+import { refreshPolicyLimits } from '../../services/policyLimits/index.js';
+import { refreshRemoteManagedSettings } from '../../services/remoteManagedSettings/index.js';
+import { switchProviderPreference } from '../../utils/model/providerSwitch.js';
+import { stripSignatureBlocks } from '../../utils/messages.js';
+import { checkAndDisableAutoModeIfNeeded, checkAndDisableBypassPermissionsIfNeeded, resetAutoModeGateCheck, resetBypassPermissionsCheck, } from '../../utils/permissions/bypassPermissionsKillswitch.js';
+import { resetUserCache } from '../../utils/user.js';
+export const cliAuthLoginServices = {
+    resetCostState,
+    clearTrustedDeviceToken,
+    enrollTrustedDevice,
+    refreshGrowthBookAfterAuthChange,
+    refreshPolicyLimits,
+    refreshRemoteManagedSettings,
+    stripSignatureBlocks,
+    switchProviderPreference,
+    resetUserCache,
+    resetBypassPermissionsCheck,
+    resetAutoModeGateCheck,
+    checkAndDisableBypassPermissionsIfNeeded,
+    checkAndDisableAutoModeIfNeeded,
+};

package/dist/src/core/auth/loginCore.js

@@ -0,0 +1,67 @@
+import { resetCostState } from '../../bootstrap/state.js';
+import { clearTrustedDeviceToken, enrollTrustedDevice } from '../../bridge/trustedDevice.js';
+import { refreshGrowthBookAfterAuthChange } from '../../services/analytics/growthbook.js';
+import { refreshPolicyLimits } from '../../services/policyLimits/index.js';
+import { refreshRemoteManagedSettings } from '../../services/remoteManagedSettings/index.js';
+import { stripSignatureBlocks } from '../../utils/messages.js';
+import { checkAndDisableAutoModeIfNeeded, checkAndDisableBypassPermissionsIfNeeded, resetAutoModeGateCheck, resetBypassPermissionsCheck, } from '../../utils/permissions/bypassPermissionsKillswitch.js';
+import { switchProviderPreference } from '../../utils/model/providerSwitch.js';
+import { resetUserCache } from '../../utils/user.js';
+export function isCoreAuthEnabled() {
+    return process.env.CORE_AUTH_ENABLED === '1';
+}
+export function parseLoginProfileName(args) {
+    const trimmedArgs = args?.trim() ?? '';
+    if (!trimmedArgs)
+        return undefined;
+    const tokens = trimmedArgs.split(/\s+/).filter(Boolean);
+    const profileIdx = tokens.findIndex(t => t === '--profile' || t === '-p');
+    if (profileIdx !== -1 && tokens[profileIdx + 1])
+        return tokens[profileIdx + 1];
+    if (tokens.length > 0 && !tokens[0].startsWith('-'))
+        return tokens[0];
+    return undefined;
+}
+function resolveProvider(targetProvider) {
+    if (!targetProvider)
+        return 'claude';
+    return targetProvider;
+}
+export function applySuccessfulLogin(params) {
+    const { context, profileName, previousModel, previousProvider, targetProvider, transcriptClassifierEnabled, } = params;
+    context.onChangeAPIKey();
+    context.setMessages(stripSignatureBlocks);
+    const restoredModel = switchProviderPreference({
+        currentModel: previousModel,
+        currentProvider: previousProvider,
+        targetProvider: resolveProvider(targetProvider),
+        targetProfileName: profileName,
+    });
+    resetCostState();
+    void refreshRemoteManagedSettings();
+    void refreshPolicyLimits();
+    resetUserCache();
+    refreshGrowthBookAfterAuthChange();
+    clearTrustedDeviceToken();
+    void enrollTrustedDevice();
+    resetBypassPermissionsCheck();
+    const appState = context.getAppState();
+    void checkAndDisableBypassPermissionsIfNeeded(appState.toolPermissionContext, context.setAppState);
+    if (transcriptClassifierEnabled) {
+        resetAutoModeGateCheck();
+        void checkAndDisableAutoModeIfNeeded(appState.toolPermissionContext, context.setAppState, appState.fastMode);
+    }
+    context.setAppState(prev => ({
+        ...prev,
+        mainLoopModel: restoredModel,
+        mainLoopModelForSession: restoredModel,
+        authVersion: prev.authVersion + 1,
+    }));
+    const shouldOpenModelPicker = !restoredModel;
+    const message = shouldOpenModelPicker
+        ? profileName
+            ? `Inicio de sesion exitoso en el perfil "${profileName}". Selecciona ahora el modelo para este perfil.`
+            : 'Inicio de sesion exitoso. Selecciona ahora el modelo para este perfil.'
+        : 'Inicio de sesión exitoso';
+    return { restoredModel, message, shouldOpenModelPicker };
+}

package/dist/src/core/auth/logoutCliAdapter.js

@@ -0,0 +1,34 @@
+import { clearTrustedDeviceTokenCache } from '../../bridge/trustedDevice.js';
+import { refreshGrowthBookAfterAuthChange } from '../../services/analytics/growthbook.js';
+import { getGroveNoticeConfig, getGroveSettings } from '../../services/api/grove.js';
+import { clearPolicyLimitsCache } from '../../services/policyLimits/index.js';
+import { clearRemoteManagedSettingsCache } from '../../services/remoteManagedSettings/index.js';
+import { getClaudeAIOAuthTokens, getOpenAIOAuthTokens, removeApiKey } from '../../utils/auth.js';
+import { clearBetasCaches } from '../../utils/betas.js';
+import { saveGlobalConfig } from '../../utils/config.js';
+import { getSecureStorage } from '../../utils/secureStorage/index.js';
+import { clearToolSchemaCache } from '../../utils/toolSchemaCache.js';
+import { resetUserCache } from '../../utils/user.js';
+async function cliClearAuthRelatedCaches() {
+    getClaudeAIOAuthTokens.cache?.clear?.();
+    getOpenAIOAuthTokens.cache?.clear?.();
+    clearTrustedDeviceTokenCache();
+    clearBetasCaches();
+    clearToolSchemaCache();
+    resetUserCache();
+    refreshGrowthBookAfterAuthChange();
+    getGroveNoticeConfig.cache?.clear?.();
+    getGroveSettings.cache?.clear?.();
+    await clearRemoteManagedSettingsCache();
+    await clearPolicyLimitsCache();
+}
+export const cliAuthLogoutServices = {
+    flushTelemetry: async () => {
+        const { flushTelemetry } = await import('../../utils/telemetry/instrumentation.js');
+        await flushTelemetry();
+    },
+    removeApiKey,
+    getSecureStorage,
+    saveGlobalConfig,
+    clearAuthRelatedCaches: cliClearAuthRelatedCaches,
+};

package/dist/src/core/auth/logoutCore.js

@@ -0,0 +1,52 @@
+import { clearTrustedDeviceTokenCache } from '../../bridge/trustedDevice.js';
+import { refreshGrowthBookAfterAuthChange } from '../../services/analytics/growthbook.js';
+import { getGroveNoticeConfig, getGroveSettings } from '../../services/api/grove.js';
+import { clearPolicyLimitsCache } from '../../services/policyLimits/index.js';
+import { clearRemoteManagedSettingsCache } from '../../services/remoteManagedSettings/index.js';
+import { getClaudeAIOAuthTokens, getOpenAIOAuthTokens, removeApiKey } from '../../utils/auth.js';
+import { clearBetasCaches } from '../../utils/betas.js';
+import { saveGlobalConfig } from '../../utils/config.js';
+import { getSecureStorage } from '../../utils/secureStorage/index.js';
+import { clearToolSchemaCache } from '../../utils/toolSchemaCache.js';
+import { resetUserCache } from '../../utils/user.js';
+export function isCoreAuthEnabled() {
+    return process.env.CORE_AUTH_ENABLED === '1';
+}
+// clearing anything memoized that must be invalidated when user/session/auth changes
+export async function clearAuthRelatedCachesCore() {
+    getClaudeAIOAuthTokens.cache?.clear?.();
+    getOpenAIOAuthTokens.cache?.clear?.();
+    clearTrustedDeviceTokenCache();
+    clearBetasCaches();
+    clearToolSchemaCache();
+    resetUserCache();
+    refreshGrowthBookAfterAuthChange();
+    getGroveNoticeConfig.cache?.clear?.();
+    getGroveSettings.cache?.clear?.();
+    await clearRemoteManagedSettingsCache();
+    await clearPolicyLimitsCache();
+}
+export async function performLogoutCore({ clearOnboarding = false, } = {}) {
+    const { flushTelemetry } = await import('../../utils/telemetry/instrumentation.js');
+    await flushTelemetry();
+    await removeApiKey();
+    const secureStorage = getSecureStorage();
+    secureStorage.delete();
+    await clearAuthRelatedCachesCore();
+    saveGlobalConfig(current => {
+        const updated = { ...current };
+        if (clearOnboarding) {
+            updated.hasCompletedOnboarding = false;
+            updated.subscriptionNoticeCount = 0;
+            updated.hasAvailableSubscription = false;
+            if (updated.customApiKeyResponses?.approved) {
+                updated.customApiKeyResponses = {
+                    ...updated.customApiKeyResponses,
+                    approved: [],
+                };
+            }
+        }
+        updated.oauthAccount = undefined;
+        return updated;
+    });
+}

package/dist/src/core/auth/preflight.smoke.js

@@ -0,0 +1,151 @@
+import assert from 'node:assert/strict';
+import { readFileSync } from 'node:fs';
+import { dirname, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { applySuccessfulLogin, parseLoginArgs, parseLoginProfileName, } from './loginCore.js';
+import { performLogoutCore } from './logoutCore.js';
+function resolveCliSrcRoot() {
+    const here = dirname(fileURLToPath(import.meta.url));
+    const candidates = [
+        resolve(here, '..', '..', '..'), // CLI/src from tsx
+        resolve(here, '..', '..', '..', '..', 'src'), // CLI/dist/src from node
+    ];
+    for (const candidate of candidates) {
+        try {
+            readFileSync(resolve(candidate, 'commands.ts'), 'utf8');
+            return candidate;
+        }
+        catch {
+            // try next candidate
+        }
+    }
+    throw new Error('auth-preflight smoke: no se encontro CLI/src/commands.ts');
+}
+function resolveRepoRoot(cliSrcRoot) {
+    return resolve(cliSrcRoot, '..', '..');
+}
+function verifyCoreAuthOrchestration() {
+    const events = [];
+    const contextState = {
+        authVersion: 5,
+        toolPermissionContext: {},
+        fastMode: false,
+    };
+    const result = applySuccessfulLogin({
+        context: {
+            onChangeAPIKey: () => events.push('onChangeAPIKey'),
+            setMessages: () => events.push('setMessages'),
+            setAppState: updater => {
+                Object.assign(contextState, updater(contextState));
+                events.push('setAppState');
+            },
+            getAppState: () => contextState,
+        },
+        previousModel: 'old-model',
+        previousProvider: 'claude',
+        targetProvider: 'openai',
+        transcriptClassifierEnabled: true,
+        profileName: 'main',
+    }, {
+        resetCostState: () => events.push('resetCostState'),
+        clearTrustedDeviceToken: () => events.push('clearTrustedDeviceToken'),
+        enrollTrustedDevice: async () => events.push('enrollTrustedDevice'),
+        refreshGrowthBookAfterAuthChange: () => events.push('refreshGrowthBook'),
+        refreshPolicyLimits: async () => events.push('refreshPolicyLimits'),
+        refreshRemoteManagedSettings: async () => events.push('refreshRemoteManagedSettings'),
+        stripSignatureBlocks: messages => messages,
+        switchProviderPreference: () => 'restored-model',
+        resetUserCache: () => events.push('resetUserCache'),
+        resetBypassPermissionsCheck: () => events.push('resetBypassPermissions'),
+        resetAutoModeGateCheck: () => events.push('resetAutoModeGateCheck'),
+        checkAndDisableBypassPermissionsIfNeeded: async () => events.push('checkBypass'),
+        checkAndDisableAutoModeIfNeeded: async () => events.push('checkAutoMode'),
+    });
+    assert.equal(result.restoredModel, 'restored-model');
+    assert.equal(result.shouldOpenModelPicker, false);
+    assert.equal(result.message, 'Inicio de sesion exitoso');
+    assert.equal(contextState.mainLoopModel, 'restored-model');
+    assert.equal(contextState.mainLoopModelForSession, 'restored-model');
+    assert.equal(contextState.authVersion, 6);
+    assert.ok(events.includes('onChangeAPIKey'));
+    assert.ok(events.includes('resetCostState'));
+    assert.equal(parseLoginProfileName('--profile work'), 'work');
+    assert.equal(parseLoginProfileName('-p team'), 'team');
+    assert.equal(parseLoginProfileName('direct-profile'), 'direct-profile');
+    assert.equal(parseLoginArgs('openai').provider, 'openai');
+    assert.equal(parseLoginArgs('gemini-google --profile corp').provider, 'gemini-google');
+    assert.equal(parseLoginArgs('gemini-google --profile corp').profileName, 'corp');
+    assert.equal(parseLoginArgs('openrouter').profileName, undefined);
+}
+async function verifyCoreLogoutOrchestration() {
+    let flushCalls = 0;
+    let removeApiKeyCalls = 0;
+    let secureDeleteCalls = 0;
+    let clearCacheCalls = 0;
+    let saveConfigCalls = 0;
+    await performLogoutCore({ clearOnboarding: true }, {
+        flushTelemetry: async () => {
+            flushCalls += 1;
+        },
+        removeApiKey: async () => {
+            removeApiKeyCalls += 1;
+        },
+        getSecureStorage: () => ({
+            delete: () => {
+                secureDeleteCalls += 1;
+            },
+            read: () => undefined,
+        }),
+        saveGlobalConfig: updater => {
+            const next = updater({
+                customApiKeyResponses: { approved: ['a'] },
+            });
+            saveConfigCalls += 1;
+            assert.equal(next.hasCompletedOnboarding, false);
+            assert.equal(next.subscriptionNoticeCount, 0);
+            assert.equal(next.hasAvailableSubscription, false);
+        },
+        clearAuthRelatedCaches: async () => {
+            clearCacheCalls += 1;
+        },
+    });
+    assert.equal(flushCalls, 1);
+    assert.equal(removeApiKeyCalls, 1);
+    assert.equal(secureDeleteCalls, 1);
+    assert.equal(clearCacheCalls, 1);
+    assert.equal(saveConfigCalls, 1);
+}
+function verifyCliAuthWiring(cliSrcRoot, repoRoot) {
+    const loginSrc = readFileSync(resolve(cliSrcRoot, 'commands', 'login', 'login.tsx'), 'utf8');
+    assert.ok(loginSrc.includes("from '../../core/auth/loginCore.js'"), 'login.tsx no importa core/auth/loginCore');
+    assert.ok(loginSrc.includes('cliAuthLoginServices'), 'login.tsx no usa cliAuthLoginServices');
+    assert.ok(/applySuccessfulLogin\([\s\S]*cliAuthLoginServices\)/.test(loginSrc), 'login.tsx no llama applySuccessfulLogin con services core');
+    const logoutSrc = readFileSync(resolve(cliSrcRoot, 'commands', 'logout', 'logout.tsx'), 'utf8');
+    assert.ok(logoutSrc.includes("from '../../core/auth/logoutCore.js'"), 'logout.tsx no importa core/auth/logoutCore');
+    assert.ok(logoutSrc.includes('cliAuthLogoutServices'), 'logout.tsx no usa cliAuthLogoutServices');
+    assert.ok(/performLogoutCore\(\{ clearOnboarding \}, cliAuthLogoutServices\)/.test(logoutSrc), 'logout.tsx no usa performLogoutCore con services core');
+    const commandsSrc = readFileSync(resolve(cliSrcRoot, 'commands.ts'), 'utf8');
+    assert.ok(commandsSrc.includes('logout,'), 'commands.ts no registra /logout');
+    assert.ok(commandsSrc.includes('login()'), 'commands.ts no registra /login');
+    const tauriMainSrc = readFileSync(resolve(repoRoot, 'apps', 'desktop', 'src-tauri', 'src', 'main.rs'), 'utf8');
+    assert.ok(tauriMainSrc.includes('fn core_auth_status('), 'main.rs no expone core_auth_status');
+    assert.ok(tauriMainSrc.includes('fn core_auth_login_start('), 'main.rs no expone core_auth_login_start');
+    assert.ok(tauriMainSrc.includes('fn core_auth_login_complete('), 'main.rs no expone core_auth_login_complete');
+    assert.ok(tauriMainSrc.includes('fn core_auth_logout('), 'main.rs no expone core_auth_logout');
+    assert.ok(tauriMainSrc.includes('core_auth_status,'), 'main.rs invoke_handler no registra core_auth_status');
+    assert.ok(tauriMainSrc.includes('core_auth_login_start,'), 'main.rs invoke_handler no registra core_auth_login_start');
+    assert.ok(tauriMainSrc.includes('core_auth_login_complete,'), 'main.rs invoke_handler no registra core_auth_login_complete');
+    assert.ok(tauriMainSrc.includes('core_auth_logout,'), 'main.rs invoke_handler no registra core_auth_logout');
+}
+export async function runAuthPreflightSmoke() {
+    const cliSrcRoot = resolveCliSrcRoot();
+    const repoRoot = resolveRepoRoot(cliSrcRoot);
+    verifyCoreAuthOrchestration();
+    await verifyCoreLogoutOrchestration();
+    verifyCliAuthWiring(cliSrcRoot, repoRoot);
+}
+const isDirectRun = process.argv[1]?.endsWith('preflight.smoke.js');
+if (isDirectRun) {
+    await runAuthPreflightSmoke();
+    console.log('auth preflight smoke: ok');
+}

package/dist/src/core/index.js

@@ -0,0 +1,21 @@
+// Stable shared surfaces already consumed by adapters.
+export * from './auth/index.js';
+export * from './providers/index.js';
+// Query contracts are part of the public adapter surface.
+export * from './query/contracts.js';
+export * from './query/runtime.js';
+// Tools migrated into core with usable execution contracts.
+export * from './tools/contracts.js';
+export * from './tools/registry.js';
+export * from './tools/filesCore.js';
+export * from './tools/shellCore.js';
+export * from './tools/gitCore.js';
+// MCP/skills/agents/tasks are exposed for incremental adoption.
+// Their presence here does not imply Fase 6 thin-client closure by itself.
+export * from './mcp/runtime.js';
+export * from './skills/index.js';
+// Downstream consumers may opt into these provisional runtimes explicitly.
+export * from './agents/registry.js';
+export * from './agents/runtime.js';
+export * from './tasks/runtime.js';
+export * from './tasks/sdkAdapter.js';

package/dist/src/core/mcp/blueprints.js

@@ -0,0 +1,27 @@
+export const SWARM_MCP_BLUEPRINTS = [
+    {
+        name: 'google-search',
+        command: 'npx',
+        args: ['-y', '@modelcontextprotocol/server-google-search'],
+        description: 'Buscador web para el Deep Research Agent. Requiere GOOGLE_API_KEY.',
+        env: { GOOGLE_API_KEY: '' } // Usuario debe proveerla
+    },
+    {
+        name: 'filesystem',
+        command: 'npx',
+        args: ['-y', '@modelcontextprotocol/server-filesystem', '.'],
+        description: 'Acceso al sistema de archivos para Docs Agent y Data Analyst.'
+    },
+    {
+        name: 'sequential-thinking',
+        command: 'npx',
+        args: ['-y', '@modelcontextprotocol/server-sequential-thinking'],
+        description: 'Pensamiento secuencial para el Orquestador.'
+    },
+    {
+        name: 'memory',
+        command: 'npx',
+        args: ['-y', '@modelcontextprotocol/server-memory'],
+        description: 'Memoria compartida para que los agentes recuerden interacciones previas.'
+    }
+];

package/dist/src/core/mcp/common.js

@@ -0,0 +1,14 @@
+export const SWARM_MCP_SERVER_NAMES = {
+    SEARCH: 'duckduckgo',
+    THINKING: 'sequential-thinking',
+    MEMORY: 'memory',
+    FILESYSTEM: 'filesystem',
+    DATABASE: 'database'
+};
+export const SWARM_MCP_TOOLS = {
+    [SWARM_MCP_SERVER_NAMES.SEARCH]: ['duckduckgo_search'],
+    [SWARM_MCP_SERVER_NAMES.THINKING]: ['sequential_thinking'],
+    [SWARM_MCP_SERVER_NAMES.MEMORY]: ['create_entities', 'create_relations', 'read_graph', 'search_nodes', 'open_nodes'],
+    [SWARM_MCP_SERVER_NAMES.FILESYSTEM]: ['read_file', 'write_file', 'list_dir', 'move_file', 'search_files'],
+    [SWARM_MCP_SERVER_NAMES.DATABASE]: ['db_connect', 'db_query', 'db_execute', 'db_list_tables', 'db_describe_table']
+};

package/dist/src/core/mcp/runtime.js

@@ -0,0 +1,67 @@
+function toCoreStatus(connection) {
+    switch (connection.type) {
+        case 'connected':
+        case 'failed':
+        case 'needs-auth':
+        case 'pending':
+        case 'disabled':
+            return connection.type;
+    }
+}
+export function isCoreMcpEnabled() {
+    return process.env.CORE_MCP_ENABLED === '1';
+}
+export class CoreMcpRuntime {
+    servers = new Map();
+    upsertServer(connection, extras) {
+        const existing = this.servers.get(connection.name);
+        const snapshot = {
+            id: connection.name,
+            name: connection.name,
+            status: toCoreStatus(connection),
+            transport: connection.config.type,
+            scope: connection.config.scope,
+            toolNames: extras?.tools?.map(tool => tool.name) ?? existing?.toolNames ?? [],
+            commandNames: extras?.commands?.map(command => command.name) ??
+                existing?.commandNames ??
+                [],
+            resourceCount: extras?.resources?.length ?? existing?.resourceCount ?? 0,
+        };
+        this.servers.set(connection.name, snapshot);
+        return snapshot;
+    }
+    updateServerTools(name, tools) {
+        const existing = this.servers.get(name);
+        if (!existing) {
+            return;
+        }
+        existing.toolNames = tools.map(tool => tool.name);
+    }
+    updateServerCommands(name, commands) {
+        const existing = this.servers.get(name);
+        if (!existing) {
+            return;
+        }
+        existing.commandNames = commands.map(command => command.name);
+    }
+    updateServerResources(name, resources) {
+        const existing = this.servers.get(name);
+        if (!existing) {
+            return;
+        }
+        existing.resourceCount = resources.length;
+    }
+    removeServer(name) {
+        this.servers.delete(name);
+    }
+    reset() {
+        this.servers.clear();
+    }
+    getServer(name) {
+        return this.servers.get(name);
+    }
+    listServers() {
+        return Array.from(this.servers.values());
+    }
+}
+export const coreMcpRuntime = new CoreMcpRuntime();

package/dist/src/core/mcp/runtime.smoke.js

@@ -0,0 +1,50 @@
+import assert from 'node:assert/strict';
+import { CoreMcpRuntime, isCoreMcpEnabled } from './runtime.js';
+const runtime = new CoreMcpRuntime();
+const config = {
+    type: 'stdio',
+    command: 'node',
+    args: ['server.js'],
+    env: {},
+    cwd: process.cwd(),
+    scope: 'local',
+};
+const connected = {
+    type: 'connected',
+    name: 'demo-mcp',
+    config,
+    client: {},
+    initializedAt: Date.now(),
+};
+runtime.upsertServer(connected, {
+    tools: [{ name: 'mcp__demo__tool' }],
+    commands: [{ name: '/demo' }],
+    resources: [{ server: 'demo-mcp', uri: 'memory://a', name: 'A' }],
+});
+let snapshot = runtime.getServer('demo-mcp');
+assert.ok(snapshot);
+assert.equal(snapshot?.status, 'connected');
+assert.equal(snapshot?.toolNames.length, 1);
+assert.equal(snapshot?.commandNames.length, 1);
+assert.equal(snapshot?.resourceCount, 1);
+runtime.updateServerTools('demo-mcp', [{ name: 'mcp__demo__next' }]);
+runtime.updateServerCommands('demo-mcp', [{ name: '/demo-next' }]);
+runtime.updateServerResources('demo-mcp', [
+    { server: 'demo-mcp', uri: 'memory://b', name: 'B' },
+    { server: 'demo-mcp', uri: 'memory://c', name: 'C' },
+]);
+snapshot = runtime.getServer('demo-mcp');
+assert.equal(snapshot?.toolNames[0], 'mcp__demo__next');
+assert.equal(snapshot?.commandNames[0], '/demo-next');
+assert.equal(snapshot?.resourceCount, 2);
+runtime.removeServer('demo-mcp');
+assert.equal(runtime.listServers().length, 0);
+runtime.upsertServer({
+    ...connected,
+    type: 'needs-auth',
+});
+assert.equal(runtime.getServer('demo-mcp')?.status, 'needs-auth');
+runtime.reset();
+assert.equal(runtime.listServers().length, 0);
+assert.equal(typeof isCoreMcpEnabled(), 'boolean');
+console.log('mcp.runtime.smoke PASS');

package/dist/src/core/mcp/swarmClient.js

@@ -0,0 +1,40 @@
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
+export class SwarmMcpClient {
+    clients = new Map();
+    async connectToServer(name, command, args, env) {
+        const transport = new StdioClientTransport({
+            command,
+            args,
+            env: { ...process.env, ...env }
+        });
+        const client = new Client({
+            name: `swarm-${name}`,
+            version: '1.0.0'
+        }, {
+            capabilities: {}
+        });
+        await client.connect(transport);
+        this.clients.set(name, client);
+        return client;
+    }
+    async listTools() {
+        const allTools = [];
+        for (const [name, client] of this.clients) {
+            const result = await client.listTools();
+            allTools.push(...result.tools.map(t => ({
+                ...t,
+                name: `${name}__${t.name}`
+            })));
+        }
+        return allTools;
+    }
+    async callTool(fullName, args) {
+        const [serverName, toolName] = fullName.split('__');
+        const client = this.clients.get(serverName);
+        if (!client)
+            throw new Error(`Server ${serverName} not found`);
+        return await client.callTool({ name: toolName, arguments: args });
+    }
+}
+export const swarmMcpClient = new SwarmMcpClient();

package/dist/src/core/mcp/swarmSetup.js

@@ -0,0 +1,43 @@
+import { buildMcpToolName } from '../../services/mcp/mcpStringUtils.js';
+import { SWARM_MCP_SERVER_NAMES, SWARM_MCP_TOOLS } from './common.js';
+export function setupSwarmMCPs() {
+    const mcpConfig = {};
+    const allowedTools = [];
+    // 1. Sequential Thinking (Siempre activo para el Orquestador)
+    mcpConfig[SWARM_MCP_SERVER_NAMES.THINKING] = {
+        type: 'stdio',
+        command: 'npx',
+        args: ['-y', '@modelcontextprotocol/server-sequential-thinking'],
+        scope: 'dynamic'
+    };
+    allowedTools.push(...SWARM_MCP_TOOLS[SWARM_MCP_SERVER_NAMES.THINKING].map(t => buildMcpToolName(SWARM_MCP_SERVER_NAMES.THINKING, t)));
+    // 2. Memory (Siempre activo para coherencia)
+    mcpConfig[SWARM_MCP_SERVER_NAMES.MEMORY] = {
+        type: 'stdio',
+        command: 'npx',
+        args: ['-y', '@modelcontextprotocol/server-memory'],
+        scope: 'dynamic'
+    };
+    allowedTools.push(...SWARM_MCP_TOOLS[SWARM_MCP_SERVER_NAMES.MEMORY].map(t => buildMcpToolName(SWARM_MCP_SERVER_NAMES.MEMORY, t)));
+    // 3. Filesystem (Solo si estamos en un directorio seguro)
+    mcpConfig[SWARM_MCP_SERVER_NAMES.FILESYSTEM] = {
+        type: 'stdio',
+        command: 'npx',
+        args: ['-y', '@modelcontextprotocol/server-filesystem', '.'],
+        scope: 'dynamic'
+    };
+    allowedTools.push(...SWARM_MCP_TOOLS[SWARM_MCP_SERVER_NAMES.FILESYSTEM].map(t => buildMcpToolName(SWARM_MCP_SERVER_NAMES.FILESYSTEM, t)));
+    // 4. Google Search (Solo si hay API KEY)
+    const googleApiKey = process.env.GOOGLE_API_KEY;
+    if (googleApiKey) {
+        mcpConfig[SWARM_MCP_SERVER_NAMES.SEARCH] = {
+            type: 'stdio',
+            command: 'npx',
+            args: ['-y', '@modelcontextprotocol/server-google-search'],
+            env: { GOOGLE_API_KEY: googleApiKey },
+            scope: 'dynamic'
+        };
+        allowedTools.push(...SWARM_MCP_TOOLS[SWARM_MCP_SERVER_NAMES.SEARCH].map(t => buildMcpToolName(SWARM_MCP_SERVER_NAMES.SEARCH, t)));
+    }
+    return { mcpConfig, allowedTools };
+}