expxagents 0.19.0 → 0.20.0

package/dist/cli/src/mcp/__tests__/catalog.test.js

@@ -0,0 +1,101 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import { loadMcpCatalog, loadMcpDefinition, listAllMcpIds } from '../catalog.js';
+let tmpDir;
+beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'mcp-catalog-test-'));
+});
+afterEach(() => {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+});
+function writeCatalog(content) {
+    fs.writeFileSync(path.join(tmpDir, '_catalog.yaml'), content, 'utf-8');
+}
+function writeDefinition(id, content) {
+    fs.writeFileSync(path.join(tmpDir, `${id}.mcp.yaml`), content, 'utf-8');
+}
+describe('loadMcpCatalog', () => {
+    it('loads and parses _catalog.yaml', () => {
+        writeCatalog(`
+catalog:
+  version: "1.0.0"
+  categories:
+    - name: development
+      mcps: [github]
+    - name: communication
+      mcps: [slack]
+`);
+        const catalog = loadMcpCatalog(tmpDir);
+        expect(catalog.version).toBe('1.0.0');
+        expect(catalog.categories).toHaveLength(2);
+        expect(catalog.categories[0].name).toBe('development');
+        expect(catalog.categories[0].mcps).toEqual(['github']);
+    });
+    it('returns empty categories when catalog is missing', () => {
+        const catalog = loadMcpCatalog(tmpDir);
+        expect(catalog.categories).toEqual([]);
+    });
+});
+describe('listAllMcpIds', () => {
+    it('flattens all MCP IDs from categories', () => {
+        writeCatalog(`
+catalog:
+  version: "1.0.0"
+  categories:
+    - name: dev
+      mcps: [github, postgresql]
+    - name: comm
+      mcps: [slack]
+`);
+        const ids = listAllMcpIds(tmpDir);
+        expect(ids).toEqual(['github', 'postgresql', 'slack']);
+    });
+});
+describe('loadMcpDefinition', () => {
+    it('loads individual MCP definition by ID', () => {
+        writeDefinition('github', `
+id: github
+name: GitHub
+description: PRs and issues
+category: development
+detection:
+  method: npm
+  npm:
+    package: "@modelcontextprotocol/server-github"
+server:
+  command: npx
+  args: ["-y", "@modelcontextprotocol/server-github"]
+  env:
+    GITHUB_PERSONAL_ACCESS_TOKEN: "\${GITHUB_PERSONAL_ACCESS_TOKEN}"
+auth:
+  - key: GITHUB_PERSONAL_ACCESS_TOKEN
+    label: "GitHub Token"
+    hint: "Create at github.com/settings/tokens"
+    required: true
+tools:
+  - name: list_issues
+    description: List issues
+relevant_sectors:
+  - development
+`);
+        const def = loadMcpDefinition(tmpDir, 'github');
+        expect(def).not.toBeNull();
+        expect(def.id).toBe('github');
+        expect(def.name).toBe('GitHub');
+        expect(def.detection.method).toBe('npm');
+        expect(def.auth).toHaveLength(1);
+        expect(def.auth[0].key).toBe('GITHUB_PERSONAL_ACCESS_TOKEN');
+        expect(def.server.args).toContain('-y');
+    });
+    it('returns null for unknown MCP ID', () => {
+        const def = loadMcpDefinition(tmpDir, 'nonexistent');
+        expect(def).toBeNull();
+    });
+    it('handles malformed YAML gracefully', () => {
+        writeDefinition('broken', '{{{{not yaml');
+        const def = loadMcpDefinition(tmpDir, 'broken');
+        expect(def).toBeNull();
+    });
+});

package/dist/cli/src/mcp/__tests__/detect.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/cli/src/mcp/__tests__/detect.test.js

@@ -0,0 +1,84 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { detectMcp, resolvePlatformBinary, detectExtension } from '../detect.js';
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+function makeDef(overrides) {
+    return {
+        name: overrides.id,
+        description: '',
+        category: 'test',
+        server: { command: 'npx', args: [], env: {} },
+        auth: [],
+        tools: [],
+        relevant_sectors: [],
+        ...overrides,
+    };
+}
+describe('resolvePlatformBinary', () => {
+    it('resolves darwin + arm64', () => {
+        expect(resolvePlatformBinary('darwin', 'arm64')).toBe('mcp-server-darwin-arm64');
+    });
+    it('resolves darwin + x64', () => {
+        expect(resolvePlatformBinary('darwin', 'x64')).toBe('mcp-server-darwin-x64');
+    });
+    it('resolves linux + x64', () => {
+        expect(resolvePlatformBinary('linux', 'x64')).toBe('mcp-server-linux-x64');
+    });
+    it('resolves win32 + x64 with .exe', () => {
+        expect(resolvePlatformBinary('win32', 'x64')).toBe('mcp-server-win32-x64.exe');
+    });
+});
+describe('detectExtension', () => {
+    let tmpDir;
+    beforeEach(() => {
+        tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'ext-detect-test-'));
+    });
+    afterEach(() => {
+        fs.rmSync(tmpDir, { recursive: true, force: true });
+    });
+    it('returns null when no extension found', () => {
+        const result = detectExtension('nonexistent-prefix-', tmpDir);
+        expect(result).toBeNull();
+    });
+    it('finds latest version', () => {
+        fs.mkdirSync(path.join(tmpDir, 'highagency.pencildev-0.6.30'));
+        fs.mkdirSync(path.join(tmpDir, 'highagency.pencildev-0.6.35'));
+        const result = detectExtension('highagency.pencildev-', tmpDir);
+        expect(result).not.toBeNull();
+        expect(result.version).toBe('0.6.35');
+        expect(result.extensionPath).toContain('0.6.35');
+    });
+});
+describe('detectMcp', () => {
+    it('npm detection — always returns available', () => {
+        const def = makeDef({
+            id: 'slack',
+            detection: { method: 'npm', npm: { package: '@modelcontextprotocol/server-slack' } },
+        });
+        const result = detectMcp(def);
+        expect(result.status).toBe('available');
+        expect(result.detail).toContain('npm');
+    });
+    it('cli detection — returns unavailable when command not found', () => {
+        const def = makeDef({
+            id: 'test-cli',
+            detection: { method: 'cli', cli: { command: 'nonexistent-binary-xyz', version_flag: '--version' } },
+        });
+        const result = detectMcp(def);
+        expect(result.status).toBe('unavailable');
+    });
+    it('hybrid detection — falls back to npm when CLI not found', () => {
+        const def = makeDef({
+            id: 'test-hybrid',
+            detection: {
+                method: 'hybrid',
+                cli: { command: 'nonexistent-binary-xyz', version_flag: '--version' },
+                npm: { package: 'some-package' },
+            },
+        });
+        const result = detectMcp(def);
+        expect(result.status).toBe('available');
+        expect(result.detail).toContain('npm');
+    });
+});

package/dist/cli/src/mcp/__tests__/setup.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/cli/src/mcp/__tests__/setup.test.js

@@ -0,0 +1,75 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import { writeMcpConfig, removeMcpConfig, readMcpJson } from '../setup.js';
+let tmpDir;
+beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'mcp-setup-test-'));
+});
+afterEach(() => {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+});
+function makeDef(id) {
+    return {
+        id,
+        name: id,
+        description: '',
+        category: 'test',
+        detection: { method: 'npm', npm: { package: `@test/${id}` } },
+        server: { command: 'npx', args: ['-y', `@test/${id}`], env: { TOKEN: '${TOKEN}' } },
+        auth: [{ key: 'TOKEN', label: 'Token', hint: 'hint', required: true }],
+        tools: [],
+        relevant_sectors: [],
+    };
+}
+describe('writeMcpConfig', () => {
+    it('creates .mcp.json with server entry', () => {
+        writeMcpConfig(tmpDir, makeDef('github'), { TOKEN: 'abc123' });
+        const json = readMcpJson(tmpDir);
+        expect(json.mcpServers.github).toBeDefined();
+        expect(json.mcpServers.github.command).toBe('npx');
+        expect(json.mcpServers.github.args).toContain('-y');
+    });
+    it('merges into existing .mcp.json without overwriting', () => {
+        const existing = { mcpServers: { pencil: { command: '/bin/pencil', args: [], env: {} } } };
+        fs.writeFileSync(path.join(tmpDir, '.mcp.json'), JSON.stringify(existing, null, 2));
+        writeMcpConfig(tmpDir, makeDef('github'), { TOKEN: 'abc' });
+        const json = readMcpJson(tmpDir);
+        expect(json.mcpServers.pencil).toBeDefined();
+        expect(json.mcpServers.github).toBeDefined();
+    });
+    it('adds env vars to .env file', () => {
+        writeMcpConfig(tmpDir, makeDef('github'), { TOKEN: 'mytoken' });
+        const env = fs.readFileSync(path.join(tmpDir, '.env'), 'utf-8');
+        expect(env).toContain('TOKEN=mytoken');
+    });
+    it('adds placeholders to .env.example', () => {
+        writeMcpConfig(tmpDir, makeDef('github'), { TOKEN: 'mytoken' });
+        const example = fs.readFileSync(path.join(tmpDir, '.env.example'), 'utf-8');
+        expect(example).toContain('TOKEN=');
+        expect(example).not.toContain('mytoken');
+    });
+    it('handles extension-based MCP with resolved command', () => {
+        const def = makeDef('pencil');
+        def.server.command = null;
+        writeMcpConfig(tmpDir, def, {}, '/resolved/path/to/binary');
+        const json = readMcpJson(tmpDir);
+        expect(json.mcpServers.pencil.command).toBe('/resolved/path/to/binary');
+    });
+});
+describe('removeMcpConfig', () => {
+    it('removes MCP entry from .mcp.json', () => {
+        const existing = {
+            mcpServers: {
+                github: { command: 'npx', args: [], env: {} },
+                slack: { command: 'npx', args: [], env: {} },
+            },
+        };
+        fs.writeFileSync(path.join(tmpDir, '.mcp.json'), JSON.stringify(existing, null, 2));
+        removeMcpConfig(tmpDir, 'github');
+        const json = readMcpJson(tmpDir);
+        expect(json.mcpServers.github).toBeUndefined();
+        expect(json.mcpServers.slack).toBeDefined();
+    });
+});

package/dist/cli/src/mcp/__tests__/validate.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/cli/src/mcp/__tests__/validate.test.js

@@ -0,0 +1,42 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { validateSquadMcps, getConfiguredMcpIds } from '../validate.js';
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+let tmpDir;
+beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'mcp-validate-test-'));
+});
+afterEach(() => {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+});
+describe('getConfiguredMcpIds', () => {
+    it('returns MCP IDs from .mcp.json', () => {
+        fs.writeFileSync(path.join(tmpDir, '.mcp.json'), JSON.stringify({
+            mcpServers: { github: { command: 'x', args: [], env: {} }, slack: { command: 'x', args: [], env: {} } },
+        }));
+        expect(getConfiguredMcpIds(tmpDir)).toEqual(['github', 'slack']);
+    });
+    it('returns empty array when .mcp.json missing', () => {
+        expect(getConfiguredMcpIds(tmpDir)).toEqual([]);
+    });
+});
+describe('validateSquadMcps', () => {
+    it('passes when squad has no mcps field', () => {
+        expect(() => validateSquadMcps(undefined, ['github'])).not.toThrow();
+    });
+    it('passes when squad has empty mcps', () => {
+        expect(() => validateSquadMcps([], ['github'])).not.toThrow();
+    });
+    it('passes when all required MCPs are configured', () => {
+        expect(() => validateSquadMcps(['github', 'slack'], ['github', 'slack', 'sentry'])).not.toThrow();
+    });
+    it('throws when required MCP is not configured', () => {
+        expect(() => validateSquadMcps(['github', 'linear'], ['github']))
+            .toThrow(/linear/i);
+    });
+    it('includes setup command in error message', () => {
+        expect(() => validateSquadMcps(['linear'], []))
+            .toThrow(/expxagents mcp setup/i);
+    });
+});

package/dist/cli/src/mcp/catalog.d.ts

@@ -0,0 +1,4 @@
+import type { McpCatalog, McpDefinition } from './types.js';
+export declare function loadMcpCatalog(mcpsDir: string): McpCatalog;
+export declare function listAllMcpIds(mcpsDir: string): string[];
+export declare function loadMcpDefinition(mcpsDir: string, id: string): McpDefinition | null;

package/dist/cli/src/mcp/catalog.js

@@ -0,0 +1,53 @@
+import fs from 'fs';
+import path from 'path';
+import yaml from 'js-yaml';
+export function loadMcpCatalog(mcpsDir) {
+    const catalogPath = path.join(mcpsDir, '_catalog.yaml');
+    if (!fs.existsSync(catalogPath)) {
+        return { version: '0.0.0', categories: [] };
+    }
+    try {
+        const raw = fs.readFileSync(catalogPath, 'utf-8');
+        const parsed = yaml.load(raw);
+        const catalog = parsed?.catalog;
+        return {
+            version: catalog?.version ?? '0.0.0',
+            categories: catalog?.categories ?? [],
+        };
+    }
+    catch {
+        return { version: '0.0.0', categories: [] };
+    }
+}
+export function listAllMcpIds(mcpsDir) {
+    const catalog = loadMcpCatalog(mcpsDir);
+    return catalog.categories.flatMap(c => c.mcps);
+}
+export function loadMcpDefinition(mcpsDir, id) {
+    const defPath = path.join(mcpsDir, `${id}.mcp.yaml`);
+    if (!fs.existsSync(defPath)) {
+        return null;
+    }
+    try {
+        const raw = fs.readFileSync(defPath, 'utf-8');
+        const parsed = yaml.load(raw);
+        if (!parsed?.id || !parsed?.detection) {
+            return null;
+        }
+        return {
+            id: parsed.id,
+            name: parsed.name ?? parsed.id,
+            description: parsed.description ?? '',
+            category: parsed.category ?? 'other',
+            icon: parsed.icon,
+            detection: parsed.detection,
+            server: parsed.server ?? { command: null, args: [], env: {} },
+            auth: parsed.auth ?? [],
+            tools: parsed.tools ?? [],
+            relevant_sectors: parsed.relevant_sectors ?? [],
+        };
+    }
+    catch {
+        return null;
+    }
+}

package/dist/cli/src/mcp/detect.d.ts

@@ -0,0 +1,9 @@
+import type { McpDefinition, McpDetectionResult } from './types.js';
+export declare function resolvePlatformBinary(platform?: string, arch?: string): string;
+export interface ExtensionInfo {
+    version: string;
+    extensionPath: string;
+}
+export declare function detectExtension(prefix: string, extensionsDir?: string): ExtensionInfo | null;
+export declare function detectMcp(def: McpDefinition, extensionsDir?: string): McpDetectionResult;
+export declare function detectAllMcps(definitions: McpDefinition[], extensionsDir?: string): McpDetectionResult[];

package/dist/cli/src/mcp/detect.js

@@ -0,0 +1,75 @@
+import { execSync } from 'child_process';
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+export function resolvePlatformBinary(platform, arch) {
+    const p = platform ?? process.platform;
+    const a = arch ?? process.arch;
+    if (p === 'win32')
+        return 'mcp-server-win32-x64.exe';
+    return `mcp-server-${p}-${a}`;
+}
+export function detectExtension(prefix, extensionsDir) {
+    const dir = extensionsDir ?? path.join(os.homedir(), '.vscode', 'extensions');
+    if (!fs.existsSync(dir))
+        return null;
+    const entries = fs.readdirSync(dir)
+        .filter(e => e.startsWith(prefix))
+        .sort((a, b) => a.localeCompare(b, undefined, { numeric: true, sensitivity: 'base' }));
+    if (entries.length === 0)
+        return null;
+    const latest = entries[entries.length - 1];
+    return {
+        version: latest.slice(prefix.length),
+        extensionPath: path.join(dir, latest),
+    };
+}
+function detectCli(command, versionFlag) {
+    try {
+        const output = execSync(`${command} ${versionFlag}`, { encoding: 'utf-8', timeout: 5000, stdio: ['pipe', 'pipe', 'pipe'] }).trim();
+        const match = output.match(/(\d+\.\d+[\.\d]*)/);
+        return { found: true, version: match?.[1] ?? 'unknown' };
+    }
+    catch {
+        return { found: false };
+    }
+}
+export function detectMcp(def, extensionsDir) {
+    const base = { id: def.id, name: def.name };
+    const { method } = def.detection;
+    if (method === 'cli' && def.detection.cli) {
+        const { command, version_flag } = def.detection.cli;
+        const cli = detectCli(command, version_flag);
+        if (cli.found) {
+            return { ...base, status: 'detected', detail: `${command} v${cli.version} found`, version: cli.version };
+        }
+        return { ...base, status: 'unavailable', detail: `${command} not found in PATH` };
+    }
+    if (method === 'npm' && def.detection.npm) {
+        return { ...base, status: 'available', detail: `Available via npm (${def.detection.npm.package})` };
+    }
+    if (method === 'extension' && def.detection.extension) {
+        const ext = detectExtension(def.detection.extension.prefix, extensionsDir);
+        if (ext) {
+            return { ...base, status: 'detected', detail: `VSCode extension v${ext.version}`, version: ext.version, extensionPath: ext.extensionPath };
+        }
+        return { ...base, status: 'unavailable', detail: 'VSCode extension not found' };
+    }
+    if (method === 'hybrid') {
+        if (def.detection.cli) {
+            const { command, version_flag } = def.detection.cli;
+            const cli = detectCli(command, version_flag);
+            if (cli.found) {
+                return { ...base, status: 'detected', detail: `${command} v${cli.version} found`, version: cli.version };
+            }
+        }
+        if (def.detection.npm) {
+            return { ...base, status: 'available', detail: `Available via npm (${def.detection.npm.package})` };
+        }
+        return { ...base, status: 'unavailable', detail: 'No CLI or npm package available' };
+    }
+    return { ...base, status: 'unavailable', detail: 'Unknown detection method' };
+}
+export function detectAllMcps(definitions, extensionsDir) {
+    return definitions.map(def => detectMcp(def, extensionsDir));
+}

package/dist/cli/src/mcp/setup.d.ts

@@ -0,0 +1,4 @@
+import type { McpDefinition, McpJson } from './types.js';
+export declare function readMcpJson(projectDir: string): McpJson;
+export declare function writeMcpConfig(projectDir: string, def: McpDefinition, authValues: Record<string, string>, resolvedCommand?: string): void;
+export declare function removeMcpConfig(projectDir: string, mcpId: string): void;

package/dist/cli/src/mcp/setup.js

@@ -0,0 +1,56 @@
+import fs from 'fs';
+import path from 'path';
+export function readMcpJson(projectDir) {
+    const mcpPath = path.join(projectDir, '.mcp.json');
+    if (!fs.existsSync(mcpPath)) {
+        return { mcpServers: {} };
+    }
+    try {
+        return JSON.parse(fs.readFileSync(mcpPath, 'utf-8'));
+    }
+    catch {
+        return { mcpServers: {} };
+    }
+}
+export function writeMcpConfig(projectDir, def, authValues, resolvedCommand) {
+    const mcpJson = readMcpJson(projectDir);
+    const command = resolvedCommand ?? def.server.command;
+    if (!command)
+        return;
+    mcpJson.mcpServers[def.id] = {
+        command,
+        args: def.server.args,
+        env: { ...def.server.env },
+    };
+    fs.writeFileSync(path.join(projectDir, '.mcp.json'), JSON.stringify(mcpJson, null, 2) + '\n');
+    // Write env vars
+    const envPath = path.join(projectDir, '.env');
+    const examplePath = path.join(projectDir, '.env.example');
+    let envContent = fs.existsSync(envPath) ? fs.readFileSync(envPath, 'utf-8') : '';
+    let exampleContent = fs.existsSync(examplePath) ? fs.readFileSync(examplePath, 'utf-8') : '';
+    const mcpHeader = `\n# MCP: ${def.name}\n`;
+    let envBlock = '';
+    let exampleBlock = '';
+    for (const auth of def.auth) {
+        const value = authValues[auth.key] ?? '';
+        if (!envContent.includes(`${auth.key}=`)) {
+            envBlock += `${auth.key}=${value}\n`;
+        }
+        if (!exampleContent.includes(`${auth.key}=`)) {
+            exampleBlock += `${auth.key}=\n`;
+        }
+    }
+    if (envBlock) {
+        envContent += mcpHeader + envBlock;
+        fs.writeFileSync(envPath, envContent);
+    }
+    if (exampleBlock) {
+        exampleContent += mcpHeader + exampleBlock;
+        fs.writeFileSync(examplePath, exampleContent);
+    }
+}
+export function removeMcpConfig(projectDir, mcpId) {
+    const mcpJson = readMcpJson(projectDir);
+    delete mcpJson.mcpServers[mcpId];
+    fs.writeFileSync(path.join(projectDir, '.mcp.json'), JSON.stringify(mcpJson, null, 2) + '\n');
+}

package/dist/cli/src/mcp/types.d.ts

@@ -0,0 +1,68 @@
+export interface McpAuthEntry {
+    key: string;
+    label: string;
+    hint: string;
+    required: boolean;
+    validate?: string;
+}
+export interface McpToolEntry {
+    name: string;
+    description: string;
+}
+export interface McpDetectionConfig {
+    method: 'cli' | 'npm' | 'extension' | 'hybrid';
+    cli?: {
+        command: string;
+        version_flag: string;
+        min_version?: string;
+    };
+    npm?: {
+        package: string;
+    };
+    extension?: {
+        prefix: string;
+        binary_dir: string;
+        binary_resolve: 'platform';
+    };
+}
+export interface McpServerConfig {
+    command: string | null;
+    args: string[];
+    env: Record<string, string>;
+}
+export interface McpDefinition {
+    id: string;
+    name: string;
+    description: string;
+    category: string;
+    icon?: string;
+    detection: McpDetectionConfig;
+    server: McpServerConfig;
+    auth: McpAuthEntry[];
+    tools: McpToolEntry[];
+    relevant_sectors: string[];
+}
+export interface McpCatalogCategory {
+    name: string;
+    mcps: string[];
+}
+export interface McpCatalog {
+    version: string;
+    categories: McpCatalogCategory[];
+}
+export interface McpDetectionResult {
+    id: string;
+    name: string;
+    status: 'detected' | 'available' | 'unavailable';
+    detail: string;
+    version?: string;
+    extensionPath?: string;
+}
+export interface McpJsonEntry {
+    command: string;
+    args: string[];
+    env: Record<string, string>;
+}
+export interface McpJson {
+    mcpServers: Record<string, McpJsonEntry>;
+}

package/dist/cli/src/mcp/types.js

@@ -0,0 +1 @@
+export {};

package/dist/cli/src/mcp/validate.d.ts

@@ -0,0 +1,2 @@
+export declare function getConfiguredMcpIds(projectDir: string): string[];
+export declare function validateSquadMcps(squadMcps: string[] | undefined, configuredMcps: string[]): void;

package/dist/cli/src/mcp/validate.js

@@ -0,0 +1,23 @@
+import fs from 'fs';
+import path from 'path';
+export function getConfiguredMcpIds(projectDir) {
+    const mcpPath = path.join(projectDir, '.mcp.json');
+    if (!fs.existsSync(mcpPath))
+        return [];
+    try {
+        const json = JSON.parse(fs.readFileSync(mcpPath, 'utf-8'));
+        return Object.keys(json.mcpServers ?? {});
+    }
+    catch {
+        return [];
+    }
+}
+export function validateSquadMcps(squadMcps, configuredMcps) {
+    if (!squadMcps || squadMcps.length === 0)
+        return;
+    const missing = squadMcps.filter(m => !configuredMcps.includes(m));
+    if (missing.length > 0) {
+        throw new Error(`Squad requires MCPs not configured: ${missing.join(', ')}.\n` +
+            `Run: expxagents mcp setup ${missing.join(' ')}`);
+    }
+}

package/dist/cli/src/pencil/detect.d.ts

@@ -1,3 +1,7 @@
+/**
+ * @deprecated — Use cli/src/mcp/detect.ts instead. This file re-exports for backwards compatibility.
+ */
+export { resolvePlatformBinary } from '../mcp/detect.js';
 export interface PencilInfo {
     version: string;
     extensionPath: string;
@@ -11,16 +15,7 @@ export interface McpConfig {
         };
     };
 }
-/**
- * Detect Pencil VSCode extension in the given extensions directory.
- * Returns info about the latest installed version, or null if not found.
- */
+/** @deprecated Use detectExtension from cli/src/mcp/detect.ts */
 export declare function detectPencilExtension(extensionsDir?: string): PencilInfo | null;
-/**
- * Resolve the correct MCP server binary name for the current platform.
- */
-export declare function resolvePlatformBinary(platform?: string, arch?: string): string;
-/**
- * Build the .mcp.json config object for Pencil MCP.
- */
+/** @deprecated Use writeMcpConfig from cli/src/mcp/setup.ts */
 export declare function buildMcpConfig(info: PencilInfo, binaryName: string): McpConfig;